How it works

Everything on this site rests on one substrate, one small language and a handful of numbers. This page defines them, so a visitor watching the viewer knows what a tape, an epoch and a compression ratio are.

The world

The world is a 2D torus of width × height cells. Every cell holds one tape of tape_len bytes, 64 by default, and tapes are the only state there is.

An epoch is one interaction per cell, cells visited in a random order. A cell picks a random neighbour within radius (a Moore neighbourhood, 1 by default); the two tapes are concatenated, A ++ B, 2×tape_len bytes; the concatenation is executed as a program for at most max_steps instructions (2¹³ by default); the result is split back into the two cells. Execution mutates the tapes in place: the program is the data.

There is no fitness function and no reproduction rule. Any copying that happens is done by the programs themselves. Energy is optional and off by default: set energy_per_epoch and every cell gets that many instructions to spend each epoch, an interaction halts once its two cells have spent theirs, and the budget refills at the start of the next epoch. After each epoch every byte is replaced by a uniformly random one with probability mutation_rate. The world is uniform by default, but it need not be: set structure to a gradient or a patchwork and that probability rises and falls with where a cell sits, so some cells mutate faster than others. Tapes are a fixed length by default, but they need not be: set max_tape_len above the length a tape starts at and a head that steps off the end of an interaction claims a fresh byte instead of wrapping, so a tape lengthens through the programs' own copying. A run is fully determined by its parameters and its seed. The substrate is the "BFF" soup of Agüera y Arcas et al., "Computational Life" (2024), made spatial so that it looks and behaves like a cellular automaton.

The instruction set

Ten byte values are instructions; every other byte is a no-op. Both heads start at 0, the instruction pointer starts at 0, and execution stops at the end of the tape, at max_steps, or on an unmatched bracket. The heads wrap modulo the current length of the concatenation. An eleventh byte, $, is an instruction only for a run that switched it on: it steals energy from the partner cell rather than moving a byte, and is a no-op like any other byte in every run that has not.

