A world from a code: a short name you can trust, and hand to a friend
Every world in The Long Watch starts as a short, readable code — a handful of characters that name how large the place is and what climate it lives in. It looks like the sort of throwaway string a lot of games hand you to seed a level. It isn’t. In this game that little code is something closer to an address: a name for one particular world, faithful enough that you can write it down, keep it, and hand it to a friend.
This is the story of that code — what it carries, why we treat it as a promise rather than a hint, and how a few characters end up being the whole identity of a living place you can return to and trust.
What a code carries
A world code has three meaningful parts. Two of them are choices you recognise on sight: a size — small, medium, or large — and a climate, one of four bands the world can live in: temperate, boreal, arid, or tropical. A temperate world is mixed forest and meadow; a boreal one a cold northern wilderness of evergreens and steppe; an arid one a dry expanse of scrubland and sand; a tropical one a lush, humid land of dense forest and wetland. The third part is the seed underneath — the small kernel that, together with those two choices, fixes every detail of the terrain that grows from it.
So the code is human where it can be and exact where it has to be. You read the size and the climate at a glance, the way you’d read a place name; the seed does the quiet work of pinning down which particular world, out of all the worlds that climate and size could be, you actually get.
The same code, the same world
Here is the part that turns a code into an address. Feed the same code in and the exact same world grows back — the same hills, the same ground, the same shape, down to the last detail. Not a world of the same flavour. The same world. That is the whole point of building it the way we did: a code isn’t a nudge that biases the terrain in roughly the right direction; it is a faithful name for one specific place, and naming the place is the same as summoning it.
For that to be true, nothing about how a world is built can be left to chance or to the moment you happened to press the button. The deeper engineering that makes a living, surprising world hold still that way — so the same code grows the same world on any machine, every time — is its own story. Here, what matters is what it buys you: a code you can count on.
A world code isn’t a hint that points the terrain in roughly the right direction. It’s a faithful name for one place — and naming the place is the same as summoning it.
The one place we let the dice fall
There is exactly one moment in all of this where we use genuine, unrepeatable randomness — and we use it on purpose. When you ask for a brand-new world, something has to invent a fresh code out of nothing, and that one roll really is a roll: a seed of seeds, drawn from true chance so that every new world starts somewhere nobody has been before. From that instant on, though, the new code is just as fixed as any other. The coin is flipped once, to mint the name; everything that name then grows is settled and reproducible.
We like that the unpredictability lives in precisely one spot. A new world should feel like an unopened place. But the moment it has a code, it stops being a gamble and becomes a fact — a world you can leave and come back to, knowing it will be exactly as you left it to grow.
A code is a promise, not a convenience
Because identical codes grow identical worlds, a code is shareable in the most literal sense: hand it to a friend and they tend the very same land you tended — the same valley, the same ridgeline, the same ground underfoot. The world you raised isn’t locked to your machine. It travels as a few characters and grows again, whole, wherever it lands.
That only means something if it keeps being true. So we treat the stability of a shared code as a binding commitment rather than a happy accident. A code that someone has already shared keeps growing the same world — that’s a contract, and we break it only on purpose, deliberately, never by drift. A world you handed to a friend a season ago should still be the world they walk into today.
Keeping the promise honest
A promise like that is easy to make and easy to quietly break, so we don’t take it on trust — we hold it to a standing check, and we’d know a code had stopped being a faithful name before it ever reached you. How that check actually proves two worlds are the same, layer by layer, belongs to the engineering story told over here. What it buys you is the thing this whole post rests on: a code you can write down and trust to grow the same place every time.
Why a few characters matter
The Long Watch asks something unusual of you. It isn’t a level you clear or a run you reset; it’s a place you keep, returning to it across many evenings as it ages. A relationship like that needs the world to have a stable identity — something that doesn’t shift underfoot between visits. A short code that always means the same terrain, the same climate turning, the same kinds of creatures is exactly that identity, made small enough to carry.
The first time you meet a world — watching it turn, rerolling until one speaks to you, choosing how large a place to tend — is its own story. This one is about what’s underneath that first meeting: the fact that the world you settle on isn’t a fleeting roll of the dice but a named, fixed, shareable place. You can write it down. You can hand it across. And whoever grows it, wherever they grow it, stands on the same ground you did.
That’s the whole quiet ambition of a world from a code: to make a living, surprising world into something you can genuinely keep — not a save slot on one machine, but a permanent address that grows the same place every time its name is spoken.
