Sal’s Kewl Korner

Home / Documentation / Sal's Kewl Signage

Sal's Kewl Signage — owner's manual

Electronic sign props for FiveM — portable message boards, overhead gantries, arrow boards, full-color digital billboards, fuel pylons, parking counters — with the messaging under script control and an export API any other resource can drive. This manual covers installation, configuration, daily use and troubleshooting for server owners.

documents resource version 1.13.0↓ PDF

Overview

Sal's Kewl Signage puts working electronic signs in your world. Twenty-seven types across six families, from a solar-powered VMS trailer at a work zone to a 24-meter overhead gantry to a drive-thru menu board to the STOP sign on the corner, and every one of them shows whatever your scripts tell it to show — not a fixed set of baked messages.

Three things make it different from a prop pack with some text on it:

  • Per-instance content. Two boards using the same prop show different things, because the lamps are drawn in world space rather than painted onto a shared texture. A street of message boards is a street of message boards, not twenty-seven copies of one.
  • It ships with the hardware, as real props. Every type has a streamed model in the download — the solar trailer with its mast and wheels, the gantry posts and truss, the billboard monopole and catwalk — lit by the game, casting shadows, with collision. A trailer blocks a lane and traffic drives round it; whether it does is one config switch.
  • A hard performance ceiling. Lamp geometry is computed once and replayed, boards off-camera cost nothing, and a per-frame triangle budget means a street full of signs degrades in detail instead of dropping your frame rate.

Server-authoritative, framework agnostic (qb / qbx / esx / standalone), no database, no dependencies.

Requirements

None. No framework, no database, no target resource, no ox_lib.

qb-core, qbx_core or es_extended are detected if present, to resolve jobs for the permission check. Without any of them the resource runs standalone and permissions fall back to ACE.

Installation

  1. Drop the folder into resources/.
  2. Add ensure sals_kewlsignage to server.cfg.
  3. Give yourself permission:
    add_ace group.admin sals_kewlsignage.admin allow
  4. Join and run /sign demo. It teleports you in front of a field containing one of every sign type, each showing its plate number — the whole catalog in one look.
  5. Run /sign probe. Every type with hardware should say OK; the three wall-mounted types say FACE, which is normal — they have nothing to stream — the models ship in stream/. MISSING means a model did not stream; DRAWN means Config.Models.UsePack is off and the type is on its fallback rig.
  6. Before you go live, set Config.Demo.Enabled = false.

The demo field ships on so that step 4 works on a fresh install, and the server console reminds you every boot until you turn it off. Demo signs are marked as config signs, so they cannot be deleted in-game — switching the setting off is how they go away.

Updating

Signs you place in-game are saved to data/signs.json, and pictures added to the library to data/images/. Neither ships in the download, so copying a new version over the old one leaves them alone. If you prefer to delete the folder and drop the new one in, keep data/ and put it back afterward. config.lua is yours too; the CHANGELOG calls out any key that changed.

Coming from 1.5.0 or earlier, read Upgrading to 1.6.0 — one default changed in a way that can stop linked pictures working.

The twenty-seven sign types

Each has a plate number, which is what the demo field prints on it.

PlatetypeWhat it isBackend
SKS-101vms_trailerPortable message board on a solar trailermatrix
SKS-102arrow_trailerSequential arrow boardlamps
SKS-103dms_gantryFull-span overhead gantry, with lane headsmatrix
SKS-104dms_cantileverHalf-span cantilever armmatrix
SKS-105lcs_headSingle lane control signallamps
SKS-106radar_speedRadar speed feedback signmatrix
SKS-107vsl_roundelVariable speed limit with zone beaconsmatrix
SKS-108lcs_bracketLane control signal with no post, on a wall bracketlamps
SKS-201billboardDigital billboard, full colordui
SKS-202fuel_pylonFuel price pylon, per gradematrix
SKS-203tickerFacade ticker strip, scrollingmatrix
SKS-204aframeSidewalk A-framematrix
SKS-205menu_boardDrive-thru menu board, full colordui
SKS-301parking_countParking space countermatrix
SKS-302transit_panelTransit arrivals panelmatrix
SKS-303marqueeVenue marquee with chasing bulbsmatrix
SKS-401yard_signYard sign on a wire H-stake, printeddui
SKS-402realty_postReal estate post sign with a rider, printeddui
SKS-403timber_signTimber business sign in a frame, printeddui
SKS-404banner_frameVinyl banner on a scaffold frame, printeddui
SKS-501wall_panelPanel mounted flat on a building, printeddui
SKS-502wall_bannerLong banner mounted flat on a building, printeddui
SKS-503facade_boardIlluminated facade or crown signdui
SKS-601road_signRoad sign on a post: STOP, YIELD, SPEED LIMIT, warning, guide, postalstreet
SKS-602street_bladeStreet name blades at a corner, with the postal codestreet
SKS-603work_standRoll-up work-zone sign on a tripod, with flagsstreet
SKS-604barricadeType III barricade with a closure panel and warning lampsstreet

The 600s are sheet metal: each wears a design that sets its shape, colors and legend, and none of them has a power switch. See Street signs.

The 400s are printed: the face is ink on a sheet, so it does not glow, it goes dark with the sky, and switching its power off does nothing — there is no switch on a sheet of plastic. See Printed signs.

The 500s are frameless: a face and no hardware at all, meant to go flat on a building. /sign place handles those with the wall tool rather than the ground one. See Signs on buildings.

How boards are drawn

Three backends, chosen per type:

matrix

Text as individual lamps on a 5×7 dot font, drawn on the plane of the board's face. Close up you see individual round lenses with dark gaps between them; further away, runs of lit lamps merge into solid strokes — which is what a real board looks like from a distance anyway, and costs a fraction of the polygons. Each lit lamp is drawn twice: a soft oversize halo in the lamp color under a whiter core, so neighboring lamps bleed into one glowing stroke the way LEDs do.

lamps

Fixed lamp patterns rather than text — the arrow boards and lane control signals, whose vocabulary is a set of shapes, not a set of words.

dui

An HTML page rendered off-screen and painted onto the board's face: pictures, any typeface, a color per line, slide shows with fades. Used by the billboard and the menu board out of the box, and available to any matrix type through Config.Dui.Types. See Full-color boards.

The hardware

Every type ships with a streamed model in stream/: a real prop, lit by the game's sun and weather, casting and receiving shadows, with collision. The screen is drawn onto a dark recess on the model, so the model carries no text and no texture swap, and two boards on one model still say two different things. Config.Models.Collision decides whether players and cars hit the hardware — on by default, so a trailer blocks a lane like a real one. If a model fails to stream, the type falls back to a drawn rig from the same dimensions: unlit, no collision, but the board still works. Config.Render.DrawRigs = false leaves such a sign screens only.

Run /sign winding once, on your first install. FiveM's DrawPoly draws one side of a triangle, and which side depends on a vertex order a script cannot ask the renderer about. Stand in front of the demo field and run /sign winding until the boards look right, then paste the letter it prints into Config.Render.Winding. The shipped default 'both' always works but costs twice as much — it is for finding out, not for keeping.

The in-game editor

