Skip to content
Back to search

decomp-wtf

MarketplaceWorks with Claude CodeGitHub

What The Function: your AI agent decompiles games you own into C that compiles to the exact same bytes. Runs locally.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today
Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/i12bp8--decomp-wtf/badge.svg)](/listings/i12bp8--decomp-wtf)

HTML

<a href="/listings/i12bp8--decomp-wtf"><img src="/api/listings/i12bp8--decomp-wtf/badge.svg" alt="findsafeskills safety rating" /></a>

Install

Install instructions from the README

As written by the repo's author. findsafeskills has not verified these steps.

These steps run a script from the network that findsafeskills does not scan.

decomp.wtf runs on **Linux**, and on **Windows** (supported, still unstable). The compilers it runs are Linux programs, so on Windows it runs in its own small Linux (a WSL 2 distribution called `decomp-wtf`), set up by the same script as on Linux. macOS isn't supported.

**Linux**

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

Can't reach decomp.wtf from your network? The same installer from GitHub (it then installs the release from GitHub too):

curl -fsSL https://raw.githubusercontent.com/i12bp8/decomp.wtf/main/site/public/install.sh | bash

**Windows** (PowerShell; new and still unstable: problems are worth an [issue](https://github.com/i12bp8/decomp.wtf/issues))

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

It turns on WSL 2 if it isn't yet (Windows asks for permission once, and may want a restart), makes decomp.wtf's Linux from Debian's official WSL image and installs everything in it. You get a `decomp` command, a Start menu entry and a desktop shortcut. Your projects are at `\\wsl.localhost\decomp-wtf\home\decomp\Decomp`.

One line sets up everything: [uv](https://docs.astral.sh/uv/), the app, the period compilers (pinned and checksum-verified) and the m2c draft decompiler. It then opens decomp.wtf 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.

**Updates** come by themselves: when there's a new version, decomp.wtf asks once, and one click installs it and restarts the app in the same tab (helper agents carry on). Settings has "check now", "install updates by itself" and "don't look for updates".

> [!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.

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

.claude-plugin/marketplace.json · Manifest · 13 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. {
  2. "name": "decomp-wtf",
  3. "owner": {"name": "decomp.wtf", "url": "https://decomp.wtf"},
  4. "metadata": {"description": "decomp.wtf: matching decompilation of games you own, with your AI agent."},
  5. "plugins": [
  6. {
  7. "name": "decomp-wtf",
  8. "source": "./plugins/decomp-wtf",
  9. "description": "Decompile games you own into C that rebuilds them byte for byte: the original compilers, a byte-for-byte judge, free matches from machine drafts, helper agents and a live view.",
  10. "version": "0.9.8"
  11. }
  12. ]
  13. }
README.md · README · 442 lines · 5 findings marked

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

  1. ## This project is discontinued
  2. I've decided to stop working on decomp.wtf and archive it.
  3. Over the last few days I noticed that a lot of the decompilation community, the people who made the tools and projects all of this is built on, is against AI decompiling like this. I didn't make decomp.wtf to do any harm, but I respect their opinion, and that's why I'm stopping it here.
  4. The code stays up as it is, under the MIT license. If you want to fork it and keep going with it, you can. I won't fix issues, review pull requests or make new releases anymore. If you already have it installed it keeps working, it just won't get any updates. You can still install the last version (0.10.6) with the commands under [Install](#install).
  5. If you do use it or build on it, please only use it on games you own, don't share the game code it produces, and respect the rules of the projects you work with, because many of them don't want AI-made contributions.
  6. Thanks to everyone who tried it, reported bugs and sent fixes.
  7. ---
  8. <p align="center">
  9. <a href="https://decomp.wtf">
  10. <picture>
  11. <source media="(prefers-color-scheme: dark)" srcset=".github/assets/banner-dark.png">
  12. <img alt="decomp.wtf: What the function? Your AI agent decompiles games you own into C that compiles to the exact same bytes." src=".github/assets/banner-light.png">
  13. </picture>
  14. </a>
  15. </p>
  16. <p align="center">
  17. <a href="https://decomp.wtf"><b>Website</b></a>
  18. &nbsp;·&nbsp;
  19. <a href="#install"><b>Install</b></a>
  20. &nbsp;·&nbsp;
  21. <a href="#how-it-works"><b>How it works</b></a>
  22. &nbsp;·&nbsp;
  23. <a href="#continue-a-public-decomp"><b>Public decomps</b></a>
  24. &nbsp;·&nbsp;
  25. <a href="#agents"><b>Agents</b></a>
  26. &nbsp;·&nbsp;
  27. <a href="#decompile-together"><b>Decompile together</b></a>
  28. </p>
  29. <p align="center">
  30. <a href="LICENSE"><img alt="MIT license" src="https://img.shields.io/badge/license-MIT-157a49?style=flat-square"></a>
  31. <img alt="Linux and Windows" src="https://img.shields.io/badge/platform-Linux%20%7C%20Windows%20(unstable)-15140f?style=flat-square">
  32. <img alt="Python 3.12 or newer" src="https://img.shields.io/badge/python-3.12%2B-15140f?style=flat-square">
  33. <img alt="Works with any MCP agent" src="https://img.shields.io/badge/agents-any%20MCP%20client-157a49?style=flat-square">
  34. </p>
  35. <br>
  36. <p align="center">
  37. <img alt="decomp.wtf at work: agents claim functions, their compile attempts drop to score 0, and the map of the game turns green." src=".github/assets/demo.webp" width="900">
  38. <br>
  39. <sub>The simulation from <a href="https://decomp.wtf">decomp.wtf</a>, on the demo ROM that ships with the app.</sub>
  40. </p>
  41. <br>
  42. Point the AI agent you already use at a game you own. **decomp.wtf** hands it the game one function at a time,
  43. compiles every attempt with the game's **original compiler**, and checks the result **byte for byte**. Score 0, or
  44. it doesn't count. There are two ways in:
  45. - **Start from scratch.** Drop in a game for N64, PlayStation 1 or 2, GameCube, Wii, Game Boy Advance or DS: a
  46. ROM, a disc image or the program file. decomp.wtf finds every function and your agents take it from there. The
  47. result is a project that rebuilds your game byte for byte: the base for ports and mods. GameCube, Wii and N64
  48. are the [recommended](#platforms) platforms; the rest are in beta.
  49. - **Continue a public decomp.** Pick one of the [245 projects on decomp.dev](https://decomp.dev) for GameCube, Wii,
  50. PlayStation 1 and 2, N64, GBA, DS, Switch, PC, Xbox 360 and more, add your own copy of its game, and your agents
  51. carry on where the community left off, in the project's real source code.
  52. On GameCube and Wii the goal is what real decomps aim for: every file **linked**, so the game is built from its C and
  53. still comes out byte for byte. That's the starting point for a native PC port.
  54. Everything runs on your computer. No account, no telemetry, nothing uploaded.
  55. ## Install
  56. decomp.wtf runs on **Linux**, and on **Windows** (supported, still unstable). The compilers it runs are Linux
  57. programs, so on Windows it runs in its own small Linux (a WSL 2 distribution called `decomp-wtf`), set up by the
  58. same script as on Linux. macOS isn't supported.
  59. **Linux**
  60. ```
  61. curl -fsSL https://decomp.wtf/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 81 on GitHub
  62. ```
  63. Can't reach decomp.wtf from your network? The same installer from GitHub (it then installs the release from GitHub
  64. too):
  65. ```
  66. curl -fsSL https://raw.githubusercontent.com/i12bp8/decomp.wtf/main/site/public/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 88 on GitHub
  67. ```
  68. **Windows** (PowerShell; new and still unstable: problems are worth an [issue](https://github.com/i12bp8/decomp.wtf/issues))
  69. ```
  70. irm https://decomp.wtf/install.ps1 | iex
  71. ```
  72. It turns on WSL 2 if it isn't yet (Windows asks for permission once, and may want a restart), makes decomp.wtf's
  73. Linux from Debian's official WSL image and installs everything in it. You get a `decomp` command, a Start menu entry
  74. and a desktop shortcut. Your projects are at `\\wsl.localhost\decomp-wtf\home\decomp\Decomp`.
  75. One line sets up everything: [uv](https://docs.astral.sh/uv/), the app, the period compilers (pinned and
  76. checksum-verified) and the m2c draft decompiler. It then opens decomp.wtf in your browser. After that, start it any
  77. time from your apps menu (the Start menu on Windows) or by typing `decomp` in a terminal.
  78. **Updates** come by themselves: when there's a new version, decomp.wtf asks once, and one click installs it and
  79. restarts the app in the same tab (helper agents carry on). Settings has "check now", "install updates by itself" and
  80. "don't look for updates".
  81. > [!TIP]
  82. > No ROM at hand? The app ships with **Demo Quest 64**, a real N64 ROM built from public-domain code and zlib.
  83. > Open it from the home screen and watch your agent go.
  84. ## Or just ask your agent
  85. Already living in Claude Code, Codex, Antigravity CLI or opencode? Give it decomp.wtf's tools once:
  86. ```
  87. decomp connect
  88. ```
  89. Then ask it, in your own terminal:
  90. > decompile my game at ~/roms/game.z64
  91. It confirms the game is your own copy, imports it, opens the live view so you can watch, and gets to work with every
  92. tool decomp.wtf has: the original compiler, the byte-for-byte judge, the autopilot, helper agents running in
  93. parallel (`start_agents`) and the rebuildable export. Behind it is `decomp mcp`, an MCP server that starts the app
  94. when needed; you can also add it yourself (`claude mcp add decomp -- decomp mcp`).
  95. | Agent | Install it as a package instead |
  96. | :-- | :-- |
  97. | **Claude Code** | `/plugin marketplace add i12bp8/decomp.wtf`, then `/plugin install decomp-wtf@decomp-wtf` (adds a "decompile" skill) |
  98. | **Codex, Antigravity CLI, opencode** | `decomp connect codex`, `decomp connect antigravity`, `decomp connect opencode` |
  99. ## How it works
  100. <p align="center">
  101. <picture>
  102. <source media="(prefers-color-scheme: dark)" srcset=".github/assets/how-dark.png">
  103. <img alt="Your ROM, split into every function by splat. Your agent writes C, the original compiler builds it, it's linked at its real address and compared byte for byte. If it doesn't match yet, the diff goes back to the agent." src=".github/assets/how-light.png">
  104. </picture>
  105. </p>
  106. 1. **Open a ROM.** splat and spimdisasm find every function and data symbol, and decomp.wtf recognises the
  107. compiler that built the game.
  108. 2. **Add agents.** Each claims a different function and gets its assembly, the data it touches, who calls it, a
  109. machine-made first draft and notes from earlier attempts.
  110. 3. **Watch them match.** Every attempt is compiled, *linked* at the function's real address and compared with the
  111. ROM. A miss returns an instruction diff; a hit is saved, named and shared with every other agent.
  112. <details>
  113. <summary><b>What a match looks like</b></summary>
  114. <br>
  115. The assembly decomp.wtf takes from the ROM:
  116. ```asm
  117. 800007D0 slt $v0, $a0, $a1
  118. 800007D4 bnez $v0, .L800007EC
  119. 800007D8 addu $v0, $a1, $zero
  120. 800007DC addu $v0, $a2, $zero
  121. 800007E0 slt $v1, $v0, $a0
  122. 800007E4 beql $v1, $zero, .L800007EC
  123. 800007E8 addu $v0, $a0, $zero
  124. .L800007EC:
  125. 800007EC jr $ra
  126. 800007F0 nop
  127. ```
  128. The C an agent wrote, which compiles to exactly those bytes with KMC GCC 2.7.2 at `-O2`:
  129. ```c
  130. s32 clamp_s32(s32 v, s32 lo, s32 hi) {
  131. if (v < lo) {
  132. return lo;
  133. }
  134. if (v > hi) {
  135. return hi;
  136. }
  137. return v;
  138. }
  139. ```
  140. </details>
  141. ## Continue a public decomp
  142. Most games people decompile already have a community project with its build set up and part of the code done.
  143. decomp.wtf plugs your agents into them as they are:
  144. 1. **Browse** the decomp.dev catalog in the app (or paste any decomp repository's address) and **fork** it: it's
  145. cloned to your computer on a local `decomp-wtf` branch.
  146. 2. **Add your copy of the game.** The app knows where common project layouts expect it (dtk-template for
  147. GameCube/Wii, configure.py + ninja, splat + make) and runs the project's own setup. Anything else you set up
  148. by its README, and decomp.wtf picks it up once it builds.
  149. 3. **Add agents.** Each claims a function and gets the target assembly, objdiff's diff, the function's source
  150. file, matched look-alikes and a machine draft. Its code goes into the real source file, the project's build
  151. compiles it with the project's compilers, and [objdiff](https://github.com/encounter/objdiff) judges it.
  152. 4. **Every match is a git commit** on `decomp-wtf`, ready for you to review and, if the project welcomes it, send
  153. upstream. Nothing is sent anywhere by itself.
  154. Guard rails, learned from people who ran agents on decomps before: agents write only C/C++ sources and headers,
  155. never targets, assembly or build scripts, and inline assembly is refused. A change that breaks any function that
  156. already matched is undone. The project's file layout (which code belongs to which source file) and which files are
  157. linked are changed by decomp.wtf itself, never typed by an agent, and kept only when the game still builds byte for
  158. byte.
  159. ### From matched to linked
  160. A function at 100% is matched. A file is **linked** when all of it, functions *and* data, matches: the project then
  161. builds the game from that C instead of from the original's code, and checks the whole game against its checksum.
  162. That's decomp.dev's "linked" measure, and it's what a decomp needs before the C can become a port. For
  163. GameCube and Wii projects (dtk-template) decomp.wtf takes care of the steps between:
  164. - **Every function gets a source file.** Most projects still have code no file covers: in Mario Party 6, 17,923
  165. functions. **Give them source files** gives each stretch of that code a file of its own (starting agents does it too),
  166. and `split_file` divides one where the game's original files divided.
  167. - **Files closest to done come first.** When a match finishes a file's functions, the agent is shown the file's data
  168. next to the original's, with what to fix (a table that should be `const`, a static that belongs inside a
  169. function). `file_status` shows it any time.
  170. - **Finished files link themselves.** decomp.wtf marks the file Matching, builds the game and runs the project's
  171. checksum check, and keeps the change only if it passes. A linked file can't be changed in a way that alters the
  172. game. The app shows **% linked** next to % matched.
  173. ## Features
  174. | Feature | What you get |
  175. | :-- | :-- |
  176. | **Live view** | A map of every function in the game, each agent's tool calls, scores falling to zero, all in real time. |
  177. | **Autopilot** | Free matches before agents spend a token: code the game has more than once is matched from its matched twin (names swapped, judged like any attempt: in Mario Party 6, 762 functions in 12 minutes, and 678 copies of hand-written assembly set aside), then every function's machine draft goes through the judge. |
  178. | **Permuter** | Near misses agents leave (95% and up) get rewritten in the background, the way decomp-permuter does it: statement and declaration order, casts, temporaries. Improvements become the function's best attempt; a match is a match. |
  179. | **Fast agents** | Small functions come in batches (one turn writes several, one call judges them all), identical code is shown in the brief, agents are told to move on after four tries without progress, and functions whose code repeats are handed out first (one match, many free). |
  180. | **Your agent, your terminal** | `decomp connect`, then ask Claude Code, Codex or Antigravity CLI to decompile your game: it imports, opens the live view and works. |
  181. | **Edit it yourself** | Every function has an editor: write C, press Ctrl+Enter, see the judge's diff. You count as an agent. |
  182. | **Byte-for-byte check** | Candidates are linked at the real address, so calls, globals, strings and jump tables are verified too. |
  183. | **Any agent** | Claude Code, Codex, Antigravity CLI, opencode, or any model with an API key, several at once: save one endpoint per machine or provider (llama.cpp, Ollama, LM Studio, DeepSeek...) and spread sessions across them. |
  184. | **Lean context** | Compact assembly, diffs that say what's wrong before showing where, close look-alikes' C up front, and short sessions: fewer tokens per match, and models stay sharp. |
  185. | **Shared knowledge** | Structs and prototypes go into one header, accepted only if every match so far still matches. |
  186. | **Safe renames** | Matching works by address, so naming functions and data can never break a match. |
  187. | **Public decomps** | Fork any of 245 community projects from decomp.dev and keep going with your agents, judged by objdiff. |
  188. | **Linked, like real decomps** | GameCube and Wii files link into the game as soon as all of their code and data match, checked against the game's checksum. |
  189. | **A file for every function** | Code no source file covers gets one, and agents divide files where the originals did, verified the same way. |
  190. | **Look-alikes** | `find_similar` spots copy-pasted and inlined code across the whole game and starts agents from what already matches. |
  191. | **Drafts** | m2c for MIPS, PowerPC and ARM; optional Ghidra for x86, AArch64 and everything else. |
  192. | **Agent toolkit** | A data inspector, a call graph, splitting merged functions, and guides for MIPS, PowerPC, ARM, x86, AArch64, IDO, GCC, Metrowerks, agbcc, PSY-Q, C++ and objdiff. |
  193. | **Decompile together** | A team of any size, each with their own copy and agents: one host, public or private rooms, hosted by you (home PC or server, `decomp host`). Only the work is shared, never the game. |
  194. | **Rebuildable export** | A decomp project that rebuilds your game byte for byte, ready for ports and mods and for any other tool or agent. |
  195. | **Every major disc format** | ROMs, PlayStation discs, GameCube and Wii discs (ISO, GCM, RVZ, WIA, WBFS, CISO, GCZ) and program files, streamed from disk. |
  196. ## Agents
  197. | Agent | How it connects |
  198. | :-- | :-- |
  199. | **Claude Code** | Runs headless against the app's local MCP server. |
  200. | **Codex CLI** | Same, with approvals limited to decomp.wtf's tools. |
  201. | **Antigravity CLI** | Same, through the workspace's own MCP config. Google's successor to Gemini CLI (`agy`), which it retired in June 2026. |
  202. | **opencode** | Same, with any provider you've set up: DeepSeek, Qwen, Kimi and more. |
  203. | **API key** | A built-in agent loop for any OpenAI-compatible API: DeepSeek, OpenRouter, OpenAI, or a model on your own computer with llama.cpp, Ollama or LM Studio. It keeps the conversation within the model's context. |
  204. | **The agent you talk to** | `decomp connect` (or the Claude Code plugin above): it drives decomp.wtf from your own terminal and can start helpers. |
  205. | **Anything else** | Point any MCP client (Cursor, Claude Desktop, your own) at `decomp mcp`, or at the app with **Connect another agent**. |
  206. 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
  207. and tells you how to sign in. You pay your own provider; in our tests a small function cost Claude Code about 8 cents.
  208. Big functions take many more attempts, and cheaper models often get stuck on them on register allocation, so expect
  209. the easy part of a game to go fast and the rest to take real time.
  210. **Local models.** Start the model with at least 16K tokens of context (llama.cpp: `-c 16384`; Ollama:
  211. `OLLAMA_CONTEXT_LENGTH=16384`, or it quietly cuts the start of each request off; LM Studio: Context Length), choose
  212. its preset under **Agents & models → API key**, and set the context size there if it isn't llama.cpp (which says it
  213. itself). The agent trims older tool output to stay within it. Small models do the small functions; the big ones
  214. need a strong model.
  215. ## Decompile together
  216. A whole team, any size, each on their own computer with their own copy of the game and their own agents, working on
  217. one game. One computer is the room's **host**: it hands out functions so nobody does the same one twice, checks every
  218. match against its own copy, and shares names, structs and notes with everyone. Nothing goes through decomp.wtf's
  219. website: the people who decompile together host their room and decide who's in.
  220. **On a home PC:** open the project, click **Decompile together**, **Open the room**. Send the link.
  221. **On a server** (or any always-on machine):
  222. ```
  223. curl -fsSL https://decomp.wtf/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 285 on GitHub
  224. decomp host mygame.z64 --own-copy --address http://my-server:6481 --service
  225. ```
  226. That runs decomp.wtf in the background (starting with the computer), imports your copy, opens the room and prints the
  227. link. **Joining:** paste the link into **Join a team's room** in the app, or `decomp join <link> <your copy> --name you`.
  228. | | |
  229. | :-- | :-- |
  230. | **Private or public** | Private rooms need the invite link; public rooms only the address. Optionally approve each new member. |
  231. | **Your address** | A free Cloudflare quick tunnel with nothing to set up, or an address you control: your LAN, Tailscale, a server. Rooms at your own address reopen with the same link after a restart. |
  232. | **The host's controls** | Who's online and on what, remove members, a fresh invite link, stop sharing. |
  233. | **Light on the host** | Members compile their own attempts; the host compiles only to verify matches. Agents wait while the host is away and carry on when it's back. |
  234. | **Every kind of project** | Games started from a ROM, GameCube, Wii and DS games started from scratch, and forks of public decomps. A git project's members get its source tree from the host (only what git tracks, never the game), build it with their own copy and tools, and follow every commit made in the room: matches are confirmed and committed by the host, edits of shared files are made there. |
  235. No ROM bytes or assembly ever cross the wire: everyone reads the code from their own copy, which must be identical to
  236. the host's. The decompiled code of a commercial game belongs to its rights holder: share it only with people who own
  237. the game.
  238. ## Platforms
  239. | Platform | Status | From scratch | Compilers | Rebuildable project | Public decomps |
  240. | :-- | :-- | :-- | :-- | :-- | :-- |
  241. | **GameCube · Wii** | ★ **Recommended** | ✓ disc (ISO, RVZ, WBFS…) or DOL | CodeWarrior GC 1.0 – Wii 1.7 | ✓ dtk-template | ✓ |
  242. | **Nintendo 64** | ★ **Recommended** | ✓ ROM | KMC GCC 2.7.2 · IDO 5.3 / 7.1 | ✓ export | ✓ |
  243. | **PlayStation** | Beta | ✓ disc (.bin, .iso, .chd) or EXE | GCC 2.7.2 / 2.8.1 (PSY-Q era) | ✓ export | ✓ |
  244. | **PlayStation 2** | Beta | ✓ disc or ELF | EE-GCC 2.96 | ✓ export | ✓ |
  245. | **Game Boy Advance** | Beta | ✓ ROM | agbcc | ✓ export | ✓ |
  246. | **Nintendo DS** | Beta | ✓ ROM (.nds) | CodeWarrior for DS 1.2 – DSi 1.6 | ✓ ds-decomp | ✓ |
  247. | **3DS · PSP · Switch · PC · Xbox · Xbox 360** | coming | | | | ✓ |
  248. **Recommended platforms: GameCube, Wii and Nintendo 64.** They're the most tested path from dropping in a game to a
  249. full decomp you can port and mod:
  250. - **GameCube and Wii** projects are the same kind as decomp.dev's (dtk-template): the game is rebuilt and checked
  251. byte for byte on every build, and finished files are linked into it as they're done, which is where a native PC
  252. port starts. Imported from scratch from Mario Party 4, Melee, Mario Kart: Double Dash, Mario Kart Wii and
  253. Twilight Princess discs.
  254. - **Nintendo 64** imports are tested on Super Mario 64, GoldenEye and Perfect Dark, including code loaded later and
  255. code shipped compressed, and the export rebuilds the ROM byte for byte. For now the export puts every function at
  256. its original address: right for matching and for a port, while a mod that makes code bigger needs a shiftable
  257. build, which is coming.
  258. **Beta: PlayStation, PlayStation 2, Game Boy Advance and DS.** They work end to end and are tested on homemade
  259. games, much less on real ones so far. Expect rough edges, and please
  260. [report](https://github.com/i12bp8/decomp.wtf/issues) what you hit: the app's error panel copies everything an issue
  261. needs. Public decomps of any platform run in their own project's build, so their status is the project's.
  262. **From scratch.** splat and spimdisasm split MIPS games, decomp-toolkit analyses GameCube and Wii programs inside a
  263. generated [dtk-template](https://github.com/encounter/dtk-template) project, [ds-decomp](https://github.com/AetiasHax/ds-decomp)
  264. analyses DS ROMs (ARM9, ITCM, DTCM, overlays) inside a generated project of the same kind, and Game Boy Advance
  265. ROMs are split by [luvdis](https://github.com/aarant/luvdis) plus decomp.wtf's own pass for code nothing calls.
  266. Code beyond the main program is found too: N64 code the game loads later (placed at its address from its own
  267. calls, including code run through the TLB and code Rare and Nintendo shipped compressed), and the PlayStation 1 and
  268. 2 overlays in a disc's other files. Every attempt is
  269. compiled with the game's compiler and checked byte for byte: linked at its address in the original (MIPS, ARM)
  270. or judged by objdiff inside the project's own build (GameCube, Wii, DS).
  271. **The base for ports and mods.** *Export project* writes a normal decomp tree (matched functions as C, the rest as
  272. assembly from splat or luvdis, a linker script and `build.py`) and proves it rebuilds your game byte for byte.
  273. GameCube and Wii projects are dtk-template projects and DS projects are ds-decomp projects; both rebuild the game on
  274. every build, and GameCube and Wii files are linked as they're finished. Game code and data stay out of git: they're regenerated from your own copy, so the tree can be shared
  275. and continued with any tool or agent.
  276. **C and C++.** GameCube, Wii and DS games are often C++, and decomp.wtf handles it there: code with C++ symbol
  277. names goes into `.cpp` files, drafts come out as C++, and agents get a guide to classes, vtables, constructors,
  278. inlines and name mangling. On N64, PlayStation, PS2 and GBA, functions started from scratch are written in C for
  279. now; C++ there (mostly PS2 games) is coming. Public decomps use whatever language the project does.
  280. **Proprietary compilers** (IDO, CodeWarrior, CodeWarrior for DS) are only installed after you accept that. Heavy
  281. tools run with a memory cap, so a runaway analysis can't take your computer down.
  282. **Windows.** Several of the compilers (KMC GCC, the PlayStation GCCs, EE-GCC, agbcc) only exist as Linux programs,
  283. so on Windows decomp.wtf runs in its own WSL 2 distribution. The installer sets that up; you use the app in your
  284. browser as usual, and the results are byte-identical to Linux. macOS isn't supported.
  285. **When something goes wrong.** A failed import stays on screen with the reason and what happened, and **Copy for a
  286. bug report** puts the version, the error and the log on your clipboard for an
  287. [issue](https://github.com/i12bp8/decomp.wtf/issues). The full log is `.decomp/logs/decomp.log` in your projects folder
  288. (`~/Decomp`), also at **The full log** in that panel.
  289. ## Development
  290. ```bash
  291. uv sync
  292. uv run decomp # opens the app; projects live in ~/Decomp (or $DECOMP_HOME)
  293. uv run pytest
  294. ```
  295. <details>
  296. <summary><b>Repository layout</b></summary>
  297. <br>
  298. | Path | What it is |
  299. | :-- | :-- |
  300. | `src/decompnet/rom/` | ROM reading (`n64.py`, `psx.py`), splitting with splat (`split.py`), the symbol table and the matcher (`match.py`). |
  301. | `src/decompnet/app/` | The app: `engine.py` (ROM projects), `forkengine.py` (forks of public decomps), `tools.py` (MCP tools and agent prompt), `agents.py` (running agents), `server.py` (GUI API and MCP), `collab.py` (rooms), `static/` (GUI), `guide/` (agent know-how). |
  302. | `src/decompnet/forks/` | Fork mode: the decomp.dev catalog, project detection and setup, objdiff, source editing, m2c and Ghidra drafts, linking and file splits for dtk-template projects (`project.py`, `dtksplits.py`), and data diffs (`datadiff.py`). |
  303. | `src/decompnet/network.py` | The coordination core the engine builds on: claims, attempts, notes, the shared header. |
  304. | `src/decompnet/toolchains.py` | The pinned compilers: verified downloads and installs. |
  305. | `src/decompnet/hostenv.py`, `app/updates.py` | Where decomp.wtf runs (Linux itself, its WSL 2 distribution on Windows, Docker on a server) and what crosses to the computer around it; updates. |
  306. | `src/decompnet/app/twins.py`, `app/permute.py` | Free matches: identical code from its matched twin, and the background permuter for near misses. |
  307. | `site/public/install.sh`, `install.ps1`, `linux-base.sh`, `Dockerfile` | The installers: decomp.wtf's own Linux (WSL on Windows, Docker on a server) is made by `linux-base.sh` on Debian. |
  308. | `projects/demo-rom/` | Builds Demo Quest 64. `tests/test_rom.py` proves the matcher on it: every function of the original source matches. |
  309. | `projects/demo-psx/` | The same game as a PlayStation executable, for `tests/test_psx.py`. |
  310. | `projects/demo-fork/` | A small decomp project in the community's shape (objdiff.json, ninja), for `tests/test_forks.py`. |
  311. | `site/` | The website (Cloudflare Workers static assets), its simulation data (`site/tools/build_sim.py`) and legal pages. |
  312. Rebuild the demo ROM with `uv run python projects/demo-rom/build.py` (needs `gcc-2.7.2-kmc` and `ld.lld`).
  313. **Testing a branch.** Run the installer from a checkout of the branch: it installs that checkout,
  314. and the installed app then follows the branch on GitHub (every new commit pushed there shows up as an update in the
  315. app: one click installs it).
  316. ```
  317. git clone -b <branch> https://github.com/i12bp8/decomp.wtf && cd decomp.wtf
  318. powershell -ExecutionPolicy Bypass -File site\public\install.ps1 # Windows
  319. bash site/public/install.sh # Linux
  320. ```
  321. Without a checkout: `$env:DECOMP_BRANCH = "<branch>"; irm https://raw.githubusercontent.com/i12bp8/decomp.wtf/<branch>/site/public/install.ps1 | iex`
  322. on Windows, `curl -fsSL https://raw.githubusercontent.com/i12bp8/decomp.wtf/<branch>/site/public/install.sh | DECOMP_BRANCH=<branch> bash`
  323. on Linux. `decomp update` (or the app's Settings) installs the newest commit by hand.
  324. </details>
  325. ## Built on
  326. [splat](https://github.com/ethteck/splat) and [spimdisasm](https://github.com/Decompollaborate/spimdisasm) split
  327. ROMs, [objdiff](https://github.com/encounter/objdiff) judges forks, [m2c](https://github.com/matt-kempster/m2c) and
  328. [Ghidra](https://github.com/NationalSecurityAgency/ghidra) write first drafts, the
  329. [decompals](https://github.com/decompals) recompiled period compilers do the building, and
  330. [decomp.dev](https://decomp.dev) lists the public projects. The look-alike finder follows the idea of
  331. [coddog](https://github.com/ethteck/coddog); [decomp-toolkit](https://github.com/encounter/decomp-toolkit),
  332. [maspsx](https://github.com/mkst/maspsx) and [wibo](https://github.com/decompals/wibo) are in the pinned toolbelt
  333. (`decompnet toolchain install <name>`). Thanks to everyone in the decomp community whose tools and ideas made this
  334. possible. decomp.wtf isn't affiliated with any of these projects.
  335. ## Use it responsibly
  336. decomp.wtf contains no game code and doesn't provide ROMs. Use games you own, don't use it to get around copy
  337. protection, and don't publish decompiled code of games whose rights you don't hold. When you continue a public
  338. decomp, follow that project's license and contribution rules; forking runs its build scripts on your computer, so
  339. fork projects you trust.
  340. Many community decomps don't accept AI-written contributions, and the ones that do expect a person to stand behind
  341. every line. decomp.wtf never sends anything upstream: your agents' work stays on your local branch. Before you open a
  342. pull request, read the project's CONTRIBUTING (or ask its maintainers), review the code yourself, and say how it
  343. was made.
  344. ## License
  345. [MIT](LICENSE) © 2026 Sam Wolfs
  346. <br>
  347. <p align="center"><sub>Not affiliated with Nintendo or Sony. Nintendo 64 and PlayStation are their trademarks.</sub></p>

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.