Simulation on Programmer.ie: Modern AI programming

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

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

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.

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

It only needs to orchestrate state transitions.

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

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.

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

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.

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:

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

A cellular automaton begins with almost nothing.

You need:

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.