Life on a Plane

Conway's Game of Life

John Conway's rule reached the public in 1970 through Martin Gardner's "Mathematical Games" column in Scientific American rather than through a research paper. The rule is B3/S23, and that's the whole of it: a dead cell with exactly 3 live neighbors is born, a live cell survives with 2 or 3 live neighbors, and every other cell dies or stays dead. No other case, no other parameter.

Gliders are this plane's translating particles — the direct 2D cousins of Chapter 2's Rule 110 particles: a small fixed pattern that reproduces itself, shifted, after a fixed number of steps, drifting across an otherwise quiescent board forever. Bill Gosper's glider gun is a fixed pattern that never stops making them: a 36-cell machine that emits one glider every 30 generations without itself moving or growing. This project's test suite checks that emission directly on the live engine — over generations 30 through 150 (120 generations, four full 30-step periods), the board's total population rises by exactly 20 cells, the mass of the four gliders (5 live cells each) the gun emits in that span.

Not every Life pattern is built by hand. Seed the same rule with random noise instead of a gun and most of it burns out in a few generations — but not always all of it:

A loop that copies itself

Christopher Langton published a smaller, cruder self-replicator in 1984: an 8-state cellular automaton whose ~86-cell loop builds a copy of itself out of a rotationally symmetric transition table, with no other machinery attached. Set one loop down on an empty plane and it doesn't stay one loop.

That's a deliberate simplification against the machine described in this project's String module: von Neumann's own design uses 29 states and a general-purpose constructing arm capable of building any machine describable to it, with self-replication arriving as one instance of that universal construction. Langton's loop keeps only the second half of that — replication — and drops universal construction entirely. Run the source paper's own computing-versus-building axis against it and the loop lands on the side that can replicate without being able to build, or compute, anything else at all.

That's exactly what this project's test suite checks, not merely asserts: starting from a single loop, the board holds exactly 1 connected component at t = 0, at least 2 by t = 250 (the canonical first daughter loop finishes budding around t = 151), and at least 3 by t = 600 — with the live-cell population strictly increasing at every one of those checkpoints. One loop becomes a colony because the rule replicates it, not because anything schedules that outcome.

Thirteen protofilaments, one seam

Mammalian microtubules are hollow tubes built from tubulin dimers arranged in parallel columns called protofilaments — 13 of them is the typical count. Those columns don't stack in flat rings: the lattice packs helically, so each trip around the tube's circumference lands three subunits further along the axis than where it started, before the lattice closes on itself at a seam. That "13_3" pattern is the standard geometric description of the mammalian microtubule lattice, not something this project derived. Running a cellular automaton over exactly that lattice is literature: Hameroff and Watt proposed information processing in microtubules in 1982 (J. Theor. Biol. 98), treating the seam-wrapped protofilament grid as a candidate computing substrate.

What follows is this project's own experiment with that geometry, not a biology claim. B3/S23 — Conway's exact rule, unchanged — runs below on a 13-wide grid whose right edge wraps back to the left with a three-row shift, the same kind of arena swap Chapter 7's cylinder ran on a quantum walk: the rule stays fixed, only the space it lives on bends. Some of Hameroff and Watt's descendants — Orch-OR most prominently — extend microtubule computation into a hypothesis about consciousness itself; this project neither adopts nor evaluates that hypothesis, only names it.

The guide line marks the seam at the grid's right edge. What crossing it does is exactly what this project's test suite checks: a pattern that straddles the seam doesn't wrap the way a plain torus would. Our test places a vertical three-cell blinker on the seam column, steps the rule once, and finds it bent into three cells spanning the seam — two still on this side, one carried across and shifted three rows down the axis — then, one step later, restored to its original three vertical cells, the period-2 blinker intact but for that seam-shaped detour. Reset below re-seeds the same random soup (seed 11); watch what happens wherever a pattern's own drift carries it across that line.

Lenia — life without cells

Bert Chan's Lenia (2019, arXiv:1812.05433) keeps Life's update logic — sample a neighborhood, grow or shrink based on what's there — and strips away the grid's remaining discreteness. State is a continuous value in [0,1] rather than a binary on/off; the neighborhood is a smooth radial kernel instead of the 8 Moore neighbors; and time advances in small steps (dt = 0.1 here) rather than whole generations — continuous in the sense that shrinking the step size refines the same trajectory rather than changing the rule, not literally infinitesimal.

The creature planted three times in the garden below was not copied out of Chan's paper: it was discovered by this project's own crescent-seed search over the growth parameters μ and σ, surviving 600 steps on its home arena and then, independently, 500 more once cropped and re-seeded on a fresh field — the same replay this project's test suite runs before trusting it. At μ = 0.13, σ = 0.016, it is a stationary ring oscillator: it holds its position and pulses, its total mass cycling on a roughly 250-step period, rather than gliding across the board. That's a different behavior from Chan's own published orbium creature, which does glide across the plane; ours is a distinct creature, found by a distinct search, and it does not.

The garden below plants three copies of that creature at separate points on the field, alongside two patches of soft random noise. Nothing enforces that all three survive: noise drifting into a copy's neighborhood, or two copies' pulses overlapping as the field wraps its torus edges, can push a copy's local density outside the growth rule's tolerance and tear it apart before the run ends. That instability is a fact about running several instances of this rule together, not a flaw in the garden — the same grow-or-shrink logic that sustains one isolated ring oscillator doesn't automatically protect it from its neighbors.

