Portfolio · Behavioural Observations
Seed Unpack — What's Hiding In The Number You Picked
An interactive piece that runs Java's LCG (the same one Minecraft uses for world generation) on whatever seed you type in, and draws the resulting state-trajectory as a network of points. Some seeds reveal a hidden lattice. Some scatter. The lattice is real, reproducible, and almost never examined in the systems that consume the seed.
Seed Unpack
What the page does
The interactive takes a single integer — the seed — and iterates it through Java's linear congruential generator:
state ← (state · 25214903917 + 11) mod 2⁴⁸
This is the standard java.util.Random step. It is also the function
that turns a Minecraft seed into a world. After each step, the 48-bit
state is unpacked into a pair of canvas coordinates by
(x, y) = (state mod W, ⌊state / W⌋ mod H)
and the resulting points are drawn as a connected polyline. The page runs a hundred steps — enough that the trajectory's character is clearly readable, few enough that the visual signal stays clean rather than smearing into a uniform field. The network depends only on the seed and the LCG. It is fully deterministic. The same seed always produces the same network.
What the network shows
Some seeds produce a network with visible structure — diagonals, clusters, near-grid behaviour, lines that close into loops. Others produce networks that look like noise. Both are correct. The LCG has an underlying lattice; some starting positions traverse it in a way that exposes the lattice and others walk through it without disturbing it. The visible difference between two seeds, watched on the same canvas, is the difference between two ways of moving inside the same fixed structure.
The seed-family chips — primes, Fibonacci, powers of two, π digits, and so on — make the comparison easier by grouping seeds that share arithmetic properties. Run a Fibonacci seed and a prime of similar magnitude and the two networks differ in ways that are reproducible across the family.
Why this is on the research site
This is not a model behaviour. It's a sketch about constants and variables. A seed is treated, almost everywhere it appears, as an opaque parameter. Pick one, paste it in, run the system. The system commits to the world the seed produces; changing the seed changes the world; nobody changes the seed.
The lattice the seed walks is fixed, deterministic, and visible the moment you draw the trajectory. It has been there the entire time. The choice to look at it has been ours, and most of the time we haven't.
The same shape recurs across the rest of the library. Where a constant looks arbitrary, it usually isn't — there's structure underneath that nobody examined. Treating the constant as a variable means looking first.
Notes on the implementation
The page is a single static HTML file. Java's LCG is implemented
with BigInt so the 48-bit modular arithmetic stays exact across
JavaScript's floating-point numbers. The compare mode splits the
canvas in half and runs two seeds side-by-side against the same
grid. Coordinates wrap through mod W and mod H, so the lattice
is the canvas-sized projection of the full 48-bit state, not the
state itself — which means the visible network is one slice of a
much larger object.