API reference

Use this reference to look up a public C# type or member. For instructions and complete examples, start with the guides.

Core

Build replicated gameplay with identities, behaviors, variables, RPCs, prediction, sync components, and project settings.

Type	Summary
AuthorityMode	Enum. Lists which process produces state for a synchronized component.
AuthorityRpcAttribute	Class. Runs on the worker that has authority over the entity.
ClientRpcAttribute	Class. Runs on every client that knows the entity (or only its owner when sent with OwnerRpc).
CohesionGroups	Static class. Which entities belong to which NetworkIdentity.CohesionGroup, in this process.
CommandLine	Static class. Tiny "-key value" / "-key=value" / "-flag" parser over Environment.GetCommandLineArgs.
CrossIslandJoint	Struct. A physics constraint Nebula cannot simulate symmetrically: a Joint or a child ArticulationBody whose two bodies belong to networked entities in different containers, so that two workers can end up each owning one side.
DatabaseUrl	Struct. Where the orchestrator keeps the control plane and saved entities, as one string (NebulaConfig.DatabaseUrl, -nebula-database).
DotEnv	Static class. Reads and writes dotenv files (.env.nebula, the file NEBULA_ENV_FILE names, nebula env pull output), and holds the rules for the names of the environment variables a game gives its workers.
FrameAttachment	Class. Fixes an entity to a container at a pose in the container's space: a crate strapped to a cargo grid in a ship's hold, a turret bolted to a deck, a crate set on a shelf in a building.
FrameInertia	Class. Lets a physics prop inside a moving physics frame feel the frame's motion: crates slide aft when the ship accelerates, outwards when it turns.
HistoricalState	Struct. What an entity looked like at one recorded server tick: the answer of NetworkIdentity.StateAt.
INetworkInput	Interface. Marker for the per-tick input struct a predicted entity consumes.
IRpcSink	Interface. Where RPCs and state changes go once a behaviour has produced them.
NebulaConfig	Class. Project-wide Nebula settings.
NebulaCost	Static class. Where a game says what one entity costs to simulate, beyond the category it falls into.
NebulaDiagnostics	Static class. Process-wide counters for rule violations Nebula rejects at the call site, so tests and the worker's profile log line can see how often game code hits them.
NebulaEnv	Static class. A game's own settings and secrets on a worker (service URLs, API keys, feature flags): the environment variables set with nebula env, in the Nebula Cloud dashboard, or in .env.nebula for local runs.
NebulaGameMode	Abstract class. Server-side game hooks, the equivalent of subclassing Mirror's NetworkManager.
NebulaLog	Static class. Thin logging wrapper so every Nebula line is greppable by prefix in headless logs.
NebulaRuntime	Static class. Process-wide role context.
NebulaServerScriptingBackend	Enum. The scripting backend of a Linux dedicated server build (NebulaConfig.ServerBuildScriptingBackend).
NetworkAnimator	Class. Replicates selected Animator parameters from the authoritative worker to clients and ghost workers.
NetworkBehaviour	Abstract class. Base class for replicated gameplay components.
NetworkIdentity	Class. Marks a GameObject as a networked entity.
NetworkMap<TKey, TValue>	Class. A keyed collection replicated from the authoritative worker to clients and ghost workers, sending only what changed.
NetworkMapBase	Abstract class. The untyped half of NetworkMap<TKey, TValue>: what NetworkIdentity needs to send and apply a map without knowing its types (docs/replicated-collections.md).
NetworkMapChange<TKey, TValue>	Struct. One key's change, raised by NetworkMap<TKey, TValue>.OnChanged on every copy of the map.
NetworkMapChangeKind	Enum. What happened to one key of a NetworkMap<TKey, TValue>.
NetworkMotionState	Class. Motion shared by scripted movement, prediction, physics, telemetry, and persistence.
NetworkPrefabs	Static class. Prefab id table shared by every process.
NetworkRigidbody	Class. Puts a Unity Rigidbody under the mesh's authority model.
NetworkSyncBehaviour	Abstract class. Base for components that replicate through the per-tick sync channel and support server or owner authority.
NetworkTime	Static class. Provides the shared 60 Hz simulation tick.
NetworkTransform	Class. Replicates selected position, rotation, and scale axes from the authoritative worker to clients and ghost workers.
NetworkVariable<T>	Class. A field replicated from the authoritative worker to clients and ghost workers.
NetworkVariableBase	Abstract class. Defines the serialization and change tracking used by every NetworkVariable<T>.
PhysicsIslands	Static class. Decides whether two networked bodies are simulated by one authority (the same island) and finds the joints that are not.
PlayerInfo	Struct. Who is joining, as the gateway told the worker (NebulaGameMode.OnSpawnPlayer).
PredictedBehaviour<TInput>	Abstract class. A server-authoritative, client-predicted behaviour (the player controller, typically).
PredictedBehaviourBase	Abstract class. Non-generic surface Nebula's worker and client drive; game code derives from PredictedBehaviour<TInput>.
RemoteInterpolator	Class. Tick-indexed pose buffer for copies of an entity this process does not simulate: ghosts on a worker and remote entities on a client.
SceneEntities	Static class. The scene-placed entities resident in this process, by NetworkIdentity.SceneId.
ServerRpcAttribute	Class. Sent by the owning client, runs on whichever worker currently has authority over the entity.
StateHistory	Class. The bounded per-entity ring of recorded ticks behind NetworkIdentity.StateAt: pose, velocity, container, epoch and the SyncHistoryAttribute variables, one entry per server tick, indexed by tick % capacity.
SyncAudience	Enum. Who receives a behavior's sync state (NetworkBehaviour.SyncAudience).
SyncAudienceCodec	Static class. The client member sets of an entity's SyncAudience.Custom behaviors, as the authority last evaluated them: [count:byte]{[behaviourIndex:byte][n:ushort]{[clientId:ulong]}}, each set sorted ascending.
SyncDistanceRating	Enum. Whether a behavior's sync state reaches far clients less often, following the entity's distance tier as its transform does (NetworkBehaviour.SyncDistanceRating, docs/server-owned-entities.md D11).
SyncHistoryAttribute	Class. Marks a NetworkVariable<T> field as part of the entity's recorded state history, so its value is snapshotted every tick alongside the pose and can be read back through NetworkIdentity.StateAt / HistoricalState.TryGetValue<T>.
SyncStateCodec	Static class. Envelope shared by the per-tick sync stream (EntityState/GhostSyncState messages) and the spawn snapshot: [count]{[behaviourIndex][flags][len:ushort][chunk]}.
UpdateGapDelay	Class. The extra render delay a client gives one remote entity whose state arrives further apart than the render delay: an entity the worker updates every few ticks (NetworkIdentity.UpdateInterval), or one the gateway sends a client only every ...

Containers

Define container volumes and look up their current worker assignments.