/signs, or bind a key in Config.Editor. Every board on your server in a searchable list, with a live preview drawn using the same font the game uses — and for a full-color board, the very page the game paints onto it, so the preview is the board.

  • Page-by-page message editing, with a per-line color, alignment and effect.
  • One-click presets from Config.Presets.
  • Place, move, duplicate and delete without touching a config file.
  • Map pins for every sign, so you can see where they all are.
  • Variables, schedule and mirroring, covered below.
  • Watch board — a camera on the sign you are editing, with the panel still open and working beside it. The preview is a drawing of the message; this is the board itself, with the street behind it. In the tablet too.
  • An arrow board or a lane signal has no text, so its preview is drawn as the hardware — the lamp grid running the real pattern.

With Config.Editor.FocusOnAimed, looking at a board and pressing the bind opens the editor on that sign.

Permission is checked on the server before the UI is allowed to open, so leaving the command available to everyone is safe. A player with only the message permission sees the message editor; the group, schedule, mirror and Jobs allowed controls are admin-only.

The tablet

The editor is the control room. The tablet is what a road crew, a traffic officer or a restaurant employee holds in their hand. /signtablet, a key bind in Config.Tablet, or using the signage_tablet item (registered as usable with qb-core, qbx_core or es_extended when your inventory defines it) opens a modern slate over the game, and the player holds a tablet prop while it is open.

  • Only the signs the player may run. An admin sees everything; a job sees what Config.Access.Jobs and each sign's own Jobs allowed list grant it — see Permissions below. The server checks the same thing on every save.
  • The same live preview the editor has.
  • Message and presets as one-tap chips; pages with hold, effect and alignment. Pictures and per-line styles a slide carries are kept.
  • A drive-thru board's item names and prices as plain fields.
  • Power, brightness, color, the arrow pattern as tiles, lane signals as the heads themselves, and the values on a data board.
  • Overrides, with Release.
  • Quick actions from the list, multi-select with one action for all of them, one-tap alert modes, "show for 20 minutes" timed messages, a camera peek at any board, and an admin health screen with release-all.

Placing signs

Two ways, and they do not mix.

Config signs — the map's furniture

Signs in Config.Signs exist on every boot and cannot be deleted in-game, so an admin cannot quietly remove the furniture and leave the next restart to put it back. Their content can still be changed.

Config.Signs = {
    {
        id      = 'vms.route68_nb',
        type    = 'vms_trailer',
        coords  = vector3(1234.5, -678.9, 60.1),
        heading = 180.0,          -- degrees the FACE points, 0 = north
        group   = 'highway',
        pages   = { { lines = { 'ROAD WORK', 'AHEAD' } } },
    },
}

coords is the base of the sign — the ground, not the screen. /sign here prints a ready-made block for wherever you are standing.

Placed signs — the in-game tool

/sign place <type> [id] [group], or Place new in the editor, gives you the real prop with a live face preview to drive into position:

KeyDoes
W A S DMove
Q / EUp and down
ScrollTurn
Arrow keysFine adjust
SpaceSnap to 90°
RSnap to the ground
ShiftMove faster
EnterPlace it
BackspaceCancel

Leave the id out and the sign is named after the street it lands on. Placed signs are saved to data/signs.json and can be moved and deleted freely.

Signs on buildings

Three types have no hardware at all — wall_panel, wall_banner and facade_board. They are a face and nothing else, meant to go flat on something that is already in the world, so /sign place gives them a different tool from the one that walks a message board into position.

Aim at a building. A shape test finds the wall and the panel squares itself to it, at whatever height you are looking at. You never touch the rotate keys.

KeyDoes
AimThe panel follows your crosshair, flat on the wall under it
EPin it, so it stops following
W A S DNudge it in the plane of the wall
ScrollWidth — and height with it, while the aspect is locked
Arrow keysHeight
RLock or free the aspect
SpaceSquare the heading to the nearest 90°
ShiftFaster
EnterPlace it
BackspaceCancel

A wall sign's size belongs to the sign rather than to its type, so it is stored on the record and survives a restart. The reach, the stand-off from the wall, the size limits and how far from vertical a surface may be before the tool refuses it are all in Config.Wall.

What it will not do

It mounts vertical panels. A sign's face is built from a coordinate and a heading with world up fixed, so a panel on a sloped roof would come out standing upright through it. Surfaces too far from vertical are refused rather than mounted badly — Config.Wall.MinWallNormal.

A panel on a distant tower will not stay flush against it. Buildings swap to a low-detail model at range, so the facade you measured against is not the one that is drawn, and the panel floats off it or sinks into it. Config.Wall.Reach is capped for that reason. Mount tower signs from close to the building.

It does not replace the game's own signs. A panel goes over one, which is deliberate: a sign record syncs to every player, and swapping a building's texture does not — that is per-client, and it breaks on game updates.

Placing a frameless type switches /sign place to this tool automatically. There is no setting for it: a yard sign stuck flat to a tower is not something anyone is trying to do, and a facade panel lying in the road is not either.

A lane signal with no post

lcs_bracket is the lane control signal on a wall bracket instead of a post, and it uses this tool too: aim at the edge of an overpass, a bridge or a tunnel wall and it bolts on, squared to it. It is hardware of a fixed size, so the size keys are off for it. It takes the same lane states as lcs_head, speed limits included.

Speed limits on lane signals

Any lane head, on a gantry, a post or a bracket, can show a speed limit: the state speed:<n>, 5 to 150, mixed freely with the others. Config.Lanes.SpeedStyle picks the look for the whole server: 'us' (the default) is a white SPEED LIMIT panel lettered like the street signs, and 'ring' is the number in a red ring. The tablet offers one-tap limits from Config.Lanes.SpeedPresets and a box for any other number; the editor has a Speed limit entry on every lane. It is a message change, so anyone who may run a board may set its limit.

Messages, pages and styles

A sign shows a list of pages, cycled with a hold time each. A line too long for the board scrolls rather than being cut.

-- the convenient forms, all equivalent to a page list
SetMessage('vms.route68_nb', 'ROAD WORK')
SetMessage('vms.route68_nb', { 'ROAD WORK', 'AHEAD' })
SetMessage('vms.route68_nb', {
    { lines = { 'ROAD WORK', 'AHEAD' }, hold = 2500 },
    { lines = { 'EXPECT', 'DELAYS' }, effect = 'flash' },
})

Every line can carry its own look through an optional styles list beside lines. Lamp boards honor color, alignment and flash; full-color boards add a typeface, a size, bold, italic, and the effects pulse, glow, scroll and rainbow.

{ lines  = { 'HAPPY HOUR', '5 TO 7 PM' },
  styles = { { color = '#FFD24A', size = 1.5, font = 'display', effect = 'glow' },
             { color = 'white', size = 0.9 } },
  background = '#1A0B2E', transition = 'fade', hold = 5000 }

Config.Messages sets the ceilings — MaxLineLength (32), MaxLines (4), MaxPages (8) — and the character set the lamp font has glyphs for. They are applied on the server to everything, including export callers, so no resource can push something that renders as garbage.

Lines are stored as typed. The lamp boards apply their single case and charset when they draw, so a lamp board reads exactly as it always did, while a full-color board keeps its capitals and its accents. As of 1.6.0 the length cap counts characters rather than bytes, so accented text gets the same room as ASCII.

Overrides

An override jumps the queue without destroying what the board was showing, and releases itself:

Override('group:highway', { 'AMBER ALERT', 'BLU SEDAN' },
         { owner = 'my_dispatch', seconds = 300 })

