Architecture

The world lives in Rust.
Engines are windows onto it.

All of the heavy lifting (plates, climate, erosion, rock history, materials, fracture and the accounting of every gram moved) runs in a Rust engine with no dependency on any game engine. A small world server sits in front of it. Unreal is the first full client, and a browser bench and this atlas are others. Any engine that can make a local network request and draw a mesh could be the next.

1 · Rust world enginePlate motion and crust, climate and weather, rivers and erosion, rock layers and their formation history, minerals and trace metals, rock strength, fracture and blast physics, and finite volumes of material.
Runs headless: the same code drives command-line runs, tests and the server.

↓

2 · World serverPublishes saved, content-identified world products; cuts terrain windows on demand wherever a player goes; accepts action requests (blast here with this energy, mine this spot) and returns small change records.
A local HTTP service; one action's change record is a few kilobytes.

↓

Unreal (today)Streams terrain around the player, renders rock looks, collides, aims, shows rubble, inventory and origin stories.

Browser (today)A geology bench and this atlas: inspect layers, sections, accounts and history from the same products.

Any engine (possible)Godot, Unity, a custom renderer or a server-side bot: fetch windows, draw them, send actions.

Changing the world · A client never edits the world directly. It sends an intent; the engine turns it into a candidate change; an independent check confirms the physics and the material accounting; only then is the change accepted into the shared record and published back to every client. Renderer state is never the truth.

Coarse to fine, built when needed, with a history

The world is not one giant mesh. Each level is generated from the level above it, only where something needs it, and every result records where it came from.

Level	Grid	What it decides
Planet	576 × 288 cells (about 70 km), 2 My steps over 400 My	Plates, crust, mountains, climate, drainage, volcanism, rock columns and their formation history
Regional skeleton	about 16 km control spacing	Where rivers and junctions run, consistent with the planet's drainage
Regional relief	32 m posts in windows of about 20 km	Valleys, river beds, hillslopes and rock bands, solved from the cells above
Near ground	8 m ring, then 2 m rock posts beside the player	Cliff faces, ledges, talus, soil, snow and vegetation
Touched rock	finite volumes where a blast or mine stroke lands	Exactly which minerals and elements move, and where to

Generated on demand. The server cuts the window a traveller needs when they arrive; a rock body is admitted into the accounting the first time something touches it. A short warm-up can prepare places ahead of time.
Repeatable. Random choices are keyed to place, so the same cell gives the same answer however and whenever it is generated.
Provenance at every level. Each window names its recipe and the exact inputs above it, and each surface point carries the id of the rock layer it exposes, back to the planet cell and the event that formed it. Pick up a lump of mined rock and the record says which body it came from, which layer, the formation event, the blast that broke it and the stroke that collected it.

Why the split

Concern	Lives in	Why
Geology, climate, physics, accounting	Rust engine	Deterministic, fast, testable without a renderer; one source of truth.
Where you are and what you can see	World server	Builds terrain around the traveller on request instead of shipping a fixed map.
Pixels, input, sound, collision	Engine client	Each engine does what it is good at; swapping engines does not change the world.
Accepted changes	Shared record	Every blast or mined lot is traceable to its source rock and history.

How Unreal is connected

A thin Unreal plugin talks to the local world server. As the player moves it asks for terrain windows around them and builds meshes and materials from them. Pressing a key to blast or mine sends an action; the server resolves it against the rock that is actually there, the change is checked and accepted, and Unreal receives the new surface, the rubble and the inventory lots. Clicking a lot shows where its minerals came from, read from the same record. Measured on one workstation in one run: a mine stroke about a second, a 1 GJ blast about 1.3 s and a 1 TJ blast about 8.5 s from click to result.

What another engine would need

Ask for terrain windows around a position and turn heights and material fields into a mesh.
Send actions (blast, mine) as requests and apply the returned change records.
Present materials, rubble and inventory however it likes; the numbers come from the server.

Lessons from using Unreal this way

Keep the truth outside the engine. When the world record lives in the server, Unreal can crash, restart or be replaced and the world comes back exactly; a blasted world restored byte for byte from the server alone.
Iterate the science outside Unreal. Cook and package cycles are slow. A light browser bench and headless Rust runs answer physics questions in seconds; Unreal is for checking how it looks and plays.
Stream, do not bake one map per place. Packaged per-location maps made good screenshots and a workflow dead end. Building terrain around the traveller on request scales to a whole planet.
Make Unreal testable without a person. Offscreen runs with scripted movement and actions, saving stills that a reviewer (human or model) actually looks at, turned "it should work" into evidence.
Keep the wire small. Re-reading a 33 MB status file per action made each mine stroke take 4 to 40 seconds; a few-kilobyte change record brought it to about a second.
Equal, not close. A published surface 15 cm off the true one made aim rays miss the rock. What the engine draws must match the record exactly.
Measure frame time with A/B switches. Adding a dense forest tripled frame time; switching features off one at a time showed which ones paid for it.
Treat the GPU as a shared, fragile resource. One Unreal job at a time behind a lock, memory caps on heavy jobs, an explicit GPU choice on multi-GPU machines, and a pause when driver errors repeat.

Why this matters beyond one project

Agentic coding can run overnight. Long engineering tasks were handed to headless coding agents that worked through the night, while a lead agent reviewed each finished piece, ran the checks and merged only what passed. The human set the goal and the rules and reviewed results in the morning. Written rules, a decision ledger and mechanical merge gates are what kept that unattended work on course.

Simulation and science are now within reach. Plate kinematics, energy-balance climate, river incision, crater scaling and exact mineral accounting from cited empirical relations used to need specialist teams. The recent wave of frontier models can read the literature, choose a defensible approximation, implement it and say what it does not cover.

Models are starting to understand game engines. They write engine plugins and build scripts, drive offscreen captures, read the screenshots and find problems such as seams, wrong materials or missed collisions. Not perfect, and still in need of human direction, but a real change in what a small team can attempt.

Honest limits

Only Unreal and the browser are built and tested today; other engines are an architectural possibility, not a shipped integration.
Plate motion is a prescribed plate model, not a solved mantle flow.
Whole-planet terrain coverage is still being completed; today's playable terrain streams from part of the planet.

← Back to the atlas home

The world lives in Rust.Engines are windows onto it.