Type	Summary
Container	Class. Defines a box-shaped authority area with its own local coordinate space.
ContainerAuthority	Enum. Who simulates what is inside a container (docs/container-tree.md D6).
ContainerFrameMode	Enum. Where a container's box is (docs/container-tree.md D1).
ContainerHint	Struct. What the game knows about a container that the orchestrator cannot measure: how expensive it really is, what it belongs with, how much a worker boundary beside it hurts, and whether it wants a machine to itself.
ContainerPlacement	Struct. Where a runtime container goes and what kind of container it is: its parent, its box, its authority and whether it gets its own physics frame.
ContainerRef	Struct. How a container is named on the wire.
ContainerRegistry	Static class. The container graph of the loaded level: every static Container, indexed deterministically so all processes agree on indices, plus adjacency (adjacent = bounds touch or overlap), plus the dynamic containers currently carried by entities ...
ContainerSource	Enum. Where a container comes from (docs/container-tree.md D1).
Double3	Struct. A 64-bit-per-axis position.
DynamicContainer	Class. Obsolete, and does nothing.
EntityLocation	Struct. Where an entity durably is, independent of which worker holds it: an opaque scope key, a container id and a pose in that container's local space.
FrameCrossing	Enum. What a crossing policy says about one entity crossing a frame boundary (docs/container-tree.md D16).
FrameInterestMode	Enum. How the contents of a container with its own physics frame are bucketed for interest management (docs/container-tree.md D18).
HistoryRewind	Struct. A scene put back as it was at a past server tick, for as long as it is held (docs/portals.md D33; the history is docs/state-history.md).
IFrameCrossingPolicy	Interface. The game's say over where entities may cross a physics frame's boundary: anywhere on the hull, or only through portals.
IInstanceContentLoader	Interface. Content of an instance part that finishes loading after InstanceScenes.Prepare returns: geometry a component builds over several frames, or assets it loads asynchronously.
InstanceContentState	Enum. Whether an instance part's content is still loading, ready, or failed.
InstancePoses	Static class. The instances this process holds whose own space is turned against their host scope's (NEB-426, docs/scope-frames.md D12): built upright in their own space and posed at a door that is not upright in the host (a door on a sphere).
InstanceScenes	Static class. Loads instance geometry into separate physics scenes.
InstanceTemplate	Class. Reusable geometry and container bounds for a private area.
LocationContainerKind	Enum. Which kind of container an EntityLocation.ContainerId names.
NebulaContainerHelpers	Static class. Geometry helpers for placing things inside a Container.
PhysicsFrame	Class. A container's own physics frame: a local physics scene in which the container stands still (docs/container-tree.md §3).
PhysicsFrameState	Struct. The motion of a physics frame in the space around it, once per tick, on every process that holds the frame (docs/container-tree.md D14): its pose, linear and angular velocity, and linear acceleration.
PhysicsFrames	Static class. The physics frames this process holds, one per container with Container.OwnPhysicsFrame (docs/container-tree.md §3): scene lifetime and pooling, interior colliders, frame state, conversion between spaces, the crossing policy, and — on a ...
Portal	Class. A way between two scopes: an opening in a wall, a hatch, a gate, a door to a room of its own (docs/portals.md).
PortalAperture	Struct. The opening of a portal, on its face's z = 0 plane (docs/portals.md D3): an oriented box centred on the face's origin.
PortalAsker	Struct. Who is asking a portal query (docs/portals.md D12, D32): the entity whose own colliders the cast skips, and the party whose link it goes through.
PortalCrossing	Struct. Where a cast went through an open portal (docs/portals.md D32): the link, the scope it left and the scope it entered, how far along it the plane was met, and the cast as it continues on the far side, as a point in the far scope's scene (...
PortalFace	Struct. One side of a Portal (docs/portals.md D2): a scope, the container the face is fixed in, and a pose, an absolute Double3 position in that scope and a rotation.
PortalHit	Struct. One thing a portal query found (docs/portals.md D32): the scope it is in, the collider and the entity, how far along the cast it is, and its point in both the asker's space and the hit scope's.
PortalHitFlags	Enum. What a PortalHit is besides a collider (docs/portals.md D32, D33).
PortalLink	Class. One party's link through a Portal (docs/portals.md D8, D9): the far scope, the state the link is in and, when it is not open, what it waits for.
PortalPose	Struct. A pose in a scope: an absolute Double3 position and a rotation in the scope's own axes.
PortalProxy	Class. Marks a collider Nebula made to carry one side of a portal into the other (docs/portals.md §6): a kinematic copy of a body that touches an open link's band (D26), a static copy of the other side's geometry in the throat (D27), or ghost h...
PortalQueries	Class. Raycasts, sweeps and overlaps that continue through an open portal (docs/portals.md D32, D33).
PortalQueryOptions	Class. Settings of a portal query (docs/portals.md D32, D33).
PortalRefusal	Enum. Why a portal did not let an entity through, or leave a companion behind (docs/portals.md D17).
Portals	Static class. Lookup for portals (docs/portals.md D1): the Portal components on this process, on a client what the network gateway has told it about the portals near it, and the link poses between scopes (Map, Turn).
ScopePose	Struct. Where a drawn scope stands against the anchor, the scope whose frame the local view's frame resolves to (docs/portals.md D40, Portals.Anchor): the composition, in double and about the faces, of the link poses along the portals from the a...

World partition

Split a large world into cell scenes, stream them by role, and keep coordinates near a floating origin.

