Artificial Life on AIBussin — AI applications, systems and books

01: How to Read This Book

Fri, 14 Aug 2026 08:30:00 +0100

This is a science book, but you do not need to reproduce every experiment to read it. You can simply follow the investigation: watch something strange appear, notice the explanation we reached for, see how the experiment tested it, then ask what survived.

If that is all you want from the book, the main text is enough. But every important result sits above a deeper record, and that record is available if you want to inspect it.

02: What Would Digital Life Mean?

Fri, 14 Aug 2026 09:00:00 +0100

Suppose life were possible in software.

What would we actually be looking for?

The honest answer is that we do not know yet, and that is the reason for this book.

We could certainly build something that looks alive: a graphical creature, an animated agent, a personality-driven assistant. That is not the experiment. The harder question is whether a computational system can produce, through its own operation, properties that justify some of the language we associate with living things.

02: What Would Digital Life Mean?

Fri, 14 Aug 2026 09:00:00 +0100

Suppose life were possible in software.

What would we actually be looking for?

The honest answer is that we do not know yet, and that is the reason for this book.

03: Look at This Thing

Fri, 14 Aug 2026 09:30:00 +0100

Don’t read anything yet.

Watch this.

One state of a continuous cellular automaton evolving through time.

Something is moving. It appears to have a boundary. Different parts of it seem to behave differently: an edge that ripples, an interior that stays denser, a leading region that seems to pull the rest along. Its shape changes as it travels, and yet some larger organization survives those changes. Watch it for thirty seconds and you will start predicting what it is about to do.

04: Now There Are Two

Fri, 14 Aug 2026 10:00:00 +0100

In the previous chapter an organization survived while nearly everything participating in it was replaced. By the end of the turnover window, only 7 of the original 20,000 agents remained, yet the broader organized network persisted.

That established persistence. It did not establish reproduction.

Persistence asks whether an organization continues. Reproduction asks whether it produces another organization with a causal descent relation. Nothing in the Physarum experiment tested that second capability.

05: So We Built the Wrong Thing on Purpose

Fri, 14 Aug 2026 10:30:00 +0100

The previous chapter ended with a specification: known rules, controlled interventions, one mechanism varied at a time, a history we can follow. That is the laboratory we will eventually need, and building it is most of the work still ahead.

Before building it, there is a cheaper question: are our tests any good?

That is not an idle worry. The last chapter produced the first positive result in this book — a bounded one, but a real one. Structural recurrence intersected with causal ancestry, and a causal claim survived a test we had not designed to make it pass.

06: It Looked Like Flocking

Fri, 14 Aug 2026 10:30:00 +0100

The previous chapter ended with a warning: a deliberately simple swarm could look organized, move coherently and preserve a measured regime without giving us anything we were prepared to call digital life.

We then went back to Outlier and almost immediately saw structures moving together — not merely outward with the expanding front, but with what looked like stronger coordination among structures sharing recent causal history. The biological noun arrived immediately: flocking.

07: The Digital Crystal

Fri, 14 Aug 2026 11:00:00 +0100

Outlier had taken us as far as it could.

Nothing in the previous chapters is retracted. Outlier had shown us what computation could support. But by the end of the flocking investigation, its limitation had become unavoidable: Outlier was much better at producing phenomena than at isolating them.

Geometry, ancestry, distance, expansion and local environment all emerged together from the same 512-bit rule. We could observe them, trace them and sometimes reconstruct their causal history. What we could not do cleanly was vary one mechanism while holding the others fixed.

08: The Crystal Gets a Past

Fri, 14 Aug 2026 11:30:00 +0100

At the end of the last chapter the Digital Crystal could tell us something about the world that formed it. Hide the forcing process, show only the final shape, and the family of that process could be recovered well above chance. Then we asked a harder question.

What happened first?

We took exactly the same environmental values and rearranged them in time. Smooth. Bursting. Periodic. Alternating. Random. The final morphology could not reliably tell them apart.

