Wolfram Rules

1D cellular automata — eight bits of rule, infinite complexity

Each rule is just eight bits — a lookup table for how a cell responds to its three neighbors. Yet from this simplicity emerges infinite variety: Sierpiński triangles, turbulent chaos, even Turing-complete computation. Draw a pattern and watch complexity unfold.

The Rule Number

A Wolfram rule is eight bits — one for each possible neighborhood. The number 30 in binary is 00011110, which means neighborhoods 1, 2, 3, and 4 produce live cells, while 0, 5, 6, and 7 produce dead ones. This tiny specification is the entire program.

function getRuleBit(neighborhood) {
  return (rule >> neighborhood) & 1;
}

The bit-shift extracts the answer directly from the rule number. No conditionals, no lookup table, just the neighborhood index into the eight bits of an integer.

Neighborhood Encoding

Each cell looks at itself and its two neighbors: left, center, right. These three bits encode a number from 0 to 7. The pattern 101 means "left alive, center dead, right alive" — the fifth neighborhood.

const left = cells[(i - 1 + width) % width];
const center = cells[i];
const right = cells[(i + 1) % width];
const neighborhood = (left << 2) | (center << 1) | right;
newCells[i] = getRuleBit(neighborhood);

The left neighbor contributes the 4s place, the center contributes the 2s place, and the right contributes the 1s place. This is the standard Wolfram encoding — the same one Stephen Wolfram used in his classification.

Stepping the Automaton

The automaton updates all cells simultaneously. Each new cell state depends only on the previous generation — no cell sees the new state of its neighbor while computing its own.

function step() {
  const newCells = new Array(width).fill(0);
  
  for (let i = 0; i < width; i++) {
    // Compute new state from old neighbors
    // ...
    newCells[i] = getRuleBit(neighborhood);
  }
  
  cells = newCells;
  generation++;
}

This is the core of cellular automata: local rules, global state, simultaneous update. The pattern at generation t determines generation t+1, and nothing else.

Toroidal Space

The grid has no edges. The leftmost cell's left neighbor is the rightmost cell. This wraparound — a torus — prevents boundary effects from contaminating the pattern.

const left = cells[(i - 1 + width) % width];
// ... somewhere later ...
const right = cells[(i + 1) % width];

Without wraparound, edges would behave differently. Information could "fall off" the sides. The torus makes the grid infinite in the sense that information never exits — it circulates.

Pattern Emergence

Rule 30 produces chaos from a single live cell. Rule 90 produces Sierpiński triangles — the same fractal that appears in Pascal's triangle. Rule 110 is Turing complete: it can compute anything computable.

cells = new Array(width).fill(0);
cells[Math.floor(width / 2)] = 1; // Single seed at center

One cell, one rule, hundreds of generations. The complexity you see — the triangles within triangles, the chaotic bursts, the regular structures — all of it emerges from eight bits applied uniformly. No guiding intelligence, no stored blueprint, just the rule iterated.

What This Reveals

Simple rules generate complexity through iteration. This is the central insight of cellular automata: the gap between specification and behavior. Eight bits fit in a byte, yet some rules produce patterns that never repeat, never settle, never become predictable. Rule 30's center column is provably random. The rule knows nothing of randomness — it just applies the bits. The randomness emerges from the dynamics, not the rule.

This is why cellular automata matter beyond pretty pictures. They demonstrate that complexity doesn't require complex specifications. The universe has simple laws too — and from them, galaxies, cells, minds. Wolfram's automata aren't models of physics; they're proofs of principle about how much can come from how little.