Not translated yet — showing English.
Core Concepts
The terms the rest of these pages use without explaining them. Each gets a short definition and a link to the page where the mechanism behind it lives.
Three things are too large for an entry and have a page each: Authority — who is calling, and what that alone decides; How the SDK Is Built — what the SDK is made of; Inheritance & Composition — how modules build on each other.
The four surfaces
Every module exposes exactly four things, and every module page is organised around them. This is the programming model:
| Surface | Meaning |
|---|---|
| Declarations | what exists and how it behaves, authored in code or in the admin panel; the same model either way |
| Hooks | your rules, called by the platform at named steps; deployed as cloud functions |
| Events | what the platform tells you happened — subscribe, don't poll |
| Operations | what you ask for or command, from a function or a client |
Actor
Who is making a call. What a call may do is decided by the actor behind it, never by which build the code was compiled into — the argument is Authority, the mechanism (atomic permissions, composed roles, InterfaceGrant) is Access & Roles.
The actor names in these pages come from the presets the platform ships. A project can name its own actors; the presets are:
player · backend-service · operator · host · moderator · schema-author · architect · bot-brain · room-owner · room-visitor · entry-validator · spectator · match-organizer · warehouse-keeper · seller — and any when a page means all of them.
Runtime surface
Where code runs. These four tags are used in every operations table:
| Tag | Surface |
|---|---|
fn | Cloud function (C# · TypeScript · Python · Go). Server-authoritative; the primary home of your rules |
cl | Game client (Unreal C++ / Unity C#). Symmetrical API; roles unlock less |
mc | The room-host surface: a master-client (a client that owns a room) or an Unreal dedicated server under its host key |
adm | Admin panel / CLI / MCP — where the SDK and operator plane share a model |
Where code runs is not who it runs as
Where code runs and which actor interface it holds are separate questions. The same code has the same rights wherever it is placed; only the grant differs.
Project & Environment
A project is one game's backend, with a schema and its data in isolated environments (dev, prod). Every call runs inside a project + environment.
Entity
The central noun. An entity is a schema declaration plus its live aspects: data 0..*, states 0..*, RPC 0..*, events 0..*, hooks, and change history. A tank, a door, a stat bar and a quest are all entities, differing only in which aspects they carry. Common combinations ship as presets (GameObject, Stat, Character, Interactable, Projectile). See Entity.
Expected state
A transition request may name the state it expects, and then it is that state or a refusal. A request that names none is evaluated against the state the machine holds when the platform processes it — never against the state at the moment it was sent.
The reply describes that moment and promises nothing about later: someone else's transition landing while the reply is in flight leaves the reply true and does not cancel it.
Name the expected state when it matters
When the outcome depends on what was there before, name the expected state. Otherwise don't read the reply as a snapshot that outlives the call.
Room
A room is a game session, not a place your code runs. The platform doesn't care what hosts it: a dedicated server, a master-client, or the backend itself. Room internals are ours; you drive a room from outside, from cloud functions and clients, through declarations, hooks, events and operations. See Rooms.
Channel & Stream
The async primitives under everything. A channel is an addressable pub/sub topic: a room, a group, an entity, or your own. A stream is a chunked flow in either direction: files are consumed as chunks arrive, queries can stream, and an RPC can fan out to a group and collect the answers. See Core.
Primitive
One of the four bricks every module is assembled from: events (declare, emit, subscribe), RPC (invoke across the wire), data and subscriptions (sync mechanics) and groups (one list, many listeners). A room, a chat and a matchmaking pool are the same group primitive under different rules.
Hook contract
One contract everywhere: a before hook runs ahead of validation, receives the typed payload, may mutate it or reject; an after hook runs once the operation has committed, receives request and result, and can only add side effects — it can never fail the operation. Hooks are ordered; every registered platform step can carry them. See Extensibility.
Delta & Revision
Clients receive state as deltas: only changed fields, encoded against the last state the receiver acknowledged. Every record carries a revision; conditional writes reject on mismatch. One versioning concept serves sync, concurrency and history. See Data. (What Unreal calls replication — which client sees which state, how often — lives here and in Visibility and Prediction. The What Survives Losing a Host page is the other one: which machine owns an entity, and which owns it next.)
Tick
Rooms simulate on a fixed step. Every state change is stamped with its tick; sync, prediction, lag compensation and history all count in ticks rather than wall-clock. Data carries its true event time, which makes rewind and reconciliation exact. See Prediction.