BFF // PRIMORDIAL SOUP

WHAT IS THIS

This is 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 SIMULATOR

Watch the soup grid

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

Watch the metrics chart

The four colored lines track soup complexity over time. The key event: a sudden rise in high-order entropy and replicator density accompanied by a spike in zero fraction, the zero-poisoning phase described in the paper.

Crank up the speed

The paper ran 16k epochs on CUDA with 131,072 tapes. In the browser we run serially, so try 100-500 steps/frame in the parameters panel. The speed bar turns amber then red (TURBO). State transitions typically happen within a few thousand epochs.

Seed a replicator

The SEED REPL button plants the paper's replicator [[{.>]-]]-]>.{[[ as a full-tape genome: the 64-byte tape is filled with [ padding, with the replicator in the last 16 bytes. This matters because the replicator always copies to position 48 of the target tape -- the [ prefix ensures the outer loop guard fires on the next generation. Several copies are seeded at once. Crank the speed up and watch the cyan spread.

BFF INSTRUCTION SET

BFF (Brainfuck+) extends the original Brainfuck language by replacing I/O streams with two independent heads operating on a single unified instruction+data tape. This allows programs to read and write to each other's code, enabling self-modification and, eventually, self-replication.

HEADS

head0 is the read/data head. head1 is the write head. Both move independently over the same tape. All head 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 head → write head position
,	tape[head0] = tape[head1]	Copy: write head → read head position
[	if tape[head0] == 0: jump past ]	Loop start (conditioned on read head)
]	if tape[head0] != 0: jump to [	Loop end
(other)	no-op	All 246 other byte values do nothing

TERMINATION

A program terminates when the instruction pointer reaches the end of the tape, or after 2¹³ = 8,192 IP reads (the paper's exact limit). Unmatched brackets also terminate. This prevents infinite loops from stalling the simulation.

THE PALINDROMIC REPLICATOR

The paper's example emergent replicator (from Figure 4) is:

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

When this program runs with its write head positioned at the left edge of the adjacent tape:

The outer loop drives execution while tape[head0] != 0
The inner loop copies one instruction per iteration: . copies read→write
The write head moves left ({), the read head moves right (>)
Result: the program is copied to the adjacent tape in reverse
Since the sequence is a palindrome, the reversed copy is identical
The copy can then replicate itself: true self-replication

The inspector panel shows OP-PALINDROME: YES when a tape's BF operator subsequence reads the same forwards and backwards. This is one fingerprint of a replicator family.

PRIMORDIAL SOUP SETUP

The simulation follows the paper's "Turing gas" variant (after Fontana 1990). Parameters faithful to the paper:

N tapes of L bytes, uniformly randomly initialized (every byte 0-255 equally likely)
Default: 2¹⁷ = 131,072 tapes of 64 bytes each. Browser uses smaller N for performance.
Tapes interact as a Turing gas: random ordered pairs (A, B) are selected, concatenated into a 2L-byte scratch tape, executed, then split back
Background mutation: Poisson-sampled number of random byte flips per epoch, at rate 0.024% per byte by default

LIFECYCLE OF A STATE TRANSITION

PRE-LIFE PERIOD

Random byte distributions. Most self-modifications happen at tape ends. Character distribution slowly converges toward a stationary bias for certain BF operators. Soup complexity (HOE) is low and roughly flat.

FIRST REPLICATOR EMERGES

Through accumulated self-modification, not random luck, 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, which then constructs the direct version. Complexity begins to rise.

ZERO-POISONING

The first replicator has a [,}<] structure: its loop breaks when head0 sees a zero byte. It can copy zeros but cannot write over them. Zeros accumulate in the soup (up to ~14% of all bytes at peak), stalling replication. Complexity temporarily degrades. This is the red spike visible in the metrics chart.

SECOND-GENERATION REPLICATOR

A more robust replicator with [<,}] structure emerges that can overwrite zeros. It rapidly displaces the first replicator and its zero-sensitive kin. The soup becomes a "very busy place" with multiple replicator variants overwriting each other. Complexity rises sharply then steadily.

ATTRACTOR STATE

The soup reaches a dynamic equilibrium dominated by replicators. This is the attractor: a fixed basin in the system's state space. Even after the soup is "taken over," competition continues; no single program dominates permanently. The paper observes 40% of runs reach this state within 16k epochs.

KEY RESULT

The paper shows through ablation that self-modification is the primary cause of replicator 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. The "long-no-noise" condition (no mutation, fixed interaction order) still produces replicators ~50% of the time.

CHART METRICS

HIGH-ORDER ENTROPY (HOE)

The paper's primary complexity metric. Defined as Shannon entropy minus normalized Kolmogorov complexity. Intuitively: captures information that can only be explained by relationships between characters, not just their individual frequencies. Random noise has HOE near 0 (high entropy, also high Kolmogorov complexity; both cancel). A soup of replicator copies has high HOE (structured repetition with non-trivial content). The paper approximates Kolmogorov complexity with brotli compression; we use a bigram repetition proxy. The state transition shows as a sharp HOE rise.

ZERO FRACTION

Fraction of all tape bytes that are zero (null byte). Zero bytes are significant because the loop condition [ ] in BFF is conditioned on tape[head0] == 0. The zero-poisoning phase is visually distinct: a spike in this metric coincides with the first replicator generation's vulnerability to zero bytes. Watch the grid turn red during this phase.

UNIQUE TOKENS (NORMALIZED)

Number of distinct byte values present in the soup, divided by 256. Random initialization uses nearly all 256 values. As replicators colonize the soup, they overwrite random bytes with their own narrow set of BF operator bytes, causing the unique token count to drop sharply. The paper uses "tracer tokens" (epoch+position tuples attached to each byte) to detect this same signal precisely; our normalized unique count is a cheap approximation of the same effect.

REPLICATOR DENSITY

Fraction of tapes that match a heuristic replicator signature: more than 22% BF operator bytes and at least one matched bracket pair and at least one copy instruction (. or ,). This is a proxy; the paper uses proper token-tracer analysis to identify true replicators, which is computationally intractable here. But the signal is clear: this metric rises sharply at the state transition and plateaus at the attractor.

GRID COLORS

Cyan: high BF operator density with copy instructions. Likely replicator or replicator variant.
Red: zero-poisoned tape. More than ~50% zero bytes. Often a tape that has been overwritten by a zero-producing replicator or failed copy.
Dim teal: some BF structure but insufficient for replication. Pre-replicator or partial rewrite.
Dark: random noise. The pre-life default state.
Bright blue highlight: currently selected/inspected tape.

THIS IMPLEMENTATION

Written in vanilla HTML5/JS with no dependencies. Runs in any modern browser. The simulation is single-threaded; the paper used CUDA with parallel execution across all 131k tapes simultaneously. A JS WebWorker port would be the natural next step for matching paper-scale performance.

INTERPRETER FAITHFULNESS

Termination: 2¹³ = 8,192 IP reads, matching the paper exactly
Tape length: 64 bytes default (paper's value)
Concatenation: A + B → exec → split at byte 64, exactly as described
Mutations: Poisson-sampled byte flips at configurable rate (default 0.024%)
Bracket matching: precomputed jump table per execution for O(1) loop jumps
Heads wrap modulo tape length

PALINDROME DETECTION

The paper notes that the first emergent replicator was a palindrome. The key insight: if a loop copies the tape in reverse (write head moving opposite to read head), and the source sequence is a palindrome, then the reversed copy is identical to the original, enabling faithful self-replication without needing to know the direction of copying.

The inspector computes palindrome status by extracting the BF operator subsequence of a tape (ignoring data bytes) and checking if it reads the same forwards and backwards. This is a necessary but not sufficient condition for replicator status; many palindromes are not replicators.

HOE APPROXIMATION

The paper computes high-order entropy using brotli compression as a Kolmogorov complexity proxy. We use a bigram repetition ratio (fraction of consecutive byte pairs that are equal) combined with Shannon entropy. This is cheaper to compute and captures the same qualitative signal: the state transition is detectable as the structured repetition of replicator sequences overwhelms the random background.

SPEED MODES

The steps/frame slider controls how many soup interactions execute per animation frame (~60fps):

1-10/frame: Slow, watch individual tapes change in real time
10-150/frame (amber bar): Fast, chart fills quickly
150-1000/frame (red TURBO): Thousands of epochs/second, state transitions in seconds

At high speeds, stats recording and rendering are throttled to avoid blocking the JS thread. The simulation itself is never throttled; all steps run.

SOURCE

This is a single self-contained HTML file. Open in any browser, or host on GitHub Pages with zero configuration.

// paper's code (CUDA/CPU): github.com/paradigms-of-intelligence/cubff // run BFF variant: ./cubff --lang bff_noheads

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 CITED IN PAPER

Tierra: Ray, T.S. (1991). Assembly-language ALife, hand-crafted ancestor replicator, parasites emerge. The original computational evolution experiment.
Avida: Ofria & Wilke (2004). Tierra-like with explicit fitness for auxiliary computation. Both Tierra and Avida start with a designed replicator; BFF paper starts from scratch.
Coreworld: Rasmussen et al. (1990). Multiple programs sharing an instruction tape with local energy resource. Two-instruction (MOV-SPL) replicators dominate.
Fontana's Turing Gas: Fontana (1990). Lambda calculus programs randomly interact. Identity function emerges as trivial replicator. BFF paper is directly inspired by this setup.
Neural CA: Mordvintsev et al. (2020). Cellular automata extended with neural networks, trained to self-replicate patterns.
SUBLEQ: the paper's counterexample: a Turing-complete one-instruction language where the shortest possible self-replicator is too long (~60 bytes) for spontaneous emergence. No state transitions observed after billions of executions.

BACKGROUND CONCEPTS

Origins of Life (OoL): the biological question this paper maps onto computation. RNA World hypothesis, autocatalytic networks, prebiotic chemistry.
Kolmogorov Complexity: theoretical measure of string compressibility. Uncomputable in general; approximated here with repetition ratio, in the paper with brotli.
Sophistication / Effective Complexity: alternative complexity metrics (Koppel, Gell-Mann & Lloyd) that attempt to factor out random noise. HOE is related but practically motivated.
Attractor State: in dynamical systems theory, an attractor is a set of states toward which the system evolves. Once the soup enters the replicator-dominated regime, it does not spontaneously return to the random noise state. The replicator regime is the attractor basin.

BRAINFUCK LINEAGE

The original Brainfuck was created by Urban Müller in 1993 as a minimalist Turing-complete language with 8 commands. BFF replaces its I/O commands (. ,) with copy operations between two independent heads on a unified tape, eliminating external I/O and making the language entirely self-contained. This is the key modification that enables self-interaction and replication.