Cellular Automata on Programmer.ie: Modern AI programming

Digital Life 05: Kill It

Tue, 11 Aug 2026 01:34:00 +0100

Digital Life 05: Kill It

We have been too kind to our systems.

So far we have:

initialized them carefully,
given them clean environments,
watched them evolve,
selected examples that behave interestingly,
and mostly left them alone.

That is a dangerous way to study anything that looks life-like.

A structure that persists when nothing interferes with it may be interesting.

But biological systems do something harder.

They persist in a world that keeps interfering with them.

Digital Life 04: When Does a Pattern Become a Thing?

Tue, 11 Aug 2026 01:26:00 +0100

Digital Life 04: When Does a Pattern Become a Thing?

Rule 30 gave us structure.

But it did not obviously give us a thing.

The pattern expanded.

It changed.

Differences propagated.

Interesting global behavior appeared.

But if I pointed at one region and asked:

Is that the same object ten generations later?

the answer was not obvious.

So let’s change systems.

Not because Conway’s Game of Life is more sophisticated.

Digital Life 03: The First Surprise

Tue, 11 Aug 2026 01:19:00 +0100

We ended the last chapter by changing one number.

rule = 22

became:

rule = 30

Nothing else changed.

Same world.

Same single active cell.

Same three-cell neighborhood.

Same synchronous update.

Same periodic boundary.

Same eight-bit lookup mechanism.

Only the rule changed.

And the spacetime diagram stopped looking simple.

There is visible structure on the left.

There is irregularity on the right.

There are repeating fragments.

There are regions that look almost patterned and then break apart.

Digital Life 02: Remove Almost Everything

Tue, 11 Aug 2026 01:08:00 +0100

In the previous chapter we started with something complicated.

A continuous field.

A smooth neighborhood.

A growth process.

Localized structures that moved through space.

Patterns that looked disturbingly creature-like.

That was useful because it gave us a mystery.

Now we are going to destroy almost all of it.

Not gradually.

Aggressively.

We want to know:

How little machinery can remain before interesting organization disappears?

Start with the kind of system we saw in Lenia.

Digital Life 01: Look at This Thing

Tue, 11 Aug 2026 01:06:00 +0100

Digital Life 01: Look at This Thing

Don’t read anything yet.

Watch this.

Something is moving.

It appears to have a boundary.

Different parts of it seem to behave differently.

Digital Life 00: What Would Digital Life Mean?

Tue, 11 Aug 2026 00:31:00 +0100

Digital Life 00: What Would Digital Life Mean?

Suppose we wanted to build life in software.

Not simulate a bird.

Not animate a creature.

Not create an AI assistant and give it a name.

Something more fundamental.

A computational system that begins to exhibit properties we associate with living things:

structure
persistence
response
adaptation
repair
memory
inheritance
evolution

The obvious temptation is to start implementing those words.

We could create:

Cellular Automata From First Principles 58: Capstone — Discover, Measure and Explain a New System

Mon, 10 Aug 2026 21:01:00 +0100

Cellular Automata From First Principles 58: Capstone — Discover, Measure and Explain a New System

The book began with one tiny rule applied to one tiny neighborhood.

We end with a different question:

Can we discover a cellular system, characterize its behavior, test its robustness and explain what we actually know about it?

That is the capstone.

Choose a system family

The capstone can use any family we built:

Cellular Automata From First Principles 57: Build a Cellular Automata Laboratory

Mon, 10 Aug 2026 21:00:00 +0100

Cellular Automata From First Principles 57: Build a Cellular Automata Laboratory

We now have enough pieces to stop thinking in terms of isolated scripts.

A useful cellular-automata laboratory should let us define, run, measure, replay and visualize experiments across many kinds of automata without hiding the mechanisms we spent the whole book learning.

The laboratory is not the model

Keep these concerns separate:

model definition
execution backend
experiment configuration
metrics
artifacts
analysis

A rule should not know where its PNG is saved.

Cellular Automata From First Principles 56: Generate Figures and Animations

Mon, 10 Aug 2026 20:59:00 +0100

Cellular Automata From First Principles 56: Generate Figures and Animations

Cellular automata are visual systems.

That makes figures and animations unusually important.

But a useful image is not merely a screenshot. It should be a reproducible output of an experiment.

Save figures from data, not from memory

Suppose an experiment has produced a spacetime history:

history = np.stack(states)

A figure generator should accept that result explicitly:

import matplotlib.pyplot as plt


def save_spacetime(history, path):
    fig, ax = plt.subplots(figsize=(10, 6))
    ax.imshow(history, interpolation="nearest", aspect="auto")
    ax.set_xlabel("cell")
    ax.set_ylabel("time")
    fig.tight_layout()
    fig.savefig(path, dpi=180)
    plt.close(fig)

Now the PNG is derived from recorded state rather than from an interactive session we cannot reproduce.

Cellular Automata From First Principles 55: Run Parameter Sweeps and Benchmarks

Mon, 10 Aug 2026 20:58:00 +0100

