:(){ :|:& };:

forkbomb: Fork your coding agent. Keep the one that exits 0.

Forkbomb clones your repo into sandboxed forks in milliseconds and gives each one a different strategy. Your test suite judges every patch: the losers get kill -9, the survivor's patch is yours.

CAlaunching
$FORKBOMB · Solana · not launched yet
fork()
1.13 ms
forks
4 → 1
race
38.7 s
vs copy
≈24×
tests
64

Recorded run 2026-10-05 · bench on MacBook Air (M2, 24 GB) · 64 automated tests in the CLI. The fork-tree animation is an illustration, not a recording.

01Recorded run · 2026-10-05

4 forks. 3 killed. 1 exit 0.

A real race: Claude Code on a Max plan, a demo calc repo with 10 of 14 tests failing. Fork 1.04 (rewriter) passed all 14 first, so the other 3 were killed.

ps -ef | grep forkbombexit 0
Recorded run 20261005-155223 on 2026-10-05. All forks ended at 38.5 s.
PIDPPIDCMDFORKTURNSTESTSSTAT
1-demo calc repo--4/14parent
1.011surgeon0.97 ms8-R+ runningSIGKILL
1.021root-cause1.46 ms8-R+ runningSIGKILL
1.031test-driven1.05 ms6-R+ runningSIGKILL
1.041rewriter1.03 ms9…14/14R+ runningexit 0
baseline
4/14
fork()
1.13 ms each
killed
3
exit 0
1.04 · 14/14
patch
94 lines · 1 file
wall
38.7 s
recorded output · run 20261005-15522314/14
node dist/cli.js run ./calc --task "fix the failing tests" --test "node --test" --forks 4run · 4 forks × 2 rounds · claude-code · race · sandbox onbaseline: 4 passing, 10 failingfork()  4 copies of pid 1 in 1.13 ms each via apfs-clonefile  1.01 surgeon   1.02 root-cause   1.03 test-driven   1.04 rewriter  1.04 ✎ create calc.js  ·  $ node --test  1.04 PASS 14/14 · 94 lines  kill -9  1.01  1.02  1.03  (1.04 passed first)exit 0  1.04: 94 lines in 1 file. All 14 tests pass. 38.7s

Replay, straight from the run's own event log. Every fork has resolved by 38.5 s.

forkbomb replay · run 20261005-155223Open full replay
  1. PID 1demo calc repoPARENTbaseline4/14
  2. 1.01surgeonKILLEDSIGKILL · 1.04 passed first
  3. 1.02root-causeKILLEDSIGKILL · 1.04 passed first
  4. 1.03test-drivenKILLEDSIGKILL · 1.04 passed first
  5. 1.04rewriterEXIT 094 lines in 1 file14/14

02How a detonation works

Fork. Race. Judge. Kill. Exit 0.

One loop, drawn from the run above. Every step is plain mechanics you can read in the source.

One detonationpid 1, a snapshot of your repo, forks into four children: 1.01 surgeon, 1.02 root-cause, 1.03 test-driven, 1.04 rewriter. They race. Fork 1.04 passes the judge first and exits 0 with all 14 tests passing. The other 3 forks get SIGKILL. If no fork passes, the best one seeds the next round.no pass? the best fork seeds round 2pid 1repo snapshot01 FORKclonefile · 1.13 ms/fork02 RACE04 KILL1.01surgeonSIGKILL1.02root-causeSIGKILL1.03test-drivenSIGKILL1.04rewriter03 JUDGEfresh clone · node --test05 EXIT 01.04 rewriter14/14patch · 94 lines · 1 fileOne detonationpid 1 forks into four children. They race. Fork 1.04 passes the judge and exits 0 with 14 of 14 tests passing. Three forks get SIGKILL.round 2pid 1repo snapshot01 FORK1.13 ms02 RACE04 KILL1.01surgeonKILL1.02root-causeKILL1.03test-drivenKILL1.04rewriter03 JUDGEfresh clone · node --test05 EXIT 01.04 rewriter14/14patch · 94 lines · 1 file
  1. Fork

    clonefile(2)

    Your repo is snapshotted once as pid 1, then cloned into N forks. Blocks are shared until a fork writes, so a fork costs metadata, not a copy.

  2. Race

    --forks N

    Each fork is a coding agent with its own strategy: surgeon, root-cause, test-driven, rewriter and more. Different approaches fail differently.

  3. Judge

    --test "npm test"

    When a fork stops, its diff minus any test edits goes onto a fresh clone, and your test command runs there.

  4. Kill

    kill -9

    Race mode: the first fork to pass wins and the rest are killed mid-run. Best mode lets all finish and keeps the smallest passing diff.

  5. Exit 0

    --apply

    The survivor's patch is yours to read and apply. No pass? The best fork's verified state seeds the next round.

03$FORKBOMB utility

Burn for compute.

The token has one job: paying for hosted forks. Burn $FORKBOMB, get USD credit at the price when the burn lands, and spend it on Forkbomb's own GPU coding model. Self-hosting stays free.

  1. Your walletholds $FORKBOMB
  2. Burn txwith memo forkbomb:<workspaceId>Solana
  3. Verifiedserver reads the burn on-chain
  4. USD creditamount × TWAP at burn time
  5. Hosted forks--engine hostedlive
  1. Burn

    Send one burn transaction from your wallet with the memo forkbomb:<workspaceId>. Burned tokens are gone for good.

  2. Credit

    The server reads the burn from Solana and credits your workspace in USD at the token's time-weighted price when the burn lands. A one-tick spike can't be timed.

  3. Compute

    Credit pays for hosted forks: our GPU coding model behind an OpenAI-compatible API that --engine hosted calls. Later: bigger models, more forks per race, warm GPUs.

