Artificial Life 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 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?