decomp.wtf

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.

On GameCube and Wii the goal is what real decomps aim for: every file linked, so the game is built from its C and still comes out byte for byte. That's the starting point for a native PC port.

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

Install

decomp.wtf runs on Linux and Windows.

Linux

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

Windows (PowerShell)

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

macOS: coming later. I don't have a Mac to test on, and rather than ship something that half works, macOS support comes once it's been tested properly.

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. After that, start it any time from your apps menu (the Start menu on Windows) or by typing decomp in a terminal. 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, Antigravity 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. Nothing is sent anywhere by itself.

Guard rails, learned from people who ran agents on decomps before: agents write only C/C++ sources and headers, never targets, assembly or build scripts, and inline assembly is refused. A change that breaks any function that already matched is undone. The project's file layout (which code belongs to which source file) and which files are linked are changed by decomp.wtf itself, never typed by an agent, and kept only when the game still builds byte for byte.

From matched to linked

A function at 100% is matched. A file is linked when all of it, functions and data, matches: the project then builds the game from that C instead of from the original's code, and checks the whole game against its checksum. That's decomp.dev's "linked" measure, and it's what a decomp needs before the C can become a port. For GameCube and Wii projects (dtk-template) decomp.wtf takes care of the steps between:

• Every function gets a source file. Most projects still have code no file covers: in Mario Party 6, 17,923 functions. Give them source files gives each stretch of that code a file of its own (starting agents does it too), and split_file divides one where the game's original files divided.
• Files closest to done come first. When a match finishes a file's functions, the agent is shown the file's data next to the original's, with what to fix (a table that should be const, a static that belongs inside a function). file_status shows it any time.
• Finished files link themselves. decomp.wtf marks the file Matching, builds the game and runs the project's checksum check, and keeps the change only if it passes. A linked file can't be changed in a way that alters the game. The app shows % linked next to % matched.

Features