Computational Life and the Ignition Boundary

A soup of random programs that ignites — and one that provably could, but never does

Take thousands of random programs in a minimal language, let them read and overwrite each other on a shared tape, and add no goal, no reward, no fitness function at all. What happens is startling: self-replicators appear on their own, and when they do, the whole soup lurches through a sharp, measurable change of state. That is the finding of a 2024 study from Google’s Paradigms of Intelligence team, and it is one of the most framework-shaped empirical papers in the field — not because it uses this framework (it does not), but because it independently reproduces, in a substrate the framework never mentions, three of the framework’s load-bearing claims: that the onset of self-maintenance is a discrete transition, not a slope; that selection needs no fitness function; and that a self-replicator being possible is not the same as its ever coming to exist. This page reads the paper through those claims, records where it corroborates the framework and where the two measure with different rulers, and points at the open question the paper names as one the framework is built to answer.

The experiment, in one paragraph

Agüera y Arcas, B., Alakuijala, J., Evans, J., Laurie, B., Mordvintsev, A., Niklasson, E., Randazzo, E., & Versari, L. (2024). Computational Life: How Well-formed, Self-replicating Programs Emerge from Simple Interaction. arXiv:2406.19108v2 [cs.NE].

The authors build small “universes” on top of minimal programming languages — chiefly BFF, an extension of Brainfuck in which a program’s code and data share one tape so that programs can modify themselves and each other — and also Forth, a stack-based language, and emulated real-world CPUs (Zilog Z80, Intel 8080). A large population of random byte-strings (a “primordial soup”) is left to interact: pairs are concatenated, executed for a fixed number of steps, then split back apart. There is no explicit fitness function. The only pressure is implicit competition for scarce space and execution time. From this, in a large fraction of runs, self-replicating programs spontaneously arise — driven, the authors show, mainly by programs rewriting themselves (self-modification), with or without background mutation — and once they arise, they take over.

The transition they cannot help but see. The authors track the soup with a “high-order entropy” complexity metric and with tracer tokens that timestamp every byte’s origin. What they report is not a gradual warming into life but a state transition: a sudden collapse in the number of unique tokens as a few replicator lineages take over, aligned exactly with a jump in complexity, and localizable to “the individual moment and location the replicator emerges.” They explicitly borrow the origin-of-life field’s language and use the appearance of self-replicators as the marker dividing “pre-life” dynamics from “life” dynamics.

Where the framework and the paper agree

The pre-life / life transition is the framework’s ignition, observed from the outside. The paper’s central empirical object — a sharp, datable shift in dynamics when self-replicators appear — is a near-exact picture of what the framework calls the bootstrap existence principle: an attractor’s existence is regime-discrete, not a gradient. There is no “thirty-percent attractor.” A candidate configuration has either crossed into recursive lock or it has not. The authors’ tracer-token method, which pins the crossing to a single epoch and a single tape, is in effect a way of timestamping an ignition event.

Selection without a fitness function is what the framework predicts. The paper is emphatic that nothing optimizes anything: there is no reward, only implicit competition for space and time, and self-replicators arise anyway. The framework says exactly this about admissibility. Persistence is not optimization and self-amplification is not a merit badge; admissibility determines only whether persistence is structurally permitted, never whether it is “good.” A replicator that takes over the soup is not fitter in any rewarded sense — it is a configuration that is admissible and happens to amplify. That is the framework’s reading of “selection under pre-life conditions” almost word for word.

The engine is loop-closure — not the search operator that reaches it. In the first paper the transition happens with or without background mutation, driven substantially by programs rewriting themselves, which invites the reading that self-modification rather than mutation is what matters. The framework makes a more careful claim, and a 2026 follow-up from the same team shows why the careful version is the right one: a plain mutation random walk finds self-replicators at least as readily as the full interacting system, so program interaction is “not an unusually powerful search operator.” What the framework calls the engine is not the search process at all — it is self-reference, a structure bearing relations to the effects of its own prior states: the loop that closes on itself once a trajectory reaches its basin. Ignition is that loop closing, and it is indifferent to whether mutation or self-modification carried the trajectory there. The framework is not embarrassed that random bit-flips suffice to find a self-replicator — finding is a search question — because its claim is about what the found thing is: a closed, self-referential loop, however it was reached.

