A complete organization and gang management system on an in-game tablet - members, ranks, permissions, treasury, reputation, heat, businesses, territories, relations, outfits and a full admin panel. Open source (GPL-3.0), one auto-detected framework, no per-framework build.

gs_organizations gives every gang and organization on your server a single tablet panel to run itself from. Leadership manages members and ranks with a per-permission editor, runs a server-validated treasury with per-level bank limits and full transaction history, and tracks reputation, levels and heat. Businesses, territories and drug statistics are kept as registries and exposed to your other resources through ~35 server exports, so gs_organizations complements your existing drug, turf and heist scripts rather than replacing them. Organizations declare alliances and rivalries with a cooldown and war log, post on-screen announcements, chat internally and share gang outfits. Players apply to join with /gangapply, gated on tracked playtime and reviewed in an admin panel with an audit log.

Everything that moves money or changes membership is decided on the server; the client only ever sends an intent. Player-typed names, ranks, messages and notes are made markup-inert on the server and escaped in the UI. Administration is an explicit ACE grant, deliberately separate from general staff.

Runs on Qbox, QBCore and ESX through the shared Greasy Scripts framework bridge - the framework and the notification resource are auto-detected. It uses no inventory or target resource and needs no items; the panel opens from a command or keybind. Ships full, readable source.

Features

• Members, invites, ranks and per-permission editing; leadership transfer; member notes
• Server-validated treasury with per-level limits and transaction history
• Reputation, levels, reputation graph, heat with decay and tiers
• Business, territory and drug registries with ~35 server exports
• Inter-organization relations (alliances/rivalries) with cooldown and war log
• Announcements, internal org chat, gang outfits
• Recruitment applications gated on tracked playtime, admin panel with audit log
• Auto table creation; idempotent SQL provided; optional Discord webhook logging (off by default)
• Optional framework-gang mirror that syncs the framework's own gang field to membership
• Qbox, QBCore and ESX via one auto-detected bridge

Requirements

ox_lib, oxmysql, and one of qbx_core / qb-core / es_extended. Notifications are auto-detected (ox_lib / qb / esx_notify); no inventory or target resource is required.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Open-source (GPL-3.0), server-authoritative FiveM anti-cheat with an evidence-based staff panel and admin command centre — auto-detects Qbox, QBCore and ESX, full readable source, no escrow.

Greasy Scripts Anti-Cheat runs every detection on the server — movement (teleport, no-clip, fly, speed, super-jump), godmode, invisibility, weapons and aim (silent-aim, aim-suspicion scoring), entities and explosions, economy reconciliation, event protection (honeypots, rate limits, remote-control), and resource integrity plus a heartbeat. The client only sends context the server treats as hints, never as proof, so an unverifiable value is never turned into a false positive.

Detections feed a suspicion score and evidence cases (with optional screenshot bursts). Staff review cases in a clean NUI panel — live threats, players, cases, bans, staff/roles — and an admin command centre (revive/heal, teleports, spectate, freeze, worlds/routing buckets, weather/time, player editor, items, self tools). Every action is permission-checked on the server by ACE ranks and per-feature levels. Every player-influenced string (names, report reasons, notes, warnings, announcements) is made markup-inert server-side, so a player name or a /report reason can never inject markup into a staff member's chat or panel.

Ships in observe mode: it detects, alerts and opens cases but never kicks or bans on its own until you turn on Config.AutoPunish. Persists to your database via oxmysql (table created on start) or to data/*.json when no database is present. Everything runs through the shared Greasy Scripts framework bridge, so one build covers Qbox, QBCore, ESX and standalone.

Features

• Server-authoritative movement, godmode, weapon, aim, entity, explosion, event and integrity detection
• Suspicion scoring, evidence cases, optional screenshot bursts, staff-approved bans (matches every identifier + hardware tokens, enforced at connect)
• Player /report command that opens a low-priority case and alerts staff
• NUI staff panel + admin command centre, all permission-checked server-side (ACE ranks + per-feature levels)
• All player-influenced text made markup-inert server-side (bridge safeText) with NUI escaping on top
• Observe mode by default; opt-in automatic punishment
• Qbox / QBCore / ESX auto-detection through the shared bridge; standalone supported with reduced coverage
• oxmysql persistence with JSON fallback; fully commented config split (config/shared.lua / config/server.lua); ox_lib locales
• Server exports for integrations: Authorize, IsAuthorized, Validate, Report, FileReport, GetRisk, GetRank, HasPermission, IsBanned, SetState
• Open source, GPL-3.0 — full readable source, nothing encrypted, no escrow

Requirements

• ox_lib (only hard dependency)
• One framework, auto-detected: Qbox, QBCore or ESX (standalone also runs, with reduced coverage)
• oxmysql — optional; used for case/ban persistence when present, JSON fallback otherwise
• Inventories/targets: framework-agnostic through the bridge (ox_inventory, qb-inventory, ESX; ox_target / qb-target). The anti-cheat itself needs no specific inventory or target
• Optional: screencapture / screenshot-basic (case screenshots / recordings), pma-voice, a clothing resource, qbx_medical / esx_ambulancejob (panel revive)

Install

1. Drop the gs_anticheat folder in your resources and ensure gs_anticheat after ox_lib and your framework.
2. Optional: import install/gs_anticheat.sql (the resource also creates the table on start if you skip it).
3. Grant a staff rank in config/shared.lua (Config.Ranks / ACE) so you can open the panel (default F10 or /anticheat).
4. Review config/shared.lua thresholds; keep Config.AutoPunish = false until you trust them. Put webhooks/secrets in config/server.lua.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Turn the bank branches and cash machines already on the map into a working retail bank, with free accounts, debit cards with hashed PINs, deposits, withdrawals and statements on your framework's own cash and bank balances.

gs_banking works on top of the cash and bank balances your framework already has, so there is nothing to migrate. Characters open a free account at a bank counter, receive a debit card as an inventory item and choose a 4-digit PIN. They pay cash in or take it out at any counter or at any base-game cash machine, check their balance and read a paged statement of their bank movements.

gs_banking moves money only between one character's own cash and their own bank balance. It does not do transfers between players, shared or society accounts, interest or loans.

Built to be careful with in-game money:

• The server decides every fee and limit, checks every amount, measures distance from the player's own ped and rate-limits every request. Timed actions run in two phases, and a finish that arrives too early is refused.
• Every two-leg money move writes an operations row before the first leg. Replays are refused, a failed credit is reversed, and a console command lists anything a server crash left unsettled.
• PINs are stored as HMAC-SHA256 with a per-card salt under a server-only pepper convar. Wrong PINs lock the card. A machine only serves the account of the player standing at it, with that player's own PIN, so a found card is useless to anyone else. Without a real pepper, card features stay off; the install placeholder is refused.
• Cash machines are map props, which the server cannot see, so the client names the machine and the server checks the model and the player's distance to it. For full enforcement, fill the optional list of machine positions: the server prints a ready-to-paste line for each machine while debug mode is on.

Works on Qbox, QBCore and ESX through the embedded Greasy Scripts bridge, with ox_inventory, qb-inventory or the ESX built-in inventory, and ox_target, qb-target or a built-in prompt. Tables are created automatically, and every player-facing string is in one locale file.

Features

• Counters at base-game bank branches with local teller peds, map blips and target options (example positions; check them on your own map)
• Every base-game cash machine model through your target resource
• Free accounts with account numbers, one per character
• Debit card item with a 4-digit PIN, weak-PIN rules, wrong-PIN lock, PIN reset at a counter and paid replacement cards (the old card stops working)
• Deposits and withdrawals at counters and cash machines, with separate limits
• Fast cash buttons, machine fees with fee-free machine models, a daily machine withdrawal limit
• Per-character credit window to stay below anticheat economy limits
• Optional server-side list of real cash machine positions
• Paged statement at the counter and a mini statement at the machine, built from the framework's own money events while the player is online
• Downed players cannot bank (dead ped, configurable state bags, Qbox/QBCore last-stand metadata, or your own server-side check)
• Server exports: balances, statement, statement notes, account check
• Server events for deposits, withdrawals and suspicious requests
• Console command for unsettled operations
• Automatic table creation plus an install SQL file
• Item entries for ox_inventory, qb-inventory and ESX, with original item art
• English locale for notifications and the whole interface

Requirements

• ox_lib
• oxmysql
• OneSync
• One framework: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended), detected automatically
• An inventory for the card item: ox_inventory (any of the three frameworks), qb-inventory (QBCore) or the ESX built-in inventory
• Optional: ox_target or qb-target (a built-in [E] prompt is used otherwise)

Install

1. Drop the gs_banking folder into your resources.
2. Add the gs_bank_card item from install/items for your inventory and copy the image.
3. Add a server-only pepper to server.cfg: set gs_banking_pin_pepper "" (use set, never setr).
4. Optional: import install/gs_banking.sql (tables are also created on start).
5. ensure gs_banking after ox_lib, oxmysql, your framework, inventory and target.
6. Check the example counter positions on your map. Optionally fill the cash machine position list.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

A server-authoritative casino floor in the base-game casino interior: memberships, a chip cage, slot machines, blackjack and a daily lucky wheel for Qbox, QBCore and ESX.

gs_casino turns the base-game casino interior into a working gaming floor. Players walk through the doors, sign up for a membership at the casino desk, buy chips at the cage and play slot machines on the interior's own machines, blackjack against the house and a free daily lucky wheel.

Every draw, paytable, limit and payout lives on the server. The client only ever says which stake or chip bundle it picked from the server's own list; it never sends an amount or a result. Slot reels and wheel segments are drawn by the server before the animation starts, the dealer's hole card never leaves the server until the hand is over, and the resource computes the exact return of your slot paytable on start and keeps the machines closed if it is above your limit.

Every round is a database row. Each payout part is written with an idempotency key before it is credited, start-up recovery pays spins a restart interrupted and voids blackjack hands it cut off, and a payout that may have been in flight goes to a review list instead of being paid again, so no win is ever paid twice. A player who wins and logs off is paid automatically at their next login. The one gap: if the server crashes in the instant between taking a stake (or charging for chips at the cage) and recording it, that single stake or purchase is not recorded.

Choose what players gamble with: casino chips (an inventory item, bought and cashed out at the cage, with an optional house spread), framework cash, or framework bank. Hourly and daily loss and winnings limits per character keep the economy under control. Everything is configurable in commented Lua files, every text is in a locale file, and the tables are created automatically.

Features

• Doors on the street and inside the interior, moved and validated by the server; downed and restrained players are refused
• Casino desk: memberships (cash or card) and a chip cage (buy with cash or card, cash out)
• Currency modes: chips item, cash or bank
• Slot machines on the interior's machines with a server paytable and a start-up return check
• Blackjack: six-deck shoe, dealer stands on soft 17, 3:2 blackjack, double on any two cards
• Free daily lucky wheel for members with 20 weighted segments
• Hourly and daily loss and winnings limits, plus a payout window
• Recorded rounds with idempotency keys and start-up recovery; no win is paid twice
• Owed payouts for players who log off, paid at their next login
• Console command listing rounds and credits that need a person
• NUI game panel, ox_lib desk menus and progress bars
• ox_target, qb-target or a built-in prompt; ox_inventory, qb-inventory or ESX inventory
• Exports and server events for your own resources; hooks for anticheat, police and ambulance resources
• English locale file; tables created automatically, SQL file included

Good to know

• Blackjack has no split and no insurance.
• Door and wheel positions are example defaults for the base-game casino; walk them on your server once.
• Players sit at slot machine stools and blackjack seats where the interior provides them, and play standing otherwise.
• ESX: es_extended has no server-side downed state. A dead ped is always refused; a medical resource that keeps downed players alive needs its state bag key or a one-line hook in the config.

Requirements

• OneSync
• ox_lib and oxmysql
• Qbox, QBCore or ESX (auto-detected)
• An IPL loader for the casino interior, such as bob74_ipl (the resource starts without it and keeps the floor closed until it runs)
• Chips mode: the included chip item registered in your inventory (ox_inventory, qb-inventory and ESX entries and an image are included)
• Optional: ox_target or qb-target (a built-in prompt is used without one)

Install

1. Drop gs_casino into your resources folder.
2. Register the chip item from install/items (or set the currency to cash or bank).
3. ensure gs_casino after ox_lib, oxmysql, your framework, inventory, target and IPL loader.
4. Optional: import install/gs_casino.sql (the tables are also created automatically).
5. Adjust config/shared.lua and config/server.lua, and walk the door and wheel positions once.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

A server-authoritative vehicle dealership with a turntable showroom, timed test drives, purchases written to your framework's own vehicle table, and hourly rental desks.

gs_dealership turns the base-game dealership showroom into a working vehicle shop. Players walk up to the consultant, browse 202 base-game vehicles by category, watch their pick spin on a turntable in the paint they choose, then book a timed test drive or sign for the car.

Every price, fee, deposit and time limit is decided by the server; the client only names a model, a paint and an account. A sale is recorded before any money moves, so a replayed request never charges twice. A failed registration is refunded exactly once, a refund owed to an offline character is paid when they next log in, and a sale a server crash left unfinished is parked for staff review instead of being guessed. Bought vehicles go into your framework's vehicle table (player_vehicles on Qbox and QBCore, through qbx_vehicles when it runs; owned_vehicles on ESX) and are either brought round to the lot with the keys or parked in a garage.

Test drives use trade plates, a timer, reminders, a grace period, a server-side distance leash and automatic recovery. Three example rental desks rent bikes, scooters and everyday cars by the hour against a refundable deposit, less damage, missing fuel and late fees.

Job scripts can create salesperson offers through an export: the buyer accepts in their own window, the seller must be on duty and nearby, and commission is paid automatically.

The framework, inventory, target and notification resources are detected automatically through the embedded Greasy Scripts bridge.

Features

• Showroom with consultant ped, floor display cars, category catalogue, turntable preview camera and paint swatches
• 202 base-game vehicles with editable prices; rows for newer game updates hide themselves on older game builds; add-on rows that only list while their stream resource runs
• Purchases registered to player_vehicles / owned_vehicles with unique plates (qbx_vehicles on Qbox)
• Delivery to the lot with keys, or into a garage (optional gs_garages integration), with a garage fallback when the bays are blocked
• Idempotent sales, one-time refunds, offline refunds paid at login, crash rows parked for review
• Category gates for returning customers, daily purchase cap, bank-only or cash with a limit
• Timed test drives with trade plates, reminders, grace period, distance leash and auto recovery
• Hourly rental desks with deposits, late fees and a return at any desk
• Salesperson offers with buyer consent and commission; catalogue, price, sale and rental exports
• ox_target, qb-target or a built-in [E] prompt; ox_lib / qb / esx notifications; fully translatable interface
• Tables created automatically; SQL file included; no inventory items needed

Requirements

• OneSync
• ox_lib, oxmysql
• One framework: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended)
• The framework's vehicle table for purchases (player_vehicles or owned_vehicles); without it the showroom still offers browsing, test drives and rentals
• Game build 3095 or newer recommended (sv_enforceGameBuild) for the full catalogue; 35 rows are hidden on older builds
• Inventories: none needed. The bridge supports ox_inventory, qb-inventory and the ESX built-in inventory, but this product uses no items
• Targets: ox_target or qb-target (optional; a built-in [E] prompt is used without them)
• Optional: a vehicle keys resource (qbx_vehiclekeys, qb-vehiclekeys or your own hook), a fuel resource (ox_fuel, LegacyFuel, cdn-fuel, ps-fuel), gs_garages, esx_license

Install

1. Drop the gs_dealership folder into your resources.
2. Optionally import install/gs_dealership.sql (the tables are also created on start).
3. ensure gs_dealership after your framework, ox_lib, oxmysql and your target, key, fuel and garage resources.
4. Set ServerConfig.Delivery.garage to a garage id your garage script knows.
5. Walk the example positions in config/shared.lua on your map and adjust them.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

A dispatch system the server controls: a duty board, unit statuses, a panic button held on the server's clock, automatic officer-down calls, and a one-line CreateCall export for your other scripts.

gs_dispatch gives your police, EMS and tow players one shared dispatch system, and the server controls all of it. Your robbery, theft, phone and alarm scripts send calls with a single server export. gs_dispatch checks each call, folds repeat witness reports into one incident, and pages only the on-duty units of the right agency with a notification, a base-game tone and a map marker.

On duty, units open the board (F5) and see every open call routed to their agency, sorted by urgency. They can attach to a call, set en route or on scene (on scene is checked against their real distance), request backup, and close calls with a reason. Units not on a call see its location rounded to 5 m. Attached units get the exact spot and a GPS route. Holding PAGEUP sends a panic alert timed on the server. An on-duty officer or medic who goes down raises an officer-down call automatically.

No client can create, move or retitle a call. Every action is checked again on the server, rate limited and logged to the database. Privacy is on by default: each agency sees only the units you allow (tow sees only tow units), and the unit status state bag stays on the server unless you turn replication on. Works on Qbox, QBCore and ESX, detected automatically, with job names set per framework.

Features

• Server exports CreateCall, CloseCall and GetOpenCalls, plus callCreated / callClosed server events
• Routing per call kind to police, EMS, tow or several agencies at once; add your own agencies in config
• Duty board (NUI): open calls, recently closed calls, your agency's visible units, your unit and callsign
• Unit statuses: available, busy, en route, on scene (distance checked on the server), clear
• Closing a call is limited to units on the call, a job boss or a configurable grade
• Hold-to-press panic button (hold time measured on the server) with a base-game radio pose
• Backup requests for police and EMS (configurable). Each one opens its own call and pages
• Automatic officer-down and medic-down calls from framework metadata, ped health or an optional medical resource export
• Duplicate report folding, per-caller and per-resource rate limits, a cap on open calls
• Configurable Units list visibility per agency; the unit status state bag is server-only by default
• Base-game street and zone names; optional custom zone labels from a zone resource export
• Base-game frontend tones per urgency (no audio files), each can be silenced
• Callsigns per character with /callsign, unique by default (all characters, online only, or off)
• Database log of calls and unit actions, tables created automatically, old rows cleaned up
• All text in an ox_lib locale file (English included)

Requirements

• ox_lib
• oxmysql
• OneSync
• One framework: Qbox (qbx_core), QBCore (qb-core) or ESX Legacy (es_extended)
• Inventory: none needed (no items). Works alongside ox_inventory, qb-inventory or the ESX inventory.
• Target: none needed (no target zones). Works alongside ox_target, qb-target or neither.
• Optional: a zone resource with a label export, a medical resource with an IsDowned(source) export

Install

1. Drop the gs_dispatch folder into your resources.
2. Optional: import install/gs_dispatch.sql (the tables are also created on start).
3. ensure gs_dispatch after ox_lib, oxmysql and your framework, and before scripts that call CreateCall at start.
4. Check the job names per framework in config/server.lua (ServerConfig.Agencies) and restart.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Server-enforced seatbelts, crashes you feel, windscreen ejection for the unbelted, a real ignition, cruise control and an in-car controls menu for Qbox, QBCore and ESX.

gs_driving makes driving on a roleplay server matter. Buckling up is a real action with an animation and a click, and the belt state is written by the server only, so HUDs, medical and police resources all see the same value. Crashes are detected from the speed a car loses together with physical evidence (damage or a collision) and play camera shake, blur and a short daze scaled by severity. The server only publishes a crash it can back with its own readings of the car (speed lost faster than braking can shed it, or speed lost while the car takes damage), and caps the reported size by what it saw.

Unbelted occupants of heavy frontal crashes can be thrown through the windscreen. The ejection is authorised by the resource's own server: seatbelts enabled, belt off, not downed, a cooldown, a fast car in the server's own speed samples, and speed lost faster than braking plus body or engine damage seen by the server. While the authorisation is open the server watches the player's distance from the crash and closes it early if they move further than a throw can explain. Other resources can query the authorisation, and an optional hook lets you tell your anticheat. No anticheat resource is required.

The engine no longer starts itself: drivers turn the key, the engine keeps running when they step out, and holding the exit key switches it off. Key checks are configurable per key resource. Cruise control holds a speed with the throttle and cancels on brake, collision or engine off; the speed limiter caps a car at the current speed or a typed limit. Arcade handling is removed (no mid-air control, no rocking a car back onto its wheels), and an ox_lib context menu and radial entry let occupants work doors, bonnet, boot, windows, seats and the interior light.

Everything is configurable in plain Lua config files, every text is in a locale file, and crashes can be logged to the database automatically.

Honest limits: the car's speed and health that the server reads are produced by the player's own game, so a modified client can still forge them. The server checks stop ordinary abuse such as braking or made-up crash reports; do not pay out money from crash events without your own checks. On ESX the server learns that a player is downed only from your ambulance resource (a state key or the provided config hook).

Features

• Server-written, replicated seatbelt state with buckle / unbuckle animation and sound
• Exit blocked while buckled; unbuckled warning chime
• Crash detection with three severities and camera effects
• Crash events backed and capped by the server's own speed and health readings
• Server-authorised windscreen ejection with cooldown, a distance watch while authorised, an authorisation export and an anticheat hook
• Manual ignition, engine left running on exit, hold exit to stop
• Configurable key checks (Qbox key resource entry included; add your own)
• Cruise control and speed limiter (mph or km/h)
• No air control, no flip-back, drive-by and seat-shuffle rules
• Occupant controls menu: doors, bonnet, boot, windows, seats, interior light (ox_lib context + radial)
• Crash log table created automatically, with an export to read a character's recent crashes
• Exports, events and state bags for HUD, medical, police and logging integrations
• Commands and default keys configurable; locale file for translations

Requirements

• OneSync
• ox_lib
• oxmysql
• Qbox, QBCore or ESX (auto-detected)
• No inventory items and no target resource needed (works with any inventory and any target)
• Optional: a vehicle key resource (entries for qbx_vehiclekeys and qb-vehiclekeys are included; their engine command settings must be checked against your installed version)

Install

1. Drop gs_driving into your resources folder.
2. ensure gs_driving after ox_lib, oxmysql, your framework and your key resource.
3. Optional: import install/gs_driving.sql (the table is also created automatically).
4. Adjust config/shared.lua, config/client.lua and config/server.lua. On ESX, fill in Config.IsPlayerDowned from your ambulance resource.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

The station side of a police or EMS shift, checked by the server: duty clocks, uniform lockers, personal lockers, a priced and limited equipment armoury, and 911 calls from every base-game payphone.

gs_emergency adds the physical side of an emergency-service shift. Officers and medics clock on and off at their station, change into a uniform, keep personal items in a locker, and draw department equipment from an armoury. Players without a phone can call 911 from any base-game payphone.

The server decides every action. A client never names a job, a grade, a duty state, a price, an item limit or a location the server trusts. Every request is checked again on the server:

• the framework job and its service category;
• duty and grade;
• the player's server-side position;
• the player is on foot and not downed.

Requests are also rate limited.

The armoury is built so equipment is hard to farm. Each catalogue entry has:

• a minimum grade;
• a per-request amount;
• a per-character allowance over a rolling window, kept in the database, so relogs and restarts do not reset it;
• a limit on how many the character may already carry;
• a price the server takes before issuing.

On ox_inventory, the default firearms are registered to the character with a department serial. Lockers refuse armoury equipment by default.

911 payphone calls go to gs_dispatch when it runs, to your own dispatch function, or straight to on-duty responders with a notification and a temporary map blip. Calls are anonymous to responders by default and logged with the caller for staff. Each character has a cooldown, and a server-wide limit per minute applies. The call position is always the caller's real server-side position.

Also included: a RequestConsent server export, so your other scripts can show a player a yes/no prompt and get the answer through a callback.

Works on Qbox, QBCore and ESX through the Greasy Scripts framework bridge. The framework, inventory and target resource are detected automatically.

Features

• Job catalogue in config: map any framework job to a service category (police, EMS, fire or your own)
• Duty clocks per station, with job, category, distance, on-foot and downed checks on the server
• Uniform lockers: built-in outfits per job or category and minimum grade (base-game clothing on the multiplayer models, own clothes restorable), or hand-off to your clothing resource by client event or export
• Personal lockers per character and locker id, stored in the database, with an item whitelist, per-item and per-locker limits, and shared locker ids between stations
• Armoury catalogues per job or category: minimum grade, per-request amount, rolling allowance, carry limit, server-set price (bank or cash), optional item metadata
• 911 from every base-game payphone prop: police, ambulance or fire, with a written description
• 911 routing: gs_dispatch (optional), your own dispatch function, or direct alerts with a map blip
• 911 abuse limits: per-character cooldown, server-wide calls per minute, optional list of vetted payphone positions, call log with caller identifier and retention
• RequestConsent server export (yes/no prompt with timeout) and a gs_emergency:server:dutyChanged server event
• Feature switches for duty, uniforms, lockers, armoury and payphones
• Five example stations at base-game locations (no custom interiors required)
• Database tables created automatically; the SQL file is optional
• Cleans up on stop: menus, dialogs, progress bars and 911 blips close, and built-in uniforms are removed
• All player-facing text in an ox_lib locale file (English included)

Requirements

• ox_lib
• oxmysql
• OneSync
• One framework: Qbox (qbx_core), QBCore (qb-core) or ESX Legacy (es_extended). ESX duty clocks need an es_extended whose jobs carry duty (1.15.x does); on older versions the clock tells the player it is not available
• Inventory (for lockers and the armoury): ox_inventory, qb-inventory or the built-in ESX inventory. On ESX without ox_inventory, weapons are not items, so weapon entries are hidden.
• Target: ox_target, qb-target, or none (ox_lib zones with an [E] prompt)
• Optional: gs_dispatch (911 routing), gs_medical or any medical resource with a server IsDowned-style export (recommended on ESX for the downed check)

Install

1. Drop the gs_emergency folder into your resources.
2. Optional: import install/gs_emergency.sql (the tables are also created on start).
3. ensure gs_emergency after ox_lib, oxmysql, your framework, inventory and target (and gs_dispatch if used).
4. Check Config.Jobs and walk the example station points in game (config/shared.lua).
5. Set the locker item list and the armoury catalogue, including prices and limits, to your server's items (config/server.lua).

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

A server-authoritative emote system: 211 solo emotes, 7 consent-based two-player emotes, hands up, pointing, crouch, walk styles and facial moods, with props that never spawn networked entities.

gs_emotes gives your players what they expect from an emote menu, built so it is hard to abuse and does not fight your other resources.

Players open an ox_lib menu (or type /e), browse or search gestures, dances, sitting and leaning poses, work and exercise emotes and prop emotes, and put favourites on quick-bind slots they bind to any key. Shared emotes ask the closest player first: they get an accept / decline dialog, and the server checks distance, routing bucket, vehicles and restraints on both the request and the answer. The two players are then lined up and start together. A player who is turned down cannot ask the same person again for a configurable cooldown (60 seconds by default).

Built for serious roleplay:

• Everything other players see (pose, prop, mood) is written by the server only, checked against the same catalog the clients animate from, and rate limited. Statebag values forged by a client are reverted.
• Prop emotes never create networked entities. The server replicates an emote id and each client builds a local prop, so there is no entity spam and nothing stays floating when a player crashes.
• Emotes are refused while downed, cuffed, busy in an inventory or progress bar, swimming, falling, in a vehicle (unless the emote allows it) or with a weapon drawn, and a running emote stops when any of those becomes true. Detection reads the ped, your framework's player data and common statebag keys, with hooks for your own ambulance and police resources. On ESX the server can only see a death through a statebag key or the hook you configure, because es_extended tracks death on the client only.
• Hands up uses the base-game surrender clip that ox_inventory's player search accepts, and other resources can read the replicated pose through a statebag or a server export.
• Commands and keys are configurable, key bindings use their own namespaced commands, and the server prints a notice at start when another known emote resource is running.

The whole catalog is plain, readable Lua in config/emotes, so you can add, remove and relabel emotes, and every player-facing text is in one locale file. Works on Qbox, QBCore and ESX through the embedded Greasy Scripts bridge. No database and no items.

Prop placement and shared-emote spacing use neutral defaults (hand placement bones with no offset, one spacing value for every pair). They are editable per row, and some may need tuning on your server.

Features

• ox_lib emote menu: categories, search, shared emotes, walk styles, moods, quick binds, stop button
• Optional ox_lib radial entries (automatic on Qbox)
• 211 solo emotes: 79 gestures, 42 dances, 39 sitting / lying / leaning, 36 work and exercise, 15 prop emotes
• 7 consent-based shared emotes (hug, handshake, high five, kiss on the cheek, hand over, pass back, long embrace), with a per-pair cooldown after a decline or an ignored request
• Hands up, camera-driven pointing with a blocked-arm pose, crouch
• 53 walk styles and 20 facial moods, saved per character on the player's PC; moods visible to other players
• 5 quick-bind slots (configurable)
• Local-only props built from a replicated emote id
• Server-written, rate-limited pose / prop / mood statebags; forged values are reverted
• Downed and cuffed detection with configurable keys and restraint hooks
• Configurable chat commands and default keys, conflict notice for other emote resources
• Client exports (play, cancel, current emote, pose, walk style) and a server pose export
• Editable emote catalog and English locale

Requirements

• ox_lib
• OneSync enabled
• One framework: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended), detected automatically
• oxmysql: not needed (no database)
• Inventory: not used, no items; works alongside any inventory
• Target: not used; works with or without ox_target / qb-target

Install

1. Drop the gs_emotes folder into your resources.
2. ensure gs_emotes after ox_lib and your framework.
3. If you run another emote resource, stop it or rename the overlapping commands in config/client.lua.
4. ESX: add your ambulance resource's death statebag key to Config.Downed.stateKeys, or fill Config.IsPlayerRestrained in config/server.lua, so the server can see downed players.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Fuel that the server burns, prices and delivers: gas pumps, EV charging, aircraft and boat fuel, jerry cans and garage persistence for Qbox, QBCore and ESX.

Greasy Fuel moves vehicle fuel to the server. Fuel burns once a second from each vehicle's class, the speed the server itself measures and the driver's throttle. Levels, prices, how much a pump delivered and every money and item change are decided on the server, so a modified client cannot set its own level, change a price or get more fuel than the pump delivered in the time it ran.

Players pull up to one of 28 base-game gas stations, switch the engine off, target a pump, pick the litres on a slider and pay by card or cash while their character holds the nozzle and a hose runs from the pump. Stopping early pays only for what went in, and a pump never takes more than the player can pay. Electric vehicles charge per kWh at stations with a charger, aircraft fuel at airfields and a heliport, and boats at a fuel dock. Jerry cans are bought and filled at a station and poured from the inventory.

Fuel levels of garage, dealership and job vehicles are remembered by plate, so cars come back out of a garage with the fuel they went in with. Staff get an ACE permission, a /setfuel command and a client export for admin vehicle spawners. Departments can fuel their vehicles on a society account through a billing hook, or for free. Optional compatibility aliases and a state.fuel mirror help existing garages and HUDs.

Vehicle classes (tank size, burn, fuel type) are learned from the players who drive each model, or pinned per model in the config, which is recommended for add-on vehicles.

Everything is configurable and translatable, and the framework, inventory, target and notifications are detected automatically.

Features

• Server-side burn by vehicle class, server-measured speed and throttle
• 28 base-game gas stations with card or cash payment, partial fills and a nozzle and hose
• EV charging priced per kWh at stations with a charger
• Aviation fuel points at 6 base-game airfield and helipad spots, marine fuel at a fuel dock
• Jerry cans: buy, fill at a pump, pour from the inventory
• Fuel gauge and low-fuel warnings (can be turned off for your own HUD)
• Plate-based fuel persistence for script-spawned vehicles, table created automatically
• ACE staff permission, /setfuel command and client/server exports
• Optional department fuel card with a society billing hook or free mode
• Optional compatibility export aliases and a state.fuel mirror for HUDs
• Full config and English locale file, ready to translate

Requirements

• OneSync enabled
• ox_lib
• oxmysql
• One framework: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended)
• Inventory: ox_inventory, qb-inventory or the ESX built-in inventory (jerry cans need the two included items; everything else works without them)
• Target: ox_target or qb-target recommended; without either, pumps use a built-in ox_lib [E] prompt
• No other fuel resource running at the same time

Install

1. Put gs_fuel in your resources folder.
2. Optional: import install/gs_fuel.sql (the table is also created on start).
3. Add the two jerry can items from install/items/ for your inventory and copy install/images/.
4. ensure gs_fuel after ox_lib, oxmysql, your framework, inventory and target, and before your garages.
5. add_ace group.admin gs_fuel.admin allow, then restart.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Server-authoritative garages with attendant parking lots, police impound and release, proof-based recovery of lost vehicles and department motor pools, for Qbox, QBCore and ESX.

gs_garages replaces "press E, car appears" with a garage system the server controls from start to finish. Players walk to a booth, pick a vehicle from a list that shows its fuel, engine and body, pay the lot's fee in cash or by card and wait while the attendant brings it round to the pickup bay. Parking is done on foot inside the lot with a key-fob animation, and the vehicle's condition is read by the server, never sent by the client.

Police impound vehicles with a reason that sets the release fee, and owners collect them from an impound yard. A vehicle that is recorded as out can be recovered at a yard only when there is proof it is gone: the garage saw it removed from the world, or it was out when the server restarted. Changing a plate is never enough to get a second copy. Recovered vehicles come back in the condition of their last snapshot, so a restart is never a free repair.

Departments get motor pools: on-duty staff sign out one service vehicle each by job and grade, with a department plate, keys and a full tank, and check it back in when they are done. Vehicles are recalled automatically when a member goes off duty, loses the job, logs out or abandons them.

Every action is two-phase and re-checked by the server: distance, ownership, duty, balance, bay clearance, routing bucket and timing. Vehicles are created by the server, one copy at a time, and fees are refunded when a delivery fails.

Features

• Public parking lots with attendant peds or self-service pay stations, per-lot fees
• Cash or card payment, fees decided by the server
• Park on foot inside a lot with server-read condition (engine, body, tank, dirt; fuel through the bridge)
• Police impound with configurable reasons and release fees (/gs_impound, renamable)
• Impound yards with release, and recovery of lost vehicles only with proof they are gone (lost fee and restart fee)
• Condition snapshots while vehicles are on the road
• Department motor pools with grade-locked fleets, department plates, automatic recalls, staff-only blips
• Uses your framework's own vehicle table (player_vehicles / owned_vehicles), schema check at start
• Vehicles stored by a previous garage resource can be collected at any public lot
• Server-side vehicle creation, duplicate protection, routing-bucket checks, early-finish detection
• ox_target, qb-target or built-in prompt; ox_lib, QBCore or ESX notifications
• Fuel through the Greasy Scripts bridge (ox_fuel, LegacyFuel, cdn-fuel, ps-fuel; gs_fuel restores its own levels), key resources through the bridge, optional qbx_garages export compatibility
• Exports and events for dealerships, tow jobs and property scripts
• Full English locale, every text translatable
• Full readable source under GPL-3.0: logic, config, locales, bridge and install files

Good to know

• All garage locations are example positions on base-game open-air spots and have not been walked in game. Place them on your map before opening your server.
• gs_garages must be the only resource that parks, impounds and spawns owned vehicles.
• No inventory items are required.

Requirements

• OneSync
• ox_lib, oxmysql
• One framework with its vehicle table: Qbox (player_vehicles from qbx_vehicles), QBCore (player_vehicles from the qb-garages or qb-vehicleshop SQL) or ESX (owned_vehicles)
• Inventory: none needed (no items)
• Targets: ox_target or qb-target recommended; a built-in prompt works without either
• Recommended: a vehicle key resource

Install

1. Drop gs_garages into resources and ensure it after ox_lib, oxmysql and your framework.
2. Optionally import install/gs_garages.sql (tables are also created on start).
3. Walk and set your own lot, yard and motor pool positions in config/garages.lua.
4. Set fees, impound jobs and reasons in config/server.lua.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

A clean NUI HUD that stays readable over any background and only speaks up when something matters.

gs_hud is a player HUD built to be read at a glance. Every element sits on an opaque plate, so it stays legible over bright sky, snow and white cars. It stays quiet until something matters: hunger and thirst show up when they drop, stress shows up as it rises, money and job appear for a few seconds when they change, and health turns red only when you are hurt.

It is light on the client. The HUD runs one client thread (100-500 ms depending on what the player is doing) and only posts to the page when a value changed. Street names are looked up only after the player moves, and while the HUD is hidden only the visibility checks run.

Players tune it themselves with /hud (or a key they bind): switch the whole HUD or any single element on or off, pick one of three sizes, and read a diagnostics block. It says why the HUD is hidden and which integrations are running. Settings are saved on the player's own PC.

Server owners get a logo slot for their own art, theme colours, currency symbol, mph or km/h, fade thresholds and update rates. There is a full English locale file and a small client API, so cutscenes, phones or any other script can hide the HUD.

gs_hud has no database, no items and no server events, so players have nothing to exploit.

Features

• Health, armour, hunger, thirst, stress, stamina (while sprinting) and oxygen (underwater) bars
• Voice pill that reads pma-voice player statebags: proximity mode and range, talking, radio transmit, radio channel, radio disabled
• Vehicle panel: speed (mph or km/h), fuel column, gear, engine off, engine damage, lights and high beam
• Seatbelt alarm, cruise control and speed limiter with the optional gs_driving
• Street, crossing street and area; district name with the optional gs_zones
• "Radio in hand" badge with the optional gs_radio
• Server logo slot on the top plaque (neutral placeholder included)
• Cash and bank reveal with a +/- change toast; job and duty pill on change
• Optional compass strip
• Per-player settings panel: whole-HUD switch, element switches, three sizes, reset, diagnostics
• Hides automatically: character not loaded, dead or last stand, pause menu, ox_inventory open, focused screens, scripted cameras, configured phones
• Client exports: SetHidden, IsVisible, OpenSettings, CloseSettings, GetSettings
• Localised through ox_lib locales and follows an ox_lib language change without a restart
• Qbox, QBCore and ESX auto-detected through the embedded Greasy Scripts bridge

Requirements

• FiveM server with OneSync
• ox_lib
• One framework: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended), auto-detected
• oxmysql: not required (gs_hud uses no database)
• Inventory: any. gs_hud adds no items. With ox_inventory it also hides while the inventory is open; other inventories hide it by taking NUI focus.
• Target: none needed (gs_hud registers no target options)
• Optional:
• pma-voice or a resource that writes the same statebags (voice pill)
• ox_fuel, LegacyFuel, cdn-fuel or ps-fuel (fuel). Any other fuel script works through one config function.
• gs_driving, gs_zones, gs_radio
• esx_status or a compatible status resource (hunger, thirst and stress on ESX)

The fuel exports and the esx_status event name are defaults that have not been checked against those resources' source. Check them against the version you run.

Install

1. Drop the gs_hud folder into your resources.
2. In server.cfg, after ox_lib and your framework: ensure gs_hud.
3. Optional: set setr voice_enableUi 0 so pma-voice's own indicator does not duplicate the voice pill.
4. Edit config/client.lua (logo, colours, currency, speed unit, integrations) and restart.

There is no SQL to import and no item to add. The install/ files exist only for the common Greasy Scripts layout and create nothing.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

An employment office that hires players into your framework's own jobs, plus transit, sanitation and vineyard careers with real, server-authoritative work loops. Open source (GPL-3.0).

gs_jobs closes the gap between "the job exists in your framework" and "a player can actually get hired into it." A clerk at a desk runs a vacancy board with three hiring tiers -- walk-in, an on-duty boss countersigning at the counter, and department-only roles that are pointed at the department and never handed out at the desk. /resign works anywhere, and /hirejob handles promotions and department hiring, gated by an ACE per job or by an on-duty boss standing next to the person and hiring below their own grade.

Three careers ship with a full work loop, all driven by one server-authoritative shift-and-ticket engine:

• Transit Authority -- three timetabled bus routes; the on-time bonus is a threshold, not a race, so there is no reward for reckless driving.
• City Sanitation -- a two-person crew round: collector on the step, driver in the cab, both paid, then a tip at the transfer station.
• Marlowe Vineyards -- pick, press and lay barrels down; the barrels age on a real clock in the database and bottle out for far more than the field work paid.

Every position, duration and payout is decided server-side; the client is never trusted. Money is your framework's own cash and bank, moved through the embedded bridge, so nothing is minted that your economy could not already remove.

Features

• Employment office with open / vouched / whitelisted hiring tiers
• /resign anywhere and /hirejob with ACE and on-duty-boss gating
• Transit, sanitation and vineyard careers with one shared shift engine
• Server-authoritative tickets: position, time and pay are never client-trusted
• Database-backed vineyard cellar with real-time barrel ageing
• Full source, GPL-3.0, every player-facing string in ox_lib locales
• Job definition packs for Qbox, QBCore and ESX included

Runs on

Qbox, QBCore and ESX (auto-detected). Needs: ox_lib, oxmysql. Optional: ox_target or qb-target (falls back to a built-in [E] prompt).

Requirements

• One framework: qbx_core (Qbox), qb-core (QBCore) or es_extended (ESX) -- auto-detected.
• ox_lib (menus, dialogs, callbacks, progress bars, locales).
• oxmysql (the vineyard cellar).
• Target (optional): ox_target or qb-target if present, otherwise a built-in [E] prompt.
• Notify (optional): ox_lib, qb or esx notifications, auto-detected.
• Inventories: works with ox_inventory, qb-inventory or the ESX inventory, but ships no items and requires none -- pay is the framework's own cash and bank.

Install

1. Drop gs_jobs in your resources folder.
2. Add the jobs it hires into to your framework using install/jobs/ (qbox.lua, qbcore.lua or esx.sql). The bus, garbage and vineyard jobs must exist for their depots to work.
3. Import install/gs_jobs.sql (optional -- the resource also creates the table on start).
4. ensure ox_lib, ensure oxmysql and your framework before ensure gs_jobs.
5. Register any ACEs for whitelisted hiring, e.g. add_ace group.admin gs_jobs.grant.police allow.
6. Coordinates are base-game map examples; adjust them in config/ before you open.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Your server's loading screen in one commented config file, with a handoff that never leaves a player on a black screen.

gs_loadscreen is a loading screen you configure instead of edit. Server name, badge, logo, headline, paragraph, rotating tips, a numbered highlights panel, footer text, eight theme colours, a font, a background image or video and optional music all live in one commented Lua file. There is no HTML or CSS to touch unless you want to.

Your branding is on screen from the first frame. The moment a player connects, the server hands the page its settings, so the screen is already yours before a single resource has downloaded. The progress bar is FiveM's own loading progress, with six status steps you can translate like any other string.

The part most loading screens get wrong is the handoff. gs_loadscreen keeps the screen up until your character selection takes over, so players never see a flash of the game world between the two. If that handoff fails - a callback that never returns, a character resource that errors - the player is left looking at a black screen with nothing to click, so gs_loadscreen closes the screen itself: first when the framework reports a loaded character, and failing that through a watchdog with a generous deadline that waits out character previews and screen fades rather than racing them. A stuck player can also type one command in the F8 console to get out.

Music is supported but nothing is bundled: point it at a file you have the rights to, and players get an on/off button, a key, and their choice remembered on their own PC.

It is safe by construction. Every configured string is inserted as text, never as HTML, and every image, video, music and font reference must be an https:// URL, an nui:// path or a relative path inside the resource. There is no database, no items, no net events and no client-to-server traffic at all.

Features

• Server name, badge and logo slot (neutral placeholder included, replace with your own art)
• Headline, kicker, paragraph and an optional "Welcome, " line
• Rotating tips: interval, random order, up to 50 entries
• Numbered highlights panel and footer text
• Eight theme colours, font family, optional web-font stylesheet, decorative grid and rings
• Background image or video with dim and blur
• Optional music: volume, loop, on/off button, toggle key, remembered choice (no music bundled)
• Real progress bar from FiveM's loadProgress events with six localised status steps
• Settings handed to the page at connection time and again when the client script starts
• Safe handoff to Qbox, QBCore and ESX character selection through the Greasy Scripts framework bridge
• Watchdog with an unconditional deadline plus a session-settle path, both waiting out character previews and screen fades
• Client console command to close a stuck loading screen; Release() / IsReleased() exports for custom character selectors
• English locale file (ox_lib locales), full readable source, GPL-3.0

Requirements

• FiveM server (recent artifact)
• ox_lib
• Optional: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended) - detected automatically; it also runs with no framework
• No database (oxmysql is not required), no items, no other dependencies
• No inventory or target resource is needed. The embedded Greasy Scripts bridge detects ox_inventory, qb-inventory and the ESX inventory, and ox_target or qb-target, but a loading screen uses none of them

Install

1. Drop the gs_loadscreen folder into your resources.
2. Disable every other loading screen (only one can be active; esx_loadingscreen on ESX).
3. ensure gs_loadscreen in server.cfg, after ox_lib and your framework.
4. Put your logo in web/assets/ and edit config/shared.lua.
5. Restart the server. There is no SQL to import and no items to add.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

A serious-roleplay medical system for Qbox, QBCore and ESX: last stand and bleed-out, body-part injuries, bystander first aid, EMS revive and treatment, hospitals with billing, a death register and staff character retirement, all decided by the server.

gs_medical replaces instant death with a medical system players actually play. Lethal damage downs a player instead of killing them: they are conscious, on the ground, bleeding out on a visible clock, able to crawl and call for an ambulance. A second hit, or running out of time, leaves them unresponsive, and from there only an on-duty ambulance crew or a hospital can bring them back.

Injuries are measured by the server from the health it sees a player lose; the player's own game only labels which body part was hit and by what. Wounds stay with the character across relogs and restarts, bleeding drains health and either clots or worsens, leg wounds make players limp, arm wounds shake their aim and head wounds make the camera sway now and then. Painkillers mask the effects for a while.

Anyone can help: check on a patient, dress their wounds, stabilise a downed player with a first aid kit, carry them to a vehicle or call an ambulance for them. Ambulance crews resuscitate and treat with a trauma bag, take over from a bystander who is already working on a patient, get medical alerts with a blip and a GPS command, formally pronounce patients and read patient records at any hospital reception. Hospitals offer walk-in treatment on a gurney, page on-duty doctors (with a cooldown), and bill whatever a patient cannot pay instead of pushing a balance negative. A player left unresponsive can be taken to the nearest hospital, but giving up keeps every injury and costs money; nobody lies on the floor forever, because an automatic collection picks up anyone nobody reached.

Every death is written to a register with the weapon, the worst injury, the place and how it ended. A killer is named only when the server itself received a weapon damage event from that player against the victim moments before and the two were within range; deaths by vehicle, explosion, fall or fire name no killer. Staff can retire a character with four locks: a permission, a connected target, the player's own consent and the character's name typed out. A retirement deletes nothing and can be undone.

Every treatment is two-phase and re-validated on the server (distance, state, job, items, real elapsed time), items and money are only ever changed by the server through the Greasy Scripts framework bridge, and each framework's own dead / last-stand state is kept in step. Logging out while downed, even at the spawn selector, does not clear the downed state.

Honest limits: the server side has been boot-tested on Qbox, QBCore and ESX test servers, with and without the SQL import and with a live resource restart. No player could join those test servers, so the client side (animations, target options, progress bars, the downed screen, the recovery scene) has been checked by reading the code only. The resource is not a drop-in replacement for qbx_medical, qb-ambulancejob or esx_ambulancejob: scripts that call their exports must call gs_medical's exports instead, and no other medical resource may run beside it.

Features

• Last stand with a bleed-out clock, crawling and calling for an ambulance, then an unresponsive phase
• Server-measured injuries by body part and cause; bleeding that clots or worsens
• Limp, aim shake and camera sway from injuries; painkillers mask them
• Bystander first aid: checkup, bandage, stabilise, carry, load into and unload from vehicles, call EMS
• Ambulance crews by job name and grade: resuscitate, treat, pronounce, patient records, alerts and GPS
• Three example hospitals on base-game exteriors (Pillbox Hill, Sandy Shores, Paleto Bay)
• Walk-in check-in, doctor paging with a cooldown, bills for unpaid charges, emergency transport with a recovery scene
• Automatic collection of anyone left unresponsive too long
• Death register and patient chart in the database; killers named only with server-side damage evidence
• Staff character retirement with consent and name confirmation, restore command and login block
• Staff revive command (permission or framework admin)
• Condition saved per character: relogging or restarting never clears a downed state
• Qbox and QBCore isdead / inlaststand metadata, ESX death events and is_dead column kept in step
• Optional gs_dispatch integration, your own dispatch hook, anticheat and audit hooks
• Exports, server events and namespaced state bags for HUD, police, dispatch and admin integrations (generic isDead-style bags available as an opt-in)
• Works with ox_target, qb-target or no target resource; action menu for any ped model
• Tables created automatically; locale file for translations

Requirements

• OneSync
• ox_lib
• oxmysql
• Qbox, QBCore or ESX (auto-detected)
• Inventory: ox_inventory, qb-inventory or the ESX built-in inventory (item definitions and images included)
• Target: ox_target, qb-target, or none (ox_lib zones with an [E] prompt)
• Optional: gs_dispatch
• No other medical or ambulance resource running beside it

Install

1. Drop gs_medical into your resources folder.
2. Add the items from install/items/ for your inventory and copy install/images/ (ox_inventory: replace the stock bandage entry, or self-bandaging stays with ox_inventory; the console says so once).
3. ensure gs_medical after ox_lib, oxmysql, your framework, inventory and target.
4. Grant staff the gs_medical.revive and gs_medical.ck ACEs.
5. Check Config.EmsJobs, Config.Hospitals and Config.Prices. Optional: import install/gs_medical.sql (the tables are also created automatically).

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Fishing and hunting as an economy rather than a minigame: bait counters whose prices fall the more you sell them, rods you work towards, a cast that can be fluffed and a fish that can be lost, licensed hunting with clean kills the server decides, and an hourly pay band a reconnect cannot reset.

gs_outdoors gives a server two jobs nobody has to be hired for. Buy a rod and a jar of worms at a bait counter, walk to the end of a pier, hold to wind up and release to cast. The wait is rolled by the server; only when it has actually been served does anything bite, and only then does your game learn how hard the fight is. Landing it is an ox_lib skill check you can lose, and the bait is gone either way.

Eleven species live across three waters - the shore and the piers, fresh water, and deep water from a boat - with bait that shifts the odds and species that only feed at certain hours. Angler skill is stored per character: it gates the rods and the deeper water, shortens the wait a little and improves the odds on the rare fish, so the deep-sea rod is something to work towards rather than something to buy on day one.

Hunting is licensed. A licence and a skinning knife are sold at a game processing point, and field dressing works on the ambient wildlife your server already spawns - this resource creates no animals and no props anyone else can see. Whether a kill was clean is decided on the server by counting weaponDamageEvent, never by asking the client, and a clean carcass yields a better pelt. A protected species list refuses the animals you do not want taken, and a per-character cap stops the forest being cleared in an afternoon.

The economy is the point of it. Each buyer's price for one species falls as their stock of it rises and recovers over time, stored against a real timestamp so it survives a restart: the fortieth fish at one counter is worth a fraction of the first, and a counter left alone for an hour has forgotten a dozen. Each character also has an hourly pay ceiling held in the database, so reconnecting or restarting the server does not hand out a fresh allowance; past it, sales still happen at a glut price and the player is told why, because a silent zero reads as a bug and a priced-down sale reads as a market.

Money and items move only on the server, by an amount the server worked out from its own config. The client sends a row index into a catalogue the server built - never a price, an item name, a species, a weight or an amount - and where the player is, what water it is, how long the wait is, what bites, how heavy it is and whether a kill was clean are all read or rolled server-side. What the client does decide is stated plainly in the README rather than hidden: whether the player cancelled, whether the landing contest was passed, and that there is a dead animal in front of them (ambient wildlife belongs to the client that sees it). Each of those is bounded by the pay band, the minimum-elapsed check on every timed action, the per-character caps and a flag event you can wire to your own anticheat.

Works on Qbox, QBCore and ESX through the embedded Greasy Scripts bridge, with ox_inventory, qb-inventory or the ESX built-in inventory, and with ox_target, qb-target or no target resource at all. Full readable source, GPL-3.0, no escrow.

Features

• Three bait counters and a game processing point as target zones with map blips (example positions on base-game spots, moved wherever your map wants them)
• Server-side catalogue of three rods and three baits; the client sends a row index, never a price
• Hold-to-cast wind-up, a server-rolled wait, a bite that cannot be reached early, and a skill check that can be lost
• Eleven species across shore, lake and deep water from a boat, with bait that shifts the odds and optional per-species hour windows
• Angler skill per character: rod tiers, water classes, rare odds and a shorter wait
• Falling sell price per buyer and species with linear decay, stored with a real timestamp
• Hourly pay ceiling per character, rebuilt from the database, with a glut price instead of a silent zero, plus hard caps on single and windowed credits
• A sale whose payment does not go through puts the goods back in the bag and says so
• Hunting licence and skinning knife, timed field dressing, clean kills judged from weaponDamageEvent, protected species, and a per-character poaching cap with its own window
• A scouting point that counts the wildlife on the hillside
• /cast and /angler (renameable), with /cast offered in the player's own key bindings menu
• gs_outdoors:server:flagged for your anticheat or log, and GlobalState.gs_outdoors_open to gate your own resources on - false again while gs_outdoors is stopped
• Nothing is drawn until the server confirms every item exists in your inventory
• 24 item definitions for all three inventories, with simple original placeholder icons included
• Five gs_outdoors_* tables, created on start or from the SQL, with a retention sweep on the logs
• Every player-facing string in one locales/en.json, through ox_lib's locale()

Requirements

• ox_lib - menus, notifications, progress circles, skill checks, callbacks, locales
• oxmysql and a MySQL/MariaDB database - skill, the price curve and the pay ceiling must survive a restart
• One framework: Qbox, QBCore or ESX, detected at runtime and never listed as a dependency
• Inventory: ox_inventory, qb-inventory or the ESX built-in inventory
• Target (optional): ox_target, qb-target, or none at all (ox_lib zones with an [E] prompt)

Install

1. Drop gs_outdoors into your resources and ensure gs_outdoors after ox_lib, oxmysql, your framework and your inventory.
2. Add the 24 items from install/items/ for your inventory, and copy the icons from install/images/ into its image folder.
3. Optionally import install/gs_outdoors.sql - the resource creates the same tables on start, and both are safe to run twice.
4. Move the coordinates in config/shared.lua to suit your map, and walk the water boxes: they are the only water test the server has, so a box that covers a road lets a player cast on it.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Organised racing timed by the server: organisers record courses by driving them, staff approve them, entry fees go into a pot and the podium gets paid.

gs_racing turns racing into an organised roleplay activity with rules, entry fees and prizes.

An organiser goes to one of the venue race desks, starts a recording and drives the course, dropping checkpoints along the way. Each checkpoint is the car's position as the server reads it, so clients cannot inject coordinates. The finished course waits for staff approval, and staff can preview it on the map first.

At the desk, the organiser opens an event on an approved course and picks an entry fee tier and a field size. Drivers bring their car to the grid and sign a timed waiver, and their fee goes into a pot held by the server. When the organiser starts the countdown, anyone who is not on the grid in the car they entered counts as a no-show and gets their fee back. Five start lights come on, and a jump start costs a time penalty.

During the race the server reads every car's position five times a second and decides checkpoint crossings itself. It interpolates crossing times, sets a minimum plausible time per segment, ignores samples faster than a plausible speed, and disqualifies after repeated position jumps. Drivers get a HUD with position, lap, checkpoint, race and lap clocks, best and last lap, and the top six. At the finish, the podium is paid from the pot minus a configurable sanction fee. Personal bests are saved, and every course has a leaderboard.

On the money side, clients never send an amount, and the pot is always the sum of the fees held. Every refund and prize is claimed in the database before it is credited, so a retry or a restart cannot pay it twice. Money owed to a player who logged off is paid when that character loads in again. If the server stops while an event is open or running, the held fees are refunded at the next start. A payout that was interrupted partway goes to a staff review list and is not paid automatically.

Vehicle control: when a vehicle keys resource answers, it decides whether the entrant may race the car. Adapters are included for qbx_vehiclekeys and qb-vehiclekeys (not verified against every version), and a hook is available for other keys scripts. Without a keys resource, a heuristic check applies: driver seat, network owner, and a script-spawned car. That keeps ambient traffic and parked world cars out, but it does not stop a player driving another player's spawned car. On ESX, use the hook with your own keys or garage script.

Features

• Record courses by driving them, with checkpoint width tiers, lapped circuits and sprints
• Staff approval with map preview; approved courses can be retired later
• Events with entry fee tiers and field sizes, a timed desk setup and a timed entry waiver
• Server-side timing: segment-based checkpoint detection, interpolated times, minimum segment times, a plausible-speed limit and repeated-jump disqualification
• Start lights, jump-start penalties, a DNF for staying out of the car too long, and a no-show refund
• Podium payouts from the pot with a configurable sanction fee and payout split
• Refunds and prizes that cannot be paid twice; players who were offline are paid when they return
• Held fees refunded after a server restart; interrupted payouts go to a staff review list
• Vehicle control: keys check with a heuristic fallback (see description for its limits)
• Race HUD, results screen, personal bests and per-course leaderboards
• Organiser and approver permissions by ACE, admin status or job
• Race desk interaction through ox_target, qb-target, or an ox_lib prompt when neither is installed
• Read-only server exports and server events for phone, news or staff resources
• Fully translatable, including the NUI
• Example venues on the base-game map (no MLO needed)

Requirements

• ox_lib
• oxmysql
• One framework, detected automatically: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended)
• OneSync
• Optional target: ox_target or qb-target (otherwise an ox_lib prompt)
• Optional vehicle keys: qbx_vehiclekeys or qb-vehiclekeys (adapters not verified against every version), or your own through vehicleControl.customCheck
• No inventory items are used, so it works alongside ox_inventory, qb-inventory or the ESX inventory

Install

1. Put gs_racing in your resources folder.
2. Optionally import install/gs_racing.sql. The resource also creates missing tables on start.
3. Add ensure gs_racing after oxmysql, ox_lib and your framework.
4. Grant gs_racing.approve and gs_racing.organise with add_ace.
5. Visit the example venue desks in config/shared.lua in game and adjust them to your map.
6. On ESX, or wherever stolen spawned cars matter, set vehicleControl.mode = 'keys' and a customCheck.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

A radio players actually carry: tune a frequency on a walk-and-talk panel, talk on pma-voice, and keep police and EMS bands closed to anyone who is not on the job.

gs_radio is a handheld radio for servers running pma-voice. A player needs the radio item. They take it out from the inventory or with /radio, switch it on and type a frequency or step through channels. Then they talk with pma-voice's own push-to-talk key or the panel's Hold to talk button. While the panel is open the radio sits in their hand. They play a hold pose, and a talk pose while transmitting. They can still walk.

The restricted bands (police, joint emergency and medical by default, all configurable) are enforced on the server. Every channel inside a band gets a pma-voice channel check. That check tests whether the player carries the radio, is not down, and holds the right job, grade and duty status. A server observer also watches pma-voice's channel statebag and undoes any change that did not pass the same tests. That covers modified clients using pma-voice's own event and clients writing their own statebags. Losing the job or going off duty drops the player from the band at once. Going down drops them at once on Qbox and on ESX death. A lost radio item, and going down on QBCore, are caught by a server audit within a couple of seconds. Tuning, callbacks and statebag writes are rate limited.

Works on Qbox, QBCore and ESX with ox_inventory, qb-inventory or the ESX built-in inventory, detected automatically. No database tables.

Features

• Radio panel: power, frequency entry, CH +/-, VOL +/-, up to 6 presets, Hold to talk
• Walk while the panel is open (mouse drives the panel, camera and attacks are held off)
• Restricted bands by job, minimum grade and on-duty rule, set in config
• Server authority: pma-voice channel checks on every restricted channel, plus a server observer for channel and statebag changes it did not approve
• Down and dead players cannot use the radio (Qbox/QBCore metadata, the ESX death event and the server's view of the ped), with a config hook for other medical scripts
• Rate limits on tuning, server callbacks and statebag writes
• Radio prop in hand (local object on each client, not a networked entity), hold and talk animations from base-game assets
• Presets and volume kept per character on the player's own PC
• ox_lib locales, configurable accent colours and screen side
• Server exports GetFrequency, ForceOff; client exports IsOpen, Close, SetPoseBlocked
• Starts without pma-voice and prints one console line saying what is missing

Requirements

• pma-voice (required for radio voice; tested against pma-voice 7.0.1)
• ox_lib
• OneSync (required by pma-voice)
• One framework: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended)
• One inventory: ox_inventory, qb-inventory or the ESX built-in inventory, with a radio item (ox_inventory and qb-core already ship one; an ESX SQL snippet and an original item image are included)
• Target resource: not used
• oxmysql: not used (no database tables)

Install

1. Put gs_radio in your resources folder.
2. Make sure the radio item exists (see install/items; ESX: import install/items/esx.sql).
3. In server.cfg, ensure pma-voice and your framework and inventory before ensure gs_radio.
4. Rename the example job names in Config.Bands (config/shared.lua) to your server's jobs.
5. Restart the server.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Open-source (GPL-3.0), server-authoritative FiveM cybercrime framework — crews pull multi-stage contracts, run field and safehouse minigames, and operate a full prescription-document forgery lab, with heat, police counterplay and deep progression. Auto-detects Qbox, QBCore and ESX; full readable source, no escrow.

gs_scamcrew is a crew-based cybercrime job, not a "press E on an ATM" script. A crew pulls a contract off a safehouse terminal and works it in stages out in the world — recon, scan, intrusion, extraction — then carries the payload back to the safehouse to process, encode and cash out. Every job produces a list of fictional "marks" and the payout is the itemised sum of what was taken off them.

Around that core sits a full progression economy: crew reputation, per-member skill XP, a gang treasury with a configurable cut on every payout, an underground market, HQ upgrades (network, power, cooling, storage, counter-surveillance and a forgery lab), server blades with a power budget, and crew specialisations. Field equipment — laptops, scanners, encoders, drives — carries a condition value and wears with use.

The eight-station forgery lab is a job in itself: scan source material, build a document profile, assemble the sheet, calibrate and print on the press (with random faults to clear), finish and verify, then inspect, package and deliver to fictional buyers on server-set contracts — with an evidence risk if you are sloppy. Police get heat-scaled counterplay: dispatch alerts that are vague at low heat and precise at high heat, physical evidence left at scenes, and device seizure on death.

Everything that touches money or items is decided on the server: payouts, prices, item grants and removals, crew membership, station proximity, rate limits and single-use minigame challenge tokens. The client is never trusted for an amount, a price, an item name or a coordinate. One build runs on Qbox, QBCore and ESX through the shared Greasy Scripts framework bridge — framework, inventory, target and notify are auto-detected.

Fiction notice. All content is fictional GTA-universe roleplay: invented marks, clinics, banks and prescription-document forgery that exist only inside this resource's economy. Forged documents and skimmed cards are mission tokens with no effect elsewhere on the server. Nothing references real people, brands or real-world fraud methods.

Features

• Contract board with multi-stage field + safehouse operations; payouts itemised from server-generated marks
• Six-plus server-seeded NUI minigames with single-use challenge tokens, station-presence and minimum-solve-time checks
• Eight-station prescription-document forgery lab; document quality from lab tier, skill, data grade, lab condition and minigame accuracy
• Progression: crew reputation, per-member skill XP, HQ upgrades, server blades + power budget, gang treasury, specialisations
• Underground market and operator "desks" (admin-placed passive-income seats, shipped with safe caps)
• Equipment durability on ox_inventory / qb-inventory metadata (ESX built-in has no metadata — see requirements)
• Police counterplay: heat-scaled dispatch alerts, physical evidence, device seizure on death
• Player-entered text shown to others is made markup-inert server-side (bridge safeText)
• Qbox / QBCore / ESX auto-detection through the shared bridge; ox_target / qb-target and ox_inventory / qb-inventory / ESX inventory
• Open source, GPL-3.0 — full readable source, nothing encrypted, no escrow

Good to know

The server seeds and gates every minigame (single-use token, station presence, minimum solve time), but the minigame itself is graded on the readable GPL client, so a modded client can report a win without playing. This is a skill gate, not an economy hole — a spoofed score only raises a forged document's quality, and income stays bounded by the server-set contract quantity, price, material cost and rate limits. Config.Forgery.quality.maxScoreContribution lets you shrink that further so lab tier, skill and data grade decide most of a document's quality. See the README "Anti-cheat and limitations".

Requirements

• ox_lib and oxmysql (hard dependencies)
• One framework, auto-detected: Qbox, QBCore or ESX
• An inventory (ox_inventory or qb-inventory; ESX built-in inventory also works, but device durability does not persist on it) and a target (ox_target or qb-target) — auto-detected
• Optional dispatch: ps-dispatch, cd_dispatch or qb-policejob — auto-detected; a built-in blip alert is used otherwise
• A gs_scamcrew crew group: a gang on Qbox/QBCore, or a job on ESX (ESX has no gangs) — install/gangs.lua

Install

1. Drop the gs_scamcrew folder in your resources and ensure gs_scamcrew after your framework, ox_lib and oxmysql.
2. Database: tables are created automatically on first start, or import install/gs_scamcrew.sql by hand.
3. Add the items from install/items/ (ox_inventory / qb-core shared items / ESX SQL) and copy install/images/*.png into your inventory images.
4. Create the gs_scamcrew crew group (gang on Qbox/QBCore, job on ESX) from install/gangs.lua.
5. Reposition stations with /gs_scamcrew coords (admin) and check the install with /gs_scamcrew doctor.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Armed store robberies with a real getaway, a stolen-car chop shop, street sales to pedestrians and a street notoriety that police can only learn by working the scene. Qbox, QBCore and ESX.

gs_streetcrime turns a city's corner stores, back streets and salvage yard into a crime loop that police actually have a reason to respond to.

Pull a weapon at a 24/7 or liquor store counter and the clerk puts their hands up, and somebody picks up a phone: the police alert goes out the moment the threat lands. Empty the drawer, drill the safe, then get away. Nothing is paid until you are clear of the store, so a fast response still matters when the robber is out of the door.

Afterwards, on-duty officers can work the scene for a description, the direction the robber went and, for robbers the street already knows, a name.

At the salvage yard the contact hands out orders for stolen cars. Bring the right model in, strip it, and get paid by its condition. It plugs into gs_vehiclekeys' stolen-car event, where every reported theft pays once, or works on its own with a "you drove it here and nobody owns it" rule.

On the street, offer something to a passer-by. Prices and acceptance depend on the area, the number of police on duty and your notoriety, and a witness may call it in.

Every price, duration, chance and position is decided on the server. The client only ever sends a store id, a network id, an item name from the server's own list and the session token the server handed it.

Features

• Store robbery on base-game 24/7 and liquor store counters (16 example stores, 5 enabled in Los Santos)
• Three stages: threat, drawer, safe drill with a skill check and a server-side snap chance
• The safe sits under the counter out of the box, so it works at every store; move any store's safe to its back office with one coordinate
• Held payout, paid only on a successful getaway; timeout, downed, disconnect and logout rules
• Per-character cooldowns, per-store daily caps, stores that stay shut after a robbery, city-wide limits, optional minimum police
• Police scene work with consistent robber descriptions
• Chop shop with server-issued orders, condition-based payouts and an owner bonus; your own car and occupied cars are refused
• Stolen-car detection through gs_vehiclekeys' event (each theft pays once) or a generic rule that refuses registered cars
• Street sales to pedestrians checked on the server, with area factors, police-count penalty, witness reports and exclusion zones
• Decaying street notoriety with four bands that change prices, reports and dispatch urgency
• Dispatch through gs_dispatch, ps-dispatch or cd_dispatch, or a built-in police alert with a map blip; alerts only reach on-duty police
• Base-game animations, props and frontend sounds only; no streamed assets or audio files
• Tables created automatically; optional SQL file
• Item templates for ox_inventory, qb-inventory and ESX with original icons
• Full English locale file; every option commented
• Exports: IsRobbing, GetNotorietyBand; a server event for anticheat logging

Requirements

• OneSync
• ox_lib, oxmysql
• Qbox, QBCore or ESX
• ox_inventory, qb-inventory or the ESX inventory
• Optional: ox_target or qb-target, gs_dispatch, gs_vehiclekeys, gs_medical, gs_zones
• The chop shop reads your framework's owned-vehicle table (player_vehicles or owned_vehicles) to tell whose car it is; it never writes to it

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Vehicle keys decided by the server: owner and spare keys, key fob, lockpicking, hotwiring, carjacking and witness police alerts for Qbox, QBCore and ESX.

gs_vehiclekeys is a vehicle key resource where the server holds every key, lock state and theft flag. Players lock and unlock with a key fob, hand keys to each other and give out spare keys. They steal vehicles by picking the driver door lock, hotwiring from the driver seat, taking the key from a running car after pulling the NPC driver out, or holding an NPC driver at gunpoint. Lockpicks and hotwires take a duration the server chooses and use ox_lib skill checks plus a server roll. A pick can snap, the alarm can go off, and a witness may call it in after a delay with a rough location and the first characters of the plate.

Owners get their key automatically. The owner is read by plate from your framework's owned-vehicle table as soon as the vehicle spawns, whichever garage or dealership spawned it, and there is a hook for garages that store owners elsewhere. When an owner hands the keys to another character, that character gets a spare key stored in the database. It survives restarts and stops working when the vehicle is sold, and the owner can list and revoke spare keys at any time.

Every client request is rate-limited and checked on the server for distance, items, timing and ownership. As with every key resource, door locks and the engine hold-off are applied by the game clients; the README explains exactly what the server enforces.

The framework, inventory, target and notification system are detected automatically. Everything ships as full, readable source under GPL-3.0: logic, configuration, locales and install files.

Features

• Server-authoritative keys, locks and theft flags, with every client request checked on the server
• Owner keys read by plate from player_vehicles (Qbox, QBCore) or owned_vehicles (ESX), with a hook for custom garages
• Spare keys stored in the database, revocable with /sparekeys and ended automatically by a sale
• Key fob on L with animation, lights and chirp; engine on G; no key, no engine
• Hand keys over through ox_target, qb-target or /givekeys
• NPC-parked cars locked at random (85 % by default)
• Lockpick and advanced lockpick with server-chosen durations, skill checks, a server roll, snapping picks and alarms
• Hotwiring on J, keys left in running NPC cars, and carjacking NPC drivers at gunpoint (chance by weapon class)
• Witness police alerts with day and night odds on the game clock, sent to your own dispatch hook, gs_dispatch, or on-duty players with the jobs you choose
• Server events for other scripts: vehicle stolen, theft reported, suspicious finish
• Staff commands /addkeys and /removekeys
• Optional compatibility with scripts written for qbx_vehiclekeys or qb-vehiclekeys (off by default)
• Lockpick items for ox_inventory, qb-inventory and ESX included, with original icons
• English locale; add a language by copying one JSON file

Requirements

• FXServer with OneSync
• ox_lib and oxmysql
• One framework: Qbox, QBCore or ESX
• Recommended: ox_target or qb-target (a built-in [E] prompt is used without one)
• Do not run another vehicle key resource at the same time

Install

1. Put the gs_vehiclekeys folder in resources.
2. Optional: import install/gs_vehiclekeys.sql (the table is created on first start otherwise).
3. Add the lockpick items for your inventory from install/items and copy the icons.
4. ensure gs_vehiclekeys after ox_lib, oxmysql, your framework, inventory and target, and before garages and jobs.
5. Qbox: turn on Config.Compat.qbx_vehiclekeys, or point qbx_core's two key functions at gs_vehiclekeys. QBCore: turn on Config.Compat.qb_vehiclekeys if your scripts use qb-vehiclekeys.
6. Other Greasy Scripts products: add the BridgeConfig.GiveVehicleKeys snippet from the README.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Server-authoritative weather and time with a realistic weather cycle, plus the world rules a roleplay city wants: no AI police or EMS, no free weapon pickups and traffic that follows the clock.

gs_world gives your server one sky and one clock, decided on the server and applied by every client. The server holds the weather, the time, the blackout and the freeze flags, publishes them in a single state bag and re-anchors the clock every minute, so nobody drifts and a modified client cannot change the weather: no net event of this resource writes it.

The weather cycle is built for roleplay, not for randomness. Each weather is a phase with its own minimum and maximum length and its own weighted list of what may follow. Weather may worsen only one step at a time, so the sun never jumps to a thunderstorm, and a storm always winds down through rain or a clearing sky. Snow, festive and neutral weather exist for admins and are never rolled by the cycle. When an admin sets the weather, the cycle holds for as long as you configure and then carries on from that weather instead of reverting it.

The second half of gs_world is the world itself. GTA answers crimes with AI police, drops free guns on the pavement, heals players back to half health and fills the streets the same way at 04:00 as at lunchtime. gs_world turns all of that off, or shapes it: dispatch services, the wanted system, ambient cops, the police scanner, parked police, ambulance, fire and military scenery, weapon, ammo, armour, health and cash pickups, NPC weapon drops, the free gun in a police car, the cinematic idle camera, pistol whipping, HUD components your own HUD draws, and traffic density that follows a day curve with a morning rush, a busy lunch, an evening rush and thin small hours.

It plays well with the rest of your server. If another weather resource is running, gs_world says so once in the console and hands the sky over instead of fighting it. Housing and shell scripts that pause qb-weathersync or cd_easytime pause gs_world too, and any script can pause it directly.

No database, no anticheat, no framework needed: ox_lib is the only hard dependency. Qbox, QBCore and ESX are auto-detected and used only for admin checks and notifications.

Features

• Server-authoritative weather, clock, blackout and freeze flags in one sanitised state bag
• Joining players read the exact clock from a callback, not an ageing snapshot
• Weighted weather cycle with per-phase lengths, a severity ladder and wet-weather exits
• Admin hold: an admin's weather sticks, then the cycle carries on from it
• Real-time clock mode (follows the server's own local time) or any clock pace you like
• Clock and weather phase survive restarts (resource KVP, no database)
• ACE-guarded commands: /weather, /time, /freezetime, /freezeweather, /blackout, /worldcycle, /worldprofile, /worldstatus - every name configurable or switchable off
• Conflict detection for qb-weathersync, cd_easytime, vSync and lookalikes, with a yield mode
• Pause support for interiors and shells, including the pause events of other weather resources
• No AI dispatch, no wanted level, no ambient cops, no police scanner (each configurable)
• Police, ambulance, fire and military scenery suppressed
• GTA weapon, ammo, armour, health and cash pickups uncollectable, with a stray-pickup sweep
• NPC weapon drops and vehicle weapon rewards blocked
• Traffic, pedestrian, parked-car and scenario density on a day curve, with day and night budgets
• Three population profiles (city, quiet, sparse) switchable from your own scripts
• HUD component hiding, pistol-whip blocking, idle-camera suppression, pause-menu title
• Health regeneration left alone by default, controllable when you want it off
• Server and client exports, server events and a per-minute client event for HUD clocks
• Qbox, QBCore and ESX auto-detected; ox_lib locales; full GPL-3.0 source

Requirements

• FiveM server (OneSync recommended)
• ox_lib
• A framework is optional: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended), used only for admin checks and notifications
• oxmysql: not required (gs_world uses no database)
• Inventory and target: not used. No items, no images.

Install

1. Put the gs_world folder in your resources.
2. In server.cfg, add ensure gs_world after ox_lib and your framework.
3. add_ace group.admin gs_world.admin allow for the commands.
4. Stop any other weather or time resource (gs_world will otherwise step aside).
5. Optional: tune config/shared.lua (weather cycle, clock, population, rules) and config/server.lua (permissions, command names, API).

No SQL, no items, no images.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

Group the map's zones into named districts your scripts can look up, with renamed area labels and shaded districts on the pause map, all from one config file.

gs_zones turns the game's neighbourhoods into districts you define. List which zones belong to which district and give each one a name and a colour. The resource does the rest:

• The area name under the minimap reads "Davis - South Los Santos", or just the district name if you prefer, in each player's own game language. Single zones can be renamed too.
• Once the map has been scanned, the pause map shows each district as a translucent shaded area with a named marker. All the markers sit under one legend heading.
• Your other scripts can ask "which zone and district is this player (or this coordinate) in?" through server exports and a player statebag. Useful for dispatch text, district names in a HUD, territory flavour or statistics.

gs_zones ships no map data. Each player's game reports its own zone, and the server keeps a zone cache for the whole map that fills in along the routes players drive. One admin command scans the whole map and fills the cache in one go, so every district is shaded. The cache is saved to a small file, so it survives restarts.

The zone information comes from the players' games, so it is meant for display and flavour, not for anti-cheat. No database, no inventory items. Runs on Qbox, QBCore and ESX.

Ships with an example set of eight districts named after the game's own geography, ready to rename, merge or replace.

Features

• Server exports for a player's zone and district, and for any coordinate (zone cache)
• Player statebag with the validated, rate-limited zone code of every player
• Self-filling zone cache: majority votes per grid cell with one vote per game licence, bounded memory and optional JSON persistence that keeps the vote counts
• /gs_zones_scan admin command to fill an area or the whole map at once
• Districts fully driven by config: name, colour, zones, marker position, per-district shading and marker toggles
• Zone label renaming in two styles (composite or district only), plus per-zone name overrides; each label's previous text is written back when the resource stops
• Pause-map shading built from the zone cache: every district after one scan, and along the routes players drive before that; optional hand-made rectangles
• Named district markers under one pause-map legend heading
• Server exports: GetPlayerZone, GetPlayerDistrict, GetZoneAt, GetDistrictAt, GetZoneInfo, GetDistrictOfZone, GetDistricts, GetCacheStats
• Client exports and local events for zone and district changes
• /zoneinfo staff command, console coordinate lookup and cache command
• Qbox, QBCore and ESX auto-detected; ox_lib locales; full readable source under GPL-3.0

Requirements

• FiveM server with OneSync enabled
• ox_lib
• One framework: Qbox (qbx_core), QBCore (qb-core) or ESX (es_extended). It is only used for the admin permission checks and notifications.
• oxmysql: not required (gs_zones uses no database)
• Inventory: not used (no items). Target: not used.

Install

1. Put the gs_zones folder in your resources.
2. In server.cfg, add ensure gs_zones after ox_lib.
3. Join as an admin and run /gs_zones_scan all once.
4. Optional: edit districts and labels in config/shared.lua, the map look in config/client.lua and the commands and cache in config/server.lua.
5. Optional: add_ace group.moderator gs_zones.zoneinfo allow / gs_zones.scan allow for another group.

No SQL, no items, no images.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.

A complete, code-only smartphone for FiveM — calls, messages, camera, social, wallet, services and more — that runs on QBCore, Qbox and ESX out of the box, ships full readable source, and adds zero image or audio files to your server.

GS Phone is a NUI smartphone built as vanilla JavaScript (no runtime framework) over a server-authoritative Lua backend. The UI never decides anything that matters: the player's number is resolved server-side, every money and item change is made by the server with the amount the server chooses, and the RPC router is allowlisted and rate-limited.

Built-in apps

• Phone — contacts, call log, voice calls through pma-voice, mumble-voip or saltychat (voice is optional; calls still log and drive the UI without it).
• Messages — 1:1 and group threads, images, sounds.
• Camera & Photos — captured from the game's own render target inside the page (never a screenshot of the UI), stored by the server and served back over the server's own HTTP endpoint. No screenshot resource required.
• Music, Browser, Calculator, Calendar, Clock, Notes, Weather, Maps.
• Recorder — voice memos (needs an upload host you configure).
• Mail — an in-city mail domain with paging.
• Settings — hashed PIN lock, wallpaper and accent, app library.
• Wallet — bank transfers with a per-transfer ceiling, a daily limit and an in-flight gate against double-spend.
• Services — company directory, company chat, boss hire / fire / set-grade, duty toggle and society deposit / withdraw.
• Garage and Home — read-outs of the player's owned vehicles and properties.

Optional social apps (behind their own SQL, hidden until you import it): Soapbox (microblog), Frames (photo grid), Flicks (short video), Kindred (matchmaking), Backroom (anonymous rooms), Swapmeet (listings), Noticeboard (community pages) and Crypto (a self-contained market — no real coin names).

Framework support that actually works on all three. Wallet and Services (hire, fire, grade, duty, company messages) run on QBCore, Qbox and ESX. Where a server genuinely cannot back a feature — no banking resource for society accounts, no housing script for the Home app — the interface simply hides that control instead of showing a button that fails on every press. Run gs_phone in the server console to see exactly what your install can and cannot do.

Security highlights

• Voice channels are granted and revoked by the server on a random, non-guessable channel id; the client never drives the voice resource, so a modified client cannot eavesdrop on live calls.
• An incoming call never forces the phone open (which would capture the cursor and disarm the player). Rings are rate-limited per caller/callee pair and per callee and time out into a missed call.
• Busy, blocked and unknown numbers answer identically, so dialling cannot probe another player's state; call pushes never leak the other party's server id.
• Player-written text is made markup-inert server-side and rendered with textContent, never innerHTML.
• The phone closes and the handset is dropped when the player is downed, cuffed or logs out; the handset is a client-local object, so it never trips entity-spam anticheats.

Features

• QBCore, Qbox and ESX auto-detected — or standalone — through one shared bridge.
• Full source, GPL-3.0. No escrow, no encryption.
• Zero image or audio assets: everything is generated in code (< 1 MB resource).
• Server-authoritative money, items and phone numbers; allowlisted, rate-limited RPC.
• 20+ built-in apps and 8 optional social apps behind their own schema.
• In-page camera and video capture, stored and served by your own server.
• Player strings via ox_lib lib.locale (locales/en.json), ready to translate.
• Idempotent SQL that the server also auto-applies at boot.

Requirements

• ox_lib
• oxmysql
• One of qb-core, qbx_core, es_extended, or nothing (standalone)
• A supported inventory for the phone item: ox_inventory or qb-inventory (or the ESX built-in inventory) — or set Config.RequireItem = false
• Optional: pma-voice / mumble-voip / saltychat for call audio
• Optional: qb-banking (Qbox/QBCore) or esx_addonaccount (ESX) for company society accounts; a housing resource (qb-houses, qb-apartments, or one you point Config.Housing.export at) for the Home app

Install

1. ensure ox_lib, ensure oxmysql and your framework, then ensure gs_phone after them in server.cfg.
2. Import install/gs_phone.sql (and install/gs_phone_social.sql for the social apps). Both are idempotent, and the server also verifies/creates the core schema at boot.
3. Add a phone item to your inventory (definitions in install/items/), or set Config.RequireItem = false.
4. Everything else is in config/ and commented.

Frameworks

Qbox, QBCore and ESX, detected automatically through the embedded Greasy Scripts bridge.

Licence

GPL-3.0. You get the full, readable source code (no escrow). Keep the licence file with the resource.