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

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