Proving the graphics card first: two throwaway proofs before a line of the real work
Two of the most visible things we have ever added to The Long Watch were about to be built on a single bet: that one modest laptop graphics card — the real, unglamorous machine the game has to run on — could carry both. Rather than write the features and hope, we spent a day proving the ground first. Two tiny throwaway programs, run on the actual card, before a line of either feature shipped.
One bet, two features
The first feature was see-through water: a translucent surface you can look down through, into the world lying beneath it. The second was drawing a whole crowd — every creature and plant on screen — in a single push to the graphics card, instead of issuing a separate instruction for each one. Different features, but they rested on the same unproven ground: that the real hardware would behave the way we needed it to. And much of what we needed was undocumented. Guess wrong, and we would bake a subtle rendering bug deep into the world — the kind that is slow to notice and expensive to dig back out.
None of this is a new instinct for us. Proving the floor before you stand on it is a habit the whole project leans on, and it has a story of its own. This is that same habit pointed squarely at the graphics card, on one particular day.
A layout oracle
Drawing a crowd in one push works like this: you hand the card one long list of numbers — sixteen per creature. Twelve describe where each one sits and how it is turned; the last four are its colour. A hundred creatures become one list, handed over once, instead of two hundred separate instructions — and the card is extraordinarily good at chewing through exactly that kind of thing. But nobody had confirmed the order those sixteen numbers must go in, and the engine’s own notes were silent on it.
So the first probe was a layout oracle: a small disposable program whose only job was to find the true order and prove it two ways that cannot fool each other. First it built a handful of creatures the ordinary slow way, one at a time, giving each deliberately lopsided, all-different values — nothing tidy or symmetric that a mistake could hide inside — then read back the list the engine actually produced and worked the recipe out slot by slot. Then it did the reverse: hand-built its own list to that recipe and confirmed it round-tripped back to exactly the same creatures. Discover the order by reading; then rebuild it from scratch and check the two agree.
Along the way it caught the trap that made the whole exercise worth doing. The engine hands you a creature’s orientation arranged one way round — as columns — but the upload list wants it the other way, as rows. Swap them and every creature is silently transposed: flipped, mis-turned, facing wrong, with no error, no crash, nothing whatsoever to tell you it went sideways. The lopsided test values were chosen for exactly this — a transposed result comes out too crooked to pass for a correct one by accident. The probe pinned the row-versus-column order down, so the fast bulk path now produces, byte for byte, precisely what the slow one-at-a-time path always did.
Get the rows and columns backwards and every creature turns wrong — no error, no crash, nothing to tell you. The only thing that catches it is a value too lopsided to fake.
The drawing this unlocked — one baked shape stamped across a whole hillside for almost nothing — is its own story. This was only the proof that the crowd would arrive the right way up. And it is a proof worth banking, because the roster it has to carry keeps growing — toward something like seventy species — and that is exactly the scale at which one list beats a separate instruction per creature.
A go/no-go gate for the water
The second probe proved the water, and it began by proving a negative. The engine ships fancier built-in tools for fluids, and the tempting thing was to reach for them — but they simply do not fit this world’s smooth voxel terrain, so a plain translucent sheet laid flat at the water line was the only real path. We walked in with a fallback already agreed: if the see-through surface corrupted or ran too slow on the real card, we would drop to a plain solid-coloured one instead — pre-accepted, no argument to be had in the moment.
Then the probe put a large see-through sheet into a real scene on the actual target card, and we watched. It passed on every count. The hardware blended it cleanly. The water stayed down inside the low basins and hid behind solid ground wherever the terrain rose above the line. The submerged floor, and the creatures moving beneath the surface, showed through. The shoreline seam didn’t fight.
And it stayed fast. On the worst-case view we could stage — the screen filled edge to edge with water, nothing cheap left in frame — it peaked at sixty frames a second, comfortably clear of the fifty-frame floor we hold. The transparent pass, in other words, was very nearly free. (Reading a frame-rate number honestly — late, on real hardware, across a short window rather than one deceptive instant — is a hard-won discipline of its own.) The pre-accepted opaque fallback went back on the shelf, never needed.
The water itself — one flat line that floods the low ground into lakes and ponds, and the first small creatures that come to swim beneath it — is told from the world’s side. This is the quiet day before that one, when we made sure the surface would actually draw.
Probes that refuse to lie
Both probes shared one last piece of care, and it is the part I would most want to keep. Run without a real graphics card — the way our fast, constant checks run — neither probe can see anything at all: the stand-in renderer stores none of the data, so the layout reads back empty and the water draws nothing. A probe in that state doesn’t fail. Worse, it would quietly appear to pass — the most reassuring, most worthless green there is.
So we built them not to. Each one detects that there is no real card under it and cleanly skips, printing a plain note that the real verdict needs the real machine. A green from a place where the truth can’t be seen is worth less than no answer at all — a lesson we ran head-first into on another feature, where the check that mattered could only ever run in a real window. Our probes would rather say “not here” than say “fine” from a place they can’t know it.
The day before the real work
Only once both probes came back green did we build the features themselves, a few days later: the see-through water, and the single-push drawing of the whole crowd, each laid on top of a recipe we had already made sure of. Neither shipped a surprise, because the surprises had all been flushed out the day before — by two small programs written to be read once and thrown away. What survived them wasn’t the programs. It was the confidence that the ground would hold. The same habit later carried a whole simulation onto the card — handing the rivers to the graphics card, proved the same way before it was leaned on.
Prove, don’t assume — and prove it where the truth actually lives, on the real machine, before you build a single thing on top.
