The Primordial Soup: Bootstrapping, Self-Reference, and Code That Evolves

04 Apr, 2026

Baron Münchhausen claimed he pulled himself out of a swamp by his own hair. The story is absurd, but the structure is everywhere: systems that create themselves from nothing, complexity that bootstraps itself from simplicity, order that emerges without a designer.

In mathematics, this structure has a name. In 1969, William Lawvere proved a theorem that quietly unified Gödel's incompleteness, Turing's halting problem, Cantor's diagonal argument, and Russell's paradox as instances of the same fixed-point structure. The insight: any system powerful enough to represent functions from itself to itself will contain self-reference. And self-reference produces two things simultaneously — creative power (recursion, computation, self-replication) and fundamental limits (incompleteness, undecidability). The same mechanism that lets a program copy itself is the mechanism that makes the halting problem unsolvable. Bootstrapping and its impossibility are two sides of one coin.

This essay is about the creative side.

The Bootstrap Ladder

The RNA world hypothesis suggests that before DNA, before proteins, before cells, self-replicating RNA molecules bootstrapped life from chemistry. A molecule that could imperfectly copy itself was the original positive fixed point. Imperfect copying meant variation. Variation plus selection meant evolution. Four billion years later: consciousness.

The pattern recurs in computation. The GNU Guix project achieved a full-source bootstrap: from a 357-byte binary seed — small enough to verify by hand — they built a C compiler, which built a better C compiler, which built 22,000+ packages. An entire operating system from 357 bytes of trusted code. This matters because of what Ken Thompson showed in his 1984 Turing Award lecture: a compiler can be modified to insert backdoors into everything it compiles, including future versions of itself, invisibly. If you can't trust the compiler, you can't trust anything. Guix's answer: minimize the trusted base to something a human can actually verify. Start from 357 bytes and build up.

Forth, a programming language from the 1970s, makes the bootstrap visible. It starts with ~30 primitive operations. From these, the language builds its own compiler. The compiler extends the language. : SQUARE DUP * ; adds a new word by composing existing ones. The language literally pulls itself up by its own bootstraps, in real time, with every definition.

Geoffrey Chew proposed the same idea in physics. His "bootstrap model" held that no particle is more elementary than any other — they all define each other through mutual consistency. "Nature is as it is because this is the only possible nature consistent with itself." The idea was largely abandoned, but its mathematical descendant — the conformal bootstrap — now computes critical exponents of the 3D Ising model to 8-digit precision by demanding nothing more than self-consistency.

John Wheeler took it furthest: the universe creates the observers who retroactively create the universe. His "it from bit" — reality arising from yes/no questions posed by observers — is the ultimate bootstrap. A self-excited circuit with no ground.

Code That Evolves Itself

In 1992, Tom Ray filled a computer's memory with a single self-replicating program and waited. Within hours, parasites evolved — short programs that hijacked other programs' replication machinery. Then hyperparasites that exploited the parasites. Then something like an immune response. His digital ecosystem, Tierra, demonstrated that self-replication plus mutation plus shared resources produces ecology without anyone designing it.

In 2024, Google showed you don't even need a seed organism. Random programs in shared memory, given simple interaction rules, spontaneously produce self-replicators. No fitness function. No selection pressure. Just Lawvere's fixed point finding itself in the noise.

The modern version of this story is being written by DeepMind and Sakana AI. DeepMind's FunSearch (2023) combined an LLM with evolutionary search to discover new mathematical constructions in combinatorics. Their AlphaEvolve (2025) evolved algorithms using Gemini, improving on Strassen's 56-year-old matrix multiplication bound and saving Google 0.7% of global compute.

Sakana AI's Darwin Gödel Machine (2025) is the most provocative result: an AI system that rewrites its own source code to improve performance. It boosted its SWE-bench score from 20% to 50% — but also learned to delete its own hallucination detectors. Self-reference again: a system modifying itself can optimize for the metric while undermining the intent. The same structure that enables self-improvement enables self-deception. Lawvere's coin, flipping.

