decomp.wtf

Website  ·  Install  ·  How it works  ·  Public decomps  ·  Agents  ·  Decompile together

_{The simulation from decomp.wtf, on the demo ROM that ships with the app.}

Point the AI agent you already use at a game you own. decomp.wtf hands it the game one function at a time,
compiles every attempt with the game's original compiler, and checks the result byte for byte. Score 0, or
it doesn't count. There are two ways in:

• Start from scratch. Drop in a game for N64, PlayStation 1 or 2, GameCube, Wii, Game Boy Advance or DS: a
  ROM, a disc image or the program file. decomp.wtf finds every function and your agents take it from there. The
  result is a project that rebuilds your game byte for byte: the base for ports and mods.
• Continue a public decomp. Pick one of the 245 projects on decomp.dev for GameCube, Wii,
  PlayStation 1 and 2, N64, GBA, DS, Switch, PC, Xbox 360 and more, add your own copy of its game, and your agents
  carry on where the community left off, in the project's real source code.

Everything runs on your computer. No account, no telemetry, nothing uploaded.

Install

macOS and Linux

curl -fsSL https://decomp.wtf/install.sh | bash

Windows (PowerShell)

irm https://decomp.wtf/install.ps1 | iex

One line sets up everything: uv, the app, the period compilers (pinned and
checksum-verified) and the m2c draft decompiler. It then adds decomp.wtf to your apps and opens it in your
browser. Remove it any time with uv tool uninstall decompnet.

[!TIP]
No ROM at hand? The app ships with Demo Quest 64, a real N64 ROM built from public-domain code and zlib.
Open it from the home screen and watch your agent go.

Or just ask your agent

Already living in Claude Code, Codex, Gemini CLI or opencode? Give it decomp.wtf's tools once:

decomp connect

Then ask it, in your own terminal:

decompile my game at ~/roms/game.z64

It confirms the game is your own copy, imports it, opens the live view so you can watch, and gets to work with every
tool decomp.wtf has: the original compiler, the byte-for-byte judge, the autopilot, helper agents running in
parallel (start_agents) and the rebuildable export. Behind it is decomp mcp, an MCP server that starts the app
when needed; you can also add it yourself (claude mcp add decomp -- decomp mcp).

How it works

1. Open a ROM. splat and spimdisasm find every function and data symbol, and decomp.wtf recognises the
   compiler that built the game.
2. Add agents. Each claims a different function and gets its assembly, the data it touches, who calls it, a
   machine-made first draft and notes from earlier attempts.
3. Watch them match. Every attempt is compiled, linked at the function's real address and compared with the
   ROM. A miss returns an instruction diff; a hit is saved, named and shared with every other agent.

The assembly decomp.wtf takes from the ROM:

800007D0  slt     $v0, $a0, $a1
800007D4  bnez    $v0, .L800007EC
800007D8   addu   $v0, $a1, $zero
800007DC  addu    $v0, $a2, $zero
800007E0  slt     $v1, $v0, $a0
800007E4  beql    $v1, $zero, .L800007EC
800007E8   addu   $v0, $a0, $zero
.L800007EC:
800007EC  jr      $ra
800007F0   nop

The C an agent wrote, which compiles to exactly those bytes with KMC GCC 2.7.2 at -O2:

s32 clamp_s32(s32 v, s32 lo, s32 hi) {
    if (v < lo) {
        return lo;
    }
    if (v > hi) {
        return hi;
    }
    return v;
}

Continue a public decomp

Most games people decompile already have a community project with its build set up and part of the code done.
decomp.wtf plugs your agents into them as they are:

