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.
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
- Drop the folder into
resources/. - Add
ensure sals_kewlsignagetoserver.cfg. - Give yourself permission:
add_ace group.admin sals_kewlsignage.admin allow - 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. - 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 instream/. MISSING means a model did not stream; DRAWN meansConfig.Models.UsePackis off and the type is on its fallback rig. - 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.
| Plate | type | What it is | Backend |
|---|---|---|---|
| SKS-101 | vms_trailer | Portable message board on a solar trailer | matrix |
| SKS-102 | arrow_trailer | Sequential arrow board | lamps |
| SKS-103 | dms_gantry | Full-span overhead gantry, with lane heads | matrix |
| SKS-104 | dms_cantilever | Half-span cantilever arm | matrix |
| SKS-105 | lcs_head | Single lane control signal | lamps |
| SKS-106 | radar_speed | Radar speed feedback sign | matrix |
| SKS-107 | vsl_roundel | Variable speed limit with zone beacons | matrix |
| SKS-108 | lcs_bracket | Lane control signal with no post, on a wall bracket | lamps |
| SKS-201 | billboard | Digital billboard, full color | dui |
| SKS-202 | fuel_pylon | Fuel price pylon, per grade | matrix |
| SKS-203 | ticker | Facade ticker strip, scrolling | matrix |
| SKS-204 | aframe | Sidewalk A-frame | matrix |
| SKS-205 | menu_board | Drive-thru menu board, full color | dui |
| SKS-301 | parking_count | Parking space counter | matrix |
| SKS-302 | transit_panel | Transit arrivals panel | matrix |
| SKS-303 | marquee | Venue marquee with chasing bulbs | matrix |
| SKS-401 | yard_sign | Yard sign on a wire H-stake, printed | dui |
| SKS-402 | realty_post | Real estate post sign with a rider, printed | dui |
| SKS-403 | timber_sign | Timber business sign in a frame, printed | dui |
| SKS-404 | banner_frame | Vinyl banner on a scaffold frame, printed | dui |
| SKS-501 | wall_panel | Panel mounted flat on a building, printed | dui |
| SKS-502 | wall_banner | Long banner mounted flat on a building, printed | dui |
| SKS-503 | facade_board | Illuminated facade or crown sign | dui |
| SKS-601 | road_sign | Road sign on a post: STOP, YIELD, SPEED LIMIT, warning, guide, postal | street |
| SKS-602 | street_blade | Street name blades at a corner, with the postal code | street |
| SKS-603 | work_stand | Roll-up work-zone sign on a tripod, with flags | street |
| SKS-604 | barricade | Type III barricade with a closure panel and warning lamps | street |
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.Jobsand 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:
| Key | Does |
|---|---|
| W A S D | Move |
| Q / E | Up and down |
| Scroll | Turn |
| Arrow keys | Fine adjust |
| Space | Snap to 90° |
| R | Snap to the ground |
| Shift | Move faster |
| Enter | Place it |
| Backspace | Cancel |
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.
| Key | Does |
|---|---|
| Aim | The panel follows your crosshair, flat on the wall under it |
| E | Pin it, so it stops following |
| W A S D | Nudge it in the plane of the wall |
| Scroll | Width — and height with it, while the aspect is locked |
| Arrow keys | Height |
| R | Lock or free the aspect |
| Space | Square the heading to the nearest 90° |
| Shift | Faster |
| Enter | Place it |
| Backspace | Cancel |
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.
| They | Because |
|---|---|
| Do not glow | The 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 lamps | Every 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.type | What the face is — the backend, and what drives it |
sign.housing | What 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
| Plate | housing | What it is | Panel |
|---|---|---|---|
| SKH-101 | boulder | Engraved boulder | 1.70 × 0.80 m |
| SKH-102 | stone_low | Low stone wall | 2.60 × 1.00 m |
| SKH-103 | masonry_piers | Masonry piers and panel | 2.40 × 1.20 m |
| SKH-104 | brick_monument | Brick monument | 2.20 × 1.05 m |
| SKH-105 | slate_plaque | Slate plaque | 1.30 × 0.78 m |
| SKH-106 | timber_stone | Timber header on stone piers | 2.20 × 1.10 m |
| SKH-107 | stone_pylon | Stone-clad pylon | 1.80 × 2.20 m |
| SKH-108 | brushed_bezel | Brushed metal bezel | 2.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.

/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
| Type | Designs |
|---|---|
road_sign | speed_limit, stop, all_way, yield, do_not_enter, one_way_left, one_way_right, no_parking, regulatory, warning, school, guide, recreation, postal |
work_stand | road_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 |
barricade | road_closed, road_closed_thru, local_traffic, closure, detour_left, detour_right |
street_blade | blade_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 finds10 50. - A phrase matches from the start of a word:
'crash'findscrashed, but'tc'is not found insideetc. - The longest phrase that matches wins, so “crashed and the car is on fire” is a vehicle fire.
- Anything from
Ignorein a call means it lights nothing. - A kind with no list is only reported by hand.
police_activityships 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. Adayslist (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":
| Target | Means |
|---|---|
'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.
| ACE | Carries |
|---|---|
sals_kewlsignage.message | change what any sign says; open the editor and the tablet |
sals_kewlsignage.place | place, move, duplicate, regroup, mirror, schedule, housing, and what a permanent street sign is |
sals_kewlsignage.delete | remove a sign |
sals_kewlsignage.images | the picture library: upload, link, rename, remove |
sals_kewlsignage.tools | face, demo, perf, live, Go to, the health tab |
sals_kewlsignage.data | export, import, save |
sals_kewlsignage.roadwork | temporary 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
| Tier | Capability | What it covers |
|---|---|---|
| What it says | message | words, pages, the arrow, lane signals and speed limits, alert modes, timed messages, power, brightness, lamp color |
| The sign itself | place | putting 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) |
delete | taking 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
| Capability | Subcommands |
|---|---|
place | place, move, mirror, housing, checked against the sign's group |
delete | delete, checked against the sign's group |
tools | face, demo, live |
data | export, import, save |
message | everything else that changes a board, checked again per sign |
message or tools | probe, perf, count, winding, here |
| nothing | list, 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
placeand nodeletegets 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 asjobs = { ... }, 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
| Setting | Default | What it does |
|---|---|---|
TriangleBudget | 8000 | Triangles per frame the boards aim to stay under. A ceiling, not a cost. |
DrawDistance | 220 m | Past this a board's content is not drawn. The prop stays. |
DotDistance | 45 m | Inside this, individual lamps; outside, merged strokes. |
MaxDrawn | 16 | Never render more than this many boards' content at once. |
RoundLamps | true | Round lenses instead of squares. Four times the triangles per lit lamp. |
DrawUnlitLamps | true | The 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.MaxSurfaces | 6 | Browser pages shared by the full-color boards in view. |
Config.Dui.SurfaceSize | 1024 | Pixels 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.Enablednow ships true, so a fresh install can run/sign demo. Your existingconfig.luais untouched./sign demonow 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. MaxLineLengthnow 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.