⌁ deterministic multiplayer engine for Unity

Two machines.
One reality.

Playband runs your game as a fixed-point deterministic simulation — same inputs, same bits, on every client. Rollback netcode, 2D & 3D physics and a managed cloud, in one Unity SDK. You just write gameplay.

Start free — 100 players Read the docs

don't take our word for it — scroll

Client A — you

tick 00000

Client B — across the wire

tick 00000

state hash

A -------- = B --------

identical desync

0 ticks verified · 0 desyncs

latency 96 ms ≈ 6 ticks

8 bytes.

That's everything a player sends per tick. Not positions, not the world — intent. The simulation does the rest, identically, everywhere.

pb_proto_input · measured on the wire

01 — the stack

Everything between input and truth.

Four layers, one contract: a tick goes in, the same bytes come out — on every machine. Each layer exists so you never have to think about the network again.

layer 01

Deterministic core

Fixed-point math end to end. No float drift, no platform quirks — the same tick produces the same bytes everywhere, provably.

layer 02

Rollback netcode

Clients predict. When a late input lands, the engine rewinds, replays and converges — in under a millisecond, invisibly.

layer 03

Physics, 2D + 3D

Stacks, joints, capsules, CCD — deterministic engines built for gameplay, gated by golden-hash CI on every commit.

layer 04

Managed cloud

Authoritative relays in 5 regions, matchmaking, late-join snapshots, reconnect deltas. You ship a build; we run the fleet.

02 — rollback, for real

Time travel,
on every tick.

This is not a video. The panel scrubs the live simulation's actual recorded states.

01 Predict
02 Late input
03 Rewind
04 Replay

simulation history · client B

60 Hz · window 40 ticks

t−40

t−32

now

Predict. Clients never wait for the network. Every machine simulates ahead at 60 Hz, so your own inputs land instantly.

Late input. Another player's input from 530 ms ago finally arrives — a real-world latency spike. Most engines smear it with interpolation, or drop it.

Rewind. Playband rewinds the world. What you're scrubbing are real recorded states — deterministic state makes time travel a memcpy, not a prayer.

Replay. …and re-simulates with the input where it belongs. Watch the yellow body appear in the past. Every machine converges — bit for bit.

specimen · live

click any body — the readout is its memory, mid-flight

03 — no floats

State you can audit.

Floats round differently across compilers, CPUs and optimization flags — that's where desyncs are born. Playband's state is 10-bit fixed-point integers. These are the actual fields of the body you selected, updating live — the same numbers the hash digests.

struct Body

every field: integer ✓

x position · 10-bit fixed point: —
y: —
vx velocity / tick: —
vy: —
r radius: —
born spawn tick: —

04 — the code

And it's just…
your game.

No RPCs. No SyncVars. No server project. You write gameplay against local state — Playband makes it deterministic and keeps every machine on the same timeline.

01

State is structs

If it's in a component, it's networked. There is no shadow copy to reconcile, ever.
02

Input is intent

OnInput packs your controls into a few bytes. The wire never carries positions — only intent.
03

Tick is truth

One function runs identically on every machine. Rollback, replay and spectators come free.

PaddleControl.cs

deterministic

using Playband;

// Components are plain data — this struct IS the networked state.
public struct Paddle
{
    public FP X;
    public FP Velocity;
}

public struct PaddleInput
{
    public FP Move;
}

public class PaddleControl : PlaybandBehaviour
{
    [Param] public FP Speed = 14;

    // Owning client only: turn device input into an 8-byte tick input.
    void OnInput(ref PaddleInput input)
    {
        input.Move = FP.FromFloat(UnityEngine.Input.GetAxisRaw("Horizontal"));
    }

    // Every machine, every tick, bit-identically. This is the whole game.
    public override void Tick()
    {
        ref var paddle = ref Get<Paddle>();
        paddle.Velocity = Input<PaddleInput>().Move * Speed;
        paddle.X += paddle.Velocity * DeltaTime;
    }
}

✗ RPCs ✗ SyncVars ✗ server build ✓ the whole multiplayer game

3,109.

Engine tests, green on every commit — each one gated by a golden state hash. Determinism isn't a feature flag; it's CI.

smoke suite · client + physics + netcode

05 — the boring half

You run gameplay.
We run everything else.

Inputs go through an authoritative relay — tiny, ordered, encrypted. Matchmaking, rooms, late-join, reconnects, region failover: already written, already running.

frankfurt
ashburn
tokyo
singapore
são paulo

input per tick on the wire: 8 B; Positions never leave the machine. Only intent does.
late-join snapshot size: −97%; LZ4-compressed world state; reconnects send XOR deltas.
regions, one App ID: 5; Matchmaking routes every room to the lowest-RTT relay.
encryption, on by default: AEAD; Authenticated transport — not a checkbox you forgot.