When it expires — or when you release it — the board goes back to its own pages on its own. That is how you do an emergency broadcast without every resource having to remember and restore state. With an owner, ClearOverride only releases overrides that owner placed, so two resources overriding the same board cannot release each other's.

Full-color boards & pictures

The billboard and the menu board render an HTML page onto their face. No model pack and no texture are involved, and every board has its own page, so two billboards side by side show two different adverts. Config.Dui.Types promotes any other message board — the marquee, the A-frame, the ticker — to full color, keeping its hardware.

Drive-thru menus

A full-color page can carry a menu instead of lines, and it is then laid out the way a menu is printed rather than as centered text: a brand strip, sections set in columns under their own rules, calories under each item name, prices in a column that lines up, and the nutrition line along the bottom.

exports.sals_kewlsignage:SetMessage('menu.drivethru', { {
    menu = {
        theme = 'light',                     -- or 'dark' for a backlit panel
        brand = "CLUCKIN' BELL", header = 'Order Here',
        accent = '#C8102E', priceHeads = { 'Med', 'Lg' },
        sections = {
            { header = 'Combo Meals', items = {
                { num = '1', name = 'Bell Box Meal', kcal = '1240 Cal',
                  price = '11.99', price2 = '13.49' },
            } },
            { header = 'Sides & More', items = { --[[ ... ]] } },
        },
        footer = '2,000 calories a day is used for general nutrition advice',
    },
} })

Every field is optional, and an item may also carry a desc and an image — a library id or a link — drawn as a thumbnail against the row. Sections are dealt into columns to suit the board's shape, and the type is sized so the rows fill the panel without clipping a name.

A menu is content, not a texture. The same exports, overrides and schedules that change a message change the prices, so a script can run a daypart or a promotion. If the board cannot get a browser page it falls back to amber lamps, and the menu writes those lines itself.

Slides

A full-color board's pages are slides: picture, text or both, each with its own hold, background color, fill-or-fit, and a cut or a fade into the next. A picture-only slide is held eight seconds by default — it is an advert, not a message.

The picture library

Pictures live on the server in data/images/ (flat in data/ if that folder is missing; the console says which), so every player sees the same picture without anyone hosting it. Staff add them from the editor: open a slide's Choose picture and paste one with Ctrl+V — copied from any app or web page, or a Win+Shift+S screenshot.

There is no Browse button. The game's embedded browser cannot open a file picker, so a file input would sit there doing nothing. The clipboard works, and so does a link.

An uploaded picture is shrunk to the board it is going on before it leaves the browser, so a screenshot of anything becomes a billboard-sized JPEG of a couple of hundred kilobytes. A board refers to a library picture as lib:<id>.

Linked pictures, and why they are off by default

A linked picture is not fetched by your server. It becomes an <img src> inside the page painted onto the board, on the machine of every player who can see it. So whoever can set a board's picture can make everyone in view fetch a URL of their choosing — an IP-logging endpoint handed to anyone with the message permission, and nothing about the board looks wrong while it happens.

So Config.Images.AllowedHosts ships empty, which refuses every link and allows only uploaded pictures. To allow links, list the hosts:

AllowedHosts = { 'i.imgur.com', '.discordapp.net', 'media.tenor.com' },

A leading dot allows subdomains and only subdomains, so .imgur.com covers i.imgur.com but not eviimgur.com. '*' allows anything — only reasonable on a server where everyone who can set a board's picture is someone you would hand a shell to. The editor grays out the link box when no host is allowed, rather than letting someone paste one and watch it be silently refused.

Settings

Config.Images sets the ceiling per picture (MaxKilobytes, 600), the library size (MaxCount, 60), and whether the jobs in Config.Access.Jobs may upload (AllowJobUploads, off — uploads are ACE by default, deleting always is). Seed puts links in the library from the start, and they go through the same allowlist.

Config.Dui.MaxSurfaces (default 6) is the pool of browser pages shared by every full-color board in view, handed out nearest first. A board without one renders as a matrix board until one frees up. /sign perf reports what is in use.

Printed signs

A yard sign, a realty panel, a timber board, a banner. These are full-color faces like the billboard — a picture from the library, slides and the export API all work the same way — but three things about them are different on purpose.

TheyBecause
Do not glowThe face is dimmed as the sky goes, down to Config.Printed.NightFloor at midnight. A yard sign at 2am is dim, the way a real one is.
Ignore power/sign off across a group to quiet the highway overnight must not come back to blank lawns. There is no switch on a sheet of plastic.
Fall back to paper, not lampsEvery full-color board renders as a dot-matrix panel when the browser-page pool is spent (Config.Dui.MaxSurfaces). For a billboard that is fine; for a street of twenty yard signs it would be twenty glowing amber boxes. So printed types fall back to a drawn sheet with the headline printed on it.

Config.Printed.Enabled = false turns all three off and they behave like any other lit board.

The poster block

A page carries a poster the way a drive-thru page carries a menu, and it replaces the lines entirely — the lines stay as the fallback for a sheet that never gets a browser page.

pages = {
    {
        poster = {
            theme    = 'white',          -- white | navy | kraft | dark
            accent   = '#1B3A6B',
            brand    = 'Johnson Realty', -- the band across the top
            headline = 'For Sale',
            lines    = { 'Quiet street, corner lot' },
            details  = {                 -- the spec strip
                { label = 'Beds',  value = '3' },
                { label = 'Baths', value = '2' },
            },
            contact  = { name = 'Dana Johnson', phone = '555-0147' },
            rider    = 'OPEN HOUSE SUN 1-4',   -- the strip across the foot
            border   = true,
            image    = 'lib:<id>',       -- behind the type, at low strength
        },
    },
}

Everything is optional. A poster with nothing but a headline is a perfectly good yard sign.

The rider is the strip that says what changed without the panel being reprinted — SOLD, OPEN HOUSE, PRICE REDUCED. On a real sign it hangs as a separate board under the panel; here it is printed in at the foot with a rule above it, which reads the same from the sidewalk.

Staff edit the headline, the phone number and the rider from the tablet's Printed sheet card, the same way a menu board's prices are edited. The layout itself is not editable there: a printed sign has one job, and a tablet in a glove box is not where it should be redesigned.

Backlit, per sign

The type is only the default. A panel over a fire station door is lit; a for-sale board on the same wall is not — and they are the same type. So any printed or wall-mounted sign can be switched either way without being re-placed:

/sign data fd.station lit true      backlit: holds its color after dark
/sign data fd.station lit false     ink: goes dark with the sky
/sign data fd.station lit -         back to whatever the type says

It is also a field on the sign in the editor and on the tablet, under Values.

A lit sign takes the billboard's defaults — white on near-black — and a printed one takes Config.Printed.Paper and Config.Printed.Ink. That matters: white text on a printed sheet is invisible by day, and black text on a billboard's background is invisible at night. Flipping lit changes both how bright the sign is and what it is written in.

Housings — monument signs

Housings — what a sign is mounted in

A monument sign is a surround and a panel: a boulder with letters cut into it, masonry piers with a board slung between them, a slate slab on two feet. The surround is its own axis rather than another twenty types, because the same stone takes carved letters, an amber message board or a full-color screen — and in the real world all three turn up in it.

 What it decides
sign.typeWhat the face is — the backend, and what drives it
sign.housingWhat it is mounted in — the hardware, and where the face sits
/sign housings                          list them
/sign housing mon.gate masonry_piers    set one
/sign housing mon.gate -                take it off

