A whole planet, built to run smoothly
A planet you can dig into and ships you can break are expensive to draw. A large share of the work on this game goes into making them cheap. These are the techniques in the game today.
Nanite-style geometry rolling out to ship hulls
Our own cluster-based detail system: every small piece of a mesh gets exactly the detail its size on screen needs.
How it works
Meshes are pre-split into small clusters arranged in a level-of-detail hierarchy. Each frame a compute shader picks the clusters whose detail matches their size on screen, culls the hidden ones against a depth pyramid, and draws the survivors with indirect draws; shadows get their own selection. It is our own implementation. Plants, trees, props and ship parts are drawn through it today; hulls and in-game editing are moving over.
GPU-driven rendering
Forests, plants, fish, butterflies and debris go to the graphics card in large batches instead of one object at a time.
How it works
Instances are submitted through Unity’s BatchRendererGroup with our own culling callback and per-instance data held in GPU buffers, and different object families share one group. Draw arguments are written by compute shaders and consumed by indirect draws, so the processor never has to count instances.
GPU culling
Only what the camera can actually see gets drawn — and the graphics card decides what that is.
How it works
Instances are rejected on the GPU by the view frustum, by size and distance, and by a hierarchical depth pyramid (Hi-Z) built each frame from what was already drawn. The Nanite-style path re-tests rejected clusters a second time against the freshly built pyramid, so nothing visible is lost.
Plants and rocks on the graphics card
Plants, rocks and grass are placed, animated and drawn by the graphics card.
How it works
Placement records come from the offline planet bake and stream in around you. Compute shaders derive, shift and cull each instance and the survivors are drawn in batches. Grass blades are generated and animated entirely on the GPU.
Burst and the Job System
The heavy loops run as compiled jobs, spread across every processor core.
How it works
Terrain meshing, plant and debris animation, cable and fish simulation and culling are written as Burst-compiled jobs over native memory and run on worker threads — the Burst compiler and the Job System from Unity’s DOTS. Game logic stays on ordinary objects; only the data-parallel hot paths are jobified.
Streamed planet terrain
The whole planet is always there from orbit, and the ground around you is built in detail as you move.
How it works
A quadtree of height tiles covers the entire globe at coarse detail, while the voxel terrain near you is meshed in level-of-detail rings by Burst-compiled surface nets on background threads. Digging re-meshes only the chunks it changed.
Tree impostors
Distant trees become pictures that still look right from every angle.
How it works
Each tree species is photographed offline from a ring of directions into an octahedral atlas. Distant trees are camera-facing cards that blend between the nearest baked views, drawn in bulk through the batch renderer — and they still cast shadows.
Baked, then streamed: heights, colour and rivers
The planet’s heights, ground colour, rivers and plant positions are worked out once, ahead of time, and loaded as you travel.
How it works
Each is baked into a compact file and paged in on demand, with a safety rule: a tile that is missing or out of date is computed live instead. Ground colour is a pyramid whose coarse levels stay loaded, while the finest level is cut into overlapping tiles paged from disk on worker threads and kept in a least-recently-used cache. Each river is a baked spline: a background thread cuts the distant ribbons from it, and nearby river surfaces are created and released as you move.
Cached shadows
A lamp that is not moving draws its shadow once, and redraws it only when something moves in its light.
How it works
Shadow maps are kept per lamp and re-rendered only on events — a moving object enters, the terrain or a part changes — under a per-frame redraw allowance.
Floating origin
The world re-centres around you as you travel, so everything stays precise anywhere on the planet.
How it works
When you drift far from the origin, the world is shifted back by whole metres and physics, audio, AI and rendering follow. Positions across the planet and the solar system are kept in double precision.
One budget for background work
Every background rebuild shares one time allowance, by priority, so the work you would notice goes first.
How it works
Re-meshing, terrain edits, water rebuilds and collider assignment all draw from one shared per-frame allowance with priorities. Collision meshes are cooked on a background thread and swapped in when they are ready, so building and damage never wait for physics geometry.
Help it exist. Back the game on Patreon, or follow how it is made.