Byte	Meaning
<	move head0 −1
>	move head0 +1
{	move head1 −1
}	move head1 +1
+	increment the byte at head0
-	decrement the byte at head0
.	copy the byte at head0 → head1
,	copy the byte at head1 → head0
[	jump forward past the matching ] if the byte at head0 is 0
]	jump back to the matching [ if the byte at head0 is non-zero
$	take steal_amount of energy from the partner cell, less the steal_loss share destroyed in transit — a no-op unless the run set steal_amount

What we measure

Every sample_every epochs a run records these observables. The engine computes all of them: nothing on this site re-derives a metric.

compress_ratio: zlib(all tapes).len / raw.len. A random soup sits near 1.0; a soup of replicators collapses well below 0.5. This is the headline signal.
distinct_tapes: How many distinct tape values the world holds.
top_share: The fraction of cells holding the single most common tape.
op_density: The fraction of bytes that are one of the ten instructions — about 10/256 in a random soup.
replicator_count: How many cells pass the replicator test below, on the first of its draws.
replicator_pass_rate: The share of the census's eight independent draws in which some tape passed the test: one draw is a coin toss on a tape at the edge of it.
replicator_count_mean: The mean of what those eight draws counted.
replicator_share: The share of 256 cells, drawn at random, whose tape reproduces itself in either orientation: it runs five generations down a chain against fresh noise, and the copy four generations on must agree with the original on three quarters of its bytes, by majority over five chains. The census above asks for a same-orientation copy of one of the sixteen commonest tapes, and the replicators that dominate every emerged world copy themselves in reverse, so the census reads them as nothing. This reading exists beside it rather than replacing it. replicator_share_rotated also accepts a copy that lands a few bytes round, and dominant_self_replicates says whether the dominant tape passes. Null on the Life substrate and on every sample recorded before they existed.
entropy_bits: The Shannon entropy of the byte distribution.
alphabet_size: How many of the 256 byte values the world still holds. With no mutation only + and - can mint a byte value, so an alphabet can only shrink — and a world down to a couple of letters reads compressible without replicating anything.
copy_rate: The share of the sampled epoch's interactions that ended with one tape copied byte-exactly over the other half, among the pairs whose halves started out different. It catches replication in situ, including replicators that only copy with a particular partner.
reverse_copy_rate: The same count with the copy reversed: one half ends holding the other's tape last byte first. A palindrome's copy counts in both rates.
distinct_lineages: How many lineages the world holds. Every cell starts its own; after an interaction a cell takes its partner's lineage when the tape it ends with differs in fewer bytes from the tape its partner arrived with than from the tape it arrived with itself, and keeps its own on a tie. It counts descent rather than shape, so two lineages that drifted onto the same tape still read as two. By default those distances are read byte for byte; a run with lineage_rule set to oriented reads each arriving tape whichever way round is nearer, so a cell overwritten by a reverse copy joins the copier's lineage.
top_lineage_share: The fraction of cells held by the largest lineage.
lineage_effective_count: How many lineages the world is really split between: one over the sum of the squared lineage shares, the inverse Simpson index. It reads 1 when one lineage holds every cell and k when k lineages hold equal shares. A fresh soup reads about as many lineages as it has cells, and the count falls as copies spread. Cells that nothing ever overwrote each keep a lineage of their own, and distinct_lineages counts every one of them. They barely move this reading, so it can tell a world of several colonies from one colony with relics left over. Null on every sample recorded before it existed.
lineages_over_one_percent: How many lineages each hold at least one percent of the cells.
lineage_variation: Whether a colony is a clone or a drifting population, in bytes per cell. For each of the eight largest lineages that hold more than one cell, the tape most of its cells hold is its modal tape; the reading is the mean number of bytes by which a cell differs from the modal tape of its own lineage, pooled over the cells of those lineages. Lineages of a single cell are left out — a cell is a clone of itself, and the crowd of them a young soup carries would read as no variation at all. It reads 0 for a lineage of identical tapes and climbs as mutation spreads one over neighbouring tapes.
lineage_variation_oriented: The same reading after each cell's tape is put the way round — as it is, or last byte first — that sits closer to its lineage's modal tape, keeping it as it is on a tie. The replicators of every emerged world copy themselves in reverse, so a lineage of near-clones is half one tape and half its reverse, and the aligned reading counts every reversed cell as most of a tape of variation. A tape that grew is reversed over the bytes it holds, not its whole slot. Under the default lineage_rule, lineages themselves are inherited aligned, so after a takeover one lineage can hold many unrelated tapes, and neither reading can see past that. Null on every sample recorded before it existed.
copy_cost: What one copy costs the dominant replicator, in interpreter steps. The replicator test already runs four trials per tested tape; this is the median of the trials that copied, read off the most populous tape that passes the test. Null when no tested tape replicates. It is the observable a world that got better at copying itself would move: the hand-written replicator the engine tests itself against needs 1 794 steps.
copy_latency: How soon the dominant tape has written itself, in interpreter steps: the step at which the partner half first holds a byte-exact copy of the tape, in either orientation, whatever the program goes on to do. copy_cost counts the steps of a copy that halted, and the reverse copiers that dominate every emerged world never halt — their loop runs out the step budget — so it reads nothing there. This is the median of five trials against fresh random partners, null when fewer than half of them complete a copy. copy_latency_orientation says which way round that copy lies: forward, reverse, or both for a palindrome. The hand-written replicator reads 1 790 steps, forward; a 64-byte reverse copier that copies a byte every four steps reads 255, reverse. Null on the Life substrate and on every sample recorded before they existed.
dominant_compressed_len: How much tape the dominant tape is, in bytes, once zlib has squeezed it — the same compressor the compression ratio uses, so a tape and the world it sits in are read on one scale. Beside it dominant_instruction_count counts how many of that tape's bytes the run's instruction set executes. They are the baseline for open-endedness: a world whose dominant tape keeps getting more complicated after emergence carries more instructions, one that found a recipe and stopped reads a flat count. The compressed length is read against the tape's own length and never alone — zlib wraps an incompressible tape in 11 bytes, so a tape of junk reads its cap plus 11 whatever the cap is. The hand-written replicator reads 36 bytes and 15 instructions. The tape read is the most populous one that passes the replicator test, and the most populous tape of the world when none does — after a crossing the copy rate confirmed, the tape most cells hold is the thing that is copying. Null only on the Life substrate, which has no tapes.
dominant_raw_len: The same tape's own length in bytes, before zlib. It is what makes the compressed reading readable: compressed over raw near 1 is an incompressible tape — junk — and well under 1 is a tape with structure in it. Beside it dominant_tape_hash is a digest of those very bytes (FNV-1a 64, sixteen hex digits), an identity rather than a magnitude: two consecutive samples with different hashes are two different dominant tapes. Null on the Life substrate, and on every sample recorded before they existed.
dominant_replicates: Whether the tape those two readings describe passed the replicator test. True and they are the complexity of a confirmed copier, the very tape copy_cost is priced on; false and they are the complexity of the tape the most cells hold, whatever it does.
conserved_core_bytes: How many byte positions the largest lineage holds invariant across its members: the positions at least nine of every ten of them give one and the same value, read off the largest lineage that holds more than one cell. Beside it conserved_core_ops counts how many of those positions hold a byte the run's instruction set executes. lineage_variation says how far a lineage has spread; these say whether a working core survived the spreading — a conserved copy loop with junk around it reads a small core of instructions inside a wide cloud, and turnover at a flat tape size reads none at all. A member too short to reach a position holds nothing there and agrees with nobody. A lineage of identical tapes reads its whole tape length. Null where no lineage holds two cells, on the Life substrate, and on every sample recorded before they existed.
conserved_core_bytes_oriented: The same core, read after each member of the lineage is put the way round that sits closer to its modal tape, as lineage_variation_oriented puts them; conserved_core_ops_oriented counts its instructions. A lineage of a tape and its reverse agrees on almost no position aligned, and on its whole length oriented.
lineage_compressed_len: The same two readings as dominant_compressed_len, taken of a tape chosen by descent rather than by population: the modal tape of the largest lineage, with lineage_instruction_count beside it. The dominant tape is whichever tape most cells hold at that sample, and it rotates — so a lineage that keeps getting more complicated while its modal tape turns over reads flat through the dominant series and moves through this one. Null where no lineage holds two cells, on the Life substrate, and on every sample recorded before they existed.
steal_rate: The share of the sampled epoch's interactions in which a steal executed. The steal op is off by default: set steal_amount on a world whose cells hold an energy stock and the byte $ becomes an instruction that takes that much energy out of the partner cell's stock, destroying the steal_loss share of it on the way. The rate reads 0 wherever the op is off, so an arm where theft never evolved can be told from one where it was never possible.
task_share_echo: The share of 256 cells, drawn at random, whose tape the task assay credits with ECHO: run alone on three small input pairs, it emits the first input in every one of them. task_share_inc, task_share_dec, task_share_add, task_share_sub, task_share_not, task_share_double and task_share_mul are the same share for the rest of the arithmetic ladder. The readings only read: a run with tasks on and no reward is the run with tasks off, byte for byte, and carries them too. Null wherever tasks are off, on the Life substrate, and on every sample recorded before they existed.
task_capability: How many tasks at least a tenth of those sampled cells solve, 26 of 256 or more. task_capability_loop counts the same over ADD, SUB, NOT, DOUBLE and MUL, the tasks whose shortest program needs a loop.
dominant_tasks: The tasks the dominant tape solves, as a bitmask in ladder order — ECHO is 1, INC 2, DEC 4, and so on to MUL at 128 — which a run's page names rather than prints. dominant_task_count is how many there are.
logic_share_echo: The share of 256 cells, drawn at random, whose tape the logic assay credits with ECHO: run alone on three pairs of whole bytes, it emits one of the inputs in every one of them. logic_share_not, logic_share_nand, logic_share_and, logic_share_orn, logic_share_or, logic_share_andn, logic_share_nor, logic_share_xor and logic_share_equ are the same share for the rest of the logic ladder. The prefix keeps them apart from the arithmetic readings: bitwise NOT of a byte is the arithmetic NOT. They only read, on draws of their own, and are null unless the run's tasks are logic, logic3 or logic4 — with tasks off or arithmetic, on the Life substrate, and on every sample recorded before they existed.
logic_capability: How many logic rungs at least a tenth of those sampled cells solve, 26 of 256 or more. logic_capability_deep counts the same over XOR and EQU, the deep rungs: each needs four or five NANDs and a stored intermediate.
dominant_logic_tasks: The logic rungs the dominant tape solves, as a bitmask in ladder order — ECHO is 1, NOT 2, NAND 4, and so on to EQU at 512 — which a run's page names rather than prints. dominant_logic_task_count is how many there are.
meta_inherit_rate: A run may give every cell a second tape, its metabolism tape, that the soup never runs and the logic assay reads instead of the cell's own tape. The world, not the program, copies it: when an interaction leaves the partner's tape a near copy of the initiator's, the initiator's metabolism tape is copied onto the partner's. This is the share of the interactions just before the sample that passed one on, and empty where no cell could afford to interact then. A near copy is a looser test than copy_rate's, so this can read far above it. On such a run the logic readings above read the metabolism tapes, and the dominant tape they name is the most common metabolism tape. Null on every run without one.
meta_diversity: How many distinct metabolism tapes the world's cells hold, the metabolism tape's distinct_tapes. Null on a run without them.
logic_capability_replicating: logic_capability read on the cells' own, replicating tapes, on draws of its own, where the run pays the metabolism tapes instead: whether the copier still computes anything. Null on a run without metabolism tapes.
logic_depth_max: Under the topless ladders, logic3 and logic4, the logic assay gets a third input and a fourth, each one byte further left, and every function of them a tape computes is a rung, worth the fewest NAND gates that build it. This is that count for the deepest rung at least a tenth of 256 sampled cells solve, and −1 where none is held. 13 is a floor: a few hundred four-input functions are only known to need 13 or more. On those runs the logic readings above read the two-input rungs, AND of any two inputs counting as AND. Null on every other run.
logic_depth_classes: How many topless rungs at least a tenth of those sampled cells solve, a rung being a function up to a reordering of its inputs. Null on every run that is not on a topless ladder.
predation_rate: Under predation, the share of the last epoch's encounters, a cell meeting a partner, that moved energy from the partner to the cell. Null on every run without predation, and on a run's first sample after a resume.
predation_relation_rate: Under predation, the share of the same encounters whose relation held (under shadow, whose coin came up), whether or not the partner had energy to give: the rate predation_shadow_p is set against. Null exactly where predation_rate is.
repertoire_mean: Under predation, how many distinct rungs a cell's metabolism tape computes, a rung being a function up to a reordering of its inputs, averaged over 256 sampled cells and read over every output the run's assay allows. Null on every run without predation.
silent_share: Under predation, the share of those sampled cells whose metabolism tape computes no rung at all: the cells every neighbour may eat. Null on every run without predation.
meta_len_mean: On a run whose metabolism tapes can grow (meta_max_len above meta_len), the mean length of those tapes over every cell, in bytes. Null on every run whose tapes keep one length.
genes_essential_held: Under meta_genes, the most essential genes at least a tenth of 256 sampled cells hold. A cell's genes are grouped by the rungs they compute, copies computing the same set being one group, and a group is essential when it computes a rung no other group of the tape computes: a duplicate counts once, and a gene whose rungs the others already compute counts nothing. Null on every run read without genes.
fidelity_p10
fidelity_p50
fidelity_p90: Under meta_fid_max, the 10th, 50th and 90th percentiles of the fidelity levels of 256 sampled cells. Level 0 is the base machine; each level above it halves the metabolism tape's error rate every two steps. Null on every run whose tapes carry no level.
transition_epoch: Recorded once per run: the first sampled epoch at which compress_ratio drops below 0.6 and stays below it for the next 3 samples, counting only samples whose alphabet is alive — op_density at most 0.9 and alphabet_size at least 16. Null until it happens. It is the primary dependent variable of every sweep. A flagged run is the signal we sweep on, not a proof of self-replication: the replicator census can still read zero, and the findings say where the two disagree.

The replicator test: a tape T is a replicator if executing T ++ R for a fresh random tape R yields T in the second half in at least 3 of 4 trials. It runs on the top_k most common tapes of each sample, 16 by default, and replicator_count counts the cells holding a tape that passed.

Words this site uses precisely

transition: The detector's event: compress_ratio under 0.6, held for 3 samples. It is a property of the compression series, nothing more.
flagged: Said of a run whose transition the detector recorded.
replicator: A tape that passes the T ++ R test above.
census: replicator_count: how many cells hold a passing tape at one sample.
emergence: A transition and a non-zero census in the same run. That is this site's reading, stated here because the design of the instrument does not define the word.
task: One rung of the arithmetic ladder a soup may be assayed on — ECHO, INC, DEC, ADD, SUB, NOT, DOUBLE, MUL. A tape solves one when some output it emits with the ! byte holds the answer on every input pair of the assay. Under logic tasks the ladder is ECHO, NOT, NAND, AND, ORN, OR, ANDN, NOR, XOR, EQU instead, on whole bytes, with ~ writing a NAND. Under logic3 and logic4 every function of three or four such inputs is a rung, worth its NAND count.
imports an objective: Said of Metabolism, the one place this programme pays for anything but being copied: a cell earns energy for computing the arithmetic tasks above. It runs on the same engine, but the record treats it as a second substrate. Its runs are never pooled with the fitness-free ones in any count on this site, its findings carry this badge, and whatever it reads, rung 4 on Soup stays "not shown". See DESIGN §1.4.
predation: A rule under which a cell takes energy from a neighbour whose every computed rung it computes too, so a cell that computes nothing is anyone's food and a cell computing the same as its neighbour is food for it as well. It names no function and pays for none: it imports a machine to compute with, not an objective. Its runs are unpaid, and whatever they read, rung 4 on Soup stays "not shown". Under count a cell takes from a neighbour that computes strictly fewer rungs than it does, whichever they are, so a tie, kin or stranger, is no food.
gene: Under meta_genes, a fixed-length piece of a metabolism tape that the assay runs alone, on a buffer of its own, so no piece can read or undo another's result; the tape computes every rung any of its genes computes. The gene length, the independence and the union are a machine the engine imposes, not anything the organisms evolved, and they name no function: they import a machine, not an objective.
fidelity: Under meta_fid_max, a heritable level each cell's metabolism tape carries, from 0, the base machine, up to that top: each level divides the tape's error rate by √2. It is inherited with the tape and moves one step up or down now and then. Under meta_fid_alpha it has a price: a copy attempt costs max_steps × 2^α·f/2, so each halving of the error rate costs the same share of a copy wherever a lineage sits. The base machine is the cheapest level, so no lineage can buy sloppiness below it. It reads no tape and names no function: it imports a machine, not an objective.
imports a machine, not an objective: Said of the runs under predation, and of those whose metabolism tape carries a heritable fidelity level that costs energy to hold. Nothing pays a cell for computing any one thing, so no objective is imported, but the world they run in was handed what they compute with: the NAND byte and the way it stacks its results, the metabolism tape the world copies on with each cell, the output byte and how many outputs a tape may emit, the input bytes, and the predation rule itself, or the fidelity menu and its price. A cell's energy moves by what its tape computes or by the level it inherits, so these runs are not plain Soup either: they are never pooled with the fitness-free ones in any count on this site, their findings carry this badge, and whatever they read, rung 4 on Soup stays "not shown". The unpaid arm without predation or a priced fidelity is plain Soup with a tape nothing reads, and is pooled.
arm: One grid value of a sweep, with its seeds.
lineage: The cells whose tapes descend from one starting cell's, as the lineage rule reads descent: aligned by default, which compares tapes byte for byte, or oriented, which also reads a tape copied in reverse as descended from the tape it copies.

The programme

Each sweep varies one property of the substrate and asks how the time to emergence responds. They run in this order in the experiments.

Mutation rate — Is there a mutation rate window for abiogenesis? Zero mutation should delay emergence and too much should destroy it (error threshold).
World size — Does time to emergence scale with cell count (more lottery tickets) or is emergence a per-cell rate?
Neighbourhood radius — Does spatial locality speed emergence and stabilise diversity afterwards?
Max steps per interaction — How much computation does one interaction need before replicators can appear? Too small a budget cannot finish a copy.
Instruction set ablations — Which of the ten BFF instructions is abiogenesis actually made of? Each arm removes one family of ops and keeps everything else fixed.
Instruction cost — Does paying for computation select for efficient copiers? Every instruction a cell executes draws down an energy budget that refills each epoch, so an interaction halts once its cells have spent theirs and a copier that needs fewer steps finishes more often.
Environmental structure — Does a world that varies from place to place raise the complexity plateau the dominant replicator settles at? A structured world runs its mutation rate high in some cells and low in others, so a strategy that pays off in one place need not pay off in the next. The secondary prediction: a heterogeneous world keeps more lineages alive after emergence than a uniform one.
Room to grow — Is the fixed tape length what makes complexity plateau? With a cap above the length a tape starts at, a head that steps off the end of an interaction claims a fresh byte instead of wrapping, so a tape lengthens through the programs' own copying and the 64-byte ceiling no longer bounds the dominant replicator by construction.
Host–parasite economy — Does complexity keep rising when energy is a contested stock? Every cell holds instruction energy that carries across epochs, so what one cell spends is gone until the influx pays it back; with the steal op on, a tape can take what a neighbour saved. That gives one tape something to gain from another's state beyond overwriting it and the other something to defend, which is the arms race the literature ties to rising structural complexity in fitness-free soups.
Asymmetric execution — Does complexity keep rising when only one partner's code runs? Under a host interaction the instruction pointer stays inside the first tape while both heads still range over the pair, so the second tape is pure read/write substrate and never runs a byte of its own. A tape's fate then depends on how the tapes that host it treat it as data, which is a pressure on what a tape looks like rather than only on what it does — the asymmetry host–parasite systems are built on.
From an emerged world — Does an existing replicator keep getting more complicated once a treatment is switched on, and does it hold at all? Each run starts from the last stored world of a host–parasite control that is at least half replicators, and carries on under its parent's own dynamics, the one priced economy that read keeps rising, a rich economy, or host mode.
Lineage diversity — After a transition, does a world stay polyphyletic, and do more lineages survive as a cell's reach shrinks? The radius sweep's diversity half, re-run at the emergent rate with lineages that follow descent through reverse copies, read on the effective number of lineages rather than a count of every tag a cell still holds.
Locality and emergence — Does emergence peak at an intermediate reach? The lineage-diversity sweep saw radius 4 emerge four times as often as radius 1 and five times as often as the well-mixed world. Its seven reaches, on fresh worlds, read on how often a world crosses at all.
Reach with room to grow — Does the reach effect carry to growable tapes? The locality-emergence sweep saw radius 4 emerge four times as often as radius 1 on fixed 64-byte tapes. The host–parasite control's world at cap 128, at radius 4: does it emerge more often than that control did at radius 1, and so give a pool of emerged worlds with room to grow?
Metabolism — Does complexity rise once computing pays? Each run starts from an emerged world under an economy where only the cell that initiates pays, and a cell earns energy by computing arithmetic on inputs the environment gives it. One arm is paid for its tasks and its twin is not, so the comparison isolates the reward. A second, labelled substrate: it imports an objective.
Logic — Does a soup assemble features beyond its one-step rungs when the parts are paid? Each run starts from an emerged world under the Metabolism economy, with one assay-only NAND byte and a ladder of nine logic tasks. One arm is paid for every rung, one for XOR and EQU alone, and one for nothing. A labelled substrate: it imports an objective and a primitive.
Meta-stack — Does a soup assemble XOR and EQU from paid parts once its computing runs off the copier? Each run starts from an emerged world under the Logic economy and ladder, with the assay reading a second, never-executed tape that the world hands on with each copy. One arm reads it with a NAND that keeps its operands, one pays that arm for XOR and EQU alone, and one keeps the in-place NAND. A labelled substrate: it imports an objective, a primitive, a hereditary channel and a choice of the primitive's semantics.
Topless rise — Does the deepest logic feature a soup holds keep getting deeper when depth is paid? Each run continues a Meta-stack world on a ladder of every function of four inputs, each paid by its minimal NAND count, for 100 000 epochs. One arm pays depth, one pays nothing deeper than five NANDs, and one pays nothing. A labelled substrate: it imports an objective, a primitive, a hereditary channel, the primitive's semantics and a ladder.
Out-compute — Does computing climb, and keep climbing, when nothing pays for it? Each run continues an emerged, never-paid world with a metabolism tape and the four-input logic machine, under a rule by which a cell takes energy from a neighbour whose every computed function it computes too. Three controls move the same energy with no ratchet, by a coin, or not at all. A labelled substrate: it imports a machine, not an objective.
Genes rise — Does held code keep rising late when nothing pays for it and the room to grow is not used up? Each run continues an emerged, never-paid world whose metabolism tape can grow, runs as independent genes and carries a priced, heritable fidelity, under a rule by which a cell takes energy from a neighbour computing fewer functions. Controls lower the cap, decide the same transfers by a coin, or move nothing. A labelled substrate: it imports a machine, not an objective.

None of them reads as a negative result on its own, which is what the control sweep ahead of them all is for — BFF positive control: Does the engine reproduce the published BFF emergence at all? A well-mixed soup of 2^17 tapes, the shape the original work used. No sweep is readable as a negative result until this one transitions.

A sweep that answers nothing can still be re-run at a longer budget, which is what Mutation rate, long runs does: Sweep 1 saw transitions only at 2^-13 and 2^-12 (one seed in ten each) within 20 000 epochs. Same world, rates around that window, three times longer: is emergence rare or just slow?

What each of them has found so far, and what is still open, is written up in the findings.