Credit is used up, not held.

  • No refunds
  • No transfers
  • No buybacks
  • No yield
  • No revenue share
forkbomb status --launchpre-launch
coin
CAlaunching
hosted pool
live
self-host
free · MIT · no token needed
app
open · burns at launch

Ledger opens at launch.

$FORKBOMB isn't live yet. Every burn will be listed with its transaction and the credit it produced.

04Benchmark

A fork costs metadata, not a copy.

On APFS, clonefile shares every data block with pid 1 until a fork writes. The bench command forks the same tree both ways and measures it.

≈24×faster to fork45 ms vs 1,108 ms
≈60×less extra disk22 MB vs 1.3 GB
node dist/cli.js bench ./tree --forks 16

Time to fork one copy

  • apfs-clonefile45 ms
  • plain copy1,108 ms

Extra disk for 16 forks

  • apfs-clonefile22 MB
  • plain copy1.3 GB

MacBook Air (M2, 24 GB) · 80 MB node_modules tree, 4,400 files · 16 forks. Extra disk is free space before vs after, so other activity on the machine shows up as noise.

05Engines

Bring a plan, a key, or burn the coin.

Pick the engine per race. The judge always runs on your machine, under Forkbomb's own sandbox.

Your Claude plan

--engine claude-code
default
Pays with
Your Claude Pro or Max plan
Each fork
A headless Claude Code session in safe mode: no CLAUDE.md, hooks, plugins or MCP
Setup
claude auth login, once

Forks count against your plan's limits: 8 forks use them about 8× as fast as one session.

Your API key

--engine api
Pays with
Pay as you go on the Anthropic API
Each fork
Forkbomb's own tool loop with two tools: bash and a text editor
Setup
ANTHROPIC_API_KEY in your environment

The key stays in Forkbomb's own process. Fork shells get a clean environment without it.

Burn $FORKBOMB

--engine hosted
live
Pays with
Credit from burning $FORKBOMB
Each fork
Forkbomb's GPU coding model over an OpenAI-compatible API
Setup
A workspace API key from the app

The code your forks read is sent to Forkbomb's hosted model. Credit opens when the coin launches.

Forkbomb is an independent open-source project. Not affiliated with Anthropic. Claude and Claude Code are Anthropic's products; you use them under your own account.

06Isolation

Every fork runs in a box.

Each shell command a fork runs goes through macOS Seatbelt. It's a bomb, but a contained one.

  • WritesOnly the fork's own clone and temp dir. .git is read-only.confined
  • Credentials~/.ssh, ~/.aws, ~/.config/gh and Keychains are unreadable.deny
  • NetworkLoopback only. --network opts in.deny
  • EnvironmentClean. No API keys or tokens in a fork's shell.stripped

Seatbelt is a macOS sandbox, not a VM. Forks can still read most of your filesystem outside the credential folders. Run it on code you'd let an agent work on.

07FAQ

man forkbomb

Straight answers. Something missing? Open an issue.

What does $FORKBOMB do?

It pays for hosted compute. Burn it with the memo forkbomb:<workspaceId>, and your workspace gets USD credit at the token's time-weighted price when the burn lands. The credit runs forks on Forkbomb's own GPU coding model through --engine hosted. Every burn and the credit it produced is listed on the public burn ledger.

Do I need the token?

No. Forkbomb is MIT licensed and self-hosting is free: run it on your Claude plan or your own API key and never touch the coin. The token buys hosted convenience and scale, not permission.

Is the hosted pool live?

The GPU pool is serving. Credit comes from burning $FORKBOMB, which opens when the coin launches. Until then the claude-code and api engines work with no token involved.

Can I get my credit back or sell it?

No. Credit is consumptive: no refunds, no transfers, no buybacks, no yield, no revenue share. Burn only what you plan to spend on compute.

Is it Mac only?

Yes, for now. Forking uses APFS clonefile and the sandbox uses Seatbelt, both macOS. Other platforms would need their own fork and sandbox backends. None ship today.

Is it on npm?

Not yet. Clone the repo, run npm install and npm run build, then node dist/cli.js doctor to check the machine.

Can a fork cheat the tests?

The judge drops test and test-config edits, applies the patch to a fresh clone, and doesn't count runs where tests went missing. It's designed against common gaming and still being hardened. Review the winning patch like any other change.

Does my code leave my machine?

Forkbomb has no telemetry. On the claude-code and api engines, the code your forks read goes to Anthropic's API, as in any Claude Code session. On the hosted engine it goes to Forkbomb's hosted model. The judge always runs locally.

Light the fuse.

Point forkbomb at a failing suite. Watch the forks race. Keep the patch that exits 0.

MIT · macOS only · not on npm yet · not affiliated with Anthropic

Install from sourcesh
# Clone and buildgit clone https://github.com/plvgger/forkbombcd forkbomb && npm install && npm run build # Check the machinenode dist/cli.js doctor # Run itnode dist/cli.js run ./my-repo \    --task "fix the failing tests" \    --test "npm test" --ui