There is a picker on the tablet and in the editor, and SetHousing(target, key) for other resources.

Only the frameless types can wear one — wall_panel, wall_banner and facade_board. A message trailer has a chassis and a gantry spans a carriageway; neither is something you set into a rock. That is enforced on the server, not just hidden in the panel.

A housed sign takes its model, its footprint and its face rectangle from the housing, so moving a sign between housings changes its shape — and resets any size you had dragged it to, because a size cut for one stone means nothing in another. Within the housing’s own limit it can still be resized. Config.Housings.UsePack = false drops back to the drawn rigs, and Config.Housings.Overrides points a housing at a prop of your own.

Carved faces

Two poster themes, stone and bronze, cut the lettering into the face rather than printing it on. Carving is not a color: it is a dark edge where the light falls and a lit edge opposite, with the letter itself barely different from the stone around it. Painting the letters darker instead gives a painted sign, which is not what a monument is.

The eight

PlatehousingWhat it isPanel
SKH-101boulderEngraved boulder1.70 × 0.80 m
SKH-102stone_lowLow stone wall2.60 × 1.00 m
SKH-103masonry_piersMasonry piers and panel2.40 × 1.20 m
SKH-104brick_monumentBrick monument2.20 × 1.05 m
SKH-105slate_plaqueSlate plaque1.30 × 0.78 m
SKH-106timber_stoneTimber header on stone piers2.20 × 1.10 m
SKH-107stone_pylonStone-clad pylon1.80 × 2.20 m
SKH-108brushed_bezelBrushed metal bezel2.60 × 1.30 m

Street signs & temporary signs

Four types, each wearing a design. The design decides the shape, the sheeting and how the words are set; the words themselves are the sign's own first page, so every message command, the editor and the tablet work on them.

Every street sign design, drawn by the resource's own renderer

/sign place road_sign                   a speed limit sign, ready to re-design
/sign designs [type]                    every design, by type
/sign design road.grove stop            make it a STOP sign
/sign design road.grove warning         a yellow diamond...
/sign msg road.grove DEER | XING        ...that says what you want
TypeDesigns
road_signspeed_limit, stop, all_way, yield, do_not_enter, one_way_left, one_way_right, no_parking, regulatory, warning, school, guide, recreation, postal
work_standroad_work, road_closed_ahead, detour_ahead, right_lane_closed, left_lane_closed, one_lane_road, flagger, utility_work, work_zone, emergency_scene, accident_ahead, checkpoint, incident, detour_left, detour_right
barricaderoad_closed, road_closed_thru, local_traffic, closure, detour_left, detour_right
street_bladeblade_green, blade_blue, blade_brown, blade_white

Fixed legends. STOP, ALL WAY, YIELD, DO NOT ENTER and ONE WAY ignore the sign's lines: a STOP sign that says something else is not a STOP sign. Choosing a design resets the legend to the design's own; /sign design <id> <design> keep does not. The incident designs are fluorescent pink, the color US incident management signs are made in. The barricade's lamps flash by default (/sign data <id> lamps steady or off).

Street names and postal codes

A fresh street name blade says {street} and {cross}, filled in where it stands from the game's own map: the street the post is on and the nearest other street. Type a name over either to pin it. {postal} is the nearest code from your postal resource (nearest-postal and its forks, found automatically), shown on a plate on the pole under the blades. The postal file is read, never written. All four — {street}, {cross}, {zone}, {postal} — work on any sign.

At night

Sign sheeting is retroreflective. A street sign at night sits dark until your own headlights are on it and then comes up to full, further on high beams. Config.Street.Retroreflective = false holds every sign at NightFloor.

Temporary signs and kits

/sign kits                              what kits are set up
/sign kit road_closed                   the whole closure, previewed, then ENTER
/sign temp work_stand flagger           one sign, with the placer
/sign pickup [metres]                   everything temporary within 30 m
/sign pickup all                        every temporary sign (needs delete)

For a kit, stand where the work is and face the traffic you are warning. Every sign is laid out up the road toward it and previews live; walk it and turn it as one, then Enter. Four kits ship: lane_closure, road_closed, emergency_scene and checkpoint, and more go in Config.Street.Kits.

Temporary signs are never written to disk and never exported. A restart clears them, they take themselves away after Config.Street.Temporary.Lifetime (120 minutes), and everything that lists one says "temporary, not saved" — so a closure gone after a restart is not mistaken for the save failing.

Who may put them out: anyone with place, the sals_kewlsignage.roadwork ACE, or an on-duty job in Config.Street.Jobs (police, sheriff, fire, ambulance, EMS, DOT and mechanic by default). The roadwork capability reaches temporary signs only: put them out, change what they say, move them, pick them up.

Incidents — ACCIDENT AHEAD

Report a crash, a vehicle fire or a closure at a spot on the map, and the message boards drivers are about to pass warn them — ACCIDENT / 1/2 MI AHEAD — then go back to what they were saying when it is over. Nobody picks the boards. A player on the job reports one where they stand, a Sonoran CAD 911 or dispatch call raises one on its own, and any other resource can do it with one export.

Which boards

Within Config.Incidents.Radius (1,200 m) of the scene, of a type in Config.Incidents.Types (the VMS trailer, the gantry and the cantilever by default), and facing traffic that is heading toward the scene. Drivers read a board, pass it and carry on the other way, so a board lights only when the scene lies behind it, within Ahead.Angle (60°) of straight back. A board past the scene, or one facing the other side of a divided highway, stays quiet. Nearest first, at most MaxSigns (6).

Which road. Every sign remembers the street the game names where it stands. Signs placed from 1.12.0 on record it themselves; for older signs, run /sign roads once, or type one into the editor's Road field. When the scene's road is known too, Config.Incidents.Road decides: 'prefer' (that road's boards when there are any), 'require' (only that road's) or 'off'.

What they say

Each kind in Config.Incidents.Kinds has its own pages: accident, vehicle_fire, hazard, road_closed and police_activity ship. {distance} is measured from each board (1/2 MI, 800 FT, or nothing inside 150 m so the board says just AHEAD); {road} and {postal} are the scene's. An incident is an override owned incident:<id>: it beats a schedule, comes down by itself, leaves a board someone else holds alone (Busy = 'skip'), and when two want one board the newer gets it and hands it back to the older when it ends.

Which calls count: the word list

Config.Incidents.Words is one list of words and phrases per kind, shared by every source that hands over a call's words rather than a kind: a Sonoran 911, a Sonoran CAD call (its code, title and description), and any other CAD or script that reports with text =. Put your CAD's call codes in it too.

Words = {
    accident     = { 'accident', 'crash', 'collision', 'rollover', 'hit and run', '10-50', '11-80', ... },
    vehicle_fire = { 'vehicle fire', 'car fire', 'car on fire', ... },
    hazard       = { 'debris', 'stalled vehicle', 'wrong way driver', ... },
    road_closed  = { 'road closed', 'road closure', 'lanes blocked', ... },
},
Ignore = { 'test call', 'training call', 'false alarm', 'disregard', ... },
  • Case and punctuation do not matter: '10-50' also finds 10 50.
  • A phrase matches from the start of a word: 'crash' finds crashed, but 'tc' is not found inside etc.
  • The longest phrase that matches wins, so “crashed and the car is on fire” is a vehicle fire.
  • Anything from Ignore in a call means it lights nothing.
  • A kind with no list is only reported by hand. police_activity ships without one, so a 911 about a shooting never lights the freeway.