The μ and σ sliders above turn the same growth parameters the search swept — μ sets the neighborhood density the rule grows toward, σ sets how forgivingly it tolerates neighborhoods that miss that target — into a live dial. Turning them mid-run is this module's smallest transmutation, the same move the next section performs at the scale of an entire rule family.

The field on the Riemann sphere ℂP¹

Chapter 7's Riemann-sphere widget folds a walk's real line onto the real projective line ℝP¹ — a circle sitting on the sphere's equator (see Chapter 7). That fold reaches only one real dimension of the sphere it lands on. This field is not a line: it's a two-dimensional lattice, which is exactly a discretized complex plane, one real axis for x and one for y. Stereographically projecting a complex plane's one-point compactification doesn't stop at the equator — it reaches the whole Riemann sphere ℂP¹, the complex projective line. The field keeps living on the same periodic torus lattice it runs on above; projecting it onto the sphere is a change of coordinates, not a change of dynamics — same stepLenia update, same μ and σ, drawn through a stereographic projection with the point at infinity always in view.

SmoothLife — a disk and a ring where Lenia had one

Stephan Rafler's SmoothLife (2011, arXiv:1111.1567) runs Conway's Life through a continuous generalization built directly from Life's own birth/survival logic, rather than from a new rule invented from scratch. Where Lenia samples one smooth ring-shaped kernel, SmoothLife samples two: an inner disk gives a local filling fraction m, and a surrounding annulus gives an outer filling fraction n. B3/S23's exact thresholds — birth at 3 neighbors, survival at 2 or 3 — become a birth interval [b1, b2] and a survival interval [d1, d2] that n is tested against, with m selecting which of the two applies: continuous generalizations of the same two counts, not a different logic.

The paper's own two time-stepping schemes — discrete replacement and a rescaled-rate "smooth" update — both die to zero activity within a few dozen steps against Figure 1's own parameters, from generic noise or blob seeds, in this project's implementation. What ships here instead is the relaxation update two independent, citable reference implementations of Rafler's paper use, f′ = f + dt·(s(n, m) − f): a documented departure from the paper's literal equations, not this project's invention. Under it, a random noise soup settles into a static, spatially structured equilibrium — a stable labyrinth of high- and low-filling domains — and stays there: mean frame-to-frame change averages below 1e-3 over steps 200–300, and spatial variance exceeds 0.02 at step 300, the two facts this project's test suite checks. Rafler's own Figure 1 caption describes a smooth-scheme glider translating across the field from an unpublished seed; that glider is real, in the literature, under Rafler's scheme, and it is not reproduced here.

A learned rule, not a written one

Every rule earlier on this page is hand-written: a fixed formula decides each cell's next state, whatever the family. Mordvintsev, Randazzo, Niklasson & Levin's "Growing Neural Cellular Automata" (Distill, 2020, doi:10.23915/distill.00023) is not. Each cell perceives its own 16-channel state — 4 visible as RGBA, 12 hidden — plus a Sobel-x and Sobel-y estimate of each channel, a 48-number perception vector, and feeds that vector through a two-layer network, 48 → 128 → 16, whose output nudges the cell's next state. That architecture is the only part anyone wrote by hand; the network's actual numbers — every weight and bias — came from gradient descent, trained so that growing toward a target image and regrowing after damage are both attractors of that same update, not two separate rules bolted together.

This page runs the paper's own published regenerating-lizard weights (Apache 2.0) through this project's own TypeScript port: inference only, nothing trains in the browser. Regrowth after a wound is not a surprise this rule stumbled into — it is exactly what those weights were optimized to do, the same trained attractor that growth from a single seed cell is.

Same rule, same weights, this project's own float arithmetic: the tests pinning this port check specific numbers, not a general impression. A grown pattern's living-cell count lands in [400, 1200] at step 96, and its footprint's intersection-over-union with itself 32 steps later is above 0.85. A damage disk cuts that overlap below 0.6, and it climbs back above 0.75 within 96 more steps. Byte-for-byte parity with the paper's own TensorFlow implementation is not claimed; the behavior these numbers pin is.

The next section's rule moves between Life and Lenia along an explicit, hand-written interpolation slider; this rule's own numbers came from training instead — written versus learned, the same two ways every rule on this page ultimately gets the numbers it runs on.

From Life to Lenia

The bridge below is a single rule family with one slider, s, running from 0 to 1. At s = 0 it is not merely similar to Conway's Life — it is Life, exactly: this project's test suite runs the same seeded soup through both this rule and the dedicated Life engine for 20 steps and checks the two boards agree cell-for-cell, an equality, not a metaphor. At s = 1 it is the Lenia rule from the section above, matched to 1e-12 against the dedicated Lenia engine over 100 steps on the frozen creature's own field.

Between those two endpoints, s parametrizes one continuous family — a kernel that widens and a growth window that narrows and softens as s rises — rather than a path that draws closer to either endpoint's shapes as it goes. Nothing here claims that gliders morph into ring oscillators, or that an intermediate rule approaches Life's or Lenia's own patterns partway through the slider. What's exact is the two ends and the interpolation connecting them; the shapes in between are their own thing, not a blend of the other two.