NullTick // the demos
Two demos. Zero networking code.
The Unity SDK comes with two demos: the Playground, where everything moves, collides and gets thrown, and Tic-Tac-Toe, where nothing moves at all. Every genre sits somewhere between the two. Both are assembled entirely from drag-and-drop components, and the server decides every outcome.
01 — Action and physics · Unity
The Playground
Everything moving at once, and a server that decides all of it.
A first-person test ground with a sign beside every feature. Walk, run and jump over slopes, stairs, ledges and hills; ride a moving platform; bounce on a trampoline; push, pick up and throw crates; get in the car and drive; throw a grenade; draw a bow or fire a cannon. Open a second player and everything you do, they see — because the server decided it once, for both of you.
| In the demo | Built from |
|---|---|
| Walking, running, jumping | The player component — the client sends input, the server works out where you are |
| Walls, slopes, stairs, hills | The scene's own colliders, baked and enforced on the server |
| Bumping into players and crates | One collision rule for every body; the heavier one pushes the lighter one |
| The ghost door | Collision layers — Unity's own layers decide what passes through what |
| Trampoline, grenade blasts | Forces on bodies; a blast can throw a player |
| Carrying and throwing crates | Server-decided pick up, carry, drop and throw |
| Bow and cannon | Projectiles whose arc comes from their stats; arrows stick where they land |
| The car and the crates | Room objects — owned by the room and shared by everyone in it |
| Health and damage | Server-owned values; an attack is a request the server checks |
02 — Turn-based · Unity
Tic-Tac-Toe
The smallest honest proof that turn-based belongs on an event-driven engine — no movement, no positions, no tick.
Two players, one board, alternating moves. A turn is an event, and the board is whatever the move stream says it is. It's deliberately two-player or nothing: placing both the X and the O yourself isn't multiplayer, so one menu item starts the second player for you.
| In the game | Built from |
|---|---|
| Moves | The reliable event channel as the turn engine — exactly-once and in order, so the board is deterministic from the move stream |
| Whose turn, the score | Network variables |
| The second player | A room — one menu item opens the other seat |
| No player movement at all | Nothing: a turn-based game never takes a movement seat |
Proof of concept · In your browser
Not an SDK demo — a proof of concept: a shared town square, running in the tab you're already in.
No install, no account, no download step. Click the link, wait out the load, and you're standing in a town square on a real server — pick a look, walk around, talk to whoever else is in there.
The HUD carries a live packets/sec readout. When the square is quiet, stand still and watch it fall — that number is the whole argument, and here you get to watch it move instead of reading a claim about it. It won't hit zero: this demo is set to send a position update once a second as insurance, so a single player standing still settles near ~1/s rather than at silence.
| In the demo | Built from |
|---|---|
| The square | A room; everyone standing in it is a networked entity |
| Walking | Server-authoritative — the walls are baked and enforced on the server, not in your tab |
| Chat | The reliable event channel — in order, exactly once |
| Your look | Network variables |
| The connection | A WebSocket, because a browser can't speak UDP |
How they're built
The netcode is the part you never write.
Both demos were assembled from inspector components — connection, movement, collision, network variables, rooms, events. The gameplay is glue a beginner could follow; the networking underneath is a component you drop in, not code you author.
And in both, the same thing shows on the stat panel: the packet count tracks what's actually moving. Stop moving, and it falls to the keepalive floor.
Open Unity and build your first one.