Cellular Automata From First Principles 55: Run Parameter Sweeps and Benchmarks

Once experiments are reproducible, we can stop treating parameters as one-off choices and start mapping behavior systematically.

A parameter sweep is not merely a convenience.

It is a way to turn a model into a measurable landscape.

Build a grid of experiments

from itertools import product

mus = [0.12, 0.14, 0.16]
sigmas = [0.01, 0.02, 0.03]

configs = [
    {"mu": mu, "sigma": sigma, "seed": seed}
    for mu, sigma, seed in product(mus, sigmas, range(10))
]

Notice the seed axis.

Cellular Automata From First Principles 54: Make Experiments Reproducible

Mon, 10 Aug 2026 20:57:00 +0100

Cellular Automata From First Principles 54: Make Experiments Reproducible

By this stage the book contains many systems whose behavior depends on parameters, seeds and implementation choices.

If we cannot reconstruct a run, we cannot really compare it.

Treat configuration as data

from dataclasses import dataclass, asdict


@dataclass(frozen=True)
class ExperimentConfig:
    model: str
    width: int
    height: int
    steps: int
    seed: int
    backend: str
    dtype: str

Then extend with model-specific parameters rather than hiding them in notebook cells.

Cellular Automata From First Principles 53: Build a Reusable Cellular Automata Engine

Mon, 10 Aug 2026 20:56:00 +0100

Cellular Automata From First Principles 53: Build a Reusable Cellular Automata Engine

Across this book we repeatedly rebuilt the same pieces:

state
neighborhood
rule
step loop
measurements
rendering

That repetition was useful while learning.

Now it is time to turn those concepts into interfaces.

Keep the engine small

A useful engine does not need to know what Conway’s Life, Lenia or an NCA is.

It only needs to orchestrate state transitions.

Cellular Automata From First Principles 52: Use FFTs for Large Neighborhoods

Mon, 10 Aug 2026 20:55:00 +0100

Cellular Automata From First Principles 52: Use FFTs for Large Neighborhoods

Small local neighborhoods are cheap to evaluate directly.

Large smooth kernels are different.

Lenia taught us that a neighborhood may cover dozens of cells in every direction. At that scale, direct convolution can become expensive.

The Fourier transform gives us another route.

Convolution becomes multiplication

For periodic domains:

convolution in space
        ↕
multiplication in frequency

So instead of sliding a large kernel over every location, we can transform both arrays, multiply them, and transform back.

Cellular Automata From First Principles 51: Run Cellular Automata on the GPU

Mon, 10 Aug 2026 20:54:00 +0100

Cellular Automata From First Principles 51: Run Cellular Automata on the GPU

Once the update is expressed as tensor operations, moving to a GPU becomes straightforward.

But a GPU is not automatically faster.

It wins when there is enough parallel work to amortize transfer and launch overhead.

A tensor implementation of Life

import torch
import torch.nn.functional as F

LIFE_KERNEL = torch.tensor(
    [[1.0, 1.0, 1.0],
     [1.0, 0.0, 1.0],
     [1.0, 1.0, 1.0]]
).view(1, 1, 3, 3)


def life_step(x):
    kernel = LIFE_KERNEL.to(x.device)
    neighbors = F.conv2d(x, kernel, padding=1)
    alive = x > 0.5
    born = neighbors == 3
    survive = alive & (neighbors == 2)
    return (born | survive).float()

Represent a batch as:

Cellular Automata From First Principles 50: Vectorize the Update Loop

Mon, 10 Aug 2026 20:53:00 +0100

Cellular Automata From First Principles 50: Vectorize the Update Loop

A cellular automaton is local.

That does not mean we should update it cell by cell in Python.

For dense grids, the same local rule is applied everywhere. That regularity is exactly what array programming is good at.

Start with the obvious implementation

def life_step_slow(grid):
    height, width = grid.shape
    next_grid = np.zeros_like(grid)

    for y in range(height):
        for x in range(width):
            total = 0
            for dy in (-1, 0, 1):
                for dx in (-1, 0, 1):
                    if dx == 0 and dy == 0:
                        continue
                    total += grid[(y + dy) % height, (x + dx) % width]

            alive = grid[y, x] == 1
            next_grid[y, x] = (
                total == 3 or (alive and total == 2)
            )

    return next_grid

This is useful because it states the mechanism clearly.

Cellular Automata From First Principles 49: Profile Before You Optimize

Mon, 10 Aug 2026 20:52:00 +0100

Cellular Automata From First Principles 49: Profile Before You Optimize

By now we have built dozens of automata.

The natural temptation is to make them faster.

The wrong first question is:

Which optimization trick should I use?

The right first question is:

Where is the time actually going?

Performance work begins with measurement.

Define the workload first

A benchmark is only meaningful if the workload is explicit.

For a cellular automaton, record at least:

Cellular Automata From First Principles 48: What Did the Neural CA Actually Learn?

Mon, 10 Aug 2026 20:41:00 +0100

Cellular Automata From First Principles 48: What Did the Neural CA Actually Learn?

