Artificial Life on Programmer.ie: Modern AI programming

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 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 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 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 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.