Conway's Game of Life
2D binary cellular automaton on a Moore (8-cell) neighborhood with birth/survival/death rules driven by the live-neighbor count.
Run it
What it looks like when it goes wrong (4)
- Nearly everything is gone within two generations. With the middle case set to die, nothing distinguishes a stable cluster from an overcrowded one, and the only cells left are the few born each step into a board with nothing to sustain them. This is the demonstration that the rule the source never states is the one carrying the entire pattern — everything people find beautiful about Life is in the clause that was left implicit.
- Explosive growth to a saturated board, then collapse as every cell is overcrowded. Life sits on a narrow ledge between extinction and saturation, and one step in rule-space falls off it. Worth reaching for whenever a rule "looks close enough" — closeness in parameter space says nothing about closeness in behaviour.
- Without overcrowding, live cells almost never die, and the board fills with static blobs that never change again. The two death rules are not redundant with each other: the floor prunes isolation, the ceiling prunes density, and removing either one ends the dynamics in the opposite direction.
- On a 16x16 board, activity crosses the whole grid in a few generations and the wrap-around meets itself. Edge handling is not specified in the evidence — this sketch wraps, and it could equally have used dead borders — so at this size the edge policy, not the rule, decides what you see. A result that changes when you change the grid size is a result about the grid.
Clean-room implementation — written from the described algorithm, not from source. Reuse policy
What it is
Conway’s Game of Life is a 2D binary cellular automaton: a grid of cells, each dead or alive, that steps forward one generation at a time based only on how many of its 8 surrounding cells — the Moore neighborhood — are currently alive. The corpus dates this to 1970, and files it under the names Game of Life and 2D Life as well as its canonical one. It’s the step up from the elementary cellular automaton: Nature of Code frames the move directly as going from a 1D CA to a 2D one, trading the single row and its rule-number lookup for a full neighbor count per cell, at the cost of a bigger neighborhood to evaluate.
How it works
The excerpts behind this page give three explicit rules, each a threshold on a cell’s live-neighbor count:
- A live cell with one or fewer live neighbors dies.
- A live cell with four or more live neighbors dies.
- A dead cell with exactly three live neighbors is born.
That’s what’s directly evidenced. What isn’t stated in what’s gathered here is the middle case — a live cell with two or three live neighbors. The obvious complement of the two death rules is that such a cell simply stays alive, and that’s the reading most implementations use, but the specific line asserting it didn’t survive this session’s extraction pass (it wasn’t a contiguous span in the source bytes). Decide the middle case deliberately when you implement this, rather than assuming this page has confirmed it.
Parameters & tuning
The whole rule reduces to three numbers: the death floor (here, 1), the death ceiling (here, 4), and the birth count (here, 3). Those are the actual knobs the evidence gives you — move any one of them and you get a different member of the same birth/death family. Nothing in the excerpts gathered for this page describes what the picture looks like once you do, so that’s something to run and watch, not something this page can tell you.
Where it’s been used
Both excerpts behind this page come from Nature of Code’s Cellular Automata chapter — a teaching treatment, not a named artwork. No specific work or artist appears in the evidence gathered for this page. That’s a gap in the corpus, not a claim that none exists.
Variants & neighbours
This sits inside the broader cellular automata frame as the 2D, Moore-neighborhood case, in contrast with the elementary cellular automaton’s single row and 8-bit rule-number lookup. The two get confused because both are generation-stepped grids of 0/1 cells driven by a fixed local rule, but the rule itself is encoded differently in kind, not degree: one number fully determines the 1D case, while this page’s three thresholds are the 2D equivalent — and the evidence gathered here doesn’t extend past them into the middle case noted above.
Go deeper
- Nature of Code — Cellular Automata — the death and birth thresholds this page draws from; read it directly for what this page’s evidence doesn’t cover, including the survival case.
Related, in brief
Probabilistic cellular automaton rules
Replacing Game of Life's deterministic birth/death outcomes with percentage chances, e.g. an overcrowded cell dying only 80% of the time.
Connected to
Further reading: The Nature of Code
Variants: Probabilistic cellular automaton rules