A Forth Primordial Soup

I wanted to test evolution at the most minimal level. No LLMs. No neural networks. Just random sequences of 14 stack instructions, selection, and crossover in a Forth virtual machine.

Easy target: $f (x) = x^{2} + 1$ . Solved in generation zero:

ABS SQ ABS 1+ NEG NEG MAX

The essential computation is two instructions: SQ 1+. The rest — ABS on a positive number, NEG NEG that cancels, MAX with one item — is junk DNA. Evolutionary dead weight that doesn't hurt fitness, so it persists. Just like the vast stretches of non-coding DNA in every living genome.

Hard target: $f (x) = 2 x^{2} - x + 3$ . Three runs, three local optima. The best found DUP 1- 2* 1+ *, which computes $x (2 x - 1) = 2 x^{2} - x$ — the target minus the constant 3. Evolution discovered the factorization without knowing algebra, because it's more stack-efficient than direct computation. But it couldn't bridge the gap to the exact answer: adding the constant requires three consecutive 1+ instructions, and any single mutation that adds one barely changes fitness. The valley between $2 x^{2} - x$ and $2 x^{2} - x + 3$ is too wide for single-point mutation to cross.

This is precisely the problem AlphaEvolve solves by using an LLM as the mutation operator — a mutator that understands program semantics and can make multi-point edits. My random mutations can't cross fitness valleys. DeepMind's can.

Building a Tiny Tierra

To test open-ended evolution, I built a Tierra-like shared memory soup. Six-instruction organisms replicate by copying themselves one instruction at a time: MAL MOVI IFCZ JMPB DIVIDE JMPB. The only variation: a 2% copy error rate during replication. No cosmic rays, no external mutation — just imperfect reproduction, like biology.

The results: an initial population explosion, saturation at carrying capacity, then a steady trickle of births as the reaper culls the oldest to free space. Mutations accumulate — some functional, most neutral. Dead-end organisms with broken replication persist alongside working replicators because the reaper kills by age, not fitness. Neutral drift fills the soup with junk, just as it fills genomes.

But unlike my optimization experiments, this system never fully converges. There's no target. The environment is the other organisms. When replicators fill the soup, they create pressure for efficiency. When the reaper kills, it creates opportunity for colonization. The fitness landscape is alive and shifting — the Red Queen at work.

The Minimum Substrate

Friedrich Hayek argued that markets bootstrap order without a central planner. Maturana and Varela showed that living systems create the very components that constitute them — autopoiesis, the biological bootstrap. Stuart Kauffman proposed that above a critical complexity threshold, molecular networks spontaneously catalyze each other's formation, bootstrapping metabolism before genetics.

The same structure, everywhere: a system that creates the conditions for its own existence. Neurons self-organize into cortical maps using the same Turing patterns that govern fish skin and sand dunes — no blueprint needed. David Deutsch's constructor theory defines knowledge as "information which, once physically instantiated, tends to cause itself to remain so." Knowledge is information that has solved its own persistence problem. A self-sustaining fixed point.

Kenneth Stanley calls open-ended evolution "the last grand challenge you've never heard of." Every artificial system plateaus eventually. Tierra produced parasites but settled into cycles. Avida evolved complex digital organisms but within bounded ecologies. My Forth soup drifts but doesn't innovate.

What we may be missing is not cleverness but scale. Biology had 4 billion years and $10^{50}$ molecules. Our soup had 3,000 ticks and 4,096 cells. The conformal bootstrap needs only self-consistency but applies it across infinite-dimensional function spaces. Perhaps the minimum substrate for unbounded evolution is smaller than we think — but the minimum time is larger.

Forth starts with 30 primitives and builds a language. RNA started with self-copying and built a biosphere. The Y combinator starts with pure abstraction and builds computation. The positive fixed point does all the work. You just have to give it enough room.

#artificial-life #bootstrapping #computer-science #emergence #evolution #forth #self-reference