09: Can Experience Change the Material?

Fri, 14 Aug 2026 12:00:00 +0100

At the end of the last chapter the Digital Crystal had a past with real consequences and nowhere inside itself to keep it.

A checkpoint could continue it exactly, but the checkpoint belonged to us. An event log could reconstruct how it formed, but the growth rule never read the log. A single received bit could redirect a later trajectory, and two matched pulse histories produced measurably different futures — yet the tested morphology readouts did not recover which history had occurred.

10: What Survives Material Loss?

Fri, 14 Aug 2026 14:00:00 +0100

The last chapter ended with a mechanism and a constraint. Experience could write a persistent local change into the material of the crystal, and that change could bias what got built nearby — but only while it remained inside the moving causal aperture.

Growth advanced outward, the aperture advanced with it, and material left behind stayed perfectly preserved and perfectly irrelevant. Every attempt to fix that was an attempt to keep the trace near the surface.

11: What Does It Cost to Stay?

Fri, 14 Aug 2026 16:00:00 +0100

The last chapter ended with an impressive number and a suspicion about it. Under its exact-count experiment, roughly 0.94–0.96 reoccupation events were observed per loss event, and more than ninety-three percent of distinct lost locations returned at least once within the finite run. Among the returns we observed, the typical delay was only a step or two — and all of it happened through the ordinary growth rule encountering ordinary empty sites.

12: Is There Actually One Thing Here?

Fri, 14 Aug 2026 18:00:00 +0100

The last chapter ended with a suspicion about a word.

We have been saying the crystal comfortably since The Digital Crystal, and the noun has been doing quiet work ever since. We kept using it after material became impermanent. We kept using it after large material turnover appeared beneath the visible state. We kept using it after computational opportunity was shown to strongly constrain its scale, and after no tested budget produced a stationary population.

13: What Does One Attachment Cause?

Fri, 14 Aug 2026 20:00:00 +0100

The last chapter took away the body’s privilege.

Two supplied spatial boundaries failed to earn causal privilege. Comparable same-side localization appeared at both tested radial cuts, but under a local update rule and an eight-update horizon that was not evidence of an individual hiding inside either one.

So stop drawing the object first.

Start with an event.

One event.

What does it cause?

That question turns out to conceal several different causal claims.

14: Can Finite Computation Couple Distant Events?

Fri, 14 Aug 2026 22:00:00 +0100

The last chapter ended with a causal difference it could measure but could not explain.

Under the corrected intervention, cumulative construction outside the measured local region was lower in both FORCE-derived branches than in PREVENT.

RETAINED far-field difference
−0.318    [−0.583, −0.068]

TRANSIENT far-field difference
−0.177    [−0.362, −0.029]

Both intervals lie below zero.

So the far-field difference is no longer merely a suggestive discrepancy. It is established under that finite-budget protocol.

15: Can the Past Redirect the Future?

Fri, 14 Aug 2026 23:30:00 +0100

The last two chapters have narrowed the question to one local event.

The What Does One Attachment Cause? chapter forced a single attachment and found an immediate causal effect consistent with the local rule’s mechanical prediction. A positive transient cumulative consequence was not established, while the late transient accumulation rate became practically consistent with zero under the frozen criterion.

The previous chapter then showed that finite computation can redistribute evaluation opportunity outside the one-step reach of the local rule, change how the perturbation is expressed, and gate whether affected opportunities receive evaluation at all — while resolving no meaningful change in mean twelve-step consequence at the declared ±0.15 scale.

16: We Found an Individual. Then We Didn't.

Sat, 15 Aug 2026 01:00:00 +0100

The Is There Actually One Thing Here? chapter asked whether visible geometry marked a privileged boundary, and failed twice to establish one.

Its candidate regions were defined primarily by geometry.

That left open a stronger possibility: perhaps a boundary that is unremarkable as shape could still be privileged causally.

Since then the book has been replacing geometric intuition with causal tests.

