BFF // PRIMORDIAL SOUP

WHAT IS THIS

An interactive browser simulation of the BFF primordial soup experiment described in Computational Life: How Well-formed, Self-replicating Programs Emerge from Simple Interaction by Blaise Agüera y Arcas, Jyrki Alakuijala, James Evans, Ben Laurie, Alexander Mordvintsev, Eyvind Niklasson, Ettore Randazzo, and Luca Versari (Google / University of Chicago, 2024).

The central question: can self-replicating programs arise spontaneously from a soup of random, non-self-replicating programs, with no fitness function, no goal, no designer? The answer, demonstrated across multiple computational substrates, is yes.

THE BIG IDEA

The paper draws an analogy to the Origin of Life. Biology has the RNA world hypothesis: at some point in prebiotic chemistry, self-replicating molecules arose from a soup of random organic compounds. The authors ask whether this transition from pre-life to life is a general property of any sufficiently expressive computational substrate, not just biochemistry.

They show that when random programs interact and modify each other, self-replication emerges as an attractor state. The mechanism is primarily self-modification, not random initialization or background mutation. Once a replicator arises, it rapidly colonizes the soup. This is a phase transition: a sudden, irreversible change in the dynamics.

HOW TO USE THIS

Watch the soup grid

Each square is one BFF tape. Teal = op-heavy replicator candidate. Red = zero-poisoned. Dark = random noise. Click any cell to inspect its raw content in the right panel.

Watch for state transitions

The status pill transitions PRE-LIFE to SPREADING to ATTRACTOR. The metrics chart shows all four signals in real time. The amber dashed line marks the moment spreading began.

Speed and SLOW@ATT

Crank steps/frame up to turbo to find an attractor fast. SLOW@ATT automatically drops to 1 step/frame once replicators dominate, so you can watch the dynamics up close.

Seed a replicator

SEED REPL plants the paper's palindromic replicator [[{.>]-]]-]>.{[[ as a full-tape genome and immediately runs 3 forced interactions to guarantee early spread. Watch the teal expand.

BFF INSTRUCTION SET

BFF (Brainfuck+) extends Brainfuck by replacing I/O streams with two independent heads on a unified instruction+data tape. Programs can read and write each other's code, enabling self-modification and eventually self-replication.

HEADS

head0 is the read head. head1 is the write head. Both move independently. All positions wrap modulo tape length.

INSTRUCTION TABLE

