Computational Life — self-replicating programs from chaos
Last updated: 2026-02-17
Random programs in a "primordial soup" spontaneously evolve self-replicators ~40% of the time. No fitness function. No design. Just interaction and time. This is computational abiogenesis.
In 1944, Schrödinger asked "What is Life?" and proposed that living systems resist entropy through information. In 2024, researchers at Google demonstrated that when random programs are placed in an environment and allowed to interact, self-replicating programs emerge spontaneously from chaos.
BFF (Brainfuck Family) extends the minimalist Brainfuck language with a shared tape model where two heads (read and write) operate on the same memory. Programs interact by concatenating and executing together, with the output split back into two programs. This models molecular chemistry: A + B → exec(AB) → A' + B'.
The key insight: no explicit fitness function is needed. Self-replicators emerge because, by definition, they make more copies of themselves. Once one appears, it spreads exponentially. The soup undergoes a phase transition: entropy metrics spike, diversity collapses, and replicator patterns dominate.
This is a "distilled" explanation—interactive, visual, equation-rich. We minimize research debt: the accumulated cost of poor explanation in science. See Research Debt by Chris Olah.
Interactive simulation. Click START to watch self-replicators emerge from random noise.
Programs interact like molecules. Concatenate, execute, split. Self-replicators are autocatalytic: S + F → 2·S. Once one appears, exponential growth causes phase transition.
The primordial soup models chemical reaction dynamics. Each epoch, random program pairs are selected, concatenated, and executed. The program reads and writes to its own tape (the concatenated program text). Output is split back into two programs that return to the soup.
Most reactions produce noise. But occasionally, a program emerges that can copy itself when it encounters "food" (any other program). This is autocatalysis: the program catalyzes its own creation.
The critical finding: self-replicators emerge even without background mutations. In ~50% of mutation-free runs with fixed shuffling patterns, replicators appear. Mutations actually increase the error rate if too high (1% degrades formation).
217 ≈ 130,000 programs of 64 random bytes from 128 ASCII codes
Random pairs concatenate, execute for fixed steps, split by output length
Default 0.024% per byte. Higher rates (1%) degrade replicator formation
High-order entropy spikes at phase transition, unique tokens collapse
Shannon entropy measures diversity. High-order entropy detects structure. Replicator equations describe selection. Error threshold limits genome size.
Shannon entropy quantifies the information content and uncertainty in molecular sequences:
The paper introduces high-order entropy: Shannon entropy minus normalized Kolmogorov complexity (approximated via compression). This captures structure that emerges from random noise.
where p̂ᵢ = frequency of ASCII code i, Ĉ = compressed size, N·64 = total characters
The replicator equation describes how frequencies of different types change through differential reproduction:
xᵢ = frequency of type i, fᵢ = fitness, f̄ = average fitness
The error threshold sets fundamental limits on information that primitive replicators can maintain:
μ = mutation rate, L = genome length, A₀/A = fitness superiority
1940s: von Neumann designs self-reproducing automata. 1984: Langton's loops. 1990s: Tierra/Avida. 1999: Evoloops show Darwinian evolution. 2024: BFF shows spontaneous emergence.
The BFF interpreter and Soup simulation. Fully documented, readable, explorable.
<script src="../../virtue/bff/bff.js"></script>
// Execute a BFF program
const result = BFF.exec('[.>}]', [65, 66, 67]);
console.log(result.output); // [65, 66, 67]
// Run a primordial soup simulation
const soup = new Soup(256, 32);
for (let i = 0; i < 1000; i++) soup.step();
console.log(soup.replicatorCount, soup.entropy);
View bff.js source → (well-documented, 600 lines)
Full CLI with REPL and batch simulation. Type-safe implementation.
cd ts && npm install && npm run build
node dist/cli.js run hello.bff # run a program
node dist/cli.js repl # interactive REPL
node dist/cli.js simulate --size 200 --epochs 1000
Full BFF interpreter with configurable tape, step limits, execution tracing
Primordial soup with reactions, mutations, entropy calculation
Command line interface with run, repl, and simulate commands
This research question has been asked for 30+ years. Most ALife systems plateau. Replication ≠ learning. We must be honest about what would actually be new.
A Turing-complete system can compute learning, but won't spontaneously. Probability of random emergence: negligible.
Replicators optimize for minimality—complexity is costly. Learning requires representational overhead.
Fitness landscape exhaustion, ecological equilibrium. No ALife system has shown sustained complexity growth.