Rule 110, the Glider Gun and Why Cellular Automata Keep Winning

In 1970 John Conway wanted the simplest possible system that could, in principle, compute anything. He got it: a grid of cells that live or die by neighbor count, no memory, no global control — and inside it, structures that glide, collide and carry information. Fifty-five years later, cellular automata remain the fastest way to feel what emergence means, because everything interesting about them is watchable.

Life: five cells that travel

The glider is the atom of Game of Life communication: five cells that reproduce themselves one diagonal step every four generations. Two facts follow from that little object. First, infinite growth is real — the Gosper glider gun fires a new glider every 30 generations forever, and its discovery in 1970 settled a bet Conway had made that no pattern could grow without limit. Second, glider collisions can be arranged to perform logic: gliders present or absent at a crossing encode 1s and 0s, and gun-to-gun timing builds gates. From there it's a short road to a Turing machine, and people have literally built them inside Life. When you stamp the gun in a simulator and watch the stream march out, you're watching the moment "simple rules ⇒ universal computation" stopped being philosophy.

Changing one number in the rule changes the universe: add birth-on-6 (HighLife's B36/S23) and a 12-cell replicator appears; remove survival entirely (Seeds' B2/S) and every pattern becomes an exploding wave. The rule string is a genome, and the phenotype is one click away.

Rule 110: universality from one byte

Wolfram's elementary automata compress the whole idea further: one row of black and white cells, a rule byte that says how each three-cell neighborhood maps to a new center cell. There are 256 of them. Rule 30 from a single seed makes the chaos Wolfram used as a random number generator in Mathematica; Rule 90 draws Sierpinski's triangle; Rule 184 is a textbook traffic model — cars moving right through jams. And Rule 110, with its regular left-moving stripes colliding in a chaotic froth, was proven by Matthew Cook to be Turing-complete. The proof required careful bookkeeping of glider collisions; the intuition requires only a screen: watch the stripes act like particles that store and transform information. It's the smallest known window into universal computation, and you can generate it from one cell.

Wireworld: circuits you can see

If Life is computation in the abstract, Wireworld is computation with a schematic. Four states — empty, copper, electron head, electron tail — and the rule that copper with exactly 1 or 2 neighboring heads becomes a head. That single threshold gives wires directionality and timed signals logic: merge two clock wires and the junction computes; space the electrons and you have AND timing. Real CPUs have been built in Wireworld, and every diode, gate and flip-flop is visible as copper you can trace with your eyes. For teaching digital logic, it's hard to beat a medium where the electrons are the pixels.

Langton's Ant: order from a million steps of chaos

Two rules — turn right on white, left on black, flip the color — and the ant paints thousands of steps of apparent noise before abruptly building a straight highway forever. Chris Langton's 1986 turmite became the mascot for emergence: no pocket of order is visible at step 10,000, and it's inevitable by step 10,100. It's also the gentlest introduction to turmites, where multi-color turn strings like LLRR produce symmetric cardiods and tape-like structures. The lesson generalizes: local rules with no obvious global pattern can still have exact, discoverable long-term behavior.

Why step them instead of reading about them

Every one of these systems is deterministic, small enough to hold in your head as a rule and yet impossible to hold in your head as behavior. That gap — between the one-line rule and the thousand-generation consequence — is exactly what a stepper closes. Run the Acorn for its full 5,206 generations at 120 steps per second and the concept "methuselah" stops being trivia. Toggle the torus and watch a glider wrap into its own residue. Change B3/S23 to B36/S23 and refresh until the replicator appears. Paint your own seed for Rule 30 and try to predict row three — then row thirty.

Complexity theory's core claim is that simple local rules generate arbitrarily complex global behavior. Cellular automata are that claim, executable. Sixty years after Conway, the cheapest laboratory for it is still a browser tab.