Cellular Automata

A grid of cells, each following the same simple rule based only on its neighbors, produces behavior so complex that it contains universal computation, simulates fluid dynamics, and — in its neural variant — learns to generate any texture you show it. The gap between the simplicity of the rules and the richness of the behavior is the central mystery, and it's been drawing physicists, computer scientists, and artists into its orbit since von Neumann first asked whether a machine could build a copy of itself.

From Conway to Wolfram to Distill

Conway's Game of Life is where most people enter. Two rules: a living cell with 2–3 living neighbors survives; a dead cell with exactly 3 living neighbors is born. From these two rules spring gliders that traverse the grid, oscillators that pulse in place, and patterns that grow without bound from a handful of initial cells. The Game of Life is Turing-complete — you can build a computer inside it — which means its behavior is formally unpredictable. There's no shortcut to knowing what a pattern will do except running it and watching.¹

Gosper's HashLife algorithm is a beautiful cheat around this unpredictability.¹ It combines quadtrees (representing the grid as a hierarchy of nested squares) with memoization (remembering the result of every sub-calculation). Because large cellular automata are full of repeated structure — vast empty regions, common patterns that recur — HashLife can skip astronomical numbers of generations in seconds. A pattern that would take a naive implementation years to simulate can be run for trillions of generations almost instantly. The trick is that regularity in space (canonicalized quadtree nodes) translates into regularity in time (memoized futures). It's one of the most elegant algorithms in computer science, and it works because the universe of the Game of Life, despite its Turing-completeness, is empirically much more structured than the worst case.

Feynman got interested in cellular automata during his time at Thinking Machines Corporation in the 1980s, drawn by the question of whether the universe itself might be a cellular automaton at the bottom — discrete in both space and time, with physics emerging as the macro-consequence of simple local rules.² He was skeptical of specific proposals (he called Fredkin and Wolfram's models "kooky") but fascinated by the question. His proposed solution to the anisotropy problem — that the underlying automata might be randomly connected rather than on a regular grid — never worked out, but his instinct that CA could be a practical tool for simulating physics was dead right. Wolfram used the Connection Machine to produce fluid dynamics simulations from hexagonal lattice automata, and the first program ever run on the machine was Conway's Game of Life.²

Neural Cellular Automata: Learning the Rules

The most exciting recent development is Neural Cellular Automata (NCA), where the update rule isn't hand-designed but learned through gradient descent.³ The Distill research thread on differentiable self-organizing systems showed that you can train an NCA to generate any target texture — zebra stripes, woven fabric, bubbles — by using a pre-trained image classifier (VGG) as a judge of pattern quality and backpropagating through the CA dynamics.

What's remarkable isn't just that it works, but how it works. The trained NCA doesn't produce a static image — it produces a living process. The cells continuously update, maintaining the pattern dynamically. If you damage part of the pattern, it regenerates. Bubbles maintain constant density by spontaneously collapsing when they get too close together. Stripes self-align over time, with misaligned fragments traveling along until they merge or disappear. The NCA has learned not a picture but an algorithm — a distributed, local procedure that generates and maintains the pattern through purely local cell-to-cell communication.³

The connection to biology is direct and deliberate. Turing's 1952 paper on morphogenesis proposed that reaction-diffusion — two substances diffusing at different rates, one activating and one inhibiting — could explain pattern formation in nature, from zebra stripes to the arrangement of leaves. NCA are essentially a learnable generalization of reaction-diffusion systems: discretize the PDE, replace the hand-specified dynamics with a neural network, and train it end-to-end. The fact that Turing patterns show up everywhere — from bacterial colonies to psychedelic hallucinations to the nanometer-wide stripes in bismuth crystals⁴ — suggests that the mechanism is extraordinarily robust. The activator and inhibitor don't even have to be chemicals; in bismuth, they're atomic displacements.

Biological Algorithms: The Anternet

The NCA work shows that you can learn CA rules from target behavior. But nature was already doing this — evolution has been optimizing distributed algorithms for billions of years, and the results sometimes converge on the same solutions as computer science.

The most striking example is the "anternet." Deborah Gordon at Stanford spent twenty years studying how harvester ant colonies decide how many foragers to send out. A forager leaves the nest and doesn't return until it finds food. If seeds are plentiful, foragers return quickly, and more ants leave. If they return empty-handed, the search slows down. The feedback loop is simple: the rate of returning foragers modulates the rate of outgoing foragers.⁵

When Gordon described this to computer scientist Balaji Prabhakar, he recognized it immediately: the ants were running Transmission Control Protocol. TCP manages data congestion on the Internet by sending packets and waiting for acknowledgments. If acks return quickly, the source boosts transmission speed. If acks are slow, the source throttles down. The ants have independently evolved the same algorithm — including slow start (sending a burst of foragers initially to gauge food availability) and time-out (stopping all foraging when no one returns for 20 minutes).⁵

Prabhakar wrote an ant algorithm based on TCP's structure, and it almost exactly matched Gordon's experimental data. "Ants have discovered an algorithm that we know well," Prabhakar said, "and they've been doing it for millions of years." The convergence isn't coincidence — both systems face the same design problem (allocating resources in a distributed network with no central controller) under the same constraints (local information, delayed feedback, no global view). This connects to the broader pattern in emergence: when the constraints are similar, distributed systems converge on similar solutions whether the components are packets, ants, or neurons.

Why This Matters

The philosophical pull of cellular automata is the question of where complexity comes from. You write down a rule that fits on a napkin, and out comes behavior that surprises you, that you can't predict without simulating, that builds structures you never designed. This is why people keep reaching for CA as a model of physics — not because the specific models work (they mostly don't) but because the phenomenon of simple rules producing complex behavior feels like it must be telling us something about how the universe operates.

The practical pull is that CA give you massive parallelism for free. Every cell runs the same rule independently. This makes them natural fits for GPUs, and the NCA work shows that when you combine this parallelism with gradient descent, you get systems that can learn to solve surprisingly complex coordination problems using only local communication. The cells in a texture-generating NCA are individually stupid — they can only see their immediate neighbors — but collectively they produce globally coherent patterns, maintain them against perturbation, and regenerate them when damaged.

This is the same trick that biology uses. Your cells are individually simple but collectively build you. The question of how local rules produce global order is the same question whether you're asking it about a Game of Life glider, a zebra's stripes, or the development of an embryo.