Skip to main content
BVDART Logo
← All guidesGenerative systems

Cellular automata

A cellular automaton updates a grid of states using local rules. Complex-looking behavior can emerge from repeatedly applying the same small decision everywhere.

Edit a Life board and inspect its synchronous next step

Generation 0Click to toggle · focus to inspect · dot: alive next step
One local decision
010001111

Live neighbors: 5
Current cell: 0 → next: 0

B3 / S23

A dead cell is born with exactly 3 neighbors. A live cell survives with 2 or 3. Every decision reads the same previous generation.

Try this Load the blinker and step twice: it returns to its starting row. Load the block and step: every live cell has three neighbors, so it stays still.

Advance the displayed cells through sixteen genuine generations, then stop. Replay continues from that result. Use any control to take over.

What to try
  1. Load a Blinker or Block, focus a cell and read its neighborhood.
  2. Step one generation, then toggle cells to change the initial arrangement.
Open in the Lab ↗

What to look for: The local inspector applies B3/S23 to the previous generation. Small board dots preview which cells will be alive next; every cell updates together.

How it works

In a Life-like binary automaton, a cell’s next state depends on whether it is alive and how many nearby cells are alive. All cells should read the previous generation. Updating cells in place would let later decisions read already-changed neighbors and implement a different system.

The Lab can generate an initial seeded population or evolve an existing image after interpreting its values as cell states. Cell size determines the display footprint of a logical cell; generations determine how far the rule is applied.

Use it in the Lab

Use automata for evolving marks or patterned fields. Keep cell size and threshold in mind when translating an existing raster into states; the interpretation of that input is part of the recipe.

Limits & distinctions

The example and Lab use bounded simulations with explicit rules. A still frame does not establish long-term stability, and the generator is not a general scientific simulation environment.

Further reading

Rules of the Grid

Cellular automata consist of a grid of cells, each in one of a finite number of states. At each time step, every cell updates simultaneously based on a rule that considers the cell's current state and its immediate neighbors.

Game of Life Rules

Conway's Game of Life rules (B3/S23): • Birth: a dead cell with exactly 3 live neighbors becomes alive • Survival: a live cell with 2 or 3 live neighbors survives • Death: all other live cells die (overcrowding or isolation)

game-of-life.ts
function step(grid: boolean[][]) {
  const next = grid.map(row => [...row]);
  for (let y = 0; y < H; y++)
    for (let x = 0; x < W; x++) {
      const n = countNeighbors(grid, x, y);
      next[y][x] = n === 3 || (grid[y][x] && n === 2);
    }
  return next;
}
typescript

Emergent Complexity

From these minimal rules emerge gliders (patterns that translate across the grid), oscillators (patterns that cycle through states), and even self-replicating structures. Conway's Game of Life is actually Turing-complete — capable of universal computation.

Beyond Life

Many rule variants exist beyond B3/S23. Wolfram's elementary automata are 1D systems with 256 possible rules — Rule 30 generates chaos from order, while Rule 110 is Turing-complete. In algorithmic art, custom rule sets are designed to produce specific visual textures and patterns.

Try modifying the birth/survival rules to discover new patterns. B36/S23 (HighLife) produces a self-replicating "replicator" pattern. B1357/S1357 creates beautiful organic growth.

Related artworks

Related Lab categories

Sources & references

Guide updated