1. Browse the decomp.dev catalog in the app (or paste any decomp repository's address) and fork it: it's
   cloned to your computer on a local decomp-wtf branch.
2. Add your copy of the game. The app knows where common project layouts expect it (dtk-template for
   GameCube/Wii, configure.py + ninja, splat + make) and runs the project's own setup. Anything else you set up
   by its README, and decomp.wtf picks it up once it builds.
3. Add agents. Each claims a function and gets the target assembly, objdiff's diff, the function's source
   file, matched look-alikes and a machine draft. Its code goes into the real source file, the project's build
   compiles it with the project's compilers, and objdiff judges it.
4. Every match is a git commit on decomp-wtf, ready for you to review and, if the project welcomes it, send
   upstream.

Guard rails, learned from people who ran agents on decomps before: agents can only write C/C++ sources and
headers (never targets, assembly, configs or build scripts), inline assembly is refused, and a change that
breaks any function that already matched is undone.

Features

Agents

Agents only get decomp.wtf's tools: no shell, and no access to your files beyond a fork's own source tree. The app installs missing agents for you
and tells you how to sign in. You pay your own provider; in our tests a small function cost Claude Code about 8 cents.

Decompile together

A whole team, any size, each on their own computer with their own copy of the game and their own agents, working on
one game. One computer is the room's host: it hands out functions so nobody does the same one twice, checks every
match against its own copy, and shares names, structs and notes with everyone. Nothing goes through decomp.wtf's
website: the people who decompile together host their room and decide who's in.

On a home PC: open the project, click Decompile together, Start sharing. Send the link.

On a server (or any always-on machine):

curl -fsSL https://decomp.wtf/install.sh | bash
decomp host mygame.z64 --own-copy --address http://my-server:6481 --service

That runs decomp.wtf in the background (starting with the computer), imports your copy, opens the room and prints the
link. Joining: paste the link into Join a team's room in the app, or decomp join <link> <your copy> --name you.

No ROM bytes or assembly ever cross the wire: everyone reads the code from their own copy, which must be identical to
the host's. The decompiled code of a commercial game belongs to its rights holder: share it only with people who own
the game. Rooms work for games started from a ROM; GameCube, Wii and DS projects are git repositories, which a team
shares like any other (GitHub, GitLab, its own server).

Platforms

From scratch. splat and spimdisasm split MIPS games, decomp-toolkit analyses GameCube and Wii programs inside a
generated dtk-template project, ds-decomp
analyses DS ROMs (ARM9, ITCM, DTCM, overlays) inside a generated project of the same kind, and Game Boy Advance
ROMs are split by luvdis plus decomp.wtf's own pass for code nothing calls. Every attempt is
compiled with the game's compiler and checked byte for byte: linked at its address in the original (MIPS, ARM)
or judged by objdiff inside the project's own build (GameCube, Wii, DS).

The base for ports and mods. Export project writes a normal decomp tree (matched functions as C, the rest as
assembly from splat or luvdis, a linker script and build.py) and proves it rebuilds your game byte for byte.
GameCube and Wii projects are dtk-template projects and DS projects are ds-decomp projects; both rebuild the game on
every build. Game code and data stay out of git: they're regenerated from your own copy, so the tree can be shared
and continued with any tool or agent.

Proprietary compilers (IDO, CodeWarrior, CodeWarrior for DS) are only installed after you accept that. Heavy
tools run with a memory cap, so a runaway analysis can't take your computer down. KMC GCC, EE-GCC and agbcc are
Linux programs (the app runs them in a sandbox); on macOS and Windows those platforms work through public decomps
for now.

Development

uv sync
uv run decomp              # opens the app; projects live in ~/Decomp (or $DECOMP_HOME)
uv run pytest

Rebuild the demo ROM with uv run python projects/demo-rom/build.py (needs gcc-2.7.2-kmc and ld.lld).

Built on

splat and spimdisasm split
ROMs, objdiff judges forks, m2c and
Ghidra write first drafts, the
decompals recompiled period compilers do the building, and
decomp.dev lists the public projects. The look-alike finder follows the idea of
coddog; decomp-toolkit,
maspsx and wibo are in the pinned toolbelt
(decompnet toolchain install <name>). Thanks to everyone in the decomp community whose tools and ideas made this
possible. decomp.wtf isn't affiliated with any of these projects.

Use it responsibly

decomp.wtf contains no game code and doesn't provide ROMs. Use games you own, don't use it to get around copy
protection, and don't publish decompiled code of games whose rights you don't hold. When you continue a public
decomp, follow that project's license and contribution rules; forking runs its build scripts on your computer, so
fork projects you trust.

License

MIT © 2026 Sam Wolfs

_{Not affiliated with Nintendo or Sony. Nintendo 64 and PlayStation are their trademarks.}