bff

A minimalistic computer simulation demonstrating the emergence of functional replicators out of random noise; based on a variant of the Brainfuck programming language.

The BFF Setup

You have a “soup” containing thousands of tapes. Each tape is exactly 64 bytes. The size never changes.

An interaction works like this:

1. Pick two random tapes from the soup
2. Temporarily concatenate them into a 128-byte tape
3. Run this as a Brainfuck program
4. Split back into two 64-byte tapes (bytes 0–63 and bytes 64–127)
5. Return both to the soup

The key insight: in standard Brainfuck, the program and the data tape are separate. In BFF, they’re the same thing. The 128-byte combined tape is simultaneously the program being executed AND the memory being operated on.

What the Instructions

Brainfuck has a read/write head that points to some position on the tape:

• < — move head left one position
• > — move head right one position
• + — increment the byte at current position (0→1, 255→0)
• - — decrement the byte at current position
• [ — if current byte is 0, jump forward to matching ]
• ] — if current byte is nonzero, jump back to matching [
• , and . — input/output (TODO: why does he keep , but drop .?)

Execution starts at byte 0 and proceeds through the tape. When it hits an instruction, it executes it. Non-instruction bytes (anything other than those 7 characters) get skipped.

How Replication Emerges

Say tape A occupies bytes 0–63 and tape B occupies bytes 64–127 in the combined tape.

If tape A happens to contain a sequence of instructions that:

1. Reads bytes from positions 0–63
2. Writes those values to positions 64–127

…then when they split apart, tape B has become a copy of tape A.

A simple copy loop might look something like:

• Move to position 0
• Read byte, move to position 64, write byte
• Move back, go to position 1
• Repeat until done

BFF results

Operations per interaction: Each dot is one interaction; height shows how many instructions executed. Before the phase transition, almost nothing happens. At the transition, a sharp vertical wall appears as copy loops start running thousands of operations per interaction.
Coding bytes per tape: Fraction of each tape containing valid instructions vs. random bytes. Rises over time because only code produces code. Jumps sharply at the phase transition when whole-tape replicators take over, continues climbing afterward as sub-replicators colonize remaining space.
Entropy by tape position: For each tape position, how variable is that byte across all tapes in the soup? Before the transition: maximum entropy everywhere (random). After: near-zero for early positions (conserved replication machinery), higher toward the end (cargo/sub-replicator space that tolerates variation).
Positions of aligned-copy loops: Where on the tape are the [ instructions performing whole-tape replication? Multiple clusters indicate competing replicator species whose populations shift over time.
Positions of self-multiplying loops: Where are [ instructions that copy themselves multiple times per interaction? These sub-replicators emerge only after whole-tape replication is stable — evolution continuing at a nested level.