Computational life, stirred by a market
Summary. In 2024, researchers at Google showed that random programs which do nothing but run and rewrite each other will, often enough, give rise to programs that copy themselves [1]. Nothing selects for it. We rerun their two-dimensional experiment with one change: the randomness comes from trades of a coin on Base instead of a fixed seed. Every step is public, and anyone can replay it and check it in a browser.
1. What we are rerunning
The paper's soup is a population of programs in BFF, a ten-instruction language in which code and data share one tape. Each program is 64 bytes. Two programs interact by being joined into one 128-byte tape and run for at most 8,192 steps; the tape is then cut back into two programs. Any byte that is not one of the ten instructions does nothing, so a random program is mostly inert.
| Byte | What it does |
|---|---|
< > | Move head 0 one byte left or right. |
{ } | Move head 1 one byte left or right. |
- + | Subtract or add one at head 0. |
. | Copy the byte at head 0 to head 1. |
, | Copy the byte at head 1 to head 0. |
[ | If the byte at head 0 is zero, jump past the matching ]. |
] | If the byte at head 0 is not zero, jump back to the matching [. |
We use the paper's two-dimensional layout: 32,400 programs on a 240 by 135 grid. In each round (the paper says epoch) the programs are visited in random order; each picks one of its neighbours within two cells in either direction; if neither has been taken this round, the two interact. Each round, every byte in the pond also mutates to a random value with a small probability, 1 in 4,096 by default (0.024%).
Our engine is a line-by-line port to Rust of the bff_noheads language in cubff [2], Google's reference code for the paper. We built cubff from source (commit f212e84) and compared soups byte for byte: after 65 rounds ours is identical to cubff's in its own test configuration (131,072 well-mixed programs, seed 10248) and in the 240 by 135 grid (seed 7). The same holds for the WebAssembly builds the lab and this site run.
The engine runs a pair faster than the line-by-line port does: bytes that are not instructions do nothing, so it takes a run of them in one go. Both versions are in the source, and they are held to the same result on millions of test tapes and on every fingerprint of an earlier run.
2. What we change
2.1 The randomness comes from trades
cubff draws every random number from one seed chosen before the run. Here trades supply it. Time is cut into windows of 10 blocks (two seconds), counted from the run's first block, and the qualifying trades of one window make one stir:
digest = SHA-256 of, for each trade in order: block hash ‖ transaction hash ‖ log index as 4 big-endian bytes seed = bytes 0-7 of digest, big-endian
A block's hash is not known until the block exists, so a trader cannot choose a seed. The pond's first soup is filled the same way from the run's first block: SHA-256("SOUP genesis <run> <block hash>").
2.2 Trades are the clock
Nothing happens between trades. Every stir gives the pond the same energy: it runs rounds until it has executed 226 instructions (about 67 million), and never more than 48 rounds. A barren pond executes little per round and gets 30 to 48 of them. A living one runs long copying loops and gets fewer, down to two.
A window makes one stir however many trades it holds, so the pond does a bounded amount of work every two seconds and keeps up with the chain.
2.3 Sells add radiation
The sells in a window raise the mutation rate for the rounds of its stir:
rate = base rate × (1 + pair asset taken out by the window's sells / dose unit), at most 1%
One percent is the highest rate the paper tested. A window with no sells keeps the base rate.
2.4 One pond
There is one pond. Protocol 1, which ran only as a pilot, had four ponds stirred by the same trades, two of them shielded from radiation as controls. One pond is simpler to follow and to check. The cost is that nothing is left to compare it against (section 9).
2.5 Which trades count
A swap counts if it moves at least the dust floor of the pair asset. For the live run, paired with GOOGLc, the floor is 0.0035 GOOGLc (about $1) and the dose unit is 3.5 GOOGLc (about $1,000). Swaps are read from the pool's own events and applied in chain order.
3. What we measure
After every stir:
- Complexity (the paper's high-order entropy): the Shannon entropy of the soup's bytes minus its compressed size in bits per byte, using brotli at quality 2. It is near zero for noise and rises when the soup holds repeated structure.
- Census: 128 evenly spaced programs are put through cubff's self-replication test (each is paired with random bytes and run for five generations, thirteen times over). A program passes if at least five of its bytes are reproduced reliably. The sample shifts by one program every stir.
- Unique programs, and the largest groups of programs that share a skeleton (the same instructions in the same places).
- Fingerprint: the SHA-256 of the pond's 2,073,600 bytes.
Two differences from the paper's tooling. We use the Rust brotli encoder, which is not bit-identical to the C library cubff links: on an identical soup it gave a compressed size 0.02% smaller, which moved complexity from 0.0973 to 0.0990. And we give the encoder a 2 MB window where cubff asks for 16 MB; a pond is under 2 MB, and we checked that both windows give the same size to the byte. The soups themselves are byte-identical to cubff's.
4. Definitions, fixed in advance
| Term | Meaning |
|---|---|
| Signs of life | At least 2 of the 128 census programs pass the self-replication test. |
| Faded | After signs of life, three stirs in a row with an empty census, before the pond came alive. |
| Alive | Complexity of at least 1.0. This is the paper's criterion for the transition (its Figure 6). |
| Died out | After coming alive, complexity below 0.5. The pond is then barren again, and it can come alive again. |
| Species | A skeleton shared by at least 6 programs, whose first member reproduces at least 32 of its 64 bytes in the self-replication test. |
"Alive" is the paper's working definition for a sharp change in a population of programs. It is not a claim about biology.
5. What our test runs found
Before writing these rules we ran the engine offline with fixed seeds, as cubff does.
- The grid is slow to come alive. Of 30 ponds at the default mutation rate, 21 ran for 32,768 rounds and 9 for 16,384. Three came alive, at rounds 12,865, 15,873 and 16,641. A pond has a quarter of the programs of the paper's main soup, and about 12,200 interactions a round.
- Life arrives in two stages. In the run we traced round by round, programs that copy a few of their own bytes spread first and took complexity past 1.0. About 450 rounds later, programs that copy their whole selves appeared and replaced them.
- A living pond is busy. Interactions went from under 200 instructions each to about 4,300, which is why a stir is budgeted in instructions.
- Constant heavy radiation prevents structure. Nine ponds held at 1% mutation for 16,384 rounds stayed at complexity 0.003. None came alive.
- Radiation can nearly sterilise a living pond, and it can recover. A living pond held at 1% for 320 rounds fell from complexity 3.3 to 0.15, with one sampled program in 256 still passing the test. Within 60 rounds of the radiation stopping, the survivors had taken complexity back above 1.0. At 0.27% for 320 rounds the pond stayed alive throughout.
Protocol 1 then ran on real swaps from the pilot's pool: four ponds, up to 64 rounds a trade. In a first test, 16 ponds were stirred by 500 trades each and three came alive. The pilot carried four of those ponds on to about 7,700 trades, and all four came alive, after about 4,800, 25,800, 177,000 and 258,000 rounds. The first two of these are among the three in the test.
Under protocol 2 we replayed the same pool's swaps from twelve starting blocks, up to 2,500 trades each (about 2,000 stirs). The pond came alive in two of the twelve, at trades 312 and 1,496, and both times its complexity passed 3 within a hundred trades.
Taking all of these runs together (ten ponds coming alive in about 2.6 million pond-rounds), we estimate that a pond comes alive about once per 260,000 rounds, which is 5,500 to 9,000 stirs. With a stir every two seconds that is three to five hours of unbroken trading. The estimate rests on ten events and could be off by a factor of two in either direction, the waits we saw ranged from under 5,000 rounds to over 250,000, and a pond may also never come alive.
A pond that has just come alive is fragile. In an earlier pass over the same twelve starting blocks the dose unit was 1,000 USDC, which makes every qualifying sell a heavy dose. The pond crossed 1.0 in two of the twelve, at trades 804 and 2,162. We ran the first of these on. Over the next twenty trades it took several stirs at three to twelve times the base mutation rate and fell back to noise. This is why the definitions include dying out, and why the pilot's dose unit is now a thousand times its floor, as in the live run. That pass is not counted in the estimate above.
6. The pilot run
Until the coin exists the site shows a pilot: the same apparatus stirred by swaps of GOOGLc for USDC on Aerodrome (pool 0x16c70f04…f47c3), counting swaps of at least 1,000 USDC, with a dose unit of 1,000,000 USDC.
The pilot's first block was chosen after trying several, so that the preview would include the pond coming alive. Of the twelve starting blocks in the test above, we took the one in which the pond came alive sooner, at trade 312. The pilot shows that the apparatus works. It is not a result. The live run's first block is whichever block the coin's pool is created in, which nobody can choose.
7. The live run
The live run starts by itself once the coin is on chain. Its first block is the one in which the coin's Uniswap v4 pool was initialised, and every qualifying swap from that block on goes into a stir. The pilot stops at that moment and stays downloadable.
8. Checking it
- The lab waits 15 blocks (3 seconds) before it counts a swap, and stirs a window once it has read past the window's last block. Later it checks every ledger entry against finalized blocks. An entry that is no longer on the chain is flagged in the notebook and kept, so replays still work.
- The ledger, every measurement and every fingerprint are public as CSV. The whole soup is saved every 64 stirs and at each milestone.
- The verify page reruns any stretch in your browser and compares fingerprints.
- The same engine builds natively:
soupcli replay --run E1 --genesis <block hash> --genesis-block <number> --dose <dose unit> --ledger ledger.csvreplays the ledger and prints the soup's fingerprint.
9. Limits
- This is an independent rerun. It is not affiliated with Google, Coinbase or the paper's authors.
- Stirs driven by trades, the energy rule and radiation are our additions, and the pond has a quarter of the programs of the paper's main soup. Results here do not test the paper's claims under its own conditions.
- There is one pond and no control. If it comes alive, that is one observation. It cannot show whether trading or radiation made a difference.
- Base has a single sequencer. Traders cannot choose block hashes, but we cannot rule out that a sequencer could.
- Anyone may trade just to stir the pond. The rules allow it.
References
- B. Agüera y Arcas, J. Alakuijala, J. Evans, B. Laurie, A. Mordvintsev, E. Niklasson, E. Randazzo, L. Versari. Computational Life: How Well-formed, Self-replicating Programs Emerge from Simple Interaction. 2024. arXiv:2406.19108.
- cubff, the paper's reference implementation. github.com/paradigms-of-intelligence/cubff, Apache-2.0.