Von Neumann showed that self-replication requires:
Machine A: a “universal constructor” that reads sequential instructions from a tape and executes them (build this part, attach it here, etc.)
Machine B: a copier that duplicates the tape itself
The tape: contains instructions for building both Machine A and Machine B
Exact biological analogues (discovered after Von Neumann’s work):
DNA = the tape (encodes instructions)
Ribosomes = Machine A (read codons, synthesize proteins according to instructions)
DNA polymerase = Machine B (copies the tape)
When you run this system, you get a copy of the whole apparatus, tape included. Anything else you want the offspring to have can also be encoded on the tape.
This is inherently computational: Machine A must 1) read symbolds from the tape 2) perform different actions depending on what symbol it reads (conditional branching) 3) loop through the tape until it hits a stop signal
→ That’s what a turing machine does.
→ If you want to build something as complex as yourself from simpler parts, you need to follow a program.
→ Replication requires (and thus produces) computation “Only code can produce more code. Non-code can’t produce anything!”
As long as the tape contains the instructions for building machine A and machine B, the tape can contain arbitrary "extra information" too.
Inert cargo. Random bytes that get copied but never execute. One-off instructions. They execute during construction btu don’t have their own replication logic. Functional additions to the organism Sub-replicators. Instructions that are themselves replicators, i.e. copying itself within the tape.
These sub-replicators can have different relationships to the host:
Catastrophic: It overwrites the host’s replication machinery. Neither can reproduce any further. Self-limiting. Neutral: It copies itself into unused regions, and leaves the host machinery alone. Symbiotic: It does something useful for the host, like redundant copies of the code, or helping with some other function, outcompeting hosts without it. Each level of this hierarchy can undergo its own selection
Code is more dynamically stable than non-code, and its dynamic stability increases through symbiosis with yet more code—in particular, when code fragments find ways to work in functional tandem.
The tape can keep getting longer, more structured, more functional – as long as the core replication loop stays intact. And the things that survive will be the ones where all the layers are at least non-catastrophic to each other, trending toward mutual benefit over time.
Life is code
In a way, symbiosis is the very essence of functionality. When we talk about a kidney’s function only making sense in context, we mean that it is in symbiosis with other functions—like those of the liver (breaking ammonia down into urea), the heart (pumping blood), and so on. Each of these functions is purposive precisely because its inputs are the outputs of others, its outputs are inputs to others, and thus they form a network of dynamically stable cycles.
The same is true of larger, planetary-scale interrelationships. The “purpose” of plants, from the perspective of animal life, is to produce oxygen and sugar, which we breathe and eat. The “purpose” of animals, from a plant’s perspective, is to turn the oxygen back into carbon dioxide, and provide compost and pollination. Our growing understanding of life as a self-reinforcing dynamical process boils down not to things, but to networks of mutually beneficial relationships. At every scale, life is an ecology of functions.
Because functions can be expressed computationally, we could even say that life is code. Individual computational instructions are the irreducible quanta of life—the minimal replicating set of entities, however immaterial and abstract they may seem, that come together to form bigger, more stable, and more complex replicators, in ever-ascending symbiotic cascades.
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:
Pick two random tapes from the soup
Temporarily concatenate them into a 128-byte tape
Run this as a Brainfuck program
Split back into two 64-byte tapes (bytes 0–63 and bytes 64–127)
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:
Reads bytes from positions 0–63
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
![[What is Intelligence - What is Life-1767462354139.webp]]![[What is Intelligence - What is Life-1767462257159.webp]]![[What is Intelligence - What is Life-1767461529967.webp]]![[What is Intelligence - What is Life-1767461534587.webp]]![[What is Intelligence - What is Life-1767461538104.webp]]
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.
Dynamic stability: A replicator is more stable than a non-replicator — not because it’s physically robust (DNA is fragile), but because its pattern persists through copying. A stone sculpture degrades; a replicating pattern can last forever. Darwinian selection is just the Second Law applied to populations of replicators: more effective replicators are more dynamically stable, so they dominate.
Complexification: Classical Darwinism (mutation + selection) only fine-tunes within an existing design space — it doesn’t explain why life gets more complex over time. Symbiogenesis does: when replicators merge, the composite is genuinely more complex than its parts, opening a new design space. This happens at every scale (chemistry → cells → multicellularity → societies). In bff, complexity doesn’t come from random mutation; it comes from smaller replicators fusing into larger ones that can host yet more sub-replicators. Complexity increases because code-in-symbiosis-with-more-code is more dynamically stable than code alone.
Takeaways
Bff suggests that symbiogenesis is a more important driver of evolutionary innovation than random mutation.
Since symbiogenesis must involve combinations of pre-existing dynamically stable entities, we should expect complex replicating entities to emerge after (and be made of) simpler ones.
As a result, zooming in on sub-replicators within a larger replicator should allow us to peer back in evolutionary time.
Due to the instability of the imperfect replicators leading up to the first true replicator, we should expect this first true replicator to be a historical “event horizon,” becoming the template for what follows and erasing independent traces of what came before.
Evolved code should not only include instructions for replicating itself as a whole, but also be rife with sub-sequences that contain instructions for independently replicating _them_selves.
If symbiosis among these parts generated the novelty driving evolution of the whole, we should see evidence in the genome of many “broken” or incomplete sub-replicators.
Code that evolved through such hierarchical symbiotic replication should also contain many sequences that are repetitive, or are copies of other parts.
A complex replicator can only form by combining simpler replicators that already exist and are already stable. You can’t merge things that don’t persist long enough to encounter each other. So there’s a necessary temporal ordering: simple first, complex later.
If complex replicators are made of simpler ones that merged, then the components are older than the composite.
When a sub-replicator succeeds, it makes copies of itself. When two replicators merge, both might contain the same sub-components (which themselves replicated). So evolved code accumulates multiple copies of successful sub-replicators, variants (copies that later diverged), and nested redundancy (a sub-replicator copied itself, then that whole region got copied again at a higher level).
This is why genomes are so compressible
Virality: Genomes are ecosystems of sub-replicators. Viruses, especially retroviruses, are replicating code that can insert itself into host DNA. When they infect germ cells, they become heritable — permanent passengers in the species’ genome.
This has happened constantly throughout evolution. At least 8% of the human genome consists of endogenous retroviruses; nearly half is transposable elements (sequences that copy themselves within the genome). This is several times more DNA than codes for “our” proteins.
The host-virus relationship follows a predictable arc: initially catastrophic or parasitic, trending toward neutral or symbiotic over time (because lethal variants kill themselves along with hosts). Ancient viral code now performs essential functions — placenta formation, immune response, cell differentiation, brain function. Former invaders became load-bearing infrastructure.
Viruses also enable horizontal gene transfer between species, tangling the tree of life into a web. The BovB retrotransposon (a functional chunk of self-copying code) has jumped between species so often that by its phylogeny, cows are more closely related to snakes than to elephants.
Unlike point mutation, a chunk of code that has already circulated, jumping around in the genome or even between species, isn’t random. It necessarily includes real functionality
Compression: Living structures show fractal-like properties (branching circulatory systems, bronchial tubes, trees, …). But life isn’t truly self-similar (you don’t find smaller fleas on fleas). It’s multifractal: repetitive structure at every scale, but different patterns at different scales.
This connects to compression: Random sequences are incompressible. Sequences built by copying sub-sequences compress well because patterns repeat. The compression ratio measures how much redundancy (= non-randomness) exists.
A single human genome compresses to a small fraction of its raw size. This is because genomes are are layered copies of sub-replicators that merged, which themselves contain copies of smaller sub-replicators.
BFF shows the same pattern: after the phase transition, tapes compress to ~5% of their original size. And compression improves as you add more tapes, because the redundancy (shared replicator ancestry) becomes more visible.
While common ancestry alone can explain many of the similarities across species (though not all, as BovB illustrates), such classical Darwinian arguments can’t explain why the genome of a single individual is also so repetitive. That only makes sense when we begin to consider genomes to be made out of smaller genomes.
DNA and bff tapes, in other words, are both systems that evolve through what we could call “multifractal symbiosis.” Our genomes are aggregates of cooperating replicators, all the way down. That’s why they are so compressible. But it’s also why wonderful new kinds of complexity emerge at every scale—and therefore why, in biology, we can always learn something new by zooming in or out.
Embodiment: The genome isn’t a literal blueprint where body parts map 1:1 to DNA sequences. A snake has hundreds of ribs, but there isn’t a “rib gene” copied hundreds of times. Instead, “Hox genes” orchestrate body plans through gene regulation and morphogenesis — ribs emerge as standing waves in morphogen concentrations (Turing’s reaction-diffusion). The code gets reused, not copy-pasted. Changing rib curvature means tweaking one function, not hundreds.
This is possible because life is computational. Von Neumann’s universal constructor is a Turing machine, so its operations are compositional: complex functions built from sub-functions, which can themselves be reused and nested. Recursion (functions calling themselves) produces Fibonacci spirals in nautilus shells and pine cones.
Compositionality is what allows building structures like the circulatory system — astronomically many branches that couldn’t possibly each be hard-coded. The branching algorithm runs recursively, with parameters adjustable for a shrew or a blue whale.
Compositionality mirrors symbiotic hierarchy. Each layer retained its own replication machinery but added regulation for the composite.
Blood vessels are tubes of muscle cells containing organelles containing mitochondria containing their own DNA. Each layer down is an older symbiotic merger, still running its own code within the larger program.
Daisyworld: Defining life is notoriously hard. Textbook definitions (“eats, metabolizes, reproduces…”) exclude mules and worker bees. Blaize proposes: “Life is self-modifying computronium arising from selection for dynamic stability; it evolves through the symbiotic composition of simpler dynamically stable entities.”
But can a singleton (like Earth) be alive? It can’t reproduce, but dynamic stability can still apply through homeostasis. The Gaia hypothesis (Lovelock, Margulis): Earth actively maintains conditions friendly to life via negative feedback loops — temperature has stayed in a narrow band for hundreds of millions of years despite the Sun getting hotter.
Daisyworld is a toy model demonstrating how this works. Two species: black daisies (warm the planet by absorbing sunlight) and white daisies (cool it by reflecting). Both reproduce best at ~72°F, declining to zero outside 41–104°F. Result: populations self-adjust to stabilize temperature across a factor of two in solar luminosity — a range that would produce 32–140°F on a lifeless planet.
This doesn’t mean Earth is conscious just because we (conscious parts) are. The social intelligence hypothesis suggests consciousness arises from social interaction — Earth has no other planets to socialize with.
Earth’s intelligence is vegetative: slow feedback loops with limited predictive power, keeping conditions stable over billions of years. But techno-humanity is upgrading this — remote sensing, modeling, long-range prediction. The planet is becoming more “animal-ish”: able to sense threats (asteroid detection), make predictions (climate models), potentially respond proactively (starting with our species becoming more animalish / conscious through better forms of long-range communication; yet to develop a small-world structure). Assuming we can get our act together and integrate humanity+technology into a new planetary homeostasis.
Élan Vital. Computers are purposive (they can be “broken” or “buggy”) but can’t reproduce, grow, or heal on their own. Engineers learned long ago that self-modifying code is hard to debug, so they avoid it. But zooming out: phones get manufactured and repaired, apps gain features and go obsolete, … Technology reproduces and evolves; we’re the reproductive organs. This makes the human-technology symbiosis our most recent major evolutionary transition.
The same logic extends further. Rivers, clouds, rocks serve ecological functions, are shaped by life, and participate in Gaian interdependency. Where exactly do we draw the line around “alive”?
This way lies vitalism, […] We resist such ideas because we tend to reserve the notion of agency only for ourselves. The idea of agency in a molecule or a storm, let alone an abstraction like money, seems especially far-fetched. We also tend to think in terms of a hierarchy in which “we” (for whatever value of “we”) are at the top, and agency must surely diminish for anything “lower”—a view reminiscent of the medieval Great Chain of Being.
The Enlightenment showed that atoms are atoms — same rules everywhere. But those rules, as Schrödinger noted in 1944, don’t yet account for computationally complex, dynamically stable, symbiotic phenomena. The “other laws of physics hitherto unknown” that he predicted — this chapter has been sketching them.
Zooming into ourselves literally gives a written record of our evolutionary history.
