Game of Life

Four rules with no exceptions, applied to every cell at once, for twelve hundred generations.

The rule

var n = CountNeighbors(grid, r, c, rows, cols);
var alive = grid[r, c] ? n == 2 || n == 3 : n == 3;

That is the whole of Conway’s Game of Life. A living cell with two or three living neighbours survives; a dead cell with exactly three is born; everything else is dead next generation. There are no other cases, no parameters and no exceptions.

Every cell is evaluated against the same grid and the results are written to a second one, which is then swapped in:

(grid, next) = (next, grid);

Updating in place would let a cell see its neighbour’s new state instead of its old one, and the automaton would no longer be Conway’s — it would be a different, and much less interesting, rule.

Step 01

Generation zero. This rendering starts from the acorn: seven cells, arranged so unremarkably that it looks like a mistake.

Why the acorn

The acorn is a methuselah — a small pattern with a long, chaotic history. Seven cells, and it does not settle for 5,206 generations, by which point it has produced 633 cells including thirteen escaped gliders. Twelve hundred generations, which is what this piece runs, catches it while the expansion is still in full flight, the whole chaotic history sprawled across the frame.

Nothing in the rule knows that. There is no distinction anywhere between a glider, a still life and debris; those are names for behaviours that an observer notices, and the automaton has no representation of any of them.

Step 02

An eighth of the run. The seed has burst, and the expansion is roughly circular because information cannot travel faster than one cell per generation in any direction.

The grid wraps

var nr = (r + dr + rows) % rows;
var nc = (c + dc + cols) % cols;

Neighbours are counted modulo the grid size, so the world is a torus: a glider that leaves the right edge arrives at the left, and one that leaves the bottom arrives at the top. There is no wall for anything to die against.

For a long run on a small grid this matters — patterns eventually collide with their own emissions from the other side, and the late history is not the history the acorn would have on an infinite plane.

Step 03

A third. Gliders have separated from the central mess and are travelling diagonally at one cell per four generations, which is the fastest any pattern of that kind can move.

The trail

if (ShowTrail && alive) lastAlive[r, c] = gen;
…
var age = (float)(generations - lastAlive[r, c]) / generations;
var fade = grid[r, c] ? 1f : MathF.Pow(1f - age, TrailPower);
paint.Color = grid[r, c] ? AliveColor : SKColorExtensions.Lerp(Background, TrailColor ?? AliveColor, fade);

Only one generation is ever drawn — the last one — but every cell remembers the most recent generation in which it was alive. Cells alive now are drawn in the ink; cells that died are drawn faded toward the background, on a squared falloff by default, so recent deaths are much brighter than old ones.

The result is a still image with time in it: the bright pixels are the present, and the dim ones are a decaying record of where the pattern has been. Glider tracks show as fading diagonal streaks — the only place in the drawing where a trajectory is visible at all.

Step 04

Two thirds. Debris has begun settling into still lifes and two-period blinkers.

Step 05

Twelve hundred generations. The bright pixels are the present; the dim ones are the record of everything the seed has been through.

Eight worlds

Rendering	Seed pattern	Generations	Ink
Acorn	7 cells	1200	`#FF66AA` on `#08000A`
Glider Gun	Gosper’s 36 cells	500	`#44BBFF` on `#050510`
Random	uniform fill at 35%	300	`#00FF88` on `#070710`
Head-on	two guns, mirrored	700	`#FFC24D` on `#0A0700`
Ember	four gliders	400	`#FFE9CF` with a `#D9431F` trail
Quilt	four acorns, mirrored	400	`#3DE0B4` with a `#0F7F63` trail
Weave	ten gliders in a row	500	`#9B7CFF` with a `#3D2A70` trail
Paper	uniform fill at 40%	300	`#1C1930` on `#F2EFE6`, no trail

Glider Gun is the one with a proof attached: Bill Gosper found it in 1970, in response to Conway’s conjecture that no pattern could grow without bound. It emits a glider every thirty generations, forever, and the emissions are what fill the frame.

Random is the opposite case — no design at all, just 35% of cells alive at generation zero. It collapses fast: most of a random field dies within a few dozen generations, and what survives is the still lifes and oscillators that a random field happens to contain.

Head-on places two guns on one diagonal, facing each other. The streams travel the same line at the same speed and meet in the middle, where glider annihilates glider every thirty generations; the trails mark the whole flight path, and the debris the meetings leave behind glows at the centre.

Ember sends four gliders at the centre from the four corners — one deliberately off the exact line, so the collision leaves debris instead of cancelling cleanly. It draws with two inks: the living cells in cream, the trail in ember, with a linear fade so the whole flight stays visible.

Quilt mirrors one acorn into the four corners and lets each bloom toward the centre, stopping just short of it. Nothing in the rule knows about symmetry — it holds only because the seeds do — and the result is the one rendering that is a pattern rather than an event.

Weave lines ten gliders up on the anti-diagonal, two to each of five parallel tracks, and runs them until their trails have combed the torus into a diagonal fabric. The trail fade is flattened so the whole weave stays in sight.

Paper inverts the frame: ink on paper instead of light on darkness, no trail, and a faint grid where the cells would be. What the random field leaves behind after three hundred generations is a scatter of still lifes, drawn like type.

Determinism

The six designed renderings are literal coordinate lists and consume no randomness at all. The two random presets use SeededRandom — the project’s stable Xoshiro256StarStar — seeded from the preset and consumed once per cell in grid order, before any generation runs. The rule itself is pure integer logic.

On the wall

The final gallery plate is the acorn as a museum would show it: hung on a dark wall, in a cream mat and a deep frame, with a caption plaque. The framing is a presentation layer — MuseumFrame wraps a finished rendering without touching the generative design — so the same mat could frame any of the other renderings without a single rule being re-run.

Progression 05

Variant 08

Gallery 01