The Systems
Six systems, what they feel like to play and how they are actually built.
World & Economy
A fixed world, finite riches
The landscape is fixed and shared. Every mountain, valley, and coastline is the same for everyone, and over time you come to know it by heart. The riches in it are not. Ore, gems, and mineral veins are hidden, finite, and revealed only as you get close, so finding the good stuff means going out, looking, mining it dry, and moving on. Stake a claim with a mailbox and the land around it is yours to build; leave it untended long enough and the world quietly takes it back.
How it works
Terrain is generated on the client from a single locked seed, so it costs the server nothing to ship. Deposits are the opposite: an authoritative Rust server places them from a resource seed that never leaves the server, reveals each one only within 30 metres, decrements it as you mine, and on depletion marks it consumed for everyone with no respawn. A claim is a free-placed 50 metre square anchored at your mailbox. Keep playing and it stays yours; go quiet for about eight weeks and it enters a grace period where it is still recoverable, and only after that does the server release the claim and heal the land back to how it started. All of it sits on Postgres and PostGIS.
- Claims are 50 m squares, dropped wherever you place the mailbox and tiling edge to edge, so there are no griefable gaps between neighbours.
- Deposits reveal within 30 m, mine within 6 m, and start with 50 units that deplete in about five harvests, then they are gone for good.
- A reboot reseeds: deposits reshuffle on the same fixed terrain and the consumed set clears. The terrain itself never regenerates.
- Decay: eight weeks of inactivity reverts a claim, structures then fall 2% a day, and bare terrain heals roughly 20% a day back toward baseline.
Terrain
Dig in, and it stays
Dig a tunnel, level a hillside, wall off a moat. The world keeps your changes, and so does everyone else's. Carve terrain and the server records the edit, gives it a place in line, and replays it to every player nearby; log in fresh and the whole edited landscape rebuilds on the spot. Inside a claim your work persists. Dig in open wilderness and the ground heals itself back over time.
How it works
The server has no voxel engine and never ships terrain or voxel data. It stores the edit operations themselves (a mode, a center, a radius), orders them per 256 metre region, and clients replay each op through the exact same calls the editing tool uses. Because the base terrain and the engine build are deterministic and version-pinned, every client reconstructs byte-identical voxels. That equivalence was proven on a Windows and a Linux box, different CPUs, before any networking code existed.
- The server stores operations, not voxels, so a hacked client cannot upload geometry. It can only request an edit, which the server then validates and replays.
- Edits validate server-side: radius 1 to 24 m, within 90 m of your real position, rate-limited, and gated against any claim you do not own.
- The claim gate is brush-aware: it tests the whole brush footprint, not just its center, so a wide brush cannot reach across a boundary into a neighbour's land.
- Owned-claim edits persist to a spatially indexed PostGIS table; wilderness edits are never stored, so they heal at decay.
NPCs
Townsfolk who talk back
Walk up to a quartermaster and ask him anything. He answers in character, remembers your name through the conversation, and knows only Tirawen. Ask him about Earth, real politics, or court intrigue above his station and he gets baffled or shrugs you off, because a weather-worn supply hand at a frontier post would not know either. The model gives each NPC a voice; the server decides what is actually true.
How it works
Dialogue runs on a small local language model, off the simulation tick, on hardware we own. The model proposes a line and a mood; the server accepts the mood only if it is one of three allowed values, and that mood is the only piece of NPC state the model is ever allowed to touch. So a model glitch, or a player trying to talk an NPC into something, cannot move it, change the world, or wedge it into a bad state. Every call is best-effort: a timeout, a hard cap on concurrent calls, and a deterministic brain that takes over the instant the model is slow, busy, or down.
- The model only ever sets one NPC field, the mood, to one of three values. Everything else (inventory, prices, position) is server state it cannot reach.
- Calls run off the 20 Hz tick with a 20-second timeout and at most four at once; excess calls fall straight through to the deterministic brain instead of queuing.
- Player input is capped and sanitized, replies are length-limited, and there is a per-player cooldown, so the dialogue channel cannot be used to flood the model.
- Topics come in three honesty tiers: canned lines, lines built from real server state, and model-voiced replies; a forged topic id is rejected like any other bad request.
Magic & Progression
Spells you write, power you earn
Magic is not a fixed spell list. You build a spell like a sentence: an effect, a target, a shape, and an element recipe drawn from six elements that fuse into things like Steam, Ice, and Magma. Save it, cast it. And there are no skill trees or level-up screens. Your four stats rise only by living the part, so a character with maxed Strength is telling you how it spent its life.
How it works
The four primaries start at eight and scale exponentially, so every ten points doubles effective power and a maxed stat is sixteen times base. Growth is use-based with steep diminishing returns, so the climb from competent to maxed is a long one and you feel every source you lean on. The stat and progression layer is server-authoritative and runs today in the Rust server. The spell-crafting engine is fully specified and in active development: it validates a spell when you write it, the way a compiler catches type errors, with mana the only cast cost.
- Four stats (Strength, Intelligence, Constitution, Dexterity) start at 8 and cap at 40; effective power is exponential, so plus 10 doubles it and a maxed stat is 16x base.
- No respec, and no points awarded after creation. Stats grow only from use, and one stat from 8 to 40 is on the order of 110,000 experience.
- Six elements on three opposed axes; cross-axis pairs fuse (Water plus Heat is Steam, Water plus Cold is Ice), and opposing a pole with itself is rejected as you write the spell.
World Generation
One planet, one coastline, everywhere
Tirawen is one continuous torus-shaped world, about the size of the Moon, with roughly 37.9 million square kilometres of surface. It has three major continents, one connected ocean, and about 320 islands large enough to matter for sailing and exploration. The important part is consistency. The world you see from orbit is the same world you walk across on foot. The coastline does not change between the world map and the terrain under your boots. A bay seen from far away is still there when you arrive. Both axes wrap, so traveling far enough in any direction brings you back around. Sea level is fixed at zero, and a seed controls generation so each location always produces the same terrain.
How it works
The terrain is built from a deterministic noise system. Every point on the planet gets its height from its position and the world seed. Because the math is deterministic, the same location always produces the same result. That same terrain logic exists in three places: Python (the reference version used for testing), Rust (the server and the in-engine generator), and GDScript (the client). All three are checked automatically to make sure they produce the exact same world. If one system thinks a location is land while another thinks it is ocean, gameplay breaks. To prevent that, the build process tests three million sample points across all three versions of the generator. The current result is zero mismatches. The coastline has its own protection. Small terrain detail fades out as it approaches sea level, so fine bumps and noise cannot accidentally turn ocean into land or land into ocean. This keeps the coastline authoritative from orbit all the way down to walking scale. That rule was checked across 2.3 million boundary cells, with zero coastline flips. Erosion is applied across the whole planet instead of only inside local chunks. Water flow is calculated across the wrapped world, carving drainage paths through mountains and valleys while leaving ocean cells untouched. Finally, the game uses a floating-origin system to keep movement and rendering stable. The planet is thousands of kilometres wide, but the voxel engine stores mesh data in 32-bit buffers. At very large coordinates, that precision starts to break down. Instead of letting the active area drift too far from the origin, the nearby world is periodically shifted back close to zero.
- Topology: flat torus (both axes wrap). Dimensions: 6,150 km per axis. Surface area: roughly 37.9 million square kilometres.
- Sea level: 0 m (fixed). Three major continents, roughly 320 notable islands.
- Generator parity: Python (reference), Rust (server and in-engine), GDScript (client). CI determinism gate: 3,000,000 cross-build samples, zero mismatches.
- Coastline gate: 2,300,000 boundary cells, zero land/ocean flips.
- Erosion: planet-wide hydraulic flow-accumulation, torus-wrapped, ocean cells excluded.
- Floating origin: rebase triggers before 32-bit mesh precision degrades, roughly 1,000 km from origin.
Server
One server that owns the truth
Your client does not run the game. It suggests things: I moved here, I swung this pickaxe, I placed this wall. The server decides whether any of it actually happened. There is no local authority. If the server did not validate it, it did not happen. Resource deposits are a good example of why this matters. The server knows where every vein of ore sits on the planet. Your client knows nothing about them until you physically walk within 30 metres of one, at which point the server tells you it is there. You cannot datamine the map. You cannot scan ahead. You find resources the way you are supposed to find them: by exploring.
How it works
The server runs on a fixed 20 Hz tick. Twenty times per second, it processes every pending action against a single authoritative game state. Movement, combat, harvesting, terrain edits, NPC behavior; all of it resolves in the same loop, in the same order, on the same clock. Each client only receives what is near it. Instead of broadcasting the entire world to every player, the server rebuilds each client's visible set every tick: nearby players, NPCs, and events within view range. Everything else is invisible until you get close enough. Persistence runs outside the tick loop so gameplay never waits on a save. Terrain edits, claims, and consumed resources are written durably in the background.
- Tick rate: 20 Hz (50 ms per tick), single authoritative game state.
- Interest management: per-client view radius, rebuilt every tick.
- Spatial indexing: uniform grid with broad-phase cells for proximity queries.
- Persistence: Postgres + PostGIS, durable writes off the main tick loop. With no database configured, the server runs fully in memory, keeping CI database-free.
- Login tokens stored as hashes only; deposits reveal at most once per client.
