SOUP

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.

ByteWhat 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:

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

TermMeaning
Signs of lifeAt least 2 of the 128 census programs pass the self-replication test.
FadedAfter signs of life, three stirs in a row with an empty census, before the pond came alive.
AliveComplexity of at least 1.0. This is the paper's criterion for the transition (its Figure 6).
Died outAfter coming alive, complexity below 0.5. The pond is then barren again, and it can come alive again.
SpeciesA 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.

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

9. Limits

References

  1. 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.
  2. cubff, the paper's reference implementation. github.com/paradigms-of-intelligence/cubff, Apache-2.0.