Try a phrase without a call, in game or from the server console: /sign incident test car flipped over answers A call saying that is accident (matched "flipped over").

Sonoran CAD

With sonorancad running there is nothing to set up on the Sonoran side; the console says Sonoran CAD found at boot. A player's /911 whose words are in the list goes up where the caller stands, on the road their game names. A call a dispatcher opens in the CAD is matched on its code, title and description and placed from its coordinates or its postal; a call made from a 911 is the same incident. When the dispatcher closes the call, the boards come back.

Config.Incidents.Sonoran.Calls911 and .Dispatch are each 'auto', 'confirm' (waits for an officer or dispatcher) or 'off'.

A caller can say anything. If prank calls start lighting your freeway, Calls911 = 'confirm' is the switch.

CAD calls, and 911s typed into the CAD, arrive through Sonoran's push events, which their documentation lists under the Plus plan. An in-game /911 needs only the callcommands plugin, on by default.

From another resource or another CAD

local id, err, boards = exports.sals_kewlsignage:ReportIncident({
    coords  = vector3(x, y, z),   -- or postal = '123'
    kind    = 'accident',         -- or text = 'the call's words', and the word list picks
    road    = 'Senora Fwy',       -- optional; narrows it to that road
    ref     = 'mycad:42',         -- optional; your own id for it
})
exports.sals_kewlsignage:ClearIncident('mycad:42')

With text and words that are no kind, it answers nil, 'err_incident_no_match', so a dispatch script can pass every call through and let the word list sort them.

Schedules

A sign can say different things at different times of day without anything driving it: a menu board that switches to breakfast at six, a marquee that runs the evening show after five, a highway board that reads differently overnight.

Config.Signs = {
  { id = 'menu.burgershot', type = 'menu_board',
    coords = vector3(...), heading = 0.0,
    pages = { { lines = { 'BURGER SHOT' } } },      -- outside every slot
    schedule = {
      { from = '06:00', to = '11:00', label = 'Breakfast',
        pages = { { lines = { 'BREAKFAST', 'UNTIL 11' } } } },
      { from = '22:00', to = '02:00', label = 'Late night',
        pages = { { lines = { 'OPEN LATE' } } } },
    } },
}

The first slot covering the current time wins, so the list is a priority order — put the exception above the rule. When no slot covers it, the board shows its own pages, which is what it did before it had a schedule. A slot crossing midnight is written the obvious way and understood: 22:00 to 02:00 is four hours, not twenty.

An override always beats a schedule. An emergency broadcast is not something a menu board's breakfast slot should be able to interrupt.

A slot needs both times and something to show. A slot with no pages is refused rather than accepted as a way to blank a board for four hours — use SetPower for that. An existing data/signs.json carrying one from an older version loses the slot, never the sign.

Which clock

Config.Schedules.Clock:

  • 'game' (default) — the in-game clock, which is what your players experience. A GTA day is 48 real minutes, so a scheduled board changes several times an hour of real time.
  • 'real' — the server's wall clock, for a server running synced or frozen time, or one that wants slots to line up with real events. A days list (1–7, Monday first) only means anything here; GTA's day of week is not something a server owner reasons about.

Slots are evaluated on the client, so a scheduled board changing costs no network traffic at all.

Settable at runtime with SetSchedule and /sign schedule, and editable in the editor — where the slot that is live right now is marked, because otherwise a scheduled board showing something other than the message in the big box looks like a bug.

Template variables

A line may contain {name} placeholders, filled in from the sign's own variables when it draws. The point is that a caller pushes the message once and then only what changes:

SetMessage('group:highway', { 'DELAY {minutes} MIN', 'VIA {route}' })
SetVars('group:highway', { minutes = 12, route = 'ROUTE 68' })

-- later, every minute, without touching the message again:
SetVars('group:highway', { minutes = 9 })

SetVars merges, so setting one name does not wipe the others. To remove one, use ClearVars(target, { 'route' }) — there is deliberately no in-band "delete" value, because false is a perfectly good thing for a variable to be (it renders as "no") and a Lua table cannot carry a nil, so any sentinel would be ambiguous with a real value. A name that has no value is left on the board exactly as typed — a board reading DELAY {minutes} MIN is a mistake you can see and fix, where DELAY  MIN is a mystery.

Substitution happens at draw time, so the stored message stays readable and the editor shows the template rather than one frozen instant of it.

Four come from where each sign stands, with nothing to set: {street}, {cross}, {zone} and {postal}. See Street signs.

Mirroring

Mirror(target, sourceId) makes a board show whatever another board is showing — its pages, its override, its schedule, its type behavior.

Mirror('dms.cantilever_nb', 'dms.gantry_nb')
Unmirror('dms.cantilever_nb')

Nothing is copied: the mirror reads through to its source every time it draws, so the two cannot drift and setting the source sets them both. A gantry's cantilever repeating the main board is the obvious use, and it is convincing.

Variables are still the mirroring board's own, so a row of near-identical signs can share one message and each fill in its own number.

Chains are followed eight deep; a cycle stops with the board showing nothing rather than with a client that has locked up. Deleting a source releases everything mirroring it back to its own pages.

Radar speed signs

The radar_speed type reads the approaching vehicle and answers under a printed SPEED LIMIT plate. It only reads vehicles inside a cone in front of it (Config.Radar.Range and ConeDegrees), so a board does not read the traffic behind it, and it flashes once the driver is FlashOver past the limit.

Config.Radar.Unit is 'mph' or 'kmh' server-wide; a sign on a server that mixes them can carry its own:

/sign data radar.grove unit kmh
/sign data radar.grove limit 30

The plate above the screen is the reference the driver is being measured against and is there the whole time. Config.Radar.Plate.Lines is { 'SPEED', 'LIMIT' } for the US plate; Canada would be { 'MAXIMUM' }.

Exports & events

Every export takes a target as its first argument and returns how many signs it changed, so a caller can tell the difference between "did it" and "that group is empty":

TargetMeans
'vms.route68_nb'one sign by id
'group:highway'every sign tagged into that group
'all'everything
local sk = exports.sals_kewlsignage

-- content
sk:SetMessage(target, pages)
sk:Clear(target)
sk:Override(target, pages, { owner = 'my_resource', seconds = 300 })
sk:ClearOverride(target, owner)

-- lamps
sk:SetArrow(target, 'seq_right')
sk:SetLanes(target, { 'green', 'amberx', 'redx' })
sk:SetLanes(target, { 'speed:45', 'speed:45', 'redx' })   -- speed limits, 5 to 150

-- numbers and switches
sk:SetData(target, { spaces = 41 })                  -- parking counter
sk:SetData(target, { prices = { REG = '3.59' } })    -- fuel pylon
sk:SetData(target, { limit = 30 })                   -- radar / variable limit
sk:SetPower(target, true)
sk:SetBrightness(target, 0.8)
sk:SetColor(target, 'amber')

-- variables, schedules, mirroring
sk:SetVars(target, { minutes = 12 })
sk:GetVars(id)
sk:ClearVars(target, names)          -- names optional; omit for all
sk:SetSchedule(target, slots)
sk:GetSchedule(id)
sk:ClearSchedule(target)
sk:Mirror(target, sourceId)
sk:Unmirror(target)

