RAC-Core
RAC-Core
Start free
Public Documentation

Install and operate RAC-Core cleanly.

This guide is written for operators. It starts with the shortest correct install path, then covers frameworks, daily use, security, analytics, resource management, launch checks, and the common issues you will actually hit.

Open demoOpen panelJoin Discord
Quick start

The shortest install path

If you want the resource running quickly, follow the four steps below in order.

4 steps
Install
Download, start, configure, verify
4 frameworks
Coverage
Standalone, ESX, QBCore, QBOX
What this docs page covers

Enough detail to launch and maintain the product

The structure mirrors the real product: install first, then configuration, framework-specific notes, daily operation, and troubleshooting.

  • Install steps and config values
  • Framework-specific behavior notes
  • Support, tablet, analytics, and resource operations
  • Launch checklist and public troubleshooting guidance
Overview

A public guide that reads like a product manual, not an internal note.

The goal is to make setup obvious, keep the public site readable on mobile, and avoid burying operators in unnecessary implementation detail.

4
Frameworks
Standalone, ESX, QBCore, QBOX
2
Core surfaces
Web panel and in-game tablet
Ack-based
Queue model
Pending actions stay queued until delivered
Public
Visibility
Customer-facing docs and troubleshooting

What RAC-Core ships

The platform is centered on the operations your staff will actually use.

Live player monitor with telemetry and screenshot feed (Pro+)
Unified support workspace for help and report threads (Pro+)
Sticky enforcement, linked identities, and watchlists (Pro+)
Resource control with performance tracking
Framework-aware character, job, and economy edits (Pro+)
Durable offline queue delivery with acknowledgements

Before you start

A few quick checks keep the install smooth.

  • Access to `server.cfg` and your FiveM resources folder
  • A RAC-Core server created in the panel
  • The framework resource loaded before RAC-Core
  • ESX status support if you want hunger and thirst writes
Install

Four steps to get live

This is the shortest safe route for a clean install. If you need to tune anything later, do that after the resource is up and the panel heartbeat is working.

Step 1 - Download and place the resource

Put the latest build inside your FiveM resources folder and keep the resource folder name as `rac-core`.

resources/
└── rac-core/
    ├── fxmanifest.lua
    ├── client/
    ├── server/
    └── ui/

Step 2 - Start framework dependencies first

Keep your framework, database, and shared utility resources above RAC-Core in `server.cfg`.

ensure oxmysql
ensure qb-core
ensure qbx_core
ensure es_extended
ensure rac-core

Step 3 - Add the panel credentials

Add your server ID and server token as convars in `server.cfg`. Get both from the Configuration page in the RAC panel.

set rac_server_id "YOUR_SERVER_ID"
set rac_server_token "YOUR_SERVER_TOKEN"

Step 4 - Restart and verify

Restart the resource or the server, then confirm the startup banner, version check, and panel heartbeat.

restart rac-core
# or
ensure rac-core
Configuration

The settings most operators need

Credentials go in server.cfg as convars. Everything else is set in rac-core/server/config.lua.

# server.cfg — credentials (required)
set rac_server_id    "YOUR_SERVER_ID"
set rac_server_token "YOUR_SERVER_TOKEN"

# rac-core/server/config.lua — optional overrides
Config.Framework = "AUTO" -- AUTO, STANDALONE, ESX, QBCORE, QBOX
Config.EnforceModeration = true

Config.FrameworkAdapters.ESX.LastNameSetKey = "lastName"
Config.FrameworkAdapters.ESX.LastNameUpdateEvent = ""

Config.VersionCheck.Channel = "stable"

Notes that matter

  • Credentials are read from convars — never hardcode them in config.lua.
  • Version checks print to the console and feed the release endpoint.
  • QBCore and QBOX use metadata-aware character handling.
  • ESX surname handling can be adapted to your character package.
Frameworks

What each framework supports

This table reflects the shipped integration behavior and makes it obvious which data is framework-backed versus standalone moderation.

Standalone

Core moderation, world/admin actions, support workflows, analytics, tablet, audit, and device link.

Best for servers that want the moderation and operations layer without framework-backed economy writes.

ESX

Job, grade, cash, bank, health, armour, hunger, thirst, offline queue, support, and analytics.

Hunger and thirst require `esx_status` or compatible handlers. Character naming can be adapted with `Config.FrameworkAdapters.ESX.LastNameSetKey` or `LastNameUpdateEvent`.

QBCore

Job, grade-only updates, cash, bank, charinfo last name, health, armour, hunger, thirst, and offline queue.

Uses `qb-core` exports and metadata-aware handling for character and status writes.

QBOX