What Does One Attachment Cause? measured the consequence of one local event.

17: How to Fail Correctly

Sat, 15 Aug 2026 03:00:00 +0100

The most dangerous result in this book was not a noisy one.

It was one of the cleanest.

measurement            ✓    M = 0.4402
                            CI [0.419, 0.461]

precision              ✓    MDE80 = 0.0268
                            against a +0.15 threshold

implementation         ✓    corrected transient intervention
                            known global channels removed

predeclaration         ✓    regions selected blind to outcome
                            threshold frozen

fresh reproduction     ✓    selected regions scored 0.4436
                            in an independent matched-null run

individuation          ✕    not established

The two numbers come from different runs. V1 measured raw causal containment on seed 20260916. V2 regenerated the selected regions on fresh seed 20260917, reproduced the raw score at 0.4436, and then asked the stronger question: did those regions exceed same-checkpoint matched controls?

18: What Is Digital Life?

Sat, 15 Aug 2026 05:00:00 +0100

The previous chapter ended with a list of what survived the tests. Now we can ask what those results add up to.

The results are experimental. The pattern they suggest is an inference.

The Wrong Way to Finish

There is an ending available that would undo everything.

The Digital Crystal grows and loses material. It replaces most of what it loses. Its material turns over while its process continues. Experimentally written hidden state can change how it responds to the same perturbation at the same visible geometry. A local event has real consequences, and finite computational constraints can reroute how those consequences are expressed. Regions of it retain their own causal influence and resist influence from outside. Earlier in the book, the Outlier system produced reproduction-like organization that survived a causal ancestry test.

From Discrete Cells to Continuous State

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

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?

0.0 -------------------------- 1.0

Now a cell can represent intensity, density, concentration, activation or some abstract amount of local material.

Neighborhoods as Convolution Kernels

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

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:

Growth Functions

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

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. This generalizes Chapter 28’s growth_function: same Gaussian-bump shape, now with explicit mu (preferred density) and sigma (tolerance) parameters instead of fixed constants.

Build Lenia From First Principles

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

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 — one historically important system, due to Bert Wang-Chak Chan (“Lenia: Biology of Artificial Life,” Complex Systems 28(3), 2019): not generic continuous CA, but Lenia specifically. The framing for this part so far:

Ch28–30
= components

Ch31
= one historically important system built from those components

Fidelity statement

The engine below implements the canonical Lenia update exactly — state plus timestep-scaled growth of the convolved field, clipped to [0, 1] — with the exponential growth mapping from Chan’s paper. It differs from full Lenia in scope, stated here so later comparisons use the same baseline:

Discover Your First Lenia Organisms

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

Running Lenia is easy.

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

This chapter turns that problem into a repeatable search pipeline. It follows Chan’s discovery playbook structurally — random soup generation, survival filtering, parameter tweaking, and, crucially, human judgment for what counts as interesting — while automating the parts that do not need eyes.

Define what counts as a candidate

We should not start with the vague objective:

Search Lenia Parameter Space

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

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.

Multi-Kernel and Multi-Channel Lenia

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

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.

This chapter builds a pedagogical multi-channel formulation in Lenia’s spirit — a connection graph with per-edge kernels and growth parameters. Canonical multi-kernel, multi-channel Lenia is Chan’s “Expanded Universe” (ALIFE 2020) direction; the book’s version is simpler and says so, keeping the graph inspectable rather than matching the canonical matrix formulation.

Damage, Robustness and Persistence

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

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.

Flow-Lenia and Mass-Conserving Artificial Life

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

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?

Flow-Lenia — Plantec et al. (2023), “Flow-Lenia: Towards open-ended evolution in cellular automata through mass conservation and parameter localization” — explores exactly that direction through two ideas: reformulating the update around transport so mass is conserved, and embedding rule parameters as local fields rather than global constants. This chapter presents both ideas with small pedagogical models, honestly labeled as stepping stones rather than reproductions.