-- placing and removing
sk:CreateSign({ id = ..., type = ..., coords = ..., heading = ..., group = ... })
sk:DeleteSign(id)

-- reading
sk:GetSign(id)
sk:ListSigns(target)        -- or no argument for everything
sk:Types()

-- the picture library
sk:AddImage({ label = 'Sprunk', url = 'https://.../sprunk.png' })
sk:RemoveImage(id)
sk:ListImages()

-- incidents: ACCIDENT AHEAD on the boards facing traffic toward the scene
sk:ReportIncident({ kind = 'accident', coords = vector3(x, y, z), ref = 'mycad:42' })
sk:ReportIncident({ text = 'caller says two car crash', postal = '123' })
sk:ClearIncident(idOrRef)
sk:ConfirmIncident(idOrRef)
sk:ListIncidents()
sk:GetIncident(idOrRef)
sk:IncidentKinds()
sk:MatchIncident(text)      -- kind, phrase: what the word list makes of it

-- moving a build between servers
sk:ExportSigns(includeStatic)
sk:ImportSigns(list, { replace = false, prefix = '', static = false })

Exports are not permission-checked. Server code is trusted by definition — if another resource can call this, it is already running on your server. Player-facing permission lives on the commands.

Events

For callers that would rather fire and forget. These are server-side events only and deliberately not net events: a client must never be able to reach them.

TriggerEvent('sals_kewlsignage:setMessage', 'group:highway', { 'FOG', 'SLOW DOWN' })
TriggerEvent('sals_kewlsignage:override', target, pages, opts)
TriggerEvent('sals_kewlsignage:clearOverride', target, owner)
TriggerEvent('sals_kewlsignage:setMode', 'group:highway', 'storm', { seconds = 1800 })
TriggerEvent('sals_kewlsignage:incident', { kind = 'accident', coords = coords, ref = 'mycad:42' })
TriggerEvent('sals_kewlsignage:clearIncident', 'mycad:42')

Alert modes, live variables, the radar hook

SetMode(target, name, { seconds }) puts every board in a target into a named look from Config.Modes — amber alert, storm, lockdown, all clear ship — as an override that beats a schedule and releases itself; ClearMode puts them back. Live variables are values every board can use in a {placeholder} with nothing pushing them: {players}, {time}, {date}, {weather}, and SetLiveVar('fuel_reg', '3.49') for the resource that knows the number. A full-color slide can carry a video link that loops behind the text, host-checked like a picture.

AddEventHandler('sals_kewlsignage:speeding', function(r)
    -- r = { sign, plate, speed, limit, unit, over, driver, model, at }
end)

A radar sign that reads a driver Config.Radar.Report.Over past the limit fires that once per driver per sign per cooldown. A client only ever reports its own vehicle and the server reads the plate itself; the speed is the trigger for a look, not a verdict.

And to listen — for a CAD bridge, a logger, or a board that mirrors another:

AddEventHandler('sals_kewlsignage:signChanged', function(id, record) end)
AddEventHandler('sals_kewlsignage:signRemoved', function(id) end)

Commands

A command that answers with a list — list, types, the help — opens a panel rather than firing one notification per row: it scrolls, it filters, you can copy out of it, and Esc closes it. Short answers stay notifications.

/signs                                  open the editor
/signtablet                             open the tablet
/sign mode <target> <mode | off> [secs]  an alert mode from Config.Modes
/sign live [name] [value | -]           live variables

/sign list                              what is placed, and its state
/sign types                             the catalog
/sign probe                             which models exist on this server
/sign perf                              what the boards are costing right now
/sign count                             what your client holds, and why a board
                                        it holds is not being drawn
/sign winding                           cycle the one-sided draw setting, live
/sign demo                              teleport to the demo field

/sign place <type> [id] [group]         drive it into position, ENTER to place
/sign move <id>                         pick an existing sign up and re-place it
/sign delete <id>
/sign here                              coords/heading block for Config.Signs
/sign perms                             what you are allowed to do, and why
/sign face <type>                       nudge a type's screen onto its prop

/sign msg <target> ROAD WORK | AHEAD    '|' splits lines
/sign clear <target>
/sign power <target> on|off
/sign arrow <target> <pattern>
/sign lanes <target> green,amberx,redx     speed:45 shows a speed limit
/sign data <target> <key> <value>
/sign override <target> <seconds> <text>
/sign release <target>

/sign vars <target>                     what this board substitutes
/sign vars <target> <name> <value>      set one ('-' drops it)
/sign schedule <target>                 the slots it runs
/sign schedule <target> add 06:00 11:00 BREAKFAST | UNTIL 11
/sign schedule <target> clear
/sign mirror <target> <source id>
/sign mirror <target> off

/sign image list                        the picture library
/sign image add <label> <url>
/sign image remove <id>

/sign export [all]                      write data/export.json
/sign import [replace] [prefix]         read it back
/sign save                              flush placed signs to disk now
/sign status                            is saving working, and to which file
/sign backup [label]                    a copy of every placed sign, kept forever
/sign backups                           what copies exist
/sign restore <which> [confirm]         put one back (adds and replaces; never deletes)

/sign designs [type]                    what each street sign type can be
/sign design <target> <design> [keep]   a street sign's design
/sign kits                              the kits in Config.Street.Kits
/sign kit <name>                        put out a whole closure, temporary
/sign temp <type> [design]              put out one temporary sign
/sign pickup [metres | all]             take temporary signs back in

/sign incident <kind> [minutes]         warn the boards ahead of where you stand
/sign incident list | kinds             what is up; the kinds and their words
/sign incident clear <id | all>         take one down (all needs full control)
/sign incident confirm <id>             a 911 waiting for confirmation goes up
/sign incident test <words>             which kind a call saying that would be
/sign roads [all]                       record the road each board stands on

Permissions

Two routes to the same capabilities, because a road crew should be able to set a board without being handed the keys to the map.

ACE is the server's own system and needs no framework, so it is the whole story on a standalone server. Jobs are the framework's, and are how a road crew gets the highway boards because they are the road crew rather than because somebody edited server.cfg.

One ACE is enough for most servers, and it carries everything:

add_ace group.admin sals_kewlsignage.admin allow

The seven capabilities

Each has an ACE of its own in Config.Access.Aces, so a server with no job system can hand out exactly as much as it means to. Full control implies all seven.

ACECarries
sals_kewlsignage.messagechange what any sign says; open the editor and the tablet
sals_kewlsignage.placeplace, move, duplicate, regroup, mirror, schedule, housing, and what a permanent street sign is
sals_kewlsignage.deleteremove a sign
sals_kewlsignage.imagesthe picture library: upload, link, rename, remove
sals_kewlsignage.toolsface, demo, perf, live, Go to, the health tab
sals_kewlsignage.dataexport, import, save
sals_kewlsignage.roadworktemporary street signs only: kit, temp, pickup, and reporting incidents; on-duty jobs in Config.Street.Jobs hold it with no ACE

place and delete are separate on purpose: a crew that builds out a work zone need not be a crew that can erase one. Grant them to a group, or to one person by identifier:

add_principal identifier.license:abc123... group.signcrew
add_ace group.signcrew sals_kewlsignage.place   allow
add_ace group.signcrew sals_kewlsignage.message allow

ACE names are matched by dotted prefix. add_ace group.admin sals_kewlsignage allow grants all seven at once — the parent, not the siblings. Granting .admin does not grant .place through the ACE system; it grants it because this resource treats full control as implying everything.

