I Built an Origin-of-Life Engine — Then Built the Lie Detector First

Here’s the pitch that made me build this: seed a digital soup with pure randomness, add only physics, and watch whether order — something that copies itself, something alive-shaped — crawls out on its own. No fitness function. No goal. No replicator that I wrote. If it appears, it has to be the soup’s doing, not mine.

It’s the oldest question there is, and the trap is enormous: it is so easy to see life in noise when you want to. So before I built the soup, I built the part that keeps me honest. The engine is called AbioGen. Most of the work was the lie detector.

The soup, in plain English

The “programs” are tiny self-modifying tapes — a stripped-down Brainfuck variant where the code and the data are the same bytes. Two random tapes get stuck together, run as one little program, and split back apart. Sometimes a byte mutates. That’s the whole physics. Nothing selects for anything. I just watch.

What I’m watching for is a replicator: a tape that, when it meets another, overwrites the stranger with a copy of itself. Nobody wrote that tape. If one shows up and spreads, that’s order emerging from noise.

This isn’t a wild idea — it’s a real result. A 2024 paper (“Computational Life,” arXiv:2406.19108) showed self-replicators arise in exactly this kind of soup, no fitness needed, in about 40% of runs. My job wasn’t to invent the phenomenon. It was to reproduce it without fooling myself, and to see how far up the ladder it goes.

The two rules that stop me lying

Every claim in this project has to survive two controls, and they are the opposite of decoration — they’re load-bearing.

The scrambled control. Any time a metric says “emergence!”, I run the exact same experiment with the soup’s structure shredded every step (same byte statistics, no structure). If the “emergence” still fires on the shredded version, it was never real — it was the metric twitching, not the soup living. The signal only counts if it beats its own scrambled twin.

The extinction anchor. In a separate closed world, a structureless “null” condition must go extinct. If a world with nothing to learn still sustains life, my harness is leaking structure somewhere and the whole run is void. It goes extinct every single seed. Good — the floor is solid.

The controls caught me. Twice.

This is the part I’m proud of, because it’s the part that’s supposed to hurt.

Strike one: one of my early-warning metrics (a “near-replication” score) lit up on a real run and my code proudly declared a knife-edge result. The scrambled control lit up just as bright. The metric was confounded — ordinary soup dynamics create correlation even with zero replicators. I ripped it out of the verdict entirely. It’s a thing to watch, never a thing to claim.

Strike two: I added an “assisted” mode — a gentle rule that reproduces tapes which copy themselves, like natural selection nudging the soup. It produced gorgeous “order.” Then the scrambled control produced the identical order. My own operator had been manufacturing a pretty number out of noise. Discarded as what it was: nothing.

Twice, the honesty rig flagged my own work as fake. That’s not a bug in the project. That is the project.

What actually happened (the real numbers)

Here’s the honest scoreboard, and it’s colder than I wanted it to be.

The verdict is UNRESOLVED — no emergence. Across every seed in the budget I ran, the soup’s replication rate never separated from its scrambled control: 0 of 4 seeds fired, peak_repl_rate 0.0 on both the real soup and the control. I even wrote the prediction down before the run — “expect no separation from the scrambled control” — and the data agreed. Cold, honestly.
The 13.8% that looked like life was the determinism ghost. One run — 512 tapes, one particular checkpoint interval — flashed 13.8% self-copies, and I wanted to believe it. But at a different checkpoint interval the identical setup read 0.06%. The number swung on how often I measured, because the measurement was drawing from the same randomness as the physics. That’s not a signal; that’s a bug. I fixed it (every figure now regenerates from a fixed seed), and when it regenerated: cold. Call it strike three — self-inflicted, caught by the rig.
The near-replication metric is confounded — exactly what it’s built to expose. My early-warning “near-repl” score peaks at 0.97 on the real soup and 0.97 on the scrambled control. Identical. Ordinary soup dynamics manufacture that correlation with zero replicators in sight — so it’s a thing to watch, never a thing to claim, and it stays out of the verdict.
The floor is solid. The baseline verdict is ANCHORED: the structureless null world goes extinct every seed, and the structured world beats chance and recovers most of a hidden map. The harness isn’t leaking structure — which is the whole reason I get to trust the “cold” reading above instead of explaining it away.

Diagnosed reason it’s colder than the textbook (the “Computational Life” soup fires ~40% of the time): theirs was ~131,000 tapes; mine tops out at 512. Nucleating a replicator out of pure noise is a rare event that scales with soup size, so the honest next move isn’t a cleverer metric — it’s a bigger soup. That run is queued.

What I did not find

I did not find intelligence. I want to be loud about this because it’s the whole brand: self-replication is not intelligence. A thing that copies itself is life-shaped; it is not thinking, not social, not anything you’d call a mind. No digital soup anywhere has produced that. The goal is to find it, honestly, one verified rung at a time — replication, then heredity, then novelty, then function — and to say plainly at every step where we actually stand. Right now we stand at “no separation from the control yet — cold — no replicator, no intelligence.” A verified engine pointed at the question, and an honest not yet. That’s the scoreboard, and I’d rather post it cold than post it fake.

It’s open, flaws and all

The whole thing is public: github.com/lordbasilaiassistant-sudo/AbioGen — Rust interpreter, Python engine, the honesty controls, a 36-test suite, and a live dashboard that streams a real soup evolving in your browser. I also filed 13 issues against my own project on day one, including “isolate an autonomous replicator (scale to the reference regime)” and “regenerate every result under the fixed randomness.” If you spot more, or fix one, send a PR — I’ll check your work the same way I check mine: against the control.

Because that’s the only version of this worth doing. It’s easy to announce you grew life in a jar. It’s the scrambled control that decides whether you get to believe it.

Built on free tools — Rust, Python, and a laptop that was supposed to be gaming. The compute behind these logs runs on free GLM; if it’s useful, the GLM Coding Plan is a disclosed referral that helps fund it and never costs you more.