The rules
Conway’s Game of Life is a two-dimensional cellular automaton on a grid of square cells, each either alive or dead. At each tick, every cell looks at its eight surrounding neighbors, and the whole grid updates at once.
- A live cell with two or three live neighbors stays alive. Otherwise it dies.
- A dead cell with exactly three live neighbors becomes alive.
Those two rules are the entire system. There is no input, no choice and no randomness once the starting pattern is set. Despite that, the behavior is rich enough to have attracted a large hobbyist community for decades.
A zoo of patterns
Certain patterns have names because they appear often and behave in predictable ways.
- Block. Four live cells in a two-by-two square. Each live cell has three live neighbors, and no dead cell nearby has exactly three, so the block never changes. This is a still life.
- Blinker. Three live cells in a row. After one tick they become a vertical line of three, and after another tick they return. It repeats with period two.
- Glider. A five-cell pattern that moves diagonally across the grid. It repeats its shape every four ticks, shifted by one cell diagonally. Gliders are the workhorses of Life computing because they move.
The existence of a pattern that travels is crucial. It means information can go from one place to another across the grid.
Signals and collisions
If gliders are signals, then logic comes from what happens when they meet. Depending on how two gliders collide, they may annihilate each other, or produce a new pattern, or one may pass through while the other is deflected. By carefully choosing the timing and angle, builders create arrangements where the presence or absence of a glider at some point represents a 1 or a 0, and the result of a collision represents a logical operation.
From there the standard route is to assemble the usual parts of a digital circuit.
- Glider guns. Patterns that emit a steady stream of gliders, acting like a clock or a constant 1 signal. A famous early example discovered by Bill Gosper produces a glider at regular intervals.
- Gates. Arrangements where streams of gliders collide to compute AND, OR and NOT, so that the output stream reflects the logic of the inputs.
- Eaters. Patterns that absorb gliders and then restore themselves, useful for cleaning up stray signals.
- Memory. Configurations that store a bit, or counters that hold a number, using structures that change only when poked by an incoming glider.
Why this means universality
With logic gates, wires, clocks and memory, you can in principle assemble any digital machine. That includes a machine that behaves like a Turing machine or a counter machine. Because of this, the Game of Life is regarded as capable of universal computation, a conclusion that was reached by constructing the necessary pieces, not by a single insight.
People have gone further and built large-scale demonstrations, including patterns that emulate programmable computers and even the Game of Life itself inside Life. Such constructions can involve enormous numbers of cells. I would rather not quote specific sizes or counts, since details vary by construction and I cannot verify them here.
Interpreting the result
A few honest caveats apply, similar to those for one-dimensional systems like Rule 110.
- It assumes unlimited space. On a finite grid, there is only a limited number of states, so the system cannot be fully universal in the strict sense.
- It is slow and vast. A computation that takes microseconds on a normal machine may need an astronomical number of generations when encoded in Life.
- The starting pattern is the program. There is no step where you enter code. You design a huge initial configuration and let it run.
- Undecidable questions follow. Because Life is universal, general questions about its behavior, such as whether a given pattern ever dies out, cannot be settled by a single algorithm that works for all cases. That is the halting problem showing up in a grid of cells.
Why it matters for programmers
Life is a favorite first project because it is easy to implement and surprisingly deep. A basic version needs a grid, a neighbor count and a pair of rules. Edge handling is an immediate design choice: you can treat outside cells as dead, or wrap the grid around into a torus, which is the same idea as wrapping edges in some grid languages.
Beyond the fun, it is a striking illustration that computation can emerge from local rules with no central control. Once you see gliders as wires and collisions as gates, the move from a toy to a computer stops being mysterious. It also gives some perspective on how much structure is needed for computing: not much, as long as there is a way to move information, combine it and store it.