Visualization gives us hypotheses.

Intervention gives us evidence.

If we suspect a hidden channel carries useful information, the next question is simple:

what happens if we remove it?

This chapter turns NCA interpretability into controlled experimentation.

Establish the behavioral baseline

Before touching the model, record its normal performance.

baseline = evaluate_suite(model, test_mazes)

Keep metrics such as:

valid-path rate
optimal-path rate
mean excess path length
unreachable-maze accuracy
stabilization time

Every intervention will be compared with this baseline.

Cellular Automata From First Principles 47: Inspect Hidden-State Propagation

Mon, 10 Aug 2026 20:40:00 +0100

Cellular Automata From First Principles 47: Inspect Hidden-State Propagation

A neural cellular automaton can solve a maze while most of its computation remains invisible.

The visible output might be one distance channel.

The internal state may contain twelve more channels evolving underneath it.

This chapter asks:

what is moving through those hidden channels while the answer is being computed?

Capture the entire state trajectory

Instead of saving only the final output:

Cellular Automata From First Principles 43: Test Generalization Beyond Training

Mon, 10 Aug 2026 20:39:00 +0100

Cellular Automata From First Principles 43: Test Generalization Beyond Training

A model can look robust while still depending on the exact conditions used during training.

So after growth, persistence and regeneration, we need a harder question:

what happens when the world changes?

Build a generalization matrix

Vary dimensions independently:

canvas size
seed position
update rate
rollout length
damage geometry
damage severity
noise level
boundary conditions

Then evaluate combinations that were not used during training.

Cellular Automata From First Principles 46: Generalize to Harder and Larger Mazes

Mon, 10 Aug 2026 20:39:00 +0100

Cellular Automata From First Principles 46: Generalize to Harder and Larger Mazes

Training accuracy answers the easiest question:

Can the model solve problems drawn from the training distribution?

The more interesting question is:

Did the local rule learn a reusable computation?

This chapter turns that into an explicit evaluation protocol.

Hold out dimensions of difficulty

Instead of one validation set, create several test families.

For example:

A: 32×32, familiar wall density
B: 48×48, familiar wall density
C: 64×64, familiar wall density
D: 32×32, denser obstacles
E: 32×32, longer required paths
F: different procedural maze generator
G: narrow bottlenecks and many dead ends

The point is not to maximize one aggregate score.

Cellular Automata From First Principles 42: Regenerate After Damage

Mon, 10 Aug 2026 20:38:00 +0100

Cellular Automata From First Principles 42: Regenerate After Damage

Persistence asks whether the organism can remain near its target.

Regeneration asks a different question:

after part of the state is destroyed, can local rules reconstruct the missing structure?

This is a much stronger test.

Damage the state, not just the image

If we erase only visible RGBA channels but leave hidden channels untouched, the model may retain a perfect invisible blueprint.

Cellular Automata From First Principles 45: Learn to Solve Mazes

Mon, 10 Aug 2026 20:38:00 +0100

Cellular Automata From First Principles 45: Learn to Solve Mazes

A pathfinding NCA becomes interesting only when the training problem itself is disciplined.

If every maze has the same size, wall density and corridor style, the model may learn the dataset more than the algorithm.

So this chapter builds the training system around procedural variation.

Generate mazes as data

Start with binary occupancy:

0 = open
1 = wall

One simple generator begins with random walls and rejects disconnected examples.

Cellular Automata From First Principles 41: Train for Persistence

Mon, 10 Aug 2026 20:37:00 +0100

Cellular Automata From First Principles 41: Train for Persistence

Growing a target once is not enough.

A useful self-organizing system should continue to satisfy its objective after it arrives.

That means the target should behave more like an attractor than a timestamped frame.

The failure mode

Suppose training always evaluates at step 64.

The model can learn:

seed
 ↓
grow
 ↓
target at step 64
 ↓
overshoot
 ↓
disintegrate

The loss never sees the failure after step 64.

Cellular Automata From First Principles 44: Neural Cellular Automata for Pathfinding

Mon, 10 Aug 2026 20:37:00 +0100

Cellular Automata From First Principles 44: Neural Cellular Automata for Pathfinding

Until now our neural cellular automata have learned to make and maintain shapes.

Now we will ask them to compute something.

Given:

walls
start
finish

can a shared local update rule discover a path?

This is an unusually good task for an NCA because classical pathfinding already has a local interpretation.

Breadth-first search expands a frontier:

start
  ↓
nearby reachable cells
  ↓
next layer of reachable cells
  ↓
...
  ↓
goal

That looks remarkably like information propagating through a cellular system.

Cellular Automata From First Principles 40: Randomize the Update Schedule

Mon, 10 Aug 2026 20:36:00 +0100

Cellular Automata From First Principles 40: Randomize the Update Schedule

Most cellular automata in this book have used synchronous updates:

all cells observe state_t
all cells update
state_t+1 appears

Neural cellular automata become more robust when we stop assuming perfect global synchronization.

Stochastic firing

Instead of applying every predicted update, sample a binary mask:

