Multiplayer server for Unity
The server decides every outcome. You drop in one component per feature.
Press Play and you're multiplayer: the server starts on your computer, with no netcode to write. When your game goes online, you run the same server on your own machine or any host you choose.
Engines
Every genre, turn-based included. Zero networking code. The Unity SDK comes with two small games built only from drag-and-drop components.
Unity is ready today. Unreal, Godot and Web are in development.
What you get
Six things that are true before you write a line.
The server decides every outcome
Where everyone is, hits, damage, health, respawns, pick-ups and throws. A player's game sends what the player wants to do, and moves its own player at once while it waits; the server's answer is final.
One component per feature
A player, walls, a vehicle, a weapon, a pet: each is a component you drop in from the NullTick menu. Hover to assemble.
Test on your own computer
The server ships inside the package and starts by itself when you press Play, on Windows and Linux. One menu item opens a second player beside the editor.
server
You host it, where you like
Run the server on a machine you control or at any hosting provider. Your players connect to your server, not ours.
It uses the cores it's given
The server finds how many cores the machine lets it use, limits included, and spreads its work across them. You can also set the count by hand.
Every genre, turn-based included
Moves and turns travel on a reliable channel: in order, exactly once, even when packets drop. A shooter and a board game use the same server.
How it works
Players ask. The server decides. Everyone sees the same thing.
A player's game never decides what happens. It only asks: "I want to go that way", "I attack that one", "I throw, that way". The server checks each request against what it holds itself (where everyone is, which way they face, what is in the way) and decides the result. Then it tells every player.
That is why a modified game can't move itself, run faster, hit from across the map or heal itself: there is nothing on the wire for it to forge. And every player sees the same result, because there is only one place it is decided.
And it still feels instant. Your own player moves the moment you press a key, with no wait for the server. Your game runs the same movement and collision code the server runs, on the same inputs, so it works out the same result the server will. When the server's answer arrives it confirms what you already saw. If it ever differs, the server's answer wins and your player is moved to it. You get the responsiveness of local movement and the fairness of a server that decides.
The server does its work when something happens, an input or a scheduled event, rather than on a fixed clock.
How it feels, measured
- Your player moves at once. It does not wait for the server's answer.
- Corrections are rare on a normal connection. In our tests, with up to 200 ms there and back and no lost packets, the server had to move a walking player back for about a tenth of one percent of the distance walked, or less. Lost packets are what cause corrections.
- A dropped player who comes back within 30 seconds is the same player. The SDK reconnects on its own and takes back its place. After 30 seconds the player joins as a new one.
- Hits are checked where players are now. The server decides a hit from where it holds the shooter and the target at that moment. It does not rewind to where the shooter saw the target.
In short Your players can't disagree about what happened, and they can't cheat it.
The world the server runs
Collision, forces and throws — decided on the server.
Physics is part of the server, not something each player's game guesses at. Every player sees the same result because there is only one place it is decided.
In the SDK today
- One collision rule. Players, vehicles, platforms, crates and thrown things all collide the same way, by their shape, their collision layers and their motion — whatever they are doing.
- Mass. A heavier body pushes a lighter one, players included.
- Forces. Blasts, knockback and bouncy floors push bodies and can throw a player.
- Carry and throw. Pick up, carry, drop and throw — the server decides each one.
- Projectiles. A bow's arrows and a cannon's balls fly an arc set by their stats, can stick where they hit, and do damage.
- Room objects. A room can own its crates, trampolines and cars, shared by everyone in it.
- Every stat is a server value. Move speed, jump, mass, throw strength, damage: you set the starting value on the component, the server owns it, and every player receives it — late joiners too.
In short The server decides what happens when things touch. Your players can't disagree about it, and can't cheat it.
Rooms, lobby, chat and turns
The parts every multiplayer game needs are in the box.
One server runs many rooms. A room is a match, a lobby or a shared world: everyone in it sees everyone else in it.
In the SDK today
- Rooms. Join a room by number, or open a new one nobody is using. The editor's NullTick Hub has a Rooms tab to try it.
- A lobby list. Ask the server which rooms are open and how many players each holds, and show it however your game likes.
- Chat. Drop in the Chat Box component: a player presses Enter, types, and everyone in the room reads it. The server passes each message on.
- Turns. Drop in the Turns component for a game played in turns. The server gives out seats, keeps whose turn it is, checks each move and says who won.
- Two sample games. A first-person playground, and Tic-Tac-Toe: a turn-based game with seats, turns and a winner, built only from components, with no networking code. See the samples.
It fits the Unity code you already have.
NullTick is components on your GameObjects. Your own scripts read them like any other component. Here, your existing UI shows the server's turn state:
using UnityEngine; using UnityEngine.UI; using NullTick; public class TurnLabel : MonoBehaviour { public NullTickTurns turns; // drag the Turns component here public Text label; // your own UI void OnEnable() { turns.Changed += Show; } void OnDisable() { turns.Changed -= Show; } void Show() { if (turns.Winner != 0) label.text = "Seat " + turns.Winner + " wins"; else if (turns.IsDraw) label.text = "Draw"; else if (turns.WaitingForPlayers) label.text = "Waiting for a player"; else if (turns.IsMyTurn) label.text = "Your move"; else label.text = "Their move"; } }
The server decides every value this reads; your script only shows it. Read the Unity guide for rooms, events, server values and the rest.
Hosting
You run the server. On your terms.
While you build, the server runs on your own computer and starts when you press Play. When your game goes online, you run the same server on a machine you choose: your own, or one rented from any hosting provider. There is nothing of ours in between.
The server finds how many cores it may use on that machine and spreads its work across them. If you want it on fewer, you set the number yourself.
What survives a server restart. Editable world blocks and a room's rules can be saved and loaded again (start the server with --world-save and --rules). Player stats, server numbers, spawned objects, positions and games in progress are not saved yet.
Licence
One licence per game. Free until your game earns.
Free
$0
While your game earns under $50,000 a year
- Every feature
- No player limit
Indie
$99 / month per game
A fixed monthly fee per game, once it earns more
- Unlimited servers and cores
- Pay yearly: $990, pay for 10 months, get 12
- No charge per player or per install.
- Stop paying and your game keeps running on the last version released while you were subscribed.
- The licence is a file your server checks offline. It never phones home.
Get in touch
Tell us what you're building.
The SDK is in early access. Tell us about your game and we'll get it to you.