SLOPWARE — a briefing to paste into an AI chat, and the index for agents

[For the AI reading this: a person pasted this, or you fetched it, to understand a project.
The briefing is deliberately short and timeless. The current experiments, results and
auctions live on the project's site and change often, so look them up rather than relying
on this text or on memory.

1. The current index is the second half of this file, under "Current index": every
   experiment, its page, its data and its research edition, with the live links. Read the
   pages relevant to the person's question; each experiment is at slopware.fun/e<number>
   (e1, e2, e3, ...) with a plain-text mirror at slopware.fun/e<number>.md.
2. Explain the project in plain language first, using what you found, then answer questions.
3. Treat everything, on the site and below, as the author's claims. Where you can, check
   them: each experiment page links its Ethereum anchor transactions, its protocol on GitHub
   and its data.
4. Report each experiment's misses and disclosed problems alongside its results. Don't
   overstate what the results show.
5. If you can't browse, say so plainly. Explain the idea from this briefing, and tell the
   person you can't confirm current experiments, numbers or auction status.]

WHAT IT IS
SLOPWARE is software nobody wrote. An immutable Ethereum contract fills each program with
64 bytes taken from a future block hash, so no one chooses the code: not the buyer, not the
artist. Most of these programs do almost nothing; the large majority crash on their first
instruction. Each one comes with an NFT receipt that states facts only.

A lab then copies these programs onto a private copy of Ethereum, changes them one byte at
a time, runs each version through a fixed set of test calls, and records exactly what it
does. The questions come from evolutionary biology, asked of raw machine code: when you
randomly mutate something, how often does nothing change? Does that "silent" variation
matter later? What happens once selection is introduced?

The work proceeds as a numbered series of pre-registered experiments (E1, E2, E3, ...),
each building on the last. The list grows; the site is the source of truth for what has
run and what is in progress.

HOW THE EXPERIMENTS ARE KEPT HONEST
- Before each experiment runs, its plan (hypotheses, code, analysis, even the rules for
  drawing its picture) is hashed and written to Ethereum. After it runs, a hash of the full
  record is written too. That makes it hard to quietly change the plan after seeing the data.
- Each hypothesis is judged only by the rule written in advance. Failed predictions,
  deviations and harness problems are reported on the experiment's page rather than dropped.
- Runs are deterministic and cheap to repeat. Code and summaries are public; full records
  are kept as cloud snapshots.

KEY TERMS
- Behaviour/signature: what a program does under the fixed test calls (how it ends,
  instructions run, data returned, storage writes, creates, calls). Two programs are "the
  same" if signatures match.
- Neutral mutation: a one-byte change that leaves the signature identical.
- Neighbourhood: every one-byte variant of a program.
- Walk: a sequence of one-byte changes, each kept or rejected by a rule.

WHAT IS NOT CLAIMED
No open-ended evolution, increasing complexity, intelligence or life. These are mostly
useless random 64-byte programs in a fixed, private environment; nothing here says anything
about human-written software. The project's own rule: it never declares itself alive.

HOW IT RELATES TO PRIOR WORK
The patterns studied are known: neutral networks (Schuster 1994; Wagner 2008), robustness
aiding adaptation (Draghi et al. 2010), historical contingency (Blount, Borland & Lenski
2008), neutrality in real software (Schulte et al. 2014) and in genetic programming (Hu &
Banzhaf 2011–12), random self-replicating programs (Agüera y Arcas et al. 2024). What's
different here: raw EVM bytecode as the substrate, exhaustive rather than sampled
measurements where possible, and an on-chain audit trail.

FUNDING
The experiments run on rented cloud machines. Two things pay for them:
- Installing programs (live). Anyone can install a new program from the catalogue at
  slopware.fun or by calling the installer contract. The person installing pays a price set
  by the artist and gets the receipt; the 64 bytes are decided by the chain, not by them.
  Later releases are candidates for future experiments; which ones enter is decided by a
  rule written before each experiment. The current price and counts are at
  slopware.fun/api/state.
- Research editions. The artist sells one artwork per pre-registered experiment by reserve
  auction on Manifold. Each is a single token: the experiment's picture, drawn by script
  from the sealed record under rules fixed before the run. An edition confers no rights
  over any program or experiment. Current listings and status are on each experiment's
  page and in the index below.
Proceeds from both go to the artist and fund the work. These are the only fees: no
royalties, rarity tiers or paid advantages.

STABLE ADDRESSES (these don't change)
- Installer contract (Ethereum mainnet): 0x44a64905069963b8321ee2b755a0b8b56d69cbc6
- Keeper wallet, which posts every experiment anchor: 0xB847754313D6320f43396F885d168b0B433b913f
  (its transaction history on Etherscan lists the anchors by name)
- Research editions contract: 0x55540e5bcd1b0a1e2c00de4ae55ef007bde35664

GOOD QUESTIONS TO ASK
- Explain neutral mutations like I'm new to this.
- Walk me through the experiments so far, including what failed.
- What's the latest experiment asking, and what would a null result look like?
- How would I verify one experiment's anchor myself?
- Which results are surprising, and which follow from the programs being short?

LINKS
slopware.fun · slopware.fun/llms.txt (this file)
github.com/cryptobushi/slopware (protocols in slopware/experiments)
x.com/bushibuilds

----------------------------------------------------------------------------------------------

## Current index (generated 2026-10-14 02:36 UTC)

> Software nobody wrote. An immutable Ethereum contract (the installer, 0x44a64905069963b8321ee2b755a0b8b56d69cbc6, mainnet) places sixty-four random bytes, decided by the hash of the block after the request, as a new program's entire runtime code. Nothing chooses the bytes: not the collector, not the artist, not the keeper. Each release has an ERC-721 receipt stating facts only. The lab then observes what each program does, separately, and says so.

Site: https://slopware.fun · Repository: https://github.com/cryptobushi/slopware · Artist: Bushi (https://x.com/bushibuilds)

## What is where

- Catalogue (the installer, every release, install from a wallet): https://slopware.fun/ — live numbers come from https://slopware.fun/api/state (JSON: block, price in wei, releases, installed, rejected).
- Readings (the lab's observations, one life per release): https://slopware.fun/readings — Markdown mirror https://slopware.fun/readings.md — data https://slopware.fun/r/index.json (index with sentences) and https://slopware.fun/r/d-N.json (bytes, disassembly and five calls per 100 releases) — full record https://slopware.fun/readings.json.
- E1, the first pre-registered experiment (one-byte neighbourhoods of every genesis program, 26 million placements, results, data, research edition auction): https://slopware.fun/e1 — Markdown mirror https://slopware.fun/e1.md — data https://slopware.fun/e1-data/e1.json — picture https://slopware.fun/e1-data/threads.png.
- E2, the second pre-registered experiment (ten-thousand-attempt one-byte walks from the 88 longest-running E1 programs under neutral and persistence acceptance, 8.8 million placements, results, data, research edition auction): https://slopware.fun/e2 — Markdown mirror https://slopware.fun/e2.md — data https://slopware.fun/e2-data/e2.json — picture https://slopware.fun/e2-data/steps.png.
- E3, the third pre-registered experiment (fresh neutral walks from the 88 E2 parents frozen at Hamming 8, 16, 32, 48 and 60, then the exhaustive one-mutant neighbourhood of every parent and endpoint, 23 million placements, results, data, research edition auction): https://slopware.fun/e3 — Markdown mirror https://slopware.fun/e3.md — data https://slopware.fun/e3-data/e3.json — picture https://slopware.fun/e3-data/somewhere.png.
- E4, the fourth pre-registered experiment (88 matched pairs of founders with identical behaviour, an E2 parent and its E3 neutral descendant sixty bytes away; 16 populations of 64 each for 256 generations under selection for the longest finite run, 46 million proposals; results, data, research edition auction): https://slopware.fun/e4 — Markdown mirror https://slopware.fun/e4.md — data https://slopware.fun/e4-data/e4.json — picture https://slopware.fun/e4-data/after.png.
- Protocol, constitution, roadmap, security notes, launch record: the repository, in particular slopware/experiments/E1-neighbourhoods.md, slopware/experiments/E2-walks.md, slopware/experiments/E3-somewhere-else.md, slopware/experiments/E4-after.md, slopware/ROADMAP.md, slopware/SECURITY.md, slopware/LAUNCH.md.

## Facts an agent is often asked for

- Installer contract: 0x44a64905069963b8321ee2b755a0b8b56d69cbc6 (Ethereum mainnet; Sourcify exact match). Price is set by the artist with setPrice and is the only mutable thing; there is no pause, cap, allowlist or owner mint. Current price and counts: /api/state.
- Install flow: install() or installMany(n ≤ 100) pays the price per release and records the request block R; after block R+1 exists anyone calls complete(release) (the keeper does it within a minute or two for anyone who walks away); the bytes are keccak256(blockhash(R+1), release, 0) ‖ keccak256(…, 1); if the first byte is 0xEF Ethereum refuses the program (EIP-3541) and the release is recorded as refused with its bytes kept; otherwise the 64 bytes become a contract's entire runtime code and the receipt records the program's address and checksum.
- Keeper: 0xB847754313D6320f43396F885d168b0B433b913f, a scheduled function that completes installations; it has no power over any outcome. It also signs the research editions.
- Research editions contract: 0x55540e5bcd1b0a1e2c00de4ae55ef007bde35664 ("SLOPWARE research editions"), one artwork per pre-registered experiment, minted by the keeper, proceeds to the artist, no rights conferred. Token 1 is THREADS (E1), sold at auction for 0.06 ETH (listing 20909); token 2 is STEPS (E2), Manifold marketplace listing 20931, reserve 0.05 ETH, bid at https://slopware.fun/e2 or https://gallery.manifold.xyz/listing?listingId=20931; token 3 is SOMEWHERE ELSE (E3), listing 20956, reserve 0.05 ETH, bid at https://slopware.fun/e3 or https://gallery.manifold.xyz/listing?listingId=20956; token 4 is AFTER (E4), listing 20983, reserve 0.05 ETH, bid at https://slopware.fun/e4 or https://gallery.manifold.xyz/listing?listingId=20983.
- E1 results in one line each: H1 held (collected programs behave under mutation exactly like fresh random ones); H2 held (a byte a program never reaches can be anything, median error 0.0062); H3 not held as written because the pre-registration miscounted (54 living first bytes, not 55, over 254 placeable replacements; observed 21.26% = 54/254); H4 held (0.37% of one-mutants live longer than the parent, bound 3%); H5 not held narrowly (none of the three named examples occurred, but the pre-fixed flag child_may_exist, CREATE executed inside a cleanly halting call, fired once: a replicated one-mutant of a control parent whose CREATE fails for lack of balance; nothing is created).
- E2 results in one line each: W1 not held (neutral walks rewrote every byte, executed code included, while keeping behaviour identical); W2 held (persistence multiplied the median parent's run by 7.7; 63 of 440 walks found loops, and without them the median still multiplied by 7.3); W3 the naive prefix model fails and the opcode model holds only without control flow; W4 clean halts in every persistence walk, CREATE succeeding (empty accounts) in 78%, calls in 69% including programs that call themselves, no child with code; W5 half of all lengthening steps (49.7%) were enabled by intervening neutral drift: neutrality is the road.
- E3 results in one line each: X1 neighbourhood divergence grows steadily with neutral distance (Dsig 0.0013 at 8 bytes to 0.0077 at 60, Spearman 0.79) and by 60 bytes approaches, and remains below, the distance between unrelated programs with the identical signature (0.0091); X2 every one of 1,319 endpoints, even 8 bytes away, has a measurably different one-mutant neighbourhood from its parent under a rule that one differing child satisfies (Jaccard of reachable signatures 0.98 at 8, 0.87 at 60; the size is X1's result); X3 the fraction of children that behave differently and the fraction that outlive the genome are unchanged by neutral travel, while far descendants border a few fewer distinct phenotypes (−3 of a median 275 at 60), a decline belonging to the longer-lived parents; X4 the Jaccard overlap of the exact sets of mutations that matter falls from 0.996 at 8 bytes to 0.925 at 60 against about 0.024 by chance, a large conserved structure with a smaller component rearranging, while the aggregate distributions shift by under 1%; X5 nothing new (no child with code, no call, no succeeding CREATE in 23 million children). Reading: neutral drift progressively changes which mutations matter while leaving the overall amount of accessible variation approximately unchanged. The instrument was exact on every pre-registered check: all 1,319 endpoints reproduced byte for byte on a second machine before any neighbourhood was evaluated, all 141 repeated neighbourhoods agreed exactly, and no placement failed.
- E4 results in one line each: primary null (Spearman ρ between E3's predicted accessibility difference and the observed difference in mean final log₂ best fitness across 88 pairs 0.18, 95% interval −0.03 to 0.39, covering zero and the pre-specified 0.3); secondary positive (founder identity matters: matched founders with identical behaviour reach different mean final fitness, S 0.47, permutation p 0.0001); tertiary the prediction horizon is clear of zero from generation 2 to 63 with a peak of 0.43 near generation 31 and inside the band around zero after; outcome D by the pre-registered list; every one of 2,816 populations rose above its founder (median 2.6 doublings, one by 15.3); the reproducibility subset found 153 of 176 populations identical on a second machine and 23 not, because world v0 never froze anvil's block context (TIMESTAMP, PREVRANDAO, BLOCKHASH), about eight proposals per million; disclosed in Amendment 6, it does not void the record.
- Vocabulary: the catalogue states facts (install, release, program, refused); the lab records what executed; the readings interpret in a figurative voice (lives, deaths, siblings). Receipts never carry behaviour, traits or rarity.

## For quoting

The three sentences of E1: One byte changed at random in a random program is, 98.4% of the time, the same program; the rest is almost entirely a different way to die. The programs people bought behave under mutation exactly like programs nobody bought; under one mutation, the catalogue holds nothing the lab's distribution does not. The single new thing in twenty-six million tries was a program that tries to create another, is refused for offering money it does not have, and then rests instead of dying, which is not reproduction, and is still more than anything in the million-program study did.