def stochastic_update(x, dx, fire_rate=0.5):
    mask = (
        torch.rand(
            x.shape[0], 1, x.shape[2], x.shape[3],
            device=x.device,
        ) <= fire_rate
    )
    return x + dx * mask

Half the cells update on average.

Cellular Automata From First Principles 39: Grow a Target From One Seed

Mon, 10 Aug 2026 20:35:00 +0100

Cellular Automata From First Principles 39: Grow a Target From One Seed

Now we can pose the central morphogenesis problem:

Start from one cell and learn local rules that construct a target pattern.

Prepare a target

Assume an RGBA image has been loaded into a tensor:

# shape: [1, 4, H, W], values in [0, 1]
target = load_target("target.png").to(DEVICE)

The NCA state contains more channels than the image, so only the visible channels are compared:

Cellular Automata From First Principles 38: Hidden Cell Channels and Local Memory

Mon, 10 Aug 2026 20:34:00 +0100

Cellular Automata From First Principles 38: Hidden Cell Channels and Local Memory

A visible pixel is not enough state for a cell that must also coordinate growth.

So give every cell a vector.

[R, G, B, alpha, h1, h2, ... h12]

The first channels can be rendered. The rest are private internal state.

CHANNELS = 16
VISIBLE = 4

state = torch.zeros(1, CHANNELS, 64, 64, device=DEVICE)

The hidden channels have no labels. We do not tell the model that channel 8 means “distance from the centre” or channel 11 means “grow east”. If useful internal signals exist, training must discover them.

Cellular Automata From First Principles 37: Learn the Local Update Rule

Mon, 10 Aug 2026 20:32:00 +0100

Cellular Automata From First Principles 37: Learn the Local Update Rule

A neural cellular automaton does not need a large neural network.

It needs a small local network applied everywhere.

That distinction matters.

The intelligence of the system comes less from the size of one cell’s computation and more from the repeated interaction of many cells over time.

Perception first

Each cell needs information about itself and nearby cells.

For a single visible channel we can compute several local features:

Cellular Automata From First Principles 36: Make the Automaton Differentiable

Mon, 10 Aug 2026 20:31:00 +0100

Cellular Automata From First Principles 36: Make the Automaton Differentiable

So far every rule in this book has been chosen by us.

Even Lenia still asks us to decide the neighborhood kernel, the growth function and the parameters that connect them.

What if we stop designing the local rule directly?

What if we define only the goal, then let gradient descent discover a local update rule that achieves it?

That requires one major change:

Cellular Automata From First Principles 35: Flow-Lenia and Mass-Conserving Artificial Life

Mon, 10 Aug 2026 20:06:00 +0100

Cellular Automata From First Principles 35: Flow-Lenia and Mass-Conserving Artificial Life

Ordinary Lenia updates local state by adding growth:

A(t + dt) = clip(A(t) + dt × G(U))

That means state can be created in one region and destroyed in another.

For many artificial-life experiments that is perfectly acceptable.

But it leaves a major question:

What changes if local structure must reorganize existing mass instead of creating or deleting it?

Cellular Automata From First Principles 34: Damage, Robustness and Persistence

Mon, 10 Aug 2026 20:03:00 +0100

Cellular Automata From First Principles 34: Damage, Robustness and Persistence

A pattern that survives in perfect conditions is only the beginning.

A stronger artificial-life question is:

What happens when the pattern is disturbed?

We can turn that into an experiment.

Define damage explicitly

Start with a rectangular ablation:

def damage_rectangle(state, y0, y1, x0, x1):
    damaged = state.copy()
    damaged[..., y0:y1, x0:x1] = 0.0
    return damaged

For a single-channel state:

damaged = damage_rectangle(state, 55, 70, 55, 70)

For multi-channel state, the ellipsis damages all channels in the same spatial region.

Cellular Automata From First Principles 33: Multi-Kernel and Multi-Channel Lenia

Mon, 10 Aug 2026 20:00:00 +0100

Cellular Automata From First Principles 33: Multi-Kernel and Multi-Channel Lenia

Our Lenia implementation has one scalar field:

A(x, y)

and one kernel:

That is enough for rich behavior.

But it also forces every local process to share the same spatial scale and the same state variable.

A richer model can use multiple channels:

A0(x, y)
A1(x, y)
A2(x, y)

and multiple kernels linking them.

Represent state as channels

import numpy as np

channels = 3
state = np.zeros((channels, 128, 128), dtype=np.float64)

Now each cell has a vector state:

Cellular Automata From First Principles 32: Search Lenia Parameter Space

Mon, 10 Aug 2026 19:57:00 +0100

Cellular Automata From First Principles 32: Search Lenia Parameter Space

A Lenia pattern is not defined by its initial state alone.

It also lives inside a particular dynamical world.

Change the kernel or growth function slightly and the same seed may:

die
explode
freeze
oscillate
move
split
stabilize into a different morphology

So discovery has two coupled search spaces:

initial condition
      +
world parameters

Define parameter ranges

