Run one Unity world across multiple game servers
Divide a Unity world into containers and run those containers on multiple dedicated servers. Nebula routes clients through one gateway and transfers entities when they move between workers.
iwr https://windows.nebula.1by3.co -useb | iexcurl -sSf https://install.nebula.1by3.co | shRun each role from the same build
Start the Unity player with a different -nebula-role for each process. Workers exchange entity copies and transfers directly over UDP. Clients connect to the gateway. The orchestrator registers workers, assigns containers, and keeps the world in SQLite or PostgreSQL.
- Worker: simulates assigned containers in a headless Unity process at 60 ticks per second.
- Gateway: routes player input and sends worker snapshots to clients.
- Orchestrator: maintains the requested worker count, assigns containers, and serves the dashboard.
- Control plane: stores registrations, assignments, heartbeats, and shared settings, hosted by the orchestrator.
- Client: predicts the local player and corrects that prediction from worker snapshots.
Divide the world into containers
Create box-shaped containers for rooms, ships, or sections of a level. Nebula assigns each container to a worker at runtime.
Transfer entities between workers
Nebula creates a non-authoritative copy on the next worker before an entity crosses a boundary. It then transfers the current state and any pending player input.
Build networked gameplay
Use NetworkBehaviour, NetworkVariable, remote calls, NetworkTransform, NetworkAnimator, and NetworkRigidbody. Check HasAuthority and IsGhost when worker ownership matters.
Add and remove workers
Change the worker count while the game runs. The orchestrator moves containers away from a worker before it stops that worker.
Use one command-line tool
Run nebula init to add the package, nebula start to run locally, and nebula deploy to deploy the build to configured virtual machines.
Stream partitioned worlds
Split a large world into cell scenes. Workers and clients load the cells they need, and Nebula shifts the Unity origin as the player moves.
Write predicted gameplay code
Define a serializable input struct and implement Simulate. The worker runs the method with client input. The client runs it ahead of the worker and repeats it after a correction. Nebula transfers pending input when the player moves to another worker.
Use AuthorityRpc to run a method on the worker that controls the target entity. Nebula sends the call to another worker when the local process only has a ghost of the target.
public sealed class PlayerController : PredictedBehaviour<PlayerInput>{ private const float Damage = 10f; public NetworkVariable<float> Health = new NetworkVariable<float>(100f); // Read local input once per tick on the owning client. protected override PlayerInput GatherInput() { /* ... */ } // Move the player on the worker and the predicting client. protected override void Simulate(uint tick, in PlayerInput input, float dt) { Move(input, dt); if (input.Fire && HasAuthority && TraceShot(out var victim)) { // Run TakeDamage on the worker that controls the victim. victim.AuthorityRpc(victim.TakeDamage, Damage); } } [AuthorityRpc] void TakeDamage(float amount) => Health.Value -= amount;}