Type	Summary
ChunkContent	Abstract class. Scene-object form of NebulaChunks.Loaded/NebulaChunks.Unloading: drop a subclass in the game scene and override OnChunkLoaded.
ChunkContext	Struct. What a game is told about one chunk of a chunked world.
ChunkGridDefinition	Class. What one procedural chunk grid is: the cell arithmetic every role must agree on, plus the one chunk that is brought into being with the scope so a client always has somewhere to arrive.
ChunkKeys	Static class. How a chunk coordinate becomes the ids a scope's containers are named by.
ChunkLattice	Class. The built-in IChunkGridGeometry: a lattice of equal boxes, either one layer of columns centred on y = 0 (Planar) or a volumetric lattice, cell (x, y, z) spanning [x, x + 1) cells on each axis.
ChunkState	Static class. Sparse, persistent state for objects that a game places procedurally inside chunks (runtime containers).
ChunkStateEntity	Class. The entity that carries one chunk's ChunkState entries.
ChunkStateOutcome	Enum. What became of a change made through ChunkStateService.
ChunkStateResult	Struct. The result of one change, passed to the callback of a ChunkStateService call.
ChunkStateService	Class. The write side of ChunkState on a worker, reached as NebulaWorker.ChunkStates.
IChunkGridGeometry	Interface. The shape of a hosted chunk grid (docs/container-tree.md D22): which cell a point of the host belongs to, each cell's box, which cells surround a cell, and what id each cell's container gets.
IWorldAnchor	Interface. Something the streamer keeps cells loaded around.
NebulaChunkedWorld	Class. The whole server and client side of an unbounded chunked world, wired from configuration alone (NebulaConfig.ChunkedWorld plus a NebulaConfig.RuntimeWorld).
NebulaChunks	Static class. Reports the runtime chunks available on each role so your game can load their content.
NebulaWorld	Static class. Nebula's floating-origin world state.
NebulaWorldStreaming	Class. Decides, per role, which cells this process keeps loaded and where the floating origin sits: worker: the cells of every container it leases plus NebulaConfig.WorkerLoadRingCells rings around them so ghosts and boundary physics have the n...
ObjectState	Struct. The saved state of one procedurally placed object: a rock that has been mined, a plant that has been harvested.
ObjectStateChange	Struct. One change to one object's entry, raised through ChunkState.Changed.
ObjectStateChangeKind	Enum. What happened to an object's entry in ObjectStateChange.
RuntimeGrid	Class. Maps runtime containers to a planar or three-dimensional grid.
RuntimeGridAllocator	Class. Opt-in worker-side allocator for a game built on RuntimeGrid: keeps a ring of cells requested around every player-owned authoritative entity (and any fixed anchor coordinates, e.g.
ScopeFrame	Class. One scope's floating origin: which cell of that scope's grid currently sits at Unity's (0,0,0), and the delta every frame position of that scope gets when it moves.
ScopeFrames	Static class. The origin frames this process holds, one per scope.
WorldAnchor	Class. Anchor component: keeps the cells around this transform loaded.
WorldCell	Class. Marks the root of a cell scene with its grid coordinate.
WorldContainerManifest	Class. The baked container tree of a partitioned world: one container per cell plus every hand-authored Container found inside the cell scenes, with cell-local poses.
WorldDefinition	Class. A world partitioned into a 3D grid of cells, each authored as its own additive scene.
WorldGrid	Static class. Grid arithmetic shared by the streamer, the editor tooling and Nebula's container integration.
WorldOrigin	Static class. The floating origin: which cell currently sits at Unity's (0,0,0).
WorldStreamer	Class. Loads and unloads cell scenes additively and keeps them placed relative to the floating origin.

Worker

Spawn and simulate authoritative entities, manage ghosts, and transfer entities between workers.

Type	Summary
AuthorityCallAction	Enum. What a worker does with an incoming call.
AuthorityCallDecision	Struct. The decision for one incoming call: the action and, for a rejection, the reason.
AuthorityCallId	Static class. The identity of one cross-worker call: the sending worker's index in the top 16 bits and a per-sender sequence in the low 48, the same shape as an entity NetId.
AuthorityCallLedger	Class. The call ids a worker has applied, so a call that arrives twice runs once (design D5).
AuthorityCallOutcome	Enum. Where an AuthorityRpc call ended up.
AuthorityCallResult	Struct. The outcome of one AuthorityRpcWithReply call, handed to its callback exactly once.
AuthorityCallRouter	Class. The rules every worker applies to an incoming AuthorityRpc call, in one place and with no engine types, so the worker, the standalone services and the conformance tests run the same code.
AuthorityCallTarget	Struct. What the receiving worker knows about a call's target when the call arrives.
AuthorityCallTracker	Class. The sender's side of the reply channel: the calls this worker sent with a reply requested and has not heard back about.
CargoPolicy	Enum. What happens to the entities riding in a carrier's container when the carrier is despawned with NebulaWorker.Despawn (docs/frame-bodies.md D5).
ContainerCostMeter	Class. What each container this worker leases is actually costing it, measured rather than guessed: the NetworkTick time spent on its entities, the replication bytes they put on the wire, and the owner state a gateway has to relay for them.
EntityRequestResult	Struct. Outcome of one EntityRequests.Request call.
EntityRequestStatus	Enum. Where a EntityRequests call ended up.
EntityRequests	Class. Asks whichever worker currently has authority over a PersistentEntity key, without needing a local ghost of it: a container query has neighbours to fall back to, but a persistent key has none, since the entity may be nowhere near this wo...
FrameProfiler	Static class. Wall time per Unity frame on a worker, and where in the frame it goes.
FrameReport	Struct. One profile window of whole-frame time, in milliseconds per Unity frame (see FrameProfiler).
IWorkerMessaging	Interface. Defines the worker messaging operations used by WorkerQuery.
InstanceTransfer	Class. A prepared crossing.
NebulaLifecycle	Static class. The moments at which the mesh brings a container or a scope to life, or puts it to sleep, as game hooks.
NebulaWorker	Class. Runs authoritative game simulation for the containers assigned to this worker.
WorkerMemorySampler	Static class. Reads a worker's memory figures for its heartbeat and its profile log line.
WorkerQuery	Class. Sends one game-defined request to several workers and collects their replies.
WorkerRegistration	Class. Registers a worker with the control plane and restores missing container assignments after the control-plane document is replaced.
WorkerScopeLifecycle	Class. The worker's half of the scope lifecycle (docs/scope-lifecycle.md): it keeps the idle clock of the scope parts it owns honest, performs the retire sequence for a scope the orchestrator moved to ScopeState.Retiring, and reports a restore ...
WorkerTelemetry	Class. Reports what a worker holds to the World map of the Nebula Dashboard (MeshTelemetry): for every container with anything in it on this worker, how many players, bots, server-driven and other authoritative entities it holds there, and how ...

Client

Connect a player to the gateway, predict the local entity, and display replicated state.

Type	Summary
DisconnectInfo	Struct. How a client's connection ended: the typed Reason, a Message for logs and the player, and whether the client will try again by itself (WillRetry).
DisconnectReason	Enum. Why a client's connection to the gateway ended, or why an attempt to connect failed.
FarEntity	Class. An entity of the far relevance tier as a client sees it (NEB-388, docs/interest-management.md §16): a large or important entity beyond its normal relevance radius, with no replica, no variables and no RPCs, only enough to draw a marker o...
FarEntityRemoval	Enum. Why an entity left NebulaClient.FarEntities.
LocalPlayerLossCause	Enum. Why the local player's pawn went away while the client stayed connected (NebulaClient.LocalPlayerLost).
NebulaClient	Class. The game client.
NebulaTitleScreen	Class. Optional IMGUI panel where a player enters the gateway address and a display name before connecting.
SceneRenderOrigin	Static class. A client's render origin for the whole scene (docs/container-tree.md D25): while cameras draw, the scene's top-level objects and the cameras are moved by -Offset, the camera's position snapped to Step, so everything near the camera is dr...
StreamLateness	Class. How late a client's world-state streams arrive, for the adaptive part of the render delay (NebulaConfig.AdaptiveInterpolationDelay).

Gateway

Accept client connections, route input to workers, and send replicated state to clients.

Type	Summary
AdmissionAction	Enum. What the admission hook may answer (AdmissionDecision).
AdmissionDecision	Struct. The game's answer to AdmissionRequest.
AdmissionKind	Enum. Why somebody is asking to enter a target (AdmissionRequest.Kind).
AdmissionRequest	Struct. What the game is told when something asks to enter a target that is at capacity.
AnonymousIdentityIssuer	Class. Identities the gateway hands to clients that present no token: an HS256 token with iss PlayerIdentity.AnonymousIssuer and a random sub, which the client keeps and presents on its next connection to get the same AuthResult.Identity back.
AuthResult	Struct. Outcome of checking the token a client presented in Hello (see OidcTokenValidator).
InterestLinkReason	Enum. Why a gateway holds a link to a worker.
JsonWebToken	Static class. Compact JSON Web Token (JWT) encoding: split, decode and sign.
MeshPeerAuth	Static class. How gateways and workers prove to each other that they belong to the mesh: HelloMsg.Token on an infrastructure link carries unixSeconds.base64url(HMAC-SHA256(key, role\|id\|incarnation\|unixSeconds)) with a key derived from the mesh token (...
NebulaAdmission	Static class. The hook that decides what happens when an interaction domain is full.
NebulaGateway	Class. Accepts client connections and maintains a connection to every worker.
OidcTokenValidator	Class. Checks OpenID Connect ID tokens against the issuers a mesh trusts (NebulaConfig.AuthIssuers): signature (RS256/384/512 and ES256/384/512 with the provider's published keys), issuer, expiry, and audience.
PlayerIdentity	Static class. A player's identity across sessions: 64 lowercase hex characters, the SHA-256 of the token's issuer and subject.
SessionClaims	Struct. What a session token says about the session it names.
SessionIds	Static class. Mesh-wide session ids.
SessionTokens	Class. Issues and checks the session tokens a gateway gives every welcomed client (WelcomeMsg.SessionToken).

Orchestrator

Start and stop workers, assign containers, and serve the dashboard.

Type	Summary
AssignmentInput	Class. Everything an assignment policy may look at.
AssignmentMove	Struct. One container the planner decided to hand to another worker, with the sentence that explains why (docs/cohesion-rebalancing.md).
AssignmentPlan	Class. What a policy would do with a hypothetical number of workers: which containers each of them would hold, and how loaded that would leave them.
AssignmentPlanner	Static class. Runs an IAssignmentPolicy as a dry run against a hypothetical worker count.
BakedAssignmentPolicy	Class. The original policy: baked containers are dealt as evenly as possible by count, sticky to their owner, in wire order when that order is spatial (NebulaOrchestrator.ComputeAssignment).
CapacityInfo	Struct. How close one container - or one whole scope - is to what a single worker can carry, derived from the cost telemetry the worker already reports (ContainerCost, docs/cost-telemetry.md).
CloudHostSettings	Class. Settings a cloud host needs to create a worker machine.
CloudWorkerHost	Class. An IWorkerHost for managed hosting: instead of calling a cloud provider, the orchestrator asks a deployment-scoped resource API for a worker (POST /d/workers), polls the list for its state and private address, and deletes, parks and unpa...
CloudWorkerHostSettings	Class. Where a managed deployment's orchestrator asks for worker machines: a resource API scoped to this one deployment, reached with a token that can do nothing else.
CohesionGroupInfo	Class. One entity cohesion group as the orchestrator sees it: the union of what every worker reported about the members it owns (NebulaWorker.CohesionSpan, docs/cohesion-hints.md D7).
ContainerCost	Struct. What one container cost the worker that leases it, split into the three components of CostComponent.
ContainerLoad	Struct. What one worker last reported about one container: who is inside it (see WorkerTelemetry).
CostBalancedAssignmentPolicy	Class. Deal by load: every container (baked or runtime) costs what CostWeights says its occupants cost, containers are ordered along a Morton curve of their centres so neighbours sit next to each other, and the curve is cut into one contiguous ...
CostComponent	Enum. The three things a container can be expensive in.
CostWeights	Struct. How much simulating a container costs a worker, from what is inside it.
HetznerWorkerHost	Class. One Hetzner Cloud VM per worker, created through the Hetzner Cloud API `(https://docs.hetzner.cloud).`
IAssignmentPolicy	Interface. Decides which worker simulates which container.
IExplainsAssignment	Interface. A policy that can say why it moved what it moved.
IWorkerHandle	Interface. One launched worker as seen by its host.
IWorkerHost	Interface. Where worker instances live.
JsonWriter	Class. Just enough JSON writing for the dashboard state document; avoids a JSON library dependency in the runtime.
LogBuffer	Class. The mesh's recent log lines, kept on the orchestrator so one place holds what every process of the mesh said last: workers, gateways and the orchestrator's own shipper post batches to POST /api/logs ({"lines":[{"at","role","instance","le...
MeshTelemetry	Class. The data behind the World map page of the Nebula Dashboard (/map).
NebulaCapacity	Static class. Deriving the capacity signal from cost rows, and reading it back off the control plane.
NebulaOrchestrator	Class. Spins worker processes up and down and authoritatively assigns containers to them through the control plane.
OrchestratorEvent	Struct. One line of the orchestrator's recent history, shown on the dashboard.
OrchestratorHttpServer	Class. The orchestrator's tiny web server: serves the dashboard page and a JSON state document, and forwards commands (POST) to the main thread.
PersistenceEditor	Class. Reads and rewrites persisted records for the dashboard's Persistence tab (/persistence).
ProcessWorkerHost	Class. Runs each worker as a child Unity process using the configured worker executable.
SaturationCause	Enum. Why the planner could not take load off the busiest worker (SaturationReport).
SaturationReport	Struct. The planner's answer to "why is this still hot?".
ScaleAction	Enum. What the scaler decided this pass.
ScaleDecision	Struct. The scaler's answer, and everything the dashboard needs to explain it.
ScaleSettings	Struct. The two lines and the two clocks the scaler works to; a copy of the matching NebulaConfig fields.
UnsplittableGroup	Struct. A group of containers the planner had to keep on one worker but could not fit there (docs/cohesion-hints.md, D9).
WorkerEnvironment	Static class. The game's environment variables a worker host gives every worker it launches, in this order (a later layer wins over an earlier one): The service manifest's Env map (ManifestEnv): the non-secret variables of a self-hosted deployment, wr...
WorkerHandleState	Enum. Lists the supported worker handle state values.
WorkerHostBase	Abstract class. Base class for hosts that do not park: Park kills, Unpark fails, and the orchestrator never parks into them.
WorkerLaunchSpec	Class. What the orchestrator asks a host to run.
WorkerLoadTracker	Class. How busy each worker is, as a fraction of its tick budget: WorkerInfo.TickMs / tickPeriodMs, sampled from every heartbeat and kept for a short window (NebulaConfig.ScaleWindowSeconds).
WorkerScaler	Class. Decides when the mesh should gain or lose a worker, by asking the assignment policy what it would do rather than dividing an abstract cost by a worker count.

Control plane

Register processes and share container assignments and settings through the control plane the orchestrator hosts, or an in-process test implementation.

Type	Summary
ControlPlaneExtensions	Static class. Provides the control plane extensions API.
ControlPlaneHost	Class. The control plane as the orchestrator hosts it: a LocalControlPlane that is the source of truth, served to workers and gateways over the orchestrator's HTTP server and kept in an IControlPlaneStorage between runs.
ControlPlaneJson	Static class. The control plane as one JSON document, and one control-plane write as one JSON object.
FileControlPlaneStorage	Class. The document in one file, written beside it and moved into place so a crash mid-write keeps the previous copy.
GatewayInfo	Class. Describes a gateway registered with the control plane.
GatewaySessionReply	Class. The result of a gateway admission operation.
GatewaySessionRequest	Class. An operation on one player's admission claim.
GatewayStats	Struct. What a gateway reports about itself on every heartbeat.
IControlPlane	Interface. Provides process registration, container assignments with epochs, and game-defined settings.
IControlPlaneStorage	Interface. Where ControlPlaneHost keeps the control plane between orchestrator runs: one JSON document (ControlPlaneJson), written a little after every change and read once at startup.
IGatewaySessionControlPlane	Interface. Optional control-plane extension for single-session gateway admission.
IScopeStore	Interface. Where the orchestrator keeps the claim on a scope key between runs.
LeaseInfo	Class. Describes the current worker assignment for one container.
LeaseState	Static class. Provides the states used by a container lease.
LocalControlPlane	Class. The control plane's state machine: registrations, heartbeats, leases with epochs and settings, kept in plain lists in this process.
MemoryControlPlaneStorage	Class. Keeps nothing: the control plane starts empty on every orchestrator run.
MeshSettings	Static class. Mesh-wide settings Nebula itself writes, in the same key/value channel the game uses (IControlPlane.Settings).
RemoteControlPlane	Class. IControlPlane for a worker or gateway: a mirror of the control plane the orchestrator hosts (ControlPlaneHost), reached over HTTP at the orchestrator's dashboard address.
ScopeAck	Class. One worker's acknowledgement that it finished a lifecycle step for one part of a scope.
ScopeActivationRequest	Class. What a caller asks for when it wants a scope to exist.
ScopeDefinition	Class. What a scope is made of: the containers to bring into being and how their occupants see the public world.
ScopeInfo	Class. A shared simulation scope the mesh has been asked to bring into being: the opaque key that names it, the definition it was activated from, and the containers that now exist for it.
ScopeJson	Static class. The scope row and the scope definition as JSON, inside the control-plane document and the activation op.
ScopeKeys	Static class. How a scope key becomes the ids every role agrees on.
ScopeKind	Static class. The shapes a ScopeDefinition can take.
ScopeLifecycle	Static class. The scope lifecycle's pure parts: how idle age and occupancy are aggregated from a scope's parts, when a scope should retire, and whether a client may be admitted to it.
ScopePart	Class. One runtime container of a scope: a stable part id and an axis-aligned box in absolute world coordinates.
ScopePhase	Static class. What a worker has finished doing to one part of a scope (ScopeAck).
ScopeRetireContext	Struct. What the retire policy is told about a scope.
ScopeState	Static class. The states a ScopeInfo row can be in.
WorkerInfo	Class. Describes a worker registered with the control plane.
WorkerRoster	Class. Which workers the orchestrator has declared dead, as a mirror of the control plane can tell: a worker row that was in the last document observed and is missing from this one, when both are the same document (IControlPlane.DocumentId).
WorkerStats	Struct. What a worker reports about itself on every heartbeat.
WorkerStatus	Static class. Provides the lifecycle states reported by a worker.

Bootstrap

Choose a process role and start its Nebula components.

Type	Summary
EditorDevPaths	Static class. Where the Multiplayer Play Mode dev loop keeps its files: under the project's Library/Nebula, shared by the main Editor and every virtual player, and never read by a build.
EditorDevSession	Static class. Binds the clients of the Multiplayer Play Mode dev loop to the server their own session started, so a client never joins some other mesh that happens to hold the port.
EditorPlayer	Enum. What one Editor process does under NebulaEditorRunMode.MultiplayerPlayMode, decided by EditorRunPlan.Resolve from facts the bootstrap reads (whether this is the Editor, whether this is the main Editor or a virtual player, its Multiplayer...
EditorRoster	Struct. What one virtual player knows about the others of the Multiplayer Play Mode window, read from the project's Library/VP/SystemData.json (EditorRosterReader).
EditorRosterReader	Static class. Reads Library/VP/SystemData.json, where Multiplayer Play Mode lists its players.
EditorRunPlan	Struct. The decision for one Editor process in the Multiplayer Play Mode dev loop, and the settings it implies.
NebulaBootstrap	Class. Entry point for Unity workers and clients.
NebulaEditorPersistence	Enum. Where the server a virtual player hosts keeps persistent entities (NebulaConfig.EditorPersistence).
NebulaEditorRunMode	Enum. What pressing Play in the Editor starts (NebulaConfig.EditorRunMode).
NebulaRoles	Enum. Lists the process roles that NebulaBootstrap can start.

Serialization

Write and read values used by messages, variables, inputs, and RPCs.

Type	Summary
INetworkSerializable	Interface. Implement on structs/classes you want to put in a NetworkVariable<T> or an RPC argument.
NetworkReader	Class. Counterpart of NetworkWriter.
NetworkSerialization	Static class. Type-driven (de)serialisation used by NetworkVariables and RPC arguments.
NetworkWriter	Class. Writes Nebula messages to a growable little-endian byte buffer.

Transport

Send reliable ordered or unreliable sequenced messages through LiteNetLib.

Type	Summary
ChaCha20Poly1305Managed	Static class. Implements ChaCha20-Poly1305 authenticated encryption with associated data (AEAD), as specified in RFC 8439.
ClientEncryption	Class. Configures gateway certificate pinning and the client handshake timeout.
Delivery	Enum. Delivery classes supported by each Nebula network link.
EncryptedTransport	Class. Encrypts client-to-gateway packets over a User Datagram Protocol (UDP) transport.
ISecureTransport	Interface. Reports encryption status for each peer.
ITransport	Interface. Provides the network transport used by Nebula.
LiteNetTransport	Class. ITransport over LiteNetLib.
MultiTransport	Class. Several transports behind one ITransport, so the gateway accepts native clients over UDP and browsers over WebRTC without caring which link a peer arrived on.
NebulaCrypto	Static class. Provides random bytes, SHA-256 hashes, hash-based message authentication codes (HMAC), and key derivation for encrypted transport connections.
NetworkSimulation	Class. Network conditions to simulate on one link, for testing prediction and lag compensation on one machine.
SimulatedNetworkTransport	Class. An ITransport that adds the latency, jitter and packet loss of a NetworkSimulation to every link of another transport, in both directions, without touching the remote side.
TransportDisconnectReason	Enum. Why a transport link closed, in terms that do not depend on the transport: carried by a TransportEvent.Kind.Disconnected event in TransportEvent.Reason.
TransportEvent	Struct. Stores the values used by transport event.
TransportIdentity	Class. Holds the gateway's X.509 certificate, RSA private signing key, and public-key fingerprint for client pinning.
TransportSecurity	Static class. Reads encryption status and handshake errors through an ITransport reference.
X25519	Static class. Implements X25519 key agreement from RFC 7748 §5 using BigInteger arithmetic.

Protocol

Inspect messages exchanged by clients, the gateway, and workers.

Type	Summary
AuthorityCallFlags	Enum. Flags on an AuthorityCallMsg.
AuthorityCallMsg	Struct. An AuthorityRpc on the worker-to-worker link (MsgId.AuthorityRpc).
AuthorityCallReplyMsg	Struct. The outcome of an AuthorityCallMsg that set AuthorityCallFlags.WantsReply (MsgId.AuthorityRpcReply), sent by the worker that decided it to the worker whose index the call id carries.
AuthorityTransferMsg	Struct. The authority event.
ByteArrayComparer	Class. Compares byte arrays by content: how a party without game types keys a map (the gateway's cache).
ClientFocusHintMsg	Struct. Client -> gateway: where the player is looking, as a hint for interest (a sniper scope, an RTS camera).
ClientInputMsg	Struct. A short run of recent inputs (redundant against loss).
ContainerOwnershipEntry	Struct. Stores the values used by container ownership entry.
ContainerOwnershipMsg	Static class. Carries the container ownership protocol message.
ContainerOwnershipUpdate	Struct. What one MsgId.ContainerOwnership message says: either the complete set of containers a client should know about (Full) or a change to it.
DespawnPlayerMsg	Struct. Gateway -> worker: the client's link ended, so the session waits for a reclaim, or the session is over (EndNow).
DriveInputMsg	Struct. A driver's recent inputs for an entity it drives (MsgId.DriveInput, protocol 25): the same frames as ClientInputMsg, for the entity NetId names instead of the sender's pawn.
EndSessionMsg	Struct. Worker -> gateway: this gateway no longer speaks for the session, because the player connected again through another gateway (NebulaConfig.SingleSessionPerPlayer).
EntityDespawnMsg	Struct. Carries the entity despawn protocol message.
EntityExtentSource	Enum. Where an entity's extent comes from: the box, in the entity's own space, that the ghost band measures to each neighbouring container instead of the entity's root position (NetworkIdentity.ExtentSource).
EntityFlags	Enum. Lists the supported entity flags values.
EntityForgetMsg	Struct. Worker -> gateway: the entity left every region this gateway subscribes on this worker.
EntityInterestFlags	Enum. Per-prefab interest hints that travel with a spawn (the standalone gateway has no prefabs to read them from).
EntityMapsMsg	Struct. Changed map entries for one entity (docs/replicated-collections.md D4): MsgId.EntityMaps worker to gateway to client, MsgId.GhostMaps worker to worker.
EntityRedirectMsg	Struct. Worker -> gateway: an entity the gateway subscribed by id (a policy extra, or one it owns) is now on another worker.
EntityRpcMsg	Struct. Carries the entity rpc protocol message.
EntitySpawnMsg	Struct. Full description of an entity.
EntityStateEntry	Struct. One entity's selected transform fields inside a WorldState/GhostState batch.
EntitySyncMsg	Struct. One entity's sync chunks for one tick (see SyncStateCodec).
EntityVarsMsg	Struct. Carries the entity vars protocol message.
FarEntitiesMsg	Static class. Worker -> gateway, and gateway -> client: a batch of far-tier entries (MsgId.FarEntities, protocol 26).
FarEntityEntry	Struct. One entity of the far relevance tier (docs/interest-management.md §16, NEB-388): a large or important entity seen beyond the normal interest radius as a pose and nothing else.
FarEntryFlags	Enum. Lists the supported far entry flags values.
FarEntryKind	Enum. What one FarEntityEntry says about its entity.
GatewayDrainingMsg	Struct. Gateway -> client: the gateway is draining and will close this link.
GoodbyeMsg	Struct. Client -> gateway: the player is leaving for good (MsgId.Goodbye, protocol 23).
HelloFlags	Enum. Lists the supported hello flags values.
HelloMsg	Struct. Carries the hello protocol message.
InstanceContainerInfo	Class. Identifies a private container's simulation scope and content.
InstancePreparationMsg	Struct. Carries the instance preparation protocol message.
InterestResyncMsg	Struct. Worker -> gateway: the last InterestSubscribeMsg could not be applied (wrong base sequence, or the result did not verify).
InterestSubscribeFlags	Enum. Lists the supported interest subscribe flags values.
InterestSubscribeMsg	Struct. Gateway -> worker: the set of regions this gateway wants entities from.
JoinHoldReason	Enum. Why a join is being held in JoinState.Starting.
JoinRejectReason	Enum. Why a join was refused, in typed form.
JoinRejectedMsg	Struct. Gateway -> client: the join was refused; Reason is fit to show the player.
JoinState	Enum. How far a client's join has got.
JoinStatusMsg	Struct. Gateway -> client: the join's state and, while JoinState.Starting, a rough wait in seconds (0 = unknown) and why.
KickPlayerMsg	Struct. Worker -> gateway: remove this player (MsgId.KickPlayer, protocol 23), sent by NebulaWorker.Kick to the gateway that speaks for the session.
KickedMsg	Struct. Gateway -> client: the server removed this player (MsgId.Kicked, protocol 23).
MsgId	Enum. Wire message ids.
NetworkMapCache	Class. The contents of an entity's maps kept as opaque bytes, by a party that relays them without knowing their types: the gateway, so a late joiner is sent the current contents (docs/replicated-collections.md D6).
NetworkMapCodec	Static class. The wire and save format of NetworkMapBase contents (docs/replicated-collections.md D3).
OwnerStateMsg	Struct. Authoritative post-simulation state of a predicted entity, for its owner's reconciliation.
PeerRole	Enum. Lists the supported peer role values.
PingMsg	Struct. Carries the ping protocol message.
PlayerClaims	Static class. Claims from a player's verified sign-in token that the gateway forwards to workers (NebulaConfig.ForwardedClaims): the claim names the game listed, with their values as strings.
PlayerSessions	Class. A worker's view of which gateway currently speaks for each player session, and how new that claim is.
PongMsg	Struct. Carries the pong protocol message.
PortalAdjacencyMsg	Struct. MsgId.PortalAdjacency (docs/portals.md D30, D45): a link the sender drives, as a worker that holds the other side of its band needs it.
PortalApertureKind	Enum. The shape of a Portal's aperture, the opening on its face's z = 0 plane (docs/portals.md D3).
PortalFarKind	Enum. How a portal names its far side (docs/portals.md D5).
PortalHandoffLink	Struct. One party's link as the worker that releases a portal's near container hands it to the new owner (PortalHandoffMsg).
PortalHandoffMsg	Struct. MsgId.PortalHandoff (docs/portals.md D44, D45): the links of one portal, sent by the worker that is releasing the portal's near container to the worker that is taking it, together with the release.
PortalIds	Static class. The ids portals and their links are named by (docs/portals.md D6): derived, so every process computes the same one.
PortalLinkFlags	Enum. Bit flags of a PortalLinkRecord.
PortalLinkRecord	Struct. One party's link through a portal, as the network gateway and a client learn it (MsgId.PortalLinks).
PortalLinksMsg	Static class. MsgId.PortalLinks: [upserts:ushort]{record}[removes:ushort]{linkId}, worker → network gateway → client.
PortalLinksUpdate	Class. A change to the links a receiver knows (MsgId.PortalLinks).
PortalRecord	Struct. A portal as the network gateway and a client learn it (MsgId.Portals, protocol 28): the near face, the far side, the aperture and the sizes of the regions derived from it.
PortalState	Enum. Where a party's PortalLink stands (docs/portals.md D9).
PortalWait	Enum. Why a link is not PortalState.Open (docs/portals.md D9).
PortalWarmMsg	Struct. MsgId.PortalWarm: a member client holds the far window of a link and its content is ready.
PortalWindow	Struct. One side's window of a portal (docs/portals.md D3, D20): the cross-section of the aperture grown by the portal's WindowMargin sideways and extruded WindowDepth into that side, an oriented box in the face's axes.
PortalsMsg	Static class. MsgId.Portals: [upserts:ushort]{record}[removes:ushort]{portalId}, worker → network gateway → client.
PortalsUpdate	Class. A change to the portals a receiver knows (MsgId.Portals): records to add or replace, and ids to forget.
ProtocolCompatibility	Static class. Checks client protocol and game content versions against the gateway's supported range.
SessionReplacedMsg	Struct. Gateway -> client: the player this client signed in as connected again elsewhere, and that newer connection now holds the session and the pawn (NebulaConfig.SingleSessionPerPlayer).
SpawnPlayerMsg	Struct. Gateway -> worker: a client wants a pawn.
SyncAudienceMsg	Struct. Worker to gateway (MsgId.SyncAudience, protocol 20): the member sets of an entity's SyncAudience.Custom behaviors changed.
TransformFields	Enum. Selected axes and encoding of a root transform update.
TransformFieldsExt	Enum. Protocol 30 additions to a root transform update, in a byte written after TransformFields to peers of HelloMsg.MotionFidelityVersion or newer.
WelcomeMsg	Struct. Carries the welcome protocol message.
WorldStateMsg	Static class. Batched transforms for one tick from one worker.

Debug

Display mesh status and measure worker tick sections.

Type	Summary
InterestProbe	Class. A client-side watchdog for interest management and content streaming: once a second it writes one machine-parsable line saying what this client can currently see and whether any of it is wrong.
NebulaDebugOverlay	Class. IMGUI status overlay for every role.
NebulaProfiler	Static class. Where a worker's tick goes.
ProfileSection	Class. A named stretch of code whose cost is accumulated by NebulaProfiler.

Editor

Build players, start a local mesh, validate a project, and author partitioned worlds in the Unity Editor.

Type	Summary
ContainerEditor	Class. Inspector for Container: the default fields plus a button that refits the box to the object's bounds.
NebulaBuild	Static class. Builds the Unity player for workers and clients, exports service data, and publishes the standalone .NET orchestrator and gateway beside it.
NebulaMesh	Static class. Developer loop: launch a local mesh from the last build (the standalone orchestrator, which hosts the control plane and starts the gateway and N workers), then press Play in the Editor as a client.
NebulaMigrate	Static class. One-off upgrades of a project's assets to the current package.
NebulaSetup	Static class. Adds the components and settings required to use Nebula in the active scene.
NebulaValidator	Static class. Nebula > Validate Project: checks the things that otherwise only show up as a broken build or a silent mesh.
SceneEntityIds	Static class. Gives every NetworkIdentity authored into a scene its NetworkIdentity.SceneId when the scene is saved: a random non-zero id, unique within the scene, that then stays with the object for good.
ServerPlayerView	Class. Takes the Game view's place in a Multiplayer Play Mode virtual player that hosts the server (EditorRunPlan.HidesGameView).
WorldAssets	Static class. Finds world definitions and manifests in the project and maps scenes back to cells.
WorldAuthoring	Static class. Create, open, close, delete and populate cell scenes.
WorldBaker	Static class. Builds the WorldContainerManifest: one container per cell plus every Container authored inside the cell scenes, with cell-local poses, in wire order.
WorldEditorPlacement	Static class. Keeps cell scenes usable in the editor even though they are authored cell-local.
WorldEditorWindow	Class. The World window (Nebula > World): a map of the cell grid, one vertical layer at a time.
WorldSetup	Static class. Nebula > Set Up World Partition: makes the active scene the hub of a partitioned world in one pass.

Storage

Keep the control plane and saved entities in SQLite or PostgreSQL from the standalone orchestrator.

Type	Summary
NebulaDatabase	Class. The standalone orchestrator's database: SQLite (a file next to the orchestrator, the default for a local mesh) or PostgreSQL (for a deployed mesh), behind one ADO.NET surface.
SqlControlPlaneStorage	Class. IControlPlaneStorage in the orchestrator's database: the document sits in the single row of nebula_control_plane, replaced on every save.
SqlPersistenceStore	Class. IPersistenceStore in the orchestrator's database (NebulaDatabase: SQLite or PostgreSQL), table nebula_entity.
SqlSharedCacheStore	Class. ISharedCacheStore in the orchestrator's database (NebulaDatabase: SQLite or PostgreSQL), table shared_cache.

Interest

Type	Summary
CarriedTransition	Class. The bookkeeping a rebucket of a carrier needs: where the carrier and everything riding in it sat before the index moved them, and which gateways each of them gains or loses as a result.
CarrierLink	Enum. The outcome of linking an item to a carrier.
ClientInterest<T, TSource>	Class. One client's interest set and the state machine that maintains it.
ConfigIssue	Struct. One problem found in a configuration, named by field so an inspector or nebula doctor can point at it.
ConfigSeverity	Enum. How much a ConfigIssue matters.
DefaultInterestPolicy	Class. What a mesh does without a game policy: one focus at the pawn, plus the client's validated hint as a second focus when it has sent one.
FarPublisher	Class. The worker's half of the far tier: which gateways hear about each far entity, and when.
FarRelevance	Static class. The far relevance tier's arithmetic (docs/interest-management.md §16, NEB-388), shared by the worker, the gateway and the tests.
FocusHintDecision	Struct. What the server decided about one incoming focus hint: which mode to treat it in, and the point itself (a policy may move it — snap an RTS camera to the territory it is allowed to watch, say).
FocusHintFilter	Class. Validation of ClientFocusHintMsg, on the gateway, before a policy ever sees a hint.
FocusMode	Enum. How much of the world a client's own ClientFocusHintMsg may move its interest to.
HandoverScope	Class. The bookkeeping one whole-subtree authority handoff needs: how deep the recursive transfer currently is, and which entities are leaving with the carrier being handed over right now.
IFocusHintPolicy	Interface. The optional second half of IInterestPolicy: the game's say over one client's focus hint, asked on the gateway loop as the hint arrives and before anything is done with it.
IInterestPolicy	Interface. The game's say in what a client hears about.
IInterestSource<T>	Interface. What ClientInterest<T,TSource> needs to know about the records it is evaluating.
InterestClient	Struct. What a policy is told about the client it is deciding for.
InterestEntity	Struct. What a policy is told about the entity it is deciding on.
InterestFocus	Struct. One place a client is interested in: a point (the usual case, its pawn) or a box (a portal's window, an RTS selection).
InterestGrid	Struct. A uniform spatial hash over absolute world coordinates: the region arithmetic every part of interest management shares (gateway, worker, standalone services).
InterestIndex<T>	Class. Region → dense list of items, with swap-remove and O(1) rebucketing.
InterestPlacement	Enum. Where an item sits in an InterestIndex<T>.
InterestPolicies	Static class. Combining policies, so a game can add one concern (parties) without rewriting another (fog of war).
InterestQuery	Class. What a policy fills in for one client: where it is looking, and any entities it must have whatever the distance.
InterestSchedule	Class. Which clients a gateway re-evaluates on this tick.
InterestSettings	Struct. The interest settings, resolved from NebulaConfig and already clamped into a set of values that work together (see Validate).
RegionKeys	Static class. How an interest region id is made unique to its scope.
RegionPublisher	Class. The worker's side of interest management: which gateways hear about each region, and the grouping that lets one serialization serve all of them.
RegionSubscription	Static class. The shared arithmetic of the region-subscription protocol: a set's fingerprint.
RegionSubscriptionReceiver	Class. The worker's end of one gateway link's subscription: the region set it filters that gateway's traffic with.
RegionSubscriptionSender	Class. The gateway's end of one worker link's subscription: what this gateway wants from that worker, and the messages that get the worker there.
RelevancePriority	Enum. How much an entity's transform updates matter to the clients that hold it, relative to its distance from them (NetworkIdentity.RelevancePriority, docs/server-owned-entities.md D3).
RelevanceTierBands	Struct. A priority's own distance tiers (NebulaConfig.InterestLowTiers and its siblings, docs/server-owned-entities.md D10): two radii and a divisor for each of the three bands they make.
RelevanceTiers	Static class. The arithmetic of RelevancePriority: pure, shared by the gateway, the worker and the tests.

Persistence

Type	Summary
IPersistenceStore	Interface. Long-term storage for entities that opted into persistence (PersistentEntity).
LocalPersistenceStore	Class. In-process IPersistenceStore with the exact write rules of the persistence module (epoch check, version bump), optionally backed by a file so a single-process run survives a restart.
NebulaPersistence	Class. The worker's persistence service: it checkpoints every authoritative entity carrying a PersistentEntity into an IPersistenceStore, and brings those entities back when this worker gains the lease of a container they were saved in.
PersistAttribute	Class. Marks a NetworkVariable<T> field as part of the entity's saved state.
PersistedEntityRecord	Class. One persisted entity as the store holds it: enough to bring the entity back on any worker (prefab or scene object, container and pose, authority epoch) plus the opaque state blob the entity itself wrote (PersistentStateCodec: opted-in Ne...
PersistedRecordJson	Static class. PersistedEntityRecord as JSON, the wire format between RemotePersistenceStore (workers) and PersistenceHost (the orchestrator).
PersistenceAnswer	Static class. Whether the answer a store is delivering right now is a stand-in for one the backend could not give.
PersistenceHost	Class. Serves the orchestrator's IPersistenceStore to workers over the orchestrator's HTTP server, so a worker needs no database driver of its own (RemotePersistenceStore is its client).
PersistentEntity	Class. Put this on a prefab or a scene object to make the entity outlive the process that simulates it.
PersistentStateCodec	Static class. The state blob of a PersistedEntityRecord: every PersistAttribute NetworkVariable and every behaviour's NetworkBehaviour.WritePersistentState chunk, each under a name.
RemotePersistenceStore	Class. IPersistenceStore for a worker: every save and load goes to the orchestrator, which owns the real store (PersistenceHost over the dashboard address, the same one the control plane uses).

SharedCache

Type	Summary
FolderSharedCacheStore	Class. ISharedCacheStore in a folder, one file per object.
ISharedCacheClient	Interface. A worker's way to the shared cache.
ISharedCacheStore	Interface. Where the shared cache keeps its objects: a folder (FolderSharedCacheStore), the orchestrator's database (SqlSharedCacheStore in the standalone orchestrator), or memory (MemorySharedCacheStore).
LocalSharedCacheClient	Class. ISharedCacheClient over a store in this process: a folder under the project or the persistent data path, or the store an orchestrator in the same process hosts.
MemorySharedCacheStore	Class. ISharedCacheStore in memory: nothing survives the process.
NebulaSharedCache	Static class. A cache that every worker of a mesh shares, for data that is expensive to compute and the same every time: baked terrain, path data, generated layouts.
RemoteSharedCacheClient	Class. ISharedCacheClient for a worker of a mesh or of Nebula Cloud: GET and PUT /cache/{key} on the orchestrator (SharedCacheHost), over the same address and mesh token that RemotePersistenceStore uses.
SharedCacheClientBase	Abstract class. What every client does around a backend call.
SharedCacheHost	Class. Serves the orchestrator's ISharedCacheStore to workers (RemoteSharedCacheClient) over the orchestrator's HTTP server, beside PersistenceHost: GET /cache/{key}: the object as application/octet-stream with its SHA-256 in X-Nebula-Checksum;...
SharedCacheKey	Static class. The rules every part of the shared cache applies to a key and to a stored object: the longest key and object, which characters a key may use, and how an object's checksum is written.
SharedCacheStats	Struct. What a process has done with the shared cache since it started.

On this page