PARAM_RANGES = {
    "radius": (8, 24),
    "ring_center": (0.25, 0.75),
    "ring_width": (0.05, 0.25),
    "mu": (0.05, 0.30),
    "sigma": (0.01, 0.08),
    "dt": (0.03, 0.20),
}

These ranges are experimental choices.

Cellular Automata From First Principles 31: Discover Your First Lenia Organisms

Mon, 10 Aug 2026 19:54:00 +0100

Cellular Automata From First Principles 31: Discover Your First Lenia Organisms

Running Lenia is easy.

Finding persistent, localized, non-trivial structures is the hard part.

This chapter turns that problem into a repeatable search pipeline.

Define what counts as a candidate

We should not start with the vague objective:

Find something that looks alive.

Instead define measurable properties.

A useful first candidate might be:

survives for 1,000 steps
stays localized
keeps non-zero mass
continues changing
avoids filling the whole board

Each condition removes a different failure mode.

Cellular Automata From First Principles 30: Build Lenia From First Principles

Mon, 10 Aug 2026 19:51:00 +0100

Cellular Automata From First Principles 30: Build Lenia From First Principles

We now have every conceptual component needed for a minimal Lenia implementation:

continuous state
radial kernel
convolution
smooth growth function
small time step
bounded update

This chapter assembles them into one runnable system.

Represent the model parameters explicitly

from dataclasses import dataclass


@dataclass(frozen=True)
class LeniaConfig:
    radius: int = 13
    ring_center: float = 0.5
    ring_width: float = 0.15
    mu: float = 0.15
    sigma: float = 0.03
    dt: float = 0.1

Keeping parameters in one object makes experiments reproducible.

Cellular Automata From First Principles 29: Growth Functions

Mon, 10 Aug 2026 19:48:00 +0100

Cellular Automata From First Principles 29: Growth Functions

We now have two pieces:

continuous state
      ↓
weighted neighborhood

But a neighborhood value does not tell us what should happen next.

We need a response curve.

In Lenia-style systems that curve is usually called a growth function.

It converts neighborhood potential into local growth or decay.

A Gaussian-shaped preference

A useful starting point is:

import numpy as np


def gaussian_growth(u, mu=0.15, sigma=0.03):
    return 2.0 * np.exp(
        -((u - mu) ** 2) / (2 * sigma ** 2)
    ) - 1.0

The output is approximately:

Cellular Automata From First Principles 28: Neighborhoods as Convolution Kernels

Mon, 10 Aug 2026 19:45:00 +0100

Cellular Automata From First Principles 28: Neighborhoods as Convolution Kernels

A neighborhood does not have to be a list of nearby coordinates.

It can be a spatial weighting function.

That lets us say:

cells near this radius matter a lot
cells closer in matter less
cells farther away do not matter at all

The standard programming tool for applying that same weighted neighborhood everywhere is convolution.

Start with a small kernel

import numpy as np

kernel = np.array([
    [0.0, 0.1, 0.0],
    [0.1, 0.6, 0.1],
    [0.0, 0.1, 0.0],
])

Normalize it:

Cellular Automata From First Principles 27: From Discrete Cells to Continuous State

Mon, 10 Aug 2026 19:43:00 +0100

Cellular Automata From First Principles 27: From Discrete Cells to Continuous State

So far most of our cellular automata have used a small set of states:

0 or 1
empty / prey / predator
ready / firing / refractory

That makes rules easy to inspect.

But it also forces every update to make a hard categorical decision.

What happens if a cell can instead hold any value between 0 and 1?

Cellular Automata From First Principles 26: Cellular Automata as Computation

Mon, 10 Aug 2026 18:59:00 +0100

Cellular Automata From First Principles 26: Cellular Automata as Computation

A cellular automaton is a state machine distributed across space.

Each cell reads local information, applies the same transition rule, and writes a new state.

That is already a form of computation.

The deeper question is whether local patterns can carry, transform and combine information in a way that supports general computation.

Information needs carriers

In ordinary software, information lives in variables and memory addresses.

Cellular Automata From First Principles 25: Evolve Rules for Desired Behaviour

Mon, 10 Aug 2026 18:58:00 +0100

Cellular Automata From First Principles 25: Evolve Rules for Desired Behaviour

Once we can represent a rule, mutate it and measure its behavior, we can evolve cellular automata.

The key idea is simple:

population of rules
      ↓
simulate
      ↓
measure
      ↓
select
      ↓
mutate
      ↓
repeat

This chapter builds that loop without hiding it behind an optimization framework.

Represent a rule as bits

For an elementary CA, eight output bits completely define the rule:

Cellular Automata From First Principles 24: Search Larger Rule Spaces

Mon, 10 Aug 2026 18:57:00 +0100

Cellular Automata From First Principles 24: Search Larger Rule Spaces

The 256 elementary rules are small enough to enumerate.

Most interesting cellular-automata design spaces are not.

Add more states, a larger neighborhood, continuous parameters, or several channels and exhaustive search quickly becomes impossible.

So we need search strategies.

Why the rule space explodes

