Glossary

One line per term. The linked page is the one that covers it in full.

A

Term	Meaning
Alarm	A named timer on a room that survives hibernation and a server stop. It wakes the room when it fires.
Anchor	In a `spatial-grid` collection, the record whose id equals the client id. Its position decides what that client sees.
Asleep	See Hibernate.
Awake	A room that is currently running. An awake room bills room-hours, an asleep one bills nothing.

B

Term	Meaning
Bot	A scripted client session opened by `irtio simulate` or `spawnBots`. It uses the same client SDK a browser does.

C

Term	Meaning
Cap	The plan or project ceiling on a billed meter. At the cap, new work is refused or an alert is raised, depending on the plan.
Client	One connected player session, identified by a client id. Use this word for the connection, and player for the person.
Collection	One named group in the schema, declared as an `entity` or a `singleton`. Visibility and ownership are decided per collection.
Correction	A frame telling an owner the server overrode its write. It overwrites the fields the server changed and leaves the rest alone.

D

Term	Meaning
Delta	One frame carrying the fields that changed since the previous one, plus the adds and removes.
Deployment	One deployed version of a project, produced by `irtio deploy`. Old deployments are kept, because old snapshots need their schema to decode.

E

Term	Meaning
Entity	A collection of many instances, each under an id you choose and each with an owner. Declared with `entity(fields, options?)`.
Event mode	`mode: 'event'`. The room has no loop and runs handlers as they arrive. It hibernates after `idleMs` of silence.

F

Term	Meaning
Flush	Sending the owned writes batched since the last one. It happens once per animation frame, capped at `writeIntervalMs` (50 ms by default), or on `room.flush()`.

H

Term	Meaning
Hibernate	To save a room’s whole state and stop it. The next join restores the state and resumes at the tick the room stopped on.

I

Term	Meaning
Identity	A stable anonymous player id that survives reconnects, hibernation and closing the tab. Turned on with `identity: true`.
Instance	One record in an entity collection, stored under its id, with exactly one owner.
Intent field	A field a client writes to say what it is trying to do, such as a direction. The server turns it into force in `tick`.
Interest management	Sending a client only the records near it, using `visibility: 'spatial-grid'`. Records enter and leave as ordinary adds and removes.
Interpolation	Drawing non-owned entities at `now - interpDelayMs`, blending between the two authoritative values either side. This is what `room.render` does.
Invariant	A built-in check `irtio simulate` runs against the bytes on the wire, such as `bandwidth` or `correction-storm`. A violation exits 1.

L

Term	Meaning
Leaderboard	A named board of integer scores per project, written only from your room code.

M

Term	Meaning
Misprediction	A correction that disagrees with what the client predicted for that same server tick. Reported in world units.

O

Term	Meaning
Owner	The one party whose writes to an instance are accepted, either a connected client or the server. The server’s owner id is the empty string.

P

Term	Meaning
Player	The person. Use client when talking about the connection.
Player storage	A per-player key-value store that outlives any one room, read and written from your room code.
Prediction	Running a local copy of the room’s physics ahead of the server so a player’s own body answers input immediately.
Presence	The built-in `clients` collection, ordered by join. You read it as `room.clients`.
Project	The unit that holds room types, deployments and usage.
Project key	The public id in your schema’s `project` option. Safe in client code and in a public repository. It is not a secret and not an API key.

Q

Term	Meaning
Quick match	A queue that answers with a room code, so two strangers end up in the same room without sharing one.

R

Term	Meaning
Reconciliation	Rebasing the client’s local physics world onto the server’s values and re-stepping it, once per authoritative tick.
Relay room	A room that runs no code of yours. It gives you presence, a room code and a raw message channel, and holds no state beyond the presence list.
Role	A label a client joins as, declared in the schema’s `roles` list. A role is a visibility filter and a value to check in a handler, not access control on its own.
Room	One live server-side session of your game, with its own state, its own id and its own lifecycle.
Room bus	`room.bus`, the direct route from one of your rooms to another. Scoped to your project.
Room code	The room id, as it appears in a shareable link. A code with no prefix means the default room type.
Room-hour	One hour of one room being awake. This is the main billed meter, and a hibernated room accrues none.
Room type	A named room definition in a project, with its own schema, tick rate, memory budget and retention window.
RPC	A typed call from a client to a room handler that decides what actually happened, and replies. A throw inside one rejects the caller’s promise.

S

Term	Meaning
Save	A numbered generation of a room’s state written by `room.save()`, restorable later with `irtio rooms restore`.
Scenario	A file that scripts bots and asserts against the server’s own recorded timeline, run with `irtio simulate`.
Schema	The single typed description of everything a room shares. Both halves of your game import it, and the wire format comes from it.
Shard	One of the servers a project runs on. Every project starts on shard 0, and a room lives on one shard for its whole life.
Simulated player	A real client session `testRoom` joins inside your test process, on a fake clock and with no sockets.
Singleton	A collection with exactly one instance and no id. Read and write its fields directly.
Size class	Small, Medium or Large, derived from a room type’s declared `memoryMb`. It decides the rate that room’s hours are billed at.
Snapshot	The room’s whole state, written when it hibernates and read back on the next join. Unlike a save, you do not ask for one.
Spatial grid	`visibility: 'spatial-grid'`. The world is divided into square cells, and a client receives the records in the block of cells around its anchor.

T

Term	Meaning
Tick	One server simulation step. Writes and RPCs that arrived since the last one are already applied when `tick` runs.
Tick rate	Ticks per second in tick mode. An integer from 1 to 240, 20 by default, set as `tickRate` in `irtio/room.ts`.

V

Term	Meaning
Validate	The room function that accepts, clamps or rejects an owner’s write before anyone else sees it. Return `next`, `prev`, or a corrected object.
Visibility	The per-collection option deciding who receives it. `'all'`, `'role'` or `'spatial-grid'`.

W

Term	Meaning
World builder	The shared module both halves import for prediction, exporting `gravity`, `setup`, `bodies` and `intents`. By convention it is `irtio/world.ts`.

Next steps

The mental model for how rooms, owners and the server fit together.
Room file API for the full server surface.
Client SDK for the full browser surface.