NullTick // the demos

Survival, farming, turn-based. Zero networking code.

A survival MMO, a farming sim, and a turn-based game — playable slices, each assembled entirely from drag-and-drop components. No transport code, no netcode, no server loop written by hand. Every section lists the engines it ships on.

Read the guides How it works Shipping today

CapTown Last Light Sprout Valley Tic Tac Toe

00 — In your browser

The one you don't have to take our word for: 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.

It's a tech showcase, not a game — the art is placeholder grey boxes; the networking is the finished part. Expect a ~54 MB first load (roughly 15–30 seconds on a decent connection), and bring a keyboard and mouse: it's WASD, desktop-first, and untested on phones. Whatever it says for players online is the real count — and right now that count is small.

Play it in your browser How it works

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

01 — Survival · Unity, Unreal, Godot

Last Light

The action showcase: everything moving at once, and a server that owns every position.

Spawn into a shared world at dusk. Gather glowing resource nodes as your hunger ticks down, craft and place a campfire, fight over what's left, and respawn. The busiest kind of game — and still, the server only works on what's actually happening.

Everyone gathers around the campfire and stands still — and the packets-per-second falls to almost nothing. Nobody's moving, so almost nothing is being sent.

In the game	Built from
Player movement & facing	Spike-driven movement with rotation sync
Hunger, health, stamina	Per-player network variables — the server owns them
Placed campfires	Spawned network objects (persistent, player-owned)
Resource nodes	Server-owned NPCs; gathering is a reliable event
Hit & gather sparks	Reliable events — never their own entities
PvP damage, death, respawn	Client-driven game logic in the demo — it shows the sync, not the authority; your production server owns your rules
World chat	The reliable event channel

02 — Farming · Unity, Unreal, Godot

Sprout Valley

The cozy showcase: persistent state, visiting neighbors, and an economy the server owns between sessions.

Tend your own farm — a room per farm, and the lobby is the neighborhood. Till plots, plant seeds, watch crops climb through their growth stages, harvest for gold, then wander over to a neighbor's farm and gift them seeds. Crops keep growing on the server whether you're watching or not.

Watering a huge farm, alone, for an hour. This whole farm sends almost nothing until someone acts — the architecture as a thing you can watch, not a claim you have to take.

In the game	Built from
Each farm	A room; the lobby is the "visit a neighbor" browser
Crop plots & growth stages	A grid of network variables on room-scoped entities
Gold & energy	Per-player network variables
Decorations & a pet	Spawned network objects
Gifting & buying	Reliable RPC — exactly-once, so a trade can't drop or double
Emotes	One-shot reliable events

03 — 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.

Zero configuration, and that's the demonstration: an empty project, one git URL, press Play. No config asset, no server address, no account — the server ships inside the package and starts itself.

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

How they're built

The netcode is the part you never write.

Every one of these was assembled from inspector components — connection, movement, network variables, spawned objects, rooms, events. The gameplay is glue a beginner could follow; the networking underneath is a component you drop in, not code you author.

4demos — CapTown, Last Light, Sprout Valley and Tic Tac Toe, from one component set

3engines — Unity, Unreal and Godot, from one component set

0lines of networking code written — all drag-and-drop

And in all three, 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.

Pick an engine and build your first one.

Read the guides contact@khalm.ai