For k possible cell states and a neighborhood containing n cells, there are:

k^n possible neighborhood configurations

A deterministic rule chooses one of k outputs for every configuration, giving:

Cellular Automata From First Principles 23: Search All 256 Elementary Rules

Mon, 10 Aug 2026 18:56:00 +0100

Cellular Automata From First Principles 23: Search All 256 Elementary Rules

Elementary cellular automata give us a rare luxury.

The complete rule space is tiny.

There are only:

256 rules

So we do not need sampling, intuition or famous examples.

We can evaluate every rule.

Build an experiment runner

Assume we already have:

run_rule(rule_number, width, generations, initial_state)
fingerprint(history)

Then exhaustive search is simple:

def scan_rules(initial_state, width=201, generations=200):
    records = []

    for rule in range(256):
        history = run_rule(
            rule,
            width=width,
            generations=generations,
            initial_state=initial_state,
        )

        records.append({
            "rule": rule,
            **fingerprint(history),
        })

    return records

The hard part is no longer execution.

Cellular Automata From First Principles 22: Classify Rule Behaviour

Mon, 10 Aug 2026 18:55:00 +0100

Cellular Automata From First Principles 22: Classify Rule Behaviour

Cellular automata are often described using four broad behavioral classes:

Class I   -> settles to homogeneous behavior
Class II  -> settles to simple stable or periodic structures
Class III -> chaotic or apparently random behavior
Class IV  -> persistent local structures and complex interactions

These labels are useful vocabulary.

But if we want to use them experimentally, we should connect them to measurable evidence rather than treating them as magic categories.

Cellular Automata From First Principles 21: Sensitivity to Initial Conditions

Mon, 10 Aug 2026 18:54:00 +0100

Cellular Automata From First Principles 21: Sensitivity to Initial Conditions

Change one cell.

Then run the same rule twice.

If the two futures remain almost identical, the rule is insensitive to that perturbation.

If the difference spreads, the rule amplifies local uncertainty.

That is one of the cleanest experiments we can perform on a cellular automaton.

Create two nearby initial states

import numpy as np