Scoped grants, without a job system

A group tag or a sign id on the end of a prefix grants the message capability for those boards and nothing else — the ACE shape of police = { 'highway' }.

add_ace group.dot    sals_kewlsignage.group.highway  allow
add_ace group.burger sals_kewlsignage.sign.bs_menu_1 allow

A holder sees only those boards on the tablet and is refused everywhere else. One ACE per scope, and no list to keep in sync in config.lua. The prefixes are Config.Access.GroupAcePrefix and SignAcePrefix. This is how a standalone server runs a road crew and a restaurant off the same install.

Place and delete can be scoped to a group too: the capability's own ACE with .group.<tag> on the end.

add_ace group.dot sals_kewlsignage.place.group.roadwork  allow
add_ace group.dot sals_kewlsignage.delete.group.roadwork allow

That crew may put up, move, copy and take down the roadwork group's signs and no others. The plain sals_kewlsignage.place still means every sign, and whoever may build or clear a group may also change what its signs say.

Two tiers: what a sign says, and the sign itself

TierCapabilityWhat it covers
What it saysmessagewords, pages, the arrow, lane signals and speed limits, alert modes, timed messages, power, brightness, lamp color
The sign itselfplaceputting one up, moving it, copying it, its group, its road, its schedule, what it mirrors, what it is set into, and what a permanent street sign is (a STOP sign into a SPEED LIMIT)
deletetaking one down

So "police can change the messages and the arrows, but not touch the hardware" is police with message and nothing else, which is what a job gets by default.

Jobs

Config.Access = {
    AcePermission = 'sals_kewlsignage.admin',
    Jobs = {
        police     = { 'highway', 'traffic' },  -- message only these groups
        sheriff    = '*',                       -- message every sign

        -- named capabilities: each one true / '*' for every sign,
        -- a group tag, or a list of group tags
        dot = {
            message = '*',                        -- run every board
            place   = { 'highway', 'roadwork' },  -- build and move these
            delete  = 'roadwork',                 -- take these down
        },
        burgershot = { place = 'burgershot', delete = 'burgershot' },
    },
    RequireOnDuty = true,
}

A job can be given message, place, delete and images; tools and data stay ACE-only. A misspelled capability grants nothing, and the console names it at boot. Place or delete includes message on the same groups, so the burger stand above may also write its own menu.

A crew limited to some groups builds inside them. A sign it places goes into its group (its first one when it names none); placing into, or regrouping into, anyone else's group is refused. A sign with no group belongs to nobody's group, so give every sign a crew should own a group.

An admin can also hand one sign to a job with Jobs allowed, next to the group in the editor or on the tablet (message only), which works with nothing in config at all. The editor and the tablet list only what the player may reach, and the server refuses a save, a release or a /sign subcommand that reaches any other sign, including through all or a group tag.

RequireOnDuty has no effect on a standalone server: with no framework to ask, everyone counts as on duty.

Which command needs what

CapabilitySubcommands
placeplace, move, mirror, housing, checked against the sign's group
deletedelete, checked against the sign's group
toolsface, demo, live
dataexport, import, save
messageeverything else that changes a board, checked again per sign
message or toolsprobe, perf, count, winding, here
nothinglist, types, help, perms

Checking what you have

/sign perms prints what the asking player holds, which ACE each capability arrived through, and which groups and signs are in reach. Open to everyone, because it reports on the caller and nobody else — and it is the way to tell an ACE that was never granted from one granted under a different name.

--- Chris --- framework: standalone ---
  role          sign crew
  place         yes, through sals_kewlsignage.place
  message       yes, through a job or a scoped ACE
  sign groups   highway
  grant more with: add_ace group.<name> sals_kewlsignage.admin allow

On a standalone server

  • The editor and the tablet are sent each capability separately, so they offer what you hold rather than what an admin holds. A crew with place and no delete gets the move button and not the delete button.
  • The tablet badge shows the role your ACEs add up to — signage admin, sign crew, sign operator — instead of the framework fallback's unemployed (Config.Access.ShowAceRole).
  • Jobs allowed is hidden: with no framework there is no job to name, and a scoped ACE does the same thing.
  • A message preset takes ace = '...' as well as jobs = { ... }, and either one matching is enough.
  • The tablet item works with ox_inventory; with no recognized inventory the item check fails open, because locking every player out of the tablet is a worse failure than a missed item check.

Audit log

Who changed what, and when. With a job-level permission tier this is the difference between "somebody put something rude on the billboard" being a question and being an answer; and when a board is showing the wrong thing, the first useful fact is whether a person or a resource put it there.

Config.Audit has three sinks, independently switchable:

  • The server console — off by default, because it is noisy on a busy server.
  • A file, data/audit.log.
  • A Discord webhook — the one that actually gets read.
Config.Audit = {
    Enabled = true,
    Console = false,
    File = 'data/audit.log',
    Webhook = 'https://discord.com/api/webhooks/...',
    LogContent = true, LogPlacement = true, LogImages = true,
    LogExports = false,
    Ignore = { 'my_dispatch' },
}

Entries name the player with their license identifier, so the log is still useful after they have left and their server id has been reused. Calls from other resources are not logged by default: they are machine traffic and can be constant. Ignore drops entries from named override owners, for the dispatch resource that cycles a board every few seconds.

The file is rewritten rather than appended — there is no append native — so it is flushed on a timer, and when it passes MaxFileKilobytes the contents move to audit.log.1 and it starts again. That is one generation of history; point the webhook at something that keeps more if you need it.

Rate limits

Everything a client can ask the server to do is capped per player in Config.Limits. None of the limits are reachable by anyone playing normally — they exist so one client in a loop cannot make the server work on its behalf.

The two that matter are StateRequests, whose answer is the whole sign registry plus the image library including thumbnails, and Uploads, whose request carries a few hundred kilobytes.

Each setting is { how many, per how many seconds }. The first time a player trips a limit the console says so once; further refusals are counted rather than printed, so the log cannot itself be used to flood you. /sign perf, run by an admin, lists who has been refused and how often.

HTTP control

Optional and off by default, so a CAD, a Discord bot or a website can put a message on a board without anything running inside FiveM. It refuses to listen without a token — an open endpoint that rewrites every sign on the map is not a feature.

Routes, all POST with the token in the body: /message, /release, /power, /mode, /modes, /vars, /live, /status, /incident ({ kind | text, coords | postal, road, seconds, ref }, or { clear: id | ref }) and /incidents. A Discord bot ships in integrations/discord-bot/ with /sign message, /sign alert, /sign status and friends driving them, with role gating; its README has the bodies and the setup.

-- server.cfg
set sals_kewlsignage_http_token "a-long-random-string"

-- config.lua
Config.Http = { Enabled = true, TokenConvar = 'sals_kewlsignage_http_token' }
POST http://your-server:30120/sals_kewlsignage/message
{ "token": "...",
  "target": "group:highway",
  "pages": [ { "lines": ["AMBER ALERT", "BLU SEDAN"] } ],
  "seconds": 300 }

With seconds it is an override that releases itself. Without, it replaces what the board says.

Backup, export & import

Placed signs live in data/signs.json and pictures in data/images/. Writes are batched a few seconds after the first change, so a dispatch resource hammering a board does not hammer the disk; /sign save flushes immediately, and so does stopping the resource.

