One number per lantern

Hand a lantern the number 3 274 118 905 and it becomes a particular shade of orange, pulsing at a particular speed, slightly out of step with the lantern next to it. Hand it a different number and it becomes a different lantern.

Nothing is stored about the colour. Nothing is stored about the flicker. There is only the number, and a rule for reading it — and that is a very good deal, because a number is tiny. Six thousand lanterns is six thousand numbers, twenty-four kilobytes, and the graphics card works out everything else while it draws.

The library never picks a colour. It picks a number, and the number picks the colour.

pcg-ts builds the field. It works out where each lantern hangs, how big it is, and which number it carries — and then it stops. It has no clock at all, on purpose, so nothing it produces can move. The same seed lays out exactly the same field on any machine, today or next year.

The web page picks it up from there. The page owns the clock, and the page owns the little program that runs on the graphics card. Between the two halves there is one wire, and the only thing travelling down it is that one number per lantern.

A pile of points in pcg-ts is not just positions. Every point carries a little row of named values, and one of them is called seed — the point's name badge. It is a scramble of where the point came from: which node made it, which number it was in the queue, and — in a streamed world — which patch of ground it fell on. Scramble the same things on another machine and you get the same badge, which is the currency the library's whole determinism claim is paid in.

A 32-bit number is thirty-two yes-or-no switches in a row. The little program on the graphics card does not use it as a quantity at all — it reaches in and reads slices, the way you would read a phone number as an area code and a line.

Almost every number a graphics card handles is a float — the kind that can be 0.5 or 3.14. A float buys that flexibility by keeping only about seven digits' worth of detail and then remembering separately how big the number is. Small numbers get counted exactly. Big ones get rounded to the nearest step, and the step keeps doubling as the numbers grow.

The badges are not small numbers. At the demo's default seed, 5 894 of the 6 000 come back from a float changed.

pcg-ts is a node graph: little boxes that each do one thing to a pile of points, wired nose to tail. The lantern graph is five of them, and it would be four if it were not trying to prove something.

Because the hue comes straight off the small end of the badge, the spread of colour in the field is a readout of how much of the badge survived the trip. Switch the demo's picker to the float column and the field falls in on itself. Four of the five numbers below are the ones the demo's own panel prints, cooked at its default seed. The fifth is counted the same way, off the same two columns:

Two thirds of the field lands on a single hue. Three hues take nearly nine in ten. The strip at the top of this page is that collapse drawn live — and it is not a contrived worst case, it is the ordinary case for a name badge. Try another seed: the numbers barely move.

It still twinkles. It is still wrong.

That second column is the reason this demo exists rather than a note in the docs. If the page had scrambled the badge again in the shader instead of reading its switches directly, the broken field would have looked exactly as random as the good one — different, but not visibly different, which is worse. Half of a wrong answer looking right is how a bug like this survives review.

And in this case the same value has to come back tomorrow, on someone else's machine. “Looks right” is not the test. The claim is about the number.

The library hands each named column to the renderer as an attribute of its own, keeping the whole-number type. The page declares it on the other side as a whole number too, and if those two disagree the graphics driver simply refuses to draw — it does not round the badge for you behind your back.

The one thing worth knowing is that the two columns fail in different ways if a graph stops producing them. A missing whole-number column is a hard stop: the page comes up empty. A missing float column reads as zero in silence, and because it is only looked at on the far side of the picker, the demo would look perfect until someone flipped the switch. So the demo names both columns as requirements when it builds the meshes, and gets told which one went missing rather than diagnosing it from whichever picture it happened to draw.

The demo's own source is worth reading for one more reason: the long comment explaining a line that is not there. Common advice says to flag this kind of channel as an integer for the renderer. Measured on this path, the channel is already an integer without the flag, so the flag does nothing — while on a float column that same flag makes the driver reject the draw. It is not dead everywhere: on a yes-or-no channel, which is stored as single bytes, it is the thing that picks the integer path at all. A line that is a no-op in a file people copy is worse than no line.