width = 201
base = np.zeros(width, dtype=np.uint8)
base[width // 2] = 1

perturbed = base.copy()
perturbed[width // 2 + 1] ^= 1

The two states differ by exactly one bit.

Cellular Automata From First Principles 20: Periodicity and Attractors

Mon, 10 Aug 2026 18:53:00 +0100

Cellular Automata From First Principles 20: Periodicity and Attractors

Many cellular automata eventually repeat.

A fixed point repeats every generation.

An oscillator repeats after several generations.

On a finite grid, deterministic cellular automata must eventually revisit a previous state because only finitely many states exist.

That makes cycle detection a fundamental measurement.

Hash each state

For binary arrays we can store the bytes:

def state_key(state):
    return state.tobytes()

Then track when each state first appeared:

Cellular Automata From First Principles 19: Entropy and Information

Mon, 10 Aug 2026 18:52:00 +0100

Cellular Automata From First Principles 19: Entropy and Information

A row with almost all zeros is highly predictable.

A row containing a balanced mixture of zeros and ones is less predictable.

Shannon entropy gives us a precise way to measure that uncertainty.

Binary entropy

If a binary state contains a fraction p of ones, then:

H = -p log2(p) - (1-p) log2(1-p)

In Python:

import math
import numpy as np


def binary_entropy(state):
    p = float(np.mean(state))

    if p in (0.0, 1.0):
        return 0.0

    return -(p * math.log2(p) + (1 - p) * math.log2(1 - p))

The maximum is 1 bit when zeros and ones occur equally often.

Cellular Automata From First Principles 18: Activity, Density and Change

Mon, 10 Aug 2026 18:51:00 +0100

Cellular Automata From First Principles 18: Activity, Density and Change

A cellular automaton can look busy while doing very little that persists.

It can also look visually quiet while preserving a small moving structure for hundreds of generations.

So we need to separate several properties that are easy to confuse:

occupancy
temporal change
spatial variation
persistence

This chapter turns those ideas into explicit measurements.

Together they form our first useful behavioral fingerprint.

Cellular Automata From First Principles 16: Generate Textures with Local Rules

Mon, 10 Aug 2026 18:50:00 +0100

Cellular Automata From First Principles 16: Generate Textures with Local Rules

Cellular automata do not need to represent a literal physical system.

They can also be used as visual machines.

The same ingredients we have used throughout the book:

local state
neighborhood perception
shared update
repetition

can generate masks, growth patterns, surface variation and animation.

The evaluation question changes.

Instead of asking:

Is this physically accurate?

we ask:

Does this local process produce useful, controllable visual structure?

Cellular Automata From First Principles 17: Measure a Cellular Automaton

Mon, 10 Aug 2026 18:50:00 +0100

Cellular Automata From First Principles 17: Measure a Cellular Automaton

Up to this point we have mostly looked at cellular automata.

That is useful.

It is also limiting.

A human can inspect a handful of spacetime diagrams.

We cannot reliably inspect:

256 elementary rules
× several initial conditions
× several widths
× hundreds of generations
× repeated stochastic runs

by eye.

If we want to compare rules, search for interesting behavior or eventually optimize a rule for some objective, we need to turn behavior into data.

Cellular Automata From First Principles 15: Grow Terrain from Local Height Rules

Mon, 10 Aug 2026 18:48:00 +0100

Cellular Automata From First Principles 15: Grow Terrain from Local Height Rules

Binary caves ask:

wall or floor?

Terrain needs richer state.

Let each cell store a height:

0.0 = low
1.0 = high

Now local rules can smooth, raise, erode and classify terrain.

The challenge is not creating a pretty array.

It is creating a process whose output we can explain and control.

Start with a height field

import numpy as np


def random_heightmap(
    rows=120,
    cols=160,
    seed=42,
):
    rng = np.random.default_rng(seed)

    return rng.random(
        (rows, cols)
    )

Raw independent noise contains variation but little large-scale geography.

Cellular Automata From First Principles 14: Generate Caves from Noise

Mon, 10 Aug 2026 18:46:00 +0100

Cellular Automata From First Principles 14: Generate Caves from Noise

A cave generator can be built from a mechanism we already understand:

random initial cells
       ↓
count nearby walls
       ↓
apply local smoothing rule
       ↓
repeat a few times
       ↓
stop and use the result

Unlike a forest-fire simulation, we are not trying to model an indefinitely evolving world.

Here the cellular automaton is a construction process.

Cellular Automata From First Principles 13: Build a Predator-Prey Ecosystem

Mon, 10 Aug 2026 18:44:00 +0100

Cellular Automata From First Principles 13: Build a Predator-Prey Ecosystem

A forest fire mostly transforms cells in place.

Rule 184 moves occupancy in one constrained direction.

An ecosystem adds a harder problem:

organisms move
organisms reproduce
predators consume prey
several organisms may want one destination

Now local intentions can conflict.

That means update semantics become part of the model.

Separate visible kind from internal state

Start with:

0 = empty
1 = prey
2 = predator

import numpy as np

EMPTY = 0
PREY = 1
PREDATOR = 2

kind = np.zeros(
    (100, 100),
    dtype=np.uint8,
)

A richer model may need predator energy, age or reproduction state.

Cellular Automata From First Principles 12: Reaction-Diffusion and Pattern Formation

Mon, 10 Aug 2026 18:42:00 +0100

Cellular Automata From First Principles 12: Reaction-Diffusion and Pattern Formation

Diffusion smooths differences.

Reaction can amplify them.

Put the two processes together and a nearly uniform field can develop persistent spots, stripes and fronts.

We will use a discrete Gray-Scott reaction-diffusion simulation because it gives us a compact bridge from local cellular updates to continuous pattern-forming dynamics.

Each lattice cell stores two values:

U = concentration of chemical U
V = concentration of chemical V

So our cell state is now a vector:

Cellular Automata From First Principles 11: Diffusion as Local Exchange

Mon, 10 Aug 2026 18:40:00 +0100

Cellular Automata From First Principles 11: Diffusion as Local Exchange

Until now most cells have stored discrete state:

0 / 1
empty / tree / fire
road / car

Now let each cell store a continuous quantity.

For diffusion:

state[y, x] = concentration

The local transition is no longer birth, death or movement.

It is local exchange.

Start with a pulse

import numpy as np

size = 121

grid = np.zeros(
    (size, size),
    dtype=np.float64,
)

grid[
    size // 2,
    size // 2,
] = 1.0

At the beginning one cell contains all the concentration.

Cellular Automata From First Principles 10: Simulate Traffic with Rule 184

Mon, 10 Aug 2026 18:38:00 +0100

Cellular Automata From First Principles 10: Simulate Traffic with Rule 184

Rule 184 is a beautiful example of moving from an abstract rule table to a model with a concrete interpretation.

Use a one-dimensional ring road:

1 = car
0 = empty road

A car moves one cell to the right when the destination is empty.

That is enough to produce free flow, queues and a macroscopic density-flow relationship.

Write the traffic mechanism directly

import numpy as np


def traffic_step(road):
    cars = road == 1

    empty_ahead = (
        np.roll(road, -1) == 0
    )

    moving = cars & empty_ahead

    next_road = road.copy()

    next_road[moving] = 0
    next_road[
        np.roll(moving, 1)
    ] = 1

    return next_road

The road is periodic, so the final road cell connects back to the first.

Cellular Automata From First Principles 09: Build a Forest Fire Simulation

Mon, 10 Aug 2026 18:36:00 +0100

Cellular Automata From First Principles 09: Build a Forest Fire Simulation

A forest fire is almost an ideal cellular-automaton exercise.

The visible states are obvious:

0 = empty
1 = tree
2 = burning

The interactions are local.

And small changes in fuel density or ignition assumptions can produce very different global outcomes.

This is not intended as a high-fidelity wildfire model.

It is a deliberately simplified spread model designed to isolate one mechanism:

Cellular Automata From First Principles 08: Add Randomness Without Losing the Model

Mon, 10 Aug 2026 18:34:00 +0100

Cellular Automata From First Principles 08: Add Randomness Without Losing the Model

So far every transition in the book has been deterministic.

Given the same state, the next state is fixed.

That makes deterministic automata unusually easy to debug: if we preserve the initial condition and rule, we preserve the trajectory.

But many useful models need another ingredient.

A tree may ignite.

An organism may reproduce.

A driver may hesitate.

Cellular Automata From First Principles 07: Beyond Conway — Life-like and Multi-State Rules

Mon, 10 Aug 2026 18:27:00 +0100

Cellular Automata From First Principles 07: Beyond Conway — Life-like and Multi-State Rules

Conway’s Game of Life is famous enough that it can accidentally become the definition of cellular automata.

It is not.

Life is one point in a much larger design space.

Keep the same two-dimensional grid and the same eight-cell Moore neighborhood, then change only the birth and survival counts.

You immediately get a family of Life-like cellular automata.

Cellular Automata From First Principles 06: Patterns as Data — Oscillators, Spaceships and Gliders

Mon, 10 Aug 2026 18:26:00 +0100

Cellular Automata From First Principles 06: Patterns as Data — Oscillators, Spaceships and Gliders

Once we can run Conway’s Game of Life, the next step is not to add more graphics.

It is to make the patterns themselves inspectable.

A blinker is not interesting because somebody named it.

It is interesting because it returns to the same state after two generations.

A glider is not interesting because it has a familiar shape.

Cellular Automata From First Principles 05: Conway's Game of Life

Mon, 10 Aug 2026 18:25:00 +0100

Cellular Automata From First Principles 05: Conway’s Game of Life

Conway’s Game of Life is one of the cleanest examples of complex two-dimensional behavior emerging from a tiny local rule.

The world is a grid of dead and live cells.

Each cell sees its eight surrounding neighbors.

Then four ideas decide the next generation:

underpopulation
survival
overpopulation
birth

The standard rule is usually written B3/S23:

a dead cell is born with exactly 3 live neighbors,
a live cell survives with 2 or 3 live neighbors.

Everything else becomes or remains dead.

Cellular Automata From First Principles 04: Rule 110 and Computation in a Grid

Mon, 10 Aug 2026 18:24:00 +0100

Cellular Automata From First Principles 04: Rule 110 and Computation in a Grid

Rule 110 looks like another one-byte transition table.

111 110 101 100 011 010 001 000
 0   1   1   0   1   1   1   0

But its behavior gives us a much deeper idea: a cellular automaton can become a computational medium.

The important shift is this:

pattern generator
      ->
signal system
      ->
computation

Rule 110 is computationally universal. Matthew Cook published the universality proof in Complex Systems in 2004, showing that this elementary one-dimensional automaton can emulate universal computation.

Cellular Automata From First Principles 03: Rule 30 and the Surprise of Complexity

Mon, 10 Aug 2026 18:23:00 +0100

Cellular Automata From First Principles 03: Rule 30 and the Surprise of Complexity

Rule 30 is a perfect demonstration of why cellular automata are worth studying.

Its transition table contains eight bits:

111 110 101 100 011 010 001 000
 0   0   0   1   1   1   1   0

Start from one active cell and repeatedly apply that rule.

The result rapidly stops looking like something generated by a tiny deterministic program.

Cellular Automata From First Principles 02: Encode All 256 Elementary Rules

Mon, 10 Aug 2026 18:22:00 +0100

Cellular Automata From First Principles 02: Encode All 256 Elementary Rules

An elementary cellular automaton has only three inputs per cell:

left centre right

Each input is one bit.

That means there are only eight possible neighborhoods:

111 110 101 100 011 010 001 000

For each neighborhood the rule chooses either 0 or 1.

Eight binary choices means:

2^8 = 256

possible rules.

The elegant part is that we can store one complete rule table in one byte.

Cellular Automata From First Principles 01: Build Your First Automaton

Mon, 10 Aug 2026 18:21:00 +0100

Cellular Automata From First Principles 01: Build Your First Automaton

In the previous chapter we reduced a cellular automaton to four things:

space
state
neighborhood
rule

Now we are going to build one.

Not a framework.

Not a library.

One update step.

That is enough to expose the whole mechanism.

Start with a one-dimensional world

Create a row of cells and turn on the centre cell:

import numpy as np

width = 41
state = np.zeros(width, dtype=np.uint8)
state[width // 2] = 1

print(state)

Conceptually:

Cellular Automata From First Principles 00: How Can Tiny Rules Build Complex Worlds?

Mon, 10 Aug 2026 18:20:00 +0100

Cellular Automata From First Principles 00: How Can Tiny Rules Build Complex Worlds?

A cellular automaton begins with almost nothing.

You need:

a collection of cells,
a state for each cell,
a neighborhood,
and a rule that tells each cell what to become next.

That is enough.

There is no central controller.

There is no object that knows what the final pattern should look like.

There is only local state changing through time.