The file is guarded: it is never written until it has been read in the current boot, a save that would lose signs nobody deleted is refused, every write is read back, and a file that will not parse is set aside rather than replaced. When a save does fail, every player online who can place signs is told in the game, in red, and anyone who places or edits a sign while saving is broken is told on the spot that it will not survive a restart. /sign status reports where the file is on disk, whether it was read this boot, what the last save did and which copies exist.

Copies kept for you

Beside the file, and never deleted by anything in this resource:

signs.json.bak                 before the last save        /sign restore bak
signs.json.1  .2  .3           the last three boots        /sign restore 1
signs-daily-YYYYMMDD.json      one per day it saved on     /sign restore daily-20261025
signs-backup-<stamp>.json     what /sign backup wrote     /sign restore latest

/sign backups lists them. A restore adds and replaces by id and never deletes a sign that is on the map but not in the copy. Without confirm it only reports the numbers; with it, it backs up the map as it stands first. Run /sign backup before-update before every update.

To move a build between servers:

/sign export            -- writes data/export.json (placed signs)
/sign export all        -- and the config signs too

/sign import                    -- skips ids that already exist
/sign import replace            -- overwrites them
/sign import replace venue.     -- and puts 'venue.' in front of every id

The export is in the same shape Config.Signs takes, so you can paste it into a config file as easily as import it. A prefix lets a build come in alongside one already using those ids, and a mirror inside an imported build points at the imported copy of its source rather than at whatever happens to hold that id already.

Validation is all or nothing: a list with one bad record imports nothing and tells you which ones failed, because half a map is worse than none of it.

Performance

/sign perf reports what the boards are actually costing: boards drawing, triangles this frame, the peak, how many are at reduced detail, and how many browser pages the full-color boards are using.

Four things keep it cheap, and they matter more than the drawing itself:

  • Nothing allocates in the render loop.
  • Lamp vertices are computed once into a flat buffer and replayed until something actually changes.
  • Boards outside the camera frustum are rejected by one dot product.
  • A hard triangle budget per frame, spent nearest board first — and spent on detail, not on existence. A board that does not fit at full detail draws at low detail rather than vanishing, because a board that disappears as you walk toward it is worse than any amount of simplification.

The dials

SettingDefaultWhat it does
TriangleBudget8000Triangles per frame the boards aim to stay under. A ceiling, not a cost.
DrawDistance220 mPast this a board's content is not drawn. The prop stays.
DotDistance45 mInside this, individual lamps; outside, merged strokes.
MaxDrawn16Never render more than this many boards' content at once.
RoundLampstrueRound lenses instead of squares. Four times the triangles per lit lamp.
DrawUnlitLampstrueThe dark lens grid. The most expensive thing a small board can do.
Winding'both'Set this properly — see above. It halves the cost of everything.
Config.Dui.MaxSurfaces6Browser pages shared by the full-color boards in view.
Config.Dui.SurfaceSize1024Pixels per side of each surface. 2048 is four times the memory.

The demo field, with every rig in one view, is the worst case you will ever see. Run /sign perf there.

Models

Nineteen models ship in stream/, one per type that has hardware, with the .ytyp that declares them — about 600 KB in all. They are generated from the catalog's own face and plate numbers, so the recess on the model and the screen the renderer draws cannot drift apart. Each has two LODs and box collision. stream/MODELS.md in the resource says how the pack is built and how to replace any model with your own.

To swap a type onto a prop you already have, or a model of your own:

Config.Models = {
    UsePack = true,
    Collision = true,                  -- players and cars hit the hardware
    Overrides = { billboard = 'prop_billboard_01' },
    Faces = { billboard = { offset = vector3(0.0, 0.30, 8.40),
                            width = 14.60, height = 4.30 } },
    Yaw   = { billboard = 180.0 },     -- for a prop modeled facing its own -Y
    Scale = { radar_speed = 1.5 },     -- fallback rigs only
}

Do not guess the face. Stand in front of a board, run /sign face <type>, nudge the screen onto the prop with the arrow keys and PgUp/PgDn, then press Enter and paste the line it prints.

Troubleshooting

The screens are invisible, or the rigs look inside out

The winding setting is wrong. Run /sign winding until they look right and paste the letter into Config.Render.Winding. On 'both' screens show but boxes look hollow — that is for finding out, not for keeping.

A board is floating, or sunk into the ground

coords is the base of the sign, not the screen. Use /sign move <id> and R to snap it to the ground, or nudge the z.

/sign probe says MISSING

A shipped model did not stream. Check stream/ is intact — nineteen .ydr files and salskewl_signage.ytyp — and that the data_file line is still in fxmanifest.lua. For an override, the prop named in Config.Models.Overrides is not on this server. DRAWN means Config.Models.UsePack is off.

A full-color board is showing amber lamps

It has not been given a browser page yet — the pool goes to the nearest boards first. If it never gets one, raise Config.Dui.MaxSurfaces. If every full-color board shows lamps, the console will say this client build has no DrawTexturedPoly native.

Placed signs vanish on restart

Run /sign status. Read at boot: NO means something failed before the file could be read (the boot console names the stage); saving is refused until the next clean boot so nothing is lost. FAILED: write failed means the server cannot write to data/ — on Linux, usually a folder owned by a different user than the one running FXServer; until it is fixed the signs are kept at signs.json in the resource root. The file and memory DISAGREE means something else is writing the file: a second instance on the same folder, or a host that redeploys the resource on restart. In every case /sign backups lists the copies to restore from.

A pasted picture is refused

Check the size against Config.Images.MaxKilobytes and the count against MaxCount. If it was a link, see linked pictures — the host allowlist ships empty.

A scheduled board is not showing what I typed in the message box

A schedule slot has taken over. The editor marks the live slot. Remember that on the in-game clock a GTA day is 48 real minutes, so slots come round far faster than you might expect.

A board reads DELAY {minutes} MIN

That variable has no value set. This is deliberate — a placeholder left visible is a mistake you can find, where a silent gap is not. Set it with /sign vars or in the editor.

Upgrading to 1.6.0

One default changed in a way that can stop something working.

Linked pictures are now refused unless their host is allowed. Config.Images.AllowedHosts ships empty, which means uploads only. If you use linked pictures, run /sign image list to see what you are using and add those hosts, or set AllowedHosts = { '*' } to keep the old behavior. Uploaded pictures are unaffected. Deleting the key entirely also keeps the old behavior, for a server that upgrades without reading this.

Everything else is additive or a fix. Worth knowing:

  • Config.Demo.Enabled now ships true, so a fresh install can run /sign demo. Your existing config.lua is untouched.
  • /sign demo now needs the admin permission — it teleports you, and it used to be reachable with the message permission.
  • Full-color surfaces are now square and interchangeable (Config.Dui.SurfaceSize). Previously a pool that filled with billboard-shaped pages had nothing to give a menu board, which then rendered as an amber matrix board for the rest of the session. No config change needed.
  • MaxLineLength now counts characters rather than bytes, so accented text gets its full line. Lines on non-English servers will get longer, not shorter.

Support

Questions, bug reports and feature requests: the Discord. Include your server's framework, the resource version from fxmanifest.lua, and the output of /sign probe and /sign perf — between them they answer most of what anyone would ask first.

The resource's own README.md ships in the download and is the source of truth; this manual is the same content organized for reading in a browser.

Didn’t find it? Ask Squawky, or open a ticket on Discord and tell us what you already tried.