Code Graph

A FiveM server is not one program. It is dozens of resources talking to each other through events, exports and NUI messages, and none of that is visible in a file tree. Code Graph reads your whole resources/ folder and draws the connections.

Opening it

Open Code Graph from the sidebar and pick a resource, or the whole project. The first parse of a large server takes a few seconds; after that Boltise re-parses only the files that changed.

What it finds

Boltise parses your Lua with the same AST parser that powers the editor’s squiggles, so it understands CfxLua as written — compound assignment (count += 1), backtick hash strings, and safe navigation (drawColor?[1]) are all valid input, not syntax errors.

It extracts far more than functions:

Symbol	What it is
Functions	Global and local function definitions
Event handlers	`AddEventHandler`, `RegisterNetEvent`
Event triggers	`TriggerEvent`, `TriggerServerEvent`, `TriggerClientEvent`
Exports	`exports('name', fn)` and every `exports.resource:fn()` that calls one
NUI	`RegisterNUICallback` and `SendNUIMessage`
Database queries	`MySQL.Async.`, `exports.oxmysql:` and friends
Commands	`RegisterCommand`
Threads	`CreateThread`, and separately the tick loops — `CreateThread` with `Wait(0)`
Callbacks	The ESX and QBCore callback patterns
State bags	`GlobalState`, `LocalPlayer.state`
Framework calls	`QBCore:GetCoreObject()`, `ESX:getSharedObject()`, ox_lib calls
Natives	GTA V and RDR2 native calls
Lifecycle	`onResourceStart`, `onResourceStop`, `onPlayerConnecting` and the rest
Convars	`GetConvar`, `SetConvar`, `RegisterConvar`
Streaming	`RequestModel`, `RequestAnimDict`, `RequestTextureDict`
Config fields	`Config.X = value` from your config files

The connections

Symbols alone are a list. The value is in the edges between them:

event — a TriggerEvent matched to the AddEventHandler that receives it
net — TriggerServerEvent paired with TriggerClientEvent, so you can follow a round trip across the client/server boundary
export_call — exports.other_resource:fn() matched to the exports('fn', …) that defines it, in a different resource
nui — SendNUIMessage matched to the RegisterNUICallback that answers it
callback — a framework callback request matched to its response
db — which symbols reach the database
state_bag — a state read matched to the write that set it
native — which functions call which natives
function_call and lifecycle — direct calls and resource lifecycle wiring

Cross-resource edges are the point. A missing export or a typo’d event name is invisible in a file tree and obvious in a graph.

Reading the map

Files are grouped by what they are — configuration, client, server, shared, ui, and dependency nodes for externals like qb-core and ox_lib that live outside your project. Resources are categorised too: script, vehicle, map, clothing, ui, data.

Click any node to open that exact line in the editor. That is the fastest way to use the graph — find the thing, jump to it, stop reading the map.

Config fields and database tables appear alongside your code, so a value in config.lua and the query that reads it are visibly connected.

Insights

Code Graph also reports structure rather than just drawing it:

God nodes — the highest-degree symbols. A function everything depends on is where a refactor hurts, and where a bug spreads.
Communities — clusters of symbols that talk to each other more than to anything else. These are your real modules, whatever the folder names say.
Connectivity — how many symbols are connected at all. Orphans are often dead code, or code wired up by a name that no longer matches.

When something is missing

If a resource shows fewer symbols than you expect, check the Problems panel — a file that fails to parse contributes nothing to the graph, and the parse error will say where. Boltise falls back to a coarser extraction if the native parser is unavailable, which finds less; a full parse is the normal case.