Elementary Cellular Automaton Simulator & Complete Rule Table - All 256 Rules

1. Prepare the initial state

  A row of cells, each holding 0 or 1.

  Gen 0: [0] [0] [1] [0] [0]

2. Look at each cell's neighborhood

  For each cell, look at left, center, and right as a set.
  The cells at each end wrap around to the opposite side, forming a ring (periodic boundary conditions).

       left center right
          ↓    ↓    ↓
  [0]  [0]  [1]  [0]  [0]

3. Look up the next state in the rule table

  Match the 3-cell combination against the rule table to get the next value.

  e.g. Rule 110:
  (0,1,0) → rule table lookup → 1

4. Update all cells simultaneously

  Apply the rule to every cell at once to produce the next generation.

  e.g. Rule 110:
  Gen 0: [0] [0] [1] [0] [0]
                ↓ all cells update at once
  Gen 1: [0] [1] [1] [0] [0]

5. Repeat

  Repeat 2→3→4 to advance through generations. Stacking them vertically creates a 2D pattern.

Elementary Cellular Automata (ECA) were systematically studied by Stephen Wolfram in the 1980s and represent the simplest form of cellular automaton. Wolfram classified cellular automaton behaviors into four classes: Class 1 (uniform), Class 2 (periodic), Class 3 (chaotic), and Class 4 (complex). Classes 1 and 2 are orderly, Class 3 is chaotic, and Class 4 sits at the boundary between order and chaos.

Among the 256 rules, several are well known: Rule 30 is used for random number generation, Rule 110 has been proven Turing complete, Rule 90 generates the Sierpinski triangle, and Rule 184 models traffic flow.

Learn more about the history and applications of cellular automata →

Of the four classes described above, Class 3 (chaotic) and Class 4 (complex) are the most noteworthy.

Class 3 — Chaos

Produces aperiodic, random-looking patterns. Rule 30 is famously used in Mathematica's random number generator, and its equivalents — Rule 86 (mirror), Rule 135 (reverse+flip), and Rule 149 (mirror + reverse+flip) — share the same chaotic structure. Rules 45 and 106 are also chaotic, each with their own equivalents (Rule 45 → 75, 89, 101; Rule 106 → 120, 169, 225).

Class 4 — Complexity

Sits at the boundary between orderly Classes 1–2 and chaotic Class 3. Neither fully regular nor fully random, these rules produce "gliders" — moving local structures that emerge naturally and interact through collisions. This is what makes them capable of computation, as explained below.

Turing completeness means the ability to perform any computation given the right initial conditions. Class 4 (complex) is neither too orderly nor too chaotic, which makes this possible. In orderly rules, information becomes fixed; in chaotic rules, information disperses and is lost. In Class 4, gliders can preserve and transmit information, enabling computation.

Rule 110

Proven Turing complete by Matthew Cook in 2004, demonstrating that this simple rule can simulate any computation. Computation is achieved through collisions and interactions of moving local structures called gliders. Its equivalents — Rule 124 (mirror), Rule 137 (reverse+flip), and Rule 193 (mirror + reverse+flip) — are all Turing complete as well.

Rule 54

Conjectured to be Turing complete, but not yet proven. Like Rule 110, it produces gliders. From a single-cell initial condition, it produces left-right symmetric output. Since its mirror (explained below) is Rule 54 itself, its only equivalent is Rule 147 (reverse+flip).

One of the most famous patterns in ECA is the Sierpinski triangle (Sierpinski gasket). Starting from a single ON cell, a self-similar fractal triangle emerges.

Exact Sierpinski triangle

Rules 18, 90, and 146 produce symmetric Sierpinski triangles. Rule 60 produces a right-leaning triangle, and Rule 102 produces a left-leaning triangle (these two are mirror equivalents).

Sierpinski from single cell only

Rules 26, 154, 210, and 218 produce a Sierpinski triangle from a single-cell initial condition, but exhibit different behavior with random initial conditions.

Sierpinski-like fractals

Rules 22, 122, and 126 produce fractal patterns that resemble the Sierpinski triangle but are not strictly identical to it.

Color-Inverted Sierpinski

Rules 60, 90, and 102 — which generate Sierpinski patterns — are palindrome rules (explained below), and their equivalents Rules 195, 165, and 153 produce color-inverted Sierpinski patterns. Likewise, Rule 126 (Sierpinski-like) is a palindrome rule, and its equivalent Rule 129 produces an inverted Sierpinski-like fractal.

Other Equivalent Sierpinski Rules

Rule 183 (reverse+flip of Rule 18) and Rule 182 (reverse+flip of Rule 146) also produce equivalent Sierpinski patterns.

Rule 184 is a particle-conserving rule used for traffic flow simulation. Treating black cells as cars and white cells as empty space, a car advances one cell if the space ahead is empty, and stops if blocked. Its equivalent Rule 226 (mirror) models traffic in the opposite direction.

Among the 256 rules, there are "equivalent rules" that generate patterns with the same structure. Equivalent rules are related by the following three transformations:

Mirror

Swaps the left cell (p) and right cell (r) in each neighborhood pattern. For example, 110 (left=1, center=1, right=0) becomes 011 (left=0, center=1, right=1). Symmetric patterns (111, 101, 010, 000) are unchanged. This results in swapping the values at bit positions 6↔3 and 4↔1, producing a left-right mirrored output from the same initial condition. When a rule produces symmetric output from a single cell (e.g., Rules 26 and 82, Rules 30 and 86), mirroring looks identical, so use random initial conditions to see the difference.

reverse+flip

Reverses the bit order, then flips each bit (0↔1). When the initial condition is also color-inverted, the output becomes the color-inverted version of the original pattern. However, some non-palindrome pairs such as Rule 110 and Rule 137 produce color-inverted patterns even from the same single-cell initial condition.

Mirror + reverse+flip

Combines the two transformations above. First swaps left and right cells in each neighborhood pattern, then reverses the bit order and flips each bit.

Note Mirror and the "reverse" in reverse+flip are different operations. Mirror swaps the left and right cells in each neighborhood pattern (swapping bit positions 6↔3 and 4↔1), while reverse reverses the entire bit string order.

When a rule's bit string is a palindrome (reads the same forwards and backwards), 255-R (simply flipping each bit) produces an equivalent rule. For example, Rule 90 (01011010) is a palindrome, so 255-R gives the equivalent Rule 165 (10100101). For palindrome rules, reverse+flip also gives the same result as bit-flip, since reversing a palindrome changes nothing.