Wolfram elementary cellular automata. Use ◀ ▶ to step through notable rules, or hit random. Each row is computed entirely from the row above.
Stephen Wolfram introduced elementary cellular automata in 1983. The setup is minimal: a one-dimensional row of binary cells, each updated in lockstep using only its own state and its two neighbors. There are 2³ = 8 possible neighborhood patterns, and each can map to 0 or 1, giving 2⁸ = 256 possible rule tables. Wolfram indexed them by treating the table as an 8-bit integer. Rule 30 is binary 00011110. Rule 110 is 01101110.
The remarkable thing is how little this indexing hides. The full computation is this:
const l = prev[(i - 1 + COLS) % COLS]; const c = prev[i]; const r = prev[(i + 1) % COLS]; const pattern = (l << 2) | (c << 1) | r; next[i] = (rule >> pattern) & 1;
Five lines. The three-cell neighborhood becomes a 3-bit index into the rule number, extracted with a right shift and mask. The rule table is not stored separately — it is the rule number. Change one integer and you get a different universe.
Rule 30 grows triangular structures on the left and pure noise on the right from a single seed cell. The center column is so unpredictable that Wolfram used it as the random number generator inside Mathematica for years. In 2019 he posted open prizes for proofs about its center column: does it contain every finite bit string? Is it periodic? Nobody has cracked it. A 2022 paper made progress on steady-state randomness bounds but the core questions stay open.
Rule 90 is the opposite of surprising. Left and right neighbors XOR'd together. The result from a single seed is a Sierpinski triangle: fractal at every scale, predictable, derivable by hand. Rule 110 sits at the other end of that spectrum — Matthew Cook proved in 2004 that Rule 110 is Turing complete. A one-dimensional binary array updated by an 8-bit rule can simulate any computation. The proof requires constructing glider-like patterns that encode a tag system, but the rule itself fits in a byte.
Most of the 256 rules are boring: all-zero, all-one, simple stripes. A handful produce Class 3 chaos or Class 4 complexity. The unsettling part is there is no obvious way to predict which. You can enumerate. You cannot shortcut to the interesting ones without running them.
← Back to showcase