A world that programs itself
Compiling the world in your browser…
- Epoch
- 0
- Compression
- —
- Replicators
- —
- Distinct tapes
- —
- Copy rate
- —
- Steal rate
- —
substrate soup · width 96 · height 96 · tape_len 64 · max_tape_len 0 · radius 1 · max_steps 8192 · energy_per_epoch 0 · energy_influx 0 · energy_stock_cap 0 · energy_payer pair · steal_amount 0 · steal_loss 0.5 · tasks off · task_every 8 · task_reward 0 · task_floor echo · logic_nand in_place · task_depth_cap 0 · task_max_outputs 4 · predation off · predation_transfer 0 · predation_loss 0.5 · predation_every 8 · predation_shadow_p 0.3 · ops <>{}+-.,[] · mutation_rate 0.000244140625 · structure uniform · structure_amplitude 0.5 · interaction concat · lineage_rule aligned · meta_len 0 · meta_rate 0.00390625 · meta_draw uniform · meta_seed zeros · meta_max_len 0 · meta_min_len 8 · meta_dup 0.0 · meta_del 0.0 · meta_seg_max 16 · meta_genes 0 · meta_fid_max 0 · meta_fid_rate 0.0 · meta_fid_alpha 0.0 · init random · sample_every 10 · top_k 16 · snapshot_every 100
- Sweeps
- 22
- Runs finished
- 5,462
- Epochs simulated
- 154,691,331
- Seeds that transitioned
- 472
- Largest replicator census
- 4,000
Every cell above holds a tiny program — 64 random bytes. Each epoch, a cell meets one of its neighbours, the two tapes are glued together and the result is executed as code. The colour of a cell is a fingerprint of the bytes it holds, its brightness the share of those bytes that are instructions. Nothing here selects for anything: there is no fitness function, no reward, no reproduction rule. The programs are the only thing that can change the programs. How it works defines the world, the ten instructions a byte can be and every number this page shows.
Watch the colours. A random soup is confetti, every cell a different tape, and the compression ratio sits near 1.0. Sooner or later one program copies itself into its neighbour, that neighbour copies it on, and the confetti collapses into a few broad stretches of one colour — life, or at least the part of it that replicates. The compression ratio falls, the replicator count climbs and the number of distinct tapes drops. The same engine runs the sweeps that measure when this happens, in the experiments. What those sweeps have settled so far, seed by seed, is written up in the findings.
What the sweeps have found
-
Paid for depth, the soup jumps once and stands: no late rise on a ladder without a near top
DESIGN §1.3 sweep 18 asked whether the deepest logic feature a soup holds keeps getting deeper when depth is paid, on a ladder of every function of four inputs, each paid by its minimal NAND count. The 54 meta-stack worlds ran another 100 000 epochs under three rewards: depth paid, depth paid up to five NANDs, nothing paid. All 162 children finished, none died out and none reached the ladder's floor. The rung-4 question is not shown: one child of the paid arm rose late against none unpaid, 1 to 0 with 53 ties (p = 0.5). Against the capped arm it is refuted, 1 to 13: the arm that pays nothing past depth five crept up a rung more often. The re-readings agree. The one late rise is a re-climb to depth 10, where most paid children sat from early on, and offline its code grew by 2 bytes, barely above drift. The soup takes the jumps a reorganisation offers early, then stands. The substrate imports an objective, a primitive, a hereditary channel, the primitive's semantics and a ladder, so rung 4 on Soup stays not shown.
-
On growable tapes, a reach of 4 emerges more than ten times as often as radius 1
DESIGN §1.3 sweep 14 asked whether the best reach of the locality finding carries to the growable tapes every rung-4 experiment runs on: the host–parasite sweep's economy-off world at cap 128, tapes of 64 bytes free to grow to 128, at radius 4 on that control's seeds 1–270. All 270 runs finished and every world they kept was read. Radius 4 emerged in 119 of 270 worlds against the control's 11 of 270 at radius 1, 10.8 times the rate (one-sided Fisher p = 1.5e-30), so the pre-registered test is shown. On fixed 64-byte tapes sweep 13 had read radius 4 at four times radius 1. In both arms the dominant replicator fills the 128 bytes it may grow to. 108 of the emerged worlds at radius 4 end with replicators holding at least half the world, against 11 in the control: a pool of parents with room to grow, though no later sweep's rule is set by it.
-
With a stack NAND on a metabolism tape, paid parts assemble the logic rungs that need an input twice, in a sixth of the worlds
DESIGN §1.3 sweep 17 moved the Logic sweep's computing off the copier: a second, 32-byte tape the soup never runs, handed on with each copy and read by the assay with a NAND that keeps its operands. The 18 emerged worlds ran another 40 000 epochs, three seeds a parent, paired with the Logic sweep's children. All 162 children finished and none died out. 9 children of 54, from 7 parents, held XOR or EQU at a tenth of their world, against none in any other arm, so the rung-4 question is shown, 9 pairs to 0 with 45 ties (p = 0.00195). The stepping-stone test against the arm paid for XOR and EQU alone is shown too, 9 to 0: the deep rungs were assembled from paid parts, Lenski's mechanism in a soup. The same tape read by the NAND that writes in place built none. Without the four piloted parents the deep tests read 8 to 0 and rest on two parents. In 14 of 15 plantings a world the deep rung was wiped from re-grew it within 500 epochs: a property of the population more than of a lineage. The ladder tops out at EQU, and the substrate imports an objective, a primitive, a hereditary channel and the semantics that let the deep rungs come, so rung 4 on Soup stays not shown.