OP	ACTION	NOTES
<	head0 -= 1	Move read head left (wraps)
>	head0 += 1	Move read head right (wraps)
{	head1 -= 1	Move write head left (wraps)
}	head1 += 1	Move write head right (wraps)
+	tape[head0] += 1	Increment byte at read head (mod 256)
-	tape[head0] -= 1	Decrement byte at read head (mod 256)
.	tape[head1] = tape[head0]	Copy: read position to write position
,	tape[head0] = tape[head1]	Copy: write position to read position
[	if tape[head0] == 0: jump past ]	Loop start
]	if tape[head0] != 0: jump to [	Loop end
(other)	no-op	246 other byte values do nothing

TERMINATION

Programs terminate when the IP reaches the end of the tape, or after 2¹³ = 8,192 IP reads (the paper's exact limit). Unmatched brackets also terminate.

THE PALINDROMIC REPLICATOR

The paper's emergent replicator from Figure 4:

[[{.>]-]]-]>.{[[ // 16 bytes, palindromic

The outer loop drives execution while tape[head0] != 0
Each iteration: . copies one byte from read to write position
Write head moves left ({), read head moves right (>)
Result: the program is copied into the adjacent tape in reverse
Since the sequence is a palindrome, the reversed copy is identical
The copy then replicates itself: self-sustaining replication

The inspector shows OP-PALINDROME: YES when a tape's BF operator subsequence reads the same forwards and backwards.

PRIMORDIAL SOUP SETUP

Parameters faithful to the paper (Section 2.1):

N tapes of L bytes, uniformly randomly initialized (every byte 0-255 equally likely)
Paper default: 2¹⁷ = 131,072 tapes of 64 bytes. Browser uses smaller N for performance.
Each epoch: random ordered pair (A, B) selected, concatenated into a 2L scratch buffer, executed by BFF, split back to A' and B'
Background mutation: Poisson-sampled byte flips at rate 0.024% per byte per epoch

LIFECYCLE

PRE-LIFE

Random byte distributions. Self-modifications happen but accumulate slowly. Shannon entropy is high, HOE is flat. Character distribution gradually develops a bias toward certain BF operators.

FIRST REPLICATOR

Through accumulated self-modification, a tape acquires a loop-and-copy structure. The paper traces this to a complex rewrite event where a pre-replicator loop in tape A inadvertently constructs a replicator in tape B. Replicator density begins to rise.

ZERO-POISONING

The first replicator has a [,}<] structure: its loop breaks on zero bytes. It can copy zeros but cannot write over them. Zeros accumulate (up to ~14% of all bytes at peak). The zero fraction spike is visible in the metrics chart.

SECOND GENERATION

A more robust [<,}] variant emerges that can overwrite zeros. It displaces the first generation. The soup becomes a competitive arena with multiple replicator variants overwriting each other.

ATTRACTOR STATE

Dynamic equilibrium dominated by replicators. No single program dominates permanently. Competition continues indefinitely. The paper observes 40% of runs reach this state within 16k epochs at full scale.

KEY RESULT

Self-modification is the primary cause of emergence, not random initialization or background mutation. Runs with zero mutation still produce replicators. Runs with only 128 epochs (too short for self-modification to accumulate) produce replicators only 0.3% of the time.

CHART METRICS

HIGH-ORDER ENTROPY (HOE)

The paper's primary complexity metric. Defined as Shannon entropy minus normalized Kolmogorov complexity. Captures information that can only be explained by relationships between characters, not just individual frequencies. Random noise has HOE near 0. Replicator-dominated soup has high HOE. The paper uses brotli compression as a Kolmogorov proxy; we use a bigram repetition ratio. The state transition appears as a sharp rise.

ZERO FRACTION

Fraction of all bytes that are zero. Significant because BFF loops are conditioned on tape[head0] == 0. The zero-poisoning phase (first-generation replicator vulnerability) shows as a distinct spike. Watch the grid turn red during this phase.

UNIQUE TOKENS

Number of distinct byte values present in the soup, normalized to 0-1. Random initialization uses nearly all 256 values (near 1.0). As replicators colonize the soup, they overwrite random bytes with a narrow set of BF operator bytes. Unique token count drops, visible as a declining line after the transition.

REPLICATOR DENSITY

Fraction of tapes matching the replicator heuristic: more than 22% BF operator bytes, at least one matched bracket pair, and at least one copy instruction. Rises sharply at the state transition and plateaus at the attractor. The status pill tracks this signal directly.

GRID COLORS

Teal: high BF operator density with copy instructions. Replicator or replicator variant.
Red: zero-poisoned. More than ~50% zero bytes.
Dim teal: partial BF structure, not yet replicating.
Dark: random noise. The pre-life default.
Bright highlight: currently selected/inspected tape.

THIS IMPLEMENTATION

Single self-contained HTML file, no dependencies beyond Google Fonts. Single-threaded JS; the paper used CUDA with all 131k tapes in parallel. A WebWorker port would be the natural next step for matching paper-scale throughput.

INTERPRETER ACCURACY

Termination: 2¹³ = 8,192 IP reads, matching the paper exactly
Default tape length: 64 bytes (paper's value)
Concatenation: A + B as one 2L scratch buffer, execute, split at byte 64
Mutations: Poisson-sampled byte flips per epoch
Bracket matching: precomputed jump table per execution, O(1) loop jumps
Heads wrap modulo tape length

FULL-TAPE GENOME (SEED REPL)

The naive seed (bare replicator + zero padding) dies every second generation: the replicator always copies itself to B[48..63], and when that tape next runs as A, the outer [ guard sees tape[0] = 0 and skips the entire program.

The fix: fill the 64-byte tape with [ (0x5b) and place the replicator in the last 16 bytes. The [ prefix floods B[0..47] on every copy, so daughter tapes have the same structure. Verified to reach 70%+ replicator density within ~5,000 epochs at 256 tapes. Three forced interactions are run immediately after seeding so the genome does not sit idle waiting for random selection.

PALINDROME DETECTION

Extracts the BF operator subsequence of a tape (ignoring data bytes) and checks if it reads the same forwards and backwards. Necessary but not sufficient for replicator status; many palindromes are not replicators. It is a fingerprint of the replicator family the paper identified.

SPEED MODES

1-10/frame: slow, individual tape changes visible
10-150/frame: fast, chart fills quickly
150-1000/frame (TURBO): thousands of epochs per second

SLOW@ATT drops to 1 step/frame automatically when replicator density exceeds 60%, so the attractor dynamics are watchable without manual intervention. Toggle it off if you want to keep turbo running through the attractor.

MUTATION SCALING

The paper's 0.024% mutation rate is calibrated for 131,072 tapes. At 256 tapes it kills replicators faster than they spread: each replicator would be hit by a random mutation roughly every 7 epochs. This implementation scales the absolute mutation count to ~2 flips/epoch for small soups (under 2048 tapes), matching the biological pressure of the paper's scale rather than the raw percentage.

SOURCE

Paper CUDA implementation: github.com/paradigms-of-intelligence/cubff

This simulation: hed0rah.github.io/bff.html

Built with Claude. No frameworks, no build step.

PRIMARY REFERENCE

Agüera y Arcas B, Alakuijala J, Evans J, Laurie B, Mordvintsev A, Niklasson E, Randazzo E, Versari L.
Computational Life: How Well-formed, Self-replicating Programs Emerge from Simple Interaction.
arXiv:2406.19108v2, 2 August 2024.
arxiv.org/abs/2406.19108 | github: cubff

RELATED WORK

Tierra: Ray, T.S. (1991). Assembly-language ALife, hand-crafted ancestor replicator, parasites emerge spontaneously.
Avida: Ofria and Wilke (2004). Tierra-like with explicit fitness function for auxiliary computation tasks.
Coreworld: Rasmussen et al. (1990). Programs sharing an instruction tape with a local energy resource.
Fontana's Turing Gas: Fontana (1990). Lambda calculus programs interact randomly. Direct inspiration for the soup model used here.
SUBLEQ: The paper's counterexample. A Turing-complete one-instruction language whose shortest possible self-replicator is ~60 bytes, too long for spontaneous emergence. No transitions observed.

BACKGROUND CONCEPTS

Kolmogorov Complexity: theoretical measure of string compressibility. Uncomputable in general; approximated with compression ratio.
High-Order Entropy: the paper's metric. Shannon entropy minus normalized Kolmogorov complexity. Distinguishes structured repetition from random noise.
Attractor State: in dynamical systems, a set of states toward which the system evolves and from which it does not spontaneously escape. The replicator-dominated soup is the attractor basin.
Brainfuck: created by Urban Muller in 1993. Minimalist Turing-complete language with 8 commands. BFF replaces I/O commands with two-head copy operations, enabling self-interaction without external streams.