Game decompilation has always been a long, patient, human effort: teams of volunteers writing C by hand until it compiles to the exact bytes of the original ROM. decomp.wtf proposes something different. You point an AI coding agent at a game you own, and it turns that game back into C, one function at a time, while the app checks every function byte for byte against your own copy of the ROM. The project's tagline is a pun that tells you exactly what it is: “What The Function.”
It is a game decompilation tool, a matching decompilation assistant, an AI reverse engineering front end, and a retro game preservation project in one package. It is free, open source under the MIT license, and it runs entirely on your own computer. You can install it with a single command, and it works with the AI agent you already pay for.
If you have ever wanted to decompile an N64 game, a GameCube game, a PlayStation 2 game or a Game Boy Advance game and did not know where to start, this is aimed squarely at you.
What Is decomp.wtf?
decomp.wtf is a desktop application, written as an open source project by Sam Wolfs, a private individual in Belgium. In its own words, it “turns games you own back into C, byte for byte,” and it does that by driving an AI agent rather than by doing the reverse engineering itself.
The important word is matching. A matching decompilation is not a rough approximation of the game's source. The goal is source code that, when compiled with the game's original compiler, produces the identical binary. That is what makes a decompilation valuable for preservation and for building native PC ports: you are not guessing at how the game worked, you are reconstructing it.
The short version: drop in a game you own for the N64, PlayStation 1, PlayStation 2, GameCube, Wii, Game Boy Advance or Nintendo DS, add an AI agent, and watch the function map fill in. Your file never leaves your computer, and the app itself hosts no ROMs and no game code.
How decomp.wtf Works: Pick a Game, Pick an Agent, Watch
The workflow is deliberately small. Three steps, and the app shows you everything happening in between.
Step one: open your game. You drop in a ROM, a disc image or a program file for N64, PlayStation 1, PlayStation 2, GameCube, Wii, Game Boy Advance or DS, and decomp.wtf finds every function in it. Alternatively you can continue a public decompilation project on any platform. Your file is never uploaded.
Step two: add your agent. decomp.wtf works with Claude Code (Anthropic), Codex (OpenAI), Antigravity CLI, opencode, or any model you have an API key for. You can run several at once, and here is the clever part: each agent takes a different function, and they share what they learn with each other, so hard-won knowledge about the game's structures propagates instead of being rediscovered.
Step three: watch it match. The map fills in as functions match. Every attempt, every score and every name is live on screen. You can export the source whenever you like, and you can also decompile as a team, where each person runs their own copy and their own agents.
The Rule That Makes It Real: Score 0, or It Doesn't Count
Anyone can ask a language model to write plausible C. The hard part is proving that the C is the actual source. decomp.wtf is strict about this, and its rule is worth quoting: “Score 0, or it doesn't count. Byte-identical, not close.”
Here is what that means in practice. When an agent drafts a function, the tool compiles it with the game's own original compiler, links it at the function's real address in memory, and compares the result against your ROM, byte for byte. The build example the site shows is a clamp function named clamp_s32.c, compiled with KMC GCC 2.7.2 -O2, linked at the address 0x800007D0, and scored. A zero means a perfect match.
Misses are not thrown away. Every failed attempt explains itself: the agent receives an instruction diff and is guided to fix the function's structure first and register allocation last, which is how real decompilation work actually proceeds. Knowledge compounds too, because structs, prototypes and names are shared between agents, and are only accepted if everything that already matched still matches. And on GameCube and Wii, a file whose code and data fully match is linked into the game and verified against its checksum, which is the same bar the community's flagship projects use.
Why the strictness matters: a decompilation that is merely “close” is an emulator with extra steps. A decompilation that is byte-identical is source code, and source code is what you can port, patch, mod and preserve. That is the difference between a demo and a preservation tool.
Supported Platforms for AI Decompilation
From scratch, decomp.wtf handles games for Nintendo 64, PlayStation 1, PlayStation 2, GameCube, Wii, Game Boy Advance and Nintendo DS, provided as a ROM, a disc image or a program file. It can also pick up public decompilation projects across a much wider set of platforms, including Switch, Xbox 360, 3DS, PSP, Xbox and PC.
Language support depends on the platform and the project. GameCube, Wii and DS games are frequently C++, and decomp.wtf handles that: code with C++ symbol names lands in .cpp files, drafts come out as C++, and agents are given guidance on classes, vtables, constructors and name mangling. Games started from scratch on N64, PlayStation, PS2 and GBA are written in C for now, with C++ support for those platforms (mostly PS2) coming later. Public projects use whatever language the project itself uses.
Continue a Public Decompilation Project
This is the feature that will get the most use, because you do not have to start from an empty map. Hundreds of games already have a community decompilation with the build set up and part of the code written, and decomp.wtf lists them from decomp.dev, a tracker for matching decompilation projects.
There are roughly 245 projects in the app's browser, spanning GameCube, PlayStation, PlayStation 2, Wii, Nintendo 64, Windows, Game Boy Advance, Nintendo DS, Switch, Xbox 360, 3DS, Xbox and PSP. Real projects on the board include Dark Cloud 2 and Persona 4 at 100 percent, The Legend of Zelda: Twilight Princess at 100 percent, Tombi! at 99.99 percent, Metroid Prime at 93.35 percent, The Wind Waker at 79.58 percent, F-Zero GX at 40.44 percent, and Jet Force Gemini at 14.49 percent.
The flow is three steps. Fork a project: browse the list in the app, or paste any decompilation repository, and it is cloned to your computer on its own branch. Add your copy: decomp.wtf puts your game where the project expects it and runs the project's own setup with its own compilers. Agents match, files link: objdiff judges every attempt and each match becomes a git commit, and on GameCube and Wii a fully matched file is linked into the game and checksum verified.
Which AI Agents Work With decomp.wtf?
You bring the agent you already use. The app supports Claude Code from Anthropic, Codex from OpenAI, Antigravity CLI, opencode, and any model you can point at with an API key. If you do not have an agent installed, the app installs one for you and walks you through signing in.
That architecture is the whole trick. decomp.wtf is the harness: it splits the ROM into functions, hands work out, compiles the results with the right period compiler, diffs them against your dump, and keeps the shared knowledge straight. The model does the reasoning. You pay your agent's subscription or API costs and nothing to decomp.wtf.
Decompiling as a Team
You can also decompile a game with other people. One person hosts the room on a home PC or a server with decomp host, chooses whether it is public or private, and decides who joins. Functions are handed out so that nobody collides, every match is verified against the host's copy of the game, and names, structs and notes are shared across the team.
Worth noting for anyone worried about sending code through someone else's cloud: nothing goes through decomp.wtf. You host the room, and you decide who sees the code.
What Does decomp.wtf Cost?
The app itself is free and open source under the MIT license, with the source on GitHub. There are no accounts, no subscriptions and no usage limits from decomp.wtf. What you pay for is the AI agent, which runs on your own plan or API credits.
The project shares real numbers from its own testing. A small function cost about 8 cents with Claude Code, a fraction of that with DeepSeek, and nothing at all with a local model. Big functions take many more attempts, and cheaper models often get stuck on them, so the easy part of a game decompiles fast and the remainder takes genuine time. That is an honest way to describe an AI tool: cheap on the easy work, slow on the hard work, and not a magic button.
On platforms, it runs natively on Linux and Windows. macOS support is deliberately held back until it has been tested on real hardware, which is a more respectable choice than shipping something half working. Compilers that only exist for Linux, including KMC GCC for N64, the PlayStation GCCs, EE-GCC for PS2 and agbcc for GBA, run inside WSL 2, which the app sets up for you after a one time wsl --install.
The AI Question in the Decompilation Community
It is the obvious objection, and decomp.wtf addresses it directly: will my agents' code end up in the community's project? The answer is no by default. In a public decompilation project, every match is a commit on your own local branch, and nothing is sent anywhere.
The site is also clear that many decompilation projects do not accept AI-written contributions at all, and that those which do expect a person to stand behind every line: read the project's contribution rules, review the code yourself, and say how it was made before opening a pull request. That is the right way to handle a genuinely contentious issue, and it lines up with what we have seen elsewhere this year, where projects that use AI rarely, if ever, push it upstream.
Is decomp.wtf Legal?
The project's own position is that decomp.wtf is a tool, like a disassembler. It contains no game code and runs on your computer, working only on files you supply. It hosts no ROMs, no game code and no user content, and it has no accounts.
On use, the guidance is sensible and worth repeating: work with software you are entitled to use, do not use it to get around copy protection, and do not publish or distribute code or data from games whose rights you do not hold. Public decompilation projects you continue come under their own licenses and rules. decomp.wtf is not affiliated with Nintendo, Sony, Microsoft or any game publisher, and the platform names are their owners' trademarks. This is not legal advice.
Why This Matters for Game Preservation and Native PC Ports
Everything we have covered on this site this year runs on decompilation. The N64 recompilations of Smash Bros. and GoldenEye 007, the Super Mario Galaxy and Xbox ports, the recompiled classics on PC: each one exists because somebody, somewhere, reconstructed a game's source code from its binary. Decompilation is the foundation, and it has always been the slowest step.
decomp.wtf aims straight at that bottleneck. It also points at the payoff: Export project writes out a normal decompilation project, with matched functions as C and the rest as assembly, that rebuilds your game byte for byte. On GameCube and Wii, finished files are linked as you go, so the game is literally built from their C. That is precisely the state a native PC port starts from, and it is why an AI decompilation assistant is really a preservation tool wearing a developer hat.
The big picture: for thirty years, the answer to “can I keep playing this old game?” has been an emulator and a prayer. Decompilation and recompilation offer a different answer, where the game becomes source code that can outlive its hardware. Tools that make decompilation faster are tools that make preservation more likely.
How to Install decomp.wtf
Two one liners, depending on your system. On Linux and macOS-style shells:
curl -fsSL https://decomp.wtf/install.sh | bashOn Windows, in PowerShell:
irm https://decomp.wtf/install.ps1 | iexEither command installs everything and opens the app. After that you start it from your apps menu, your desktop, or by typing decomp. If you would rather read before you run, the site offers the install scripts to read first, which is good practice with any pipe to a shell.
Worth knowing before you begin: a game's decompilation only decompiles the parts that a model can actually work through. Some functions will be hard, some agents will get stuck, and the remainder will need real time and better models. Plan for the easy third to go quickly and the rest to be a project.
decomp.wtf FAQ
What is a matching decompilation? It is a reconstruction of a game's original source code that compiles, with the game's own compiler, into a binary identical to the retail release. Matching decompilations are what native ports and speedrun-accurate mods are built from.
Can decomp.wtf decompile an N64 game? Yes, along with PlayStation 1, PlayStation 2, GameCube, Wii, Game Boy Advance and Nintendo DS games. It also continues public decompilation projects for a much wider range of platforms.
Do I need to know MIPS or assembly? No. The agent does the work and the app shows you what is happening. If you do read assembly, you can follow every attempt and contribute directly.
Is my ROM uploaded anywhere? No. decomp.wtf runs locally, your file never leaves your computer, and the app hosts no ROMs, game code or user content. Team rooms run on a host that you control, not on decomp.wtf's servers.
Is decomp.wtf free? The app is free and open source under the MIT license. You pay only for the AI agent, on your own subscription or API credits, and small functions came in at roughly 8 cents each in the project's own testing with Claude Code.
Does it work on macOS? Not yet, and for a good reason: the author does not have a Mac to test on and would rather not ship something half working. Linux and Windows are supported today.
Resources & Links
- Official site: decomp.wtf
- Source code: i12bp8/decomp.wtf on GitHub (MIT license)
- Project tracker: decomp.dev, home of the public matching decompilation projects
- Legal notice: decomp.wtf legal page, which names Sam Wolfs as the maintainer
- Built on: splat and spimdisasm for splitting ROMs, objdiff for judging matches, m2c and Ghidra for first drafts, and the decompilation community's period compilers for building
- Requirements: Linux or Windows, a game you own, and an AI agent with your own plan or API credits