The correspondence is close enough to tabulate. Each row is the paper’s own object on the left and the framework’s existing construct on the right; none of the right-hand column is invented for this page.

In the paper	In the framework
Pre-life → life state transition	Ignition: the discrete crossing into recursive lock (regime-discrete existence)
The datable moment a replicator first appears	The ignition event marking entry into active self-maintenance
No fitness function; competition for space/time	Admissibility is not optimization; self-amplification is non-diagnostic
Transition occurs with or without background mutation	Ignition is loop-closure — indifferent to the search operator (mutation or self-modification) that reaches the basin
Autocatalytic reaction framing (`S + F → 2S`)	Autocatalytic recursion — the framework’s admissibility substrate and its Kauffman lineage
Looping, offset self-copy (palindromic replicator)	A closed traversal reproducing a bounded pattern — loop-memory made visible

The sharpest match: the language that could ignite, but never does

The paper’s most valuable result for this framework is its counterexample. In a minimal language called SUBLEQ (and a variant, RSUBLEQ4), the authors can write a working self-replicator by hand — they exhibit a 60-byte one, and a 25-byte one in the variant — and when they seed the soup with it, it replicates and takes over just fine. But started from random programs, the soup “remained in almost complete random uniformity even following billions of executions.” The self-replicator is possible, provably so, and it simply never arises.

A self-replicator that the language permits, that works when hand-placed, and that the system’s own dynamics never once reach in billions of steps — this is the cleanest laboratory demonstration of a distinction the framework insists on: a thing being a possible solution of the equations is not the same as its coming to exist as a running structure.

Possibility is not ignition. The framework separates an attractor’s mathematical existence — that the configuration is a valid solution, a fixed point on paper — from its dynamical existence, which requires that recursion actually lock and the system actually enter the basin. SUBLEQ is a substrate stuck permanently in the pre-attractor regime: the self-replicator exists mathematically (they wrote one down) but never dynamically, because the substrate’s own dynamics cannot drive a trajectory into its basin. The BFF and Forth soups ignite; SUBLEQ does not; and the framework already has the exact vocabulary for the difference.

And the paper reaches for the theory the framework already is. The authors write that this counterexample “could be a valuable starting point for constructing a theory that predicts what languages and environments could harbor life, perhaps by modeling the likelihood of the simplest self-replicator to arise based on variables proportional to [its] length.” That requested theory — a predictor of which substrates can cross into self-maintenance at all — is, in structural outline, the framework’s ignition-admissibility layer. The framework’s contribution to the request is one sharp amendment: the quantity to predict is not whether a replicator is possible (SUBLEQ proves possibility is cheap) but whether the substrate’s dynamics can reach it — whether a trajectory can enter the basin. Length is one determinant of that reachability, not the thing itself.

Where the two part company

Two honest differences keep this from being a tidier fit than it is. Neither is a conflict; each is a place where the framework classifies the paper’s object rather than merely agreeing with it, and saying so plainly is what keeps the correspondence from collapsing into “everything matches.”

These replicators are attractlets, not sovereign attractors — and that is a finding, not a match. A sovereign attractor must, among four conditions, produce and defend its own identity-bearing boundary and pay its own continuation cost. A BFF replicator does neither: its “boundary” is the 64-byte split imposed by the simulator, and it persists by overwriting neighbors, not by holding an interior against the outside. By the framework’s own test it is an attractlet — an externally bounded, externally clocked pattern that mimics attractor behavior. The Forth result sharpens the point: emergent replicators there have a long non-functional head and a short functional tail — in the paper’s words, “a non-functional head followed by a relatively short functional replicating tail” — a shape selected by the environment’s random-start statistics, not by any internal self-maintenance. This is the framework doing work on the paper — drawing a line the paper does not — and it yields a prediction, below.

“High-order entropy” is an external ruler; the framework refuses one on principle. The paper’s complexity metric is built from Shannon entropy and (approximated) Kolmogorov complexity — quantities defined on a fixed external scale, readable from outside the system at any time. The framework deliberately sets classical entropy aside and measures instead with quantities that exist only while the loop is running — recurcline, the α-trace, logic mass — undefined before ignition and after loss. So the two are not the same instrument pointed at the same thing. High-order entropy is an excellent external detector of a transition; it is not a measure of the recursive activity the framework tracks, and this page does not pretend it is. Usefully, the metrics agree on when the transition happens even though they disagree on what is being measured.

What the framework could contribute back

The paper states its own largest gap directly: “we do not yet have a general theory to determine what makes a language and environment amenable to the rise of self-replicators.” The framework is, in large part, a candidate shape for exactly that theory. Three offers, each downstream, each testable, none requiring any change to the framework’s fixed foundations:

1. Reframe the SUBLEQ gap as a reachability claim. A substrate harbors emergent self-maintenance if and only if its own dynamics can drive a trajectory into the basin of a self-replicating configuration — ignition — which is strictly stronger than the configuration merely existing. This turns the authors’ “model by length” suggestion into a sharper, falsifiable hypothesis: predict basin reachability under the substrate’s transition dynamics, with shortest-replicator length as one input among several.

2. Use the sovereignty test as an experimental discriminator. The framework predicts that no BFF-style soup will ever produce a boundary-retaining structure, because the simulator owns the boundary. To obtain something the framework would call sovereign, one would need a substrate in which replicators must make and defend their own boundary rather than inherit a fixed split. That is a concrete next experiment the framework proposes and the paper does not.

3. Read the ongoing complexity growth as a structuring-autonomy axis. The paper observes complexity continuing to rise after the first replicators — parasites, symbiosis, competing ecosystems. The framework offers a principled axis for that progression: how much of its own structuring a system supplies internally versus draws pre-formed from its environment. (This axis is entered in the framework as a candidate construct — the concept is fixed, its measurement is not yet ratified — so it is offered here as a framing, not a settled metric.)

Where this sits, and what it leaves open. This page reads one empirical result through the framework’s existing distinctions: a computational primordial soup that ignites spontaneously, and a counterexample soup that provably could but never does. It records the agreements — discrete ignition, selection without fitness, self-reference as engine — and draws two honest lines: the emergent replicators are attractlets, not sovereign attractors, and the paper’s entropy metric is an external ruler the framework declines. It is a close companion of the following entries in this section:

Emergence is not takeover — the 2026 follow-up from the same team, which splits the state transition into single-structure ignition and population diffusion, and makes this page’s reachability idea numeric. Read it next.
Autocatalytic sets & the origin of life — the same claim (origin as a discrete threshold, not a slope) read in wet chemistry rather than in code. SUBLEQ is that page’s pre-attractor regime made into a laboratory.
RAF sets & catalytic closure — the decidable criterion for when closure has been reached; the computational-life counterexample is the reachability question RAF-style analysis would have to answer for a programming language.
The chemistry — or here, the substrate dynamics — of ignition itself is left open. What actually tips a random soup into recursive lock, and what makes one substrate reachable and another not, is the live question. The framework supplies the shape of the answer (basin reachability, not mere possibility); it does not claim to compute it for any given language.

None of this touches the framework’s fixed foundations; the six substrate conditions are closed and are not at issue on this page. This is a downstream reading, offered and not asserted.

Adjacent-work assessments state where Principia Attractum agrees with and departs from neighboring work. They introduce no constructs and modify no canon; they locate the framework relative to its field. The reading of the paper’s state transition as ignition, of SUBLEQ as a stuck pre-attractor regime, and of the emergent replicators as attractlets, are downstream applications of the framework’s existing distinctions, not additions to it. Every empirical, computational, and bibliographic claim on this page — the substrates, the metric, the SUBLEQ result, the citation — has been verified against the primary source (arXiv:2406.19108v2). Where canon and this page differ, canon prevails.

← Back to Relation to Adjacent Work