There’s a hard limit to how many players a single game server can simulate before the tick rate buckles. For decades that limit has shaped what multiplayer games could be. Our chunk system is how we move past it — and it’s built right into the engine, so you get the benefit without architecting a distributed system yourself.
Dividing the world
Your world is split into chunks: sections with a fixed width and depth that tile together to form the whole map. Each chunk contains the entities currently within its bounds, and — critically — each chunk can be simulated on its own. The world looks seamless to players, but underneath it’s a grid of independently running pieces.
A chunk is the unit of simulation and the unit of scaling. Because chunks are independent, the work of running your world can be spread across many servers instead of piling onto one.
Independent simulation across servers
Since chunks don’t depend on one another to tick, different chunks can run on different servers at the same time. Add players and the load spreads out across the grid rather than concentrating on a single machine. This is what lets a Planetary Processing world support player counts that would flatten a conventional single-server game.
Loaded and unloaded chunks
Not every part of your world needs to be alive at once. Chunks are dynamically loaded and unloaded based on activity:
- Loaded chunks are actively simulated — entities update, physics run, scripts tick.
- Unloaded chunks save their state and stop consuming compute, then resume exactly where they left off when activity returns.
A vast world where players are clustered in a few regions costs you compute only for the regions that are busy. Empty wilderness sits dormant and free until someone wanders in.
What happens at the seams
The engine manages the boundaries between chunks for you, so an entity walking from one chunk to the next — even when those chunks live on different servers — transitions smoothly. Players never see the grid; they just experience one continuous world. Your scripts mostly don’t need to think about chunk borders at all.
Chunks, dimensions and entities together
The chunk system scales a single world horizontally. Dimensions scale it by running many independent worlds in parallel. And because behaviour is entity-centric, the same scripts run no matter which chunk or dimension an entity ends up in. The three ideas compose: chunks make one world big, dimensions make many worlds, entities make all of them behave.
What it means for you
- Build genuinely large worlds without writing your own distributed backend.
- Pay for the compute your players actually use, not for empty space.
- Support concurrent player counts well beyond a single-server ceiling.
- Keep your game logic simple — the engine handles the hard distribution problems.
Scaling is usually the moment a successful multiplayer game becomes an engineering crisis. With chunks, scale is a property of the platform you’re already building on, not a rewrite you have to survive later.