Job, grade-only updates, cash, bank, charinfo last name, health, armour, hunger, thirst, and offline queue.

Detected through `qbx_core` and uses the qbx export path directly.

Daily operations

Use the product without jumping through extra tools

RAC-Core is built around support, moderation, monitoring, and recovery tasks that happen throughout the day.

Support workflows (Pro+)

Help and report threads, assignment, replies, status changes, and screenshots in one place. Requires Pro or Premium plan.

Live monitor (Pro+)

16-slot live operator view with screenshots, telemetry, and slot control. Screenshot capture requires Pro or Premium plan.

Security (Pro+)

VPN/proxy visibility, join controls, sticky risk tracking, and RBAC-gated actions. Requires Pro or Premium plan.

In-game tablet

A focused ops surface for staff who are already in session

The tablet is a condensed form of the same product, tuned for quick tasks instead of full desktop workflows.

Tablet modules

Support, live players, notifications, settings, and linking are the core tablet workflows.

  • Device-like shell with fast tab transitions
  • Grouped action rows and telemetry chips
  • Sticky notifications for replies and assignments
  • Mobile-friendly layouts and touch targets

What stays tablet-only

Actor-bound actions stay in the in-game surface where they belong.

  • goto / bring / spectate
  • Live support responses and notifications
  • Quick actions on the current session or local context
Security & RBAC

Capability gating and review tools

RBAC is matrix-first, with role presets and per-user overrides. Sensitive actions are audited and stay server-side permissioned.

Security controls

VPN/proxy visibility, allowlists, banned identifiers, join controls, chat flood protection, and weighted risk scoring.

RBAC model

Role templates work as presets, then user-level overrides let server owners tune access without rewriting every role.

Analytics

Server health and behavior tracking

Player density, crash locations, disconnect reasons, entity trends, and per-player activity history are presented as operational signals rather than generic charts.

Player activity

Player count trends, live density, and per-player activity timelines.

Crash and disconnect maps

Crash hotspots, disconnect breakdowns, and visual density overlays.

Economy and jobs

Economy flow sampling and job movement trends over time.

Resource management

Control resources without guessing

Listing and control are separately permissioned. That keeps the sensitive surface obvious and easy to gate.

Control

Start, stop, restart, and refresh from the panel with RBAC protection.

Monitoring

Track state, average and max ms, restart counts, and resource event logs.

Policy

Sensitive actions can be restricted through role capabilities and server policy.

Launch checklist

Confirm the basics before handing it to live staff

Most launch problems are validation problems, not missing features.

The server console prints the RAC-Core startup banner and version check.

The panel shows the server as online and the heartbeat card updates.

Player, resource, and RBAC pages open without permission errors.

Support, monitor, and help/report pages require a Pro or Premium subscription.

Offline actions stay queued until the resource polls and acknowledges them.

Free plan servers are capped at 64 tracked players — upgrade to Pro for unlimited.

Release process

Keep packaging and notes aligned

Use the release scaffolding instead of hand-copying versions between files.

Artifacts and versioning

  • Use `CHANGELOG.md` for human-readable notes and `/changelog` for the hosted page.
  • Run `scripts/prepare-release.ps1` to generate the resource zip and align version metadata.

Validation

  • Run `docs/SMOKE_TEST_MATRIX.md` before publishing.
  • Keep `docs/RELEASE_PROCESS.md` with the deployment runbook.
Commands

The public commands and endpoints operators use

This keeps the setup and support surface visible without reading backend code.

In-game commands

`/support` - Open the unified support chooser for help or report.

`/help` - Jump straight into the help request flow.

`/report` - Jump straight into the report flow.

`/racpanel` - Open the RAC-Core in-game control panel.

`/ractablet` - Open the tablet-mode control surface.

Resource endpoints

GET /api/v1/resource/version - latest version metadata

GET /api/v1/resource/download - resource package redirect

POST /api/v1/resource/poll - player polling and leased command delivery

POST /api/v1/resource/poll/ack - explicit delivery acknowledgement

Troubleshooting

The most common setup issues

These are the things to check first when something does not behave as expected.

Connection and framework issues

  • No players in the panel: confirm the API base, server ID, server token, and startup banner.
  • Resource instance mismatch: make sure the linked server is using the expected license token.
  • Framework values missing: keep `Config.Framework = "AUTO"` unless you need to force detection.

Queue and web issues

  • Queued actions remain pending: inspect the panel heartbeat and backend/resource logs for poll or ack failures.
  • ESX hunger or thirst missing: verify `esx_status` or compatible handlers are installed.
  • Self-hosted web issues: check the web, backend, and nginx containers, then review your deployment checklist.