Imagine a line of squares, or cells, stretching out indefinitely. Each cell can be in one of two states: black or white. Now, imagine a simple set of rules that determines each cell's color in the next moment, based only on its current color and the colors of its immediate left and right neighbors. That's the basic idea of a cellular automaton.

A cellular automaton is a model of computation made of three simple parts:

1. A grid of cells (we'll start with a 1D line).
2. A set of possible states for each cell (like black/white or 0/1).
3. A rule that determines a cell's next state based on its neighborhood. The entire grid of cells evolves in discrete time steps, with every cell updating its state simultaneously based on the same rule.

The simplest cellular automata are called "elementary cellular automata." They operate on a one-dimensional line of cells, and each cell's fate depends on a neighborhood of three: itself and its two adjacent neighbors. With two possible states (let's use black and white), there are $2^3 = 8$ possible neighborhood configurations.

A rule for an elementary cellular automaton simply specifies the outcome for the center cell for each of these eight possibilities. Since there are eight configurations and two possible outcomes (black or white) for each, there are $2^8 = 256$ possible rules. These rules are numbered from 0 to 255. Let's see how one of these rules is defined.

To run a cellular automaton, we start with an initial configuration, or first generation, of cells. A common starting point is a line of all white cells with a single black cell in the middle. Then, we apply the rule to every cell simultaneously to generate the next row, and the next, and so on. Stacking these rows vertically reveals the system's evolution over time.

While many of the 256 elementary rules produce simple, repetitive, or nested patterns, some generate behavior that is astonishingly complex and seemingly random. The most famous example is Rule 30.

From the simple starting condition of a single black cell, Rule 30 produces a pattern that never repeats. The left side has a regular, triangular pattern, but the right side appears completely chaotic. It’s so random, in fact, that it has been used as a random number generator in software.

This is the profound insight offered by cellular automata. An extremely simple, deterministic rule, applied repeatedly, can generate immense complexity. There is no shortcut to knowing what Rule 30 will produce 100 steps from now; you have to run the simulation step by step to find out. This behavior is a core idea in Stephen Wolfram's exploration of the computational universe, showing that even the simplest programs can create patterns as complex as those we see in nature.

Let's check your understanding of these simple but powerful systems.

These simple models are more than just a curiosity. They provide a framework for thinking about how complexity arises in the universe, from the patterns on a seashell to the dynamics of weather systems.