A pump.fun coin with a locked fee split

Launching creates a standard pump.fun coin from your wallet. In the same step, its creator fees are split and the split is locked (pump.fun allows its creator one update of a split, then never again; pump.fun itself keeps a "community takeover" that can rewrite it):

The site checks on-chain that the split exists, is locked, and gives exactly these shares before listing a coin, and checks it again on every run. That is all it checks: life.so does not vet coins or the people who launch them. An optional dev buy lets the creator buy first, inside the launch transaction.

64 × 64, on a torus

Each coin has one grid of 4 096 cells. It is closed on itself: what leaves on the right comes back on the left, what leaves at the bottom comes back at the top. Every grid starts empty at the coin's launch slot.

Cells follow Conway's rules, unchanged forever: a dead cell with exactly 3 living neighbours is born, a living cell with 2 or 3 living neighbours survives, every other cell is dead at the next generation.

Where and how many

The transaction signature (64 bytes) is read as one big number. Its value modulo 4 096 gives the cell.

The amount is the SOL that entered or left the coin's bonding curve. The trade acts on the 3 × 3 box centred on (x, y), wrapping across the edges. The nine positions are put in an order by a Fisher–Yates shuffle driven by bytes 0 to 7 of the signature, and the first n are used. A buy switches them on, a sell switches them off.

Nobody chooses a signature, so nobody chooses a cell.

One generation every 10 slots

A slot lasts about 0.4 s, so the grid advances about every 4 seconds, whether anyone trades or not. Generation 0 is the empty grid. The state at any generation depends only on the list of trades before it: anyone can rebuild the whole life of a coin from the chain.

When the 70 % are spent

Fees are distributed from the coin's vault to its three shareholders. The 70 % then wait in the coin's buyback wallet, and only three events of the grid spend them:

An oscillator (a blinker, for instance) changes at every generation, so a grid that still holds one never fossilises. Amounts below 0.001 SOL are carried over to the next buyback.

There is no dedicated Solana program. A public service replays every grid, detects the events with the rules on this page, and executes the buybacks and burns from the buyback wallets. Each one is listed on the coin's page with its transactions.

Patterns that appear on their own

At every generation, living cells closer than three cells to each other are grouped. A group is compared, under every rotation and reflection and in every phase, with a library of known patterns: block, beehive, blinker, toad, beacon, glider, lightweight spaceship, pulsar, pentadecathlon. It counts when it is seen two generations in a row with nothing else living within two cells.

The first appearance of each pattern on a coin enters the museum. The badge goes to the most recent buy whose cells fell within two cells of the pattern. Badges carry no fees.

What nobody can do

• choose where a cell lands
• pause the grid, reset it, or draw on it
• change the rules: birth on 3, survival on 2 or 3, 64 × 64, 10 slots, 300 generations
• change the 70 / 20 / 10 split once it is locked (only pump.fun's takeover can)
• for life.so: spend the 70 % outside the three events

The whole simulation is one file

life.js runs in this page and in node. The two functions that matter:

function footprint(trade) {
  const b = decode58(trade.sig, 64);
  const p = ((b[62] & 15) << 8) | b[63];
  const x = p % 64, y = (p / 64) | 0;
  const order = [0, 1, 2, 3, 4, 5, 6, 7, 8];
  for (let i = 8; i > 0; i--) {
    const j = b[8 - i] % (i + 1);
    [order[i], order[j]] = [order[j], order[i]];
  }
  const n = Math.min(9, Math.floor(trade.lamports / 1e8));
  return order.slice(0, n).map(o =>
    ((y + ((o / 3) | 0) - 1 + 64) % 64) * 64 + (x + (o % 3) - 1 + 64) % 64);
}

function step(src, dst) {           // B3/S23 on the torus
  for (let i = 0; i < 4096; i++) {
    const c = neighbours(i).reduce((s, j) => s + src[j], 0);
    dst[i] = (c === 3 || (c === 2 && src[i])) ? 1 : 0;
  }
}

The page and the service must see the same grid

The page replays in JavaScript, the service in Python. An off-by-one in the clock would give two different grids and fees moving on events nobody can see. So both replay the same coins and compare a hash of the grid at every generation, the population, and every event. The witness also runs once with the service shifted by one slot, to check that it does catch a difference.