Skip to content
Back to search

decomp-anything

MarketplaceWorks with Claude CodeGitHub

decomp.wtf fork: Windows PE matching, MinGW/clang-cl toolchains, and an optional REA MCP bridge

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/giveen--decomp-anything/badge.svg)](/listings/giveen--decomp-anything)

HTML

<a href="/listings/giveen--decomp-anything"><img src="/api/listings/giveen--decomp-anything/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.anything runs on **Linux x86-64** and, through **WSL 2**, on Windows. macOS isn't supported. It needs Python 3.12 or newer and [uv](https://docs.astral.sh/uv/). Node.js is needed for npm-based agents and for REA; Java 21 or newer is needed for Ghidra.

**From this repository:**

git clone https://github.com/giveen/decomp.anything.git
cd decomp.anything
uv sync
uv run decomp

That starts the app and opens it in your browser. Projects live in `~/Decomp` by default; set `DECOMP_HOME` to put them elsewhere.

**Desktop install from the checkout.** The repository's own installers install this checkout, not the upstream release:

bash install/install.sh

On Windows, in PowerShell:

powershell -ExecutionPolicy Bypass -File install\install.ps1

The Windows installer turns on WSL 2 if needed, creates the `decomp-wtf` distribution, installs this checkout inside it, and adds a `decomp` command plus app-menu and desktop shortcuts. Checkout installs record this repository as their update source, so updates follow decomp.anything rather than upstream.

**Settings → About** also checks npm for updates to the app-managed REA toolset. **Update REA** installs the exact stable release into a separate folder, checks its MCP connection and supported tool catalog, then restarts the app to refresh agent connections. A failed installation leaves the selected version intact. REA automatic updates have their own switch (off by default), and wait for helpers and background jobs to be idle. **Look for updates** controls both feeds; **Check now** checks them manually. Custom REA commands stay externally managed. Ghidra, IDA, Hopper, Rizin and external agent registrations or skills retain their own setup and update process.

**From GitHub, without a website:**

curl -fsSL https://raw.githubusercontent.com/giveen/decomp.anything/main/install/install.sh | bash

On Windows, in PowerShell:

irm https://raw.githubusercontent.com/giveen/decomp.anything/main/install/install.ps1 | iex

Those follow `main` by default. Add `DECOMP_SOURCE` or `DECOMP_BRANCH` to install a branch, or run the checkout installer to install a local tree.

Open **Compilers & tools** to install what a target needs. The period compilers are pinned and checksum-verified; proprietary ones (IDO, CodeWarrior) are only installed after you accept their license. REA and Ghidra are optional.

> [!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 an 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
  1. {
  2. "name": "decomp-anything",
  3. "owner": {"name": "decomp.anything", "url": "https://github.com/giveen/decomp.anything"},
  4. "metadata": {"description": "decomp.anything: reverse-engineer games, programs, apps and more with your AI agent."},
  5. "plugins": [
  6. {
  7. "name": "decomp-anything",
  8. "source": "./plugins/decomp-anything",
  9. "description": "Decompile games or programs you own into C or C++ that rebuilds them byte for byte, or open any other binary as an REA analysis project: agents, findings and the same dashboard.",
  10. "version": "0.11.0"
  11. }
  12. ]
  13. }
README.md · README · 720 lines · 2 findings marked
  1. # decomp.anything
  2. **Point an AI agent at something you own and take it apart.** decomp.anything is a matching-decompilation and
  3. reverse-engineering workbench for games, Windows and Linux programs, apps, web pages, firmware and plain files.
  4. Agents write C or C++ against the real binary, the original compiler builds it, and the result is checked byte for byte —
  5. or, when there is no original build to match, the same project opens the binary with REA and agents analyze its
  6. functions instead.
  7. <p align="center">
  8. <a href="https://github.com/i12bp8/decomp.wtf">
  9. <picture>
  10. <source media="(prefers-color-scheme: dark)" srcset=".github/assets/banner-dark.png">
  11. <img alt="decomp.anything builds on decomp.wtf: your AI agent decompiles software you own into C that compiles to the exact same bytes." src=".github/assets/banner-light.png">
  12. </picture>
  13. </a>
  14. </p>
  15. <p align="center">
  16. <a href="#install"><b>Install</b></a>
  17. &nbsp;·&nbsp;
  18. <a href="#how-matching-works"><b>How matching works</b></a>
  19. &nbsp;·&nbsp;
  20. <a href="#inspect-anything"><b>Inspect anything</b></a>
  21. &nbsp;·&nbsp;
  22. <a href="#continue-a-public-decomp"><b>Public decomps</b></a>
  23. &nbsp;·&nbsp;
  24. <a href="#agents"><b>Agents</b></a>
  25. &nbsp;·&nbsp;
  26. <a href="#decompile-together"><b>Decompile together</b></a>
  27. &nbsp;·&nbsp;
  28. <a href="#built-on"><b>Built on</b></a>
  29. </p>
  30. <p align="center">
  31. <a href="LICENSE"><img alt="MIT license" src="https://img.shields.io/badge/license-MIT-157a49?style=flat-square"></a>
  32. <img alt="Linux and Windows" src="https://img.shields.io/badge/platform-Linux%20%7C%20Windows%20(WSL%202)-15140f?style=flat-square">
  33. <img alt="Python 3.12 or newer" src="https://img.shields.io/badge/python-3.12%2B-15140f?style=flat-square">
  34. <img alt="Works with any MCP agent" src="https://img.shields.io/badge/agents-any%20MCP%20client-157a49?style=flat-square">
  35. </p>
  36. ## Fork of decomp.wtf
  37. decomp.anything is an independent fork of **[decomp.wtf](https://github.com/i12bp8/decomp.wtf)** by Sam Wolfs. The
  38. upstream project is discontinued, but its code is MIT licensed, so this fork continues it and extends it. This
  39. repository is the active continuation.
  40. Where decomp.wtf focused on matching retro games, decomp.anything extends the same engine to arbitrary software:
  41. Windows and Linux binaries can be matched byte for byte, and anything else opens as an **REA project** — the same
  42. project dashboard, agents and notes, with its procedures as work items. There is no separate REA mode to learn.
  43. What stays from decomp.wtf:
  44. - the split → claim → write C or C++ → compile with the original compiler → link at the real address → compare byte for byte
  45. workflow;
  46. - the matching engine and matchers for MIPS, PowerPC, ARM, x86 and x86-64;
  47. - the live view, autopilot, permuter, shared knowledge, helper agents and rebuildable exports;
  48. - continuation of public decomp projects, judged with objdiff;
  49. - the installers, toolchain registry and local-first design: no account, no telemetry, nothing uploaded.
  50. What this fork adds:
  51. - **[RE console](#inspect-anything):** a graphical front end for [REA](https://rea.tools)'s tool catalog, opened from
  52. a procedure work item (or a PC function). Browse native binaries, Android apps, .NET assemblies, JavaScript and
  53. Electron apps, web pages, firmware and plain files; functions, pseudocode, strings, flow graphs and call graphs,
  54. plus a generated form for every REA tool.
  55. - **Linux targets:** x86 and x86-64 ELF executables and shared libraries import and match like Windows programs.
  56. - **Windows targets:** 32-bit and 64-bit PE executables and DLLs, with a relocation-aware x86 matcher.
  57. - **REA for agents:** `inspect_binary` can ask REA for pseudocode, signatures and callers; REA itself can be installed
  58. from **Compilers & tools**.
  59. - **Reference folders:** point an agent at a matched decomp, notes or symbol lists; it can read and search them.
  60. - **opencode 2** support for helper agents and `decomp connect`.
  61. Matching is still the byte-exact path. Every binary opens as a normal project: matchable targets get the compile-and-
  62. compare loop, and everything else gets REA work items, the same agents, the same dashboard and findings instead.
  63. ## What you can do
  64. | Goal | What decomp.anything gives you |
  65. | :-- | :-- |
  66. | **Decompile a game** | Drop in a ROM, disc image or program file. Agents claim functions, write C or C++, and the original compiler proves each match byte for byte. |
  67. | **Match a PC program** | Import a Windows `.exe`/`.dll` or a Linux ELF program or `.so`, write C or C++, and compare the compiler's bytes with the original's. |
  68. | **Continue a public decomp** | Fork one of the community projects the app knows about and let agents carry on in the project's real source tree. |
  69. | **Inspect anything else** | Drop it like a game. If this app can't split or match it, REA opens it in a normal project: its procedures become work items, agents read them in parallel, and their findings land on the same dashboard. Add tasks for areas with no procedure of their own. |
  70. | **Look inside an archive** | Drop a ZIP, TAR or similar archive. Every regular file is a work item; **Contents** previews it, and a binary or nested archive can open as a linked child project. |
  71. | **Work together** | Host a room, invite people, and share matches, names, structs and notes without sharing the original file. |
  72. | **Use your own agent** | Claude Code, Codex, Antigravity CLI, opencode, an OpenAI-compatible endpoint, or any MCP client. |
  73. Everything runs on your computer. No account, no telemetry, nothing uploaded.
  74. ## Install
  75. decomp.anything runs on **Linux x86-64** and, through **WSL 2**, on Windows. macOS isn't supported. It needs
  76. Python 3.12 or newer and [uv](https://docs.astral.sh/uv/). Node.js is needed for npm-based agents and for REA; Java
  77. 21 or newer is needed for Ghidra.
  78. **From this repository:**
  79. ```bash
  80. git clone https://github.com/giveen/decomp.anything.git
  81. cd decomp.anything
  82. uv sync
  83. uv run decomp
  84. ```
  85. That starts the app and opens it in your browser. Projects live in `~/Decomp` by default; set `DECOMP_HOME` to put
  86. them elsewhere.
  87. **Desktop install from the checkout.** The repository's own installers install this checkout, not the upstream
  88. release:
  89. ```bash
  90. bash install/install.sh
  91. ```
  92. On Windows, in PowerShell:
  93. ```powershell
  94. powershell -ExecutionPolicy Bypass -File install\install.ps1
  95. ```
  96. The Windows installer turns on WSL 2 if needed, creates the `decomp-wtf` distribution, installs this checkout inside
  97. it, and adds a `decomp` command plus app-menu and desktop shortcuts. Checkout installs record this repository as their
  98. update source, so updates follow decomp.anything rather than upstream.
  99. **Settings → About** also checks npm for updates to the app-managed REA toolset. **Update REA** installs the exact
  100. stable release into a separate folder, checks its MCP connection and supported tool catalog, then restarts the app
  101. to refresh agent connections. A failed installation leaves the selected version intact. REA automatic updates have
  102. their own switch (off by default), and wait for helpers and background jobs to be idle. **Look for updates** controls
  103. both feeds; **Check now** checks them manually. Custom REA commands stay externally managed. Ghidra, IDA, Hopper,
  104. Rizin and external agent registrations or skills retain their own setup and update process.
  105. **From GitHub, without a website:**
  106. ```bash
  107. curl -fsSL https://raw.githubusercontent.com/giveen/decomp.anything/main/install/install.sh | bash
    • Note: Pipes a downloaded script directly into a shell (curl | sh / wget | bash)
    • Line 135 on GitHub
  108. ```
  109. On Windows, in PowerShell:
  110. ```powershell
  111. irm https://raw.githubusercontent.com/giveen/decomp.anything/main/install/install.ps1 | iex
  112. ```
  113. Those follow `main` by default. Add `DECOMP_SOURCE` or `DECOMP_BRANCH` to install a branch, or run the checkout
  114. installer to install a local tree.
  115. Open **Compilers & tools** to install what a target needs. The period compilers are pinned and checksum-verified;
  116. proprietary ones (IDO, CodeWarrior) are only installed after you accept their license. REA and Ghidra are optional.
  117. > [!TIP]
  118. > No ROM at hand? The app ships with **Demo Quest 64**, a real N64 ROM built from public-domain code and zlib.
  119. > Open it from the home screen and watch an agent go.
  120. ## Ask your agent
  121. Already using Claude Code, Codex, Antigravity CLI or opencode? Give it decomp.anything's tools once:
  122. ```bash
  123. decomp connect
  124. ```
  125. Then ask in your own terminal:
  126. > decompile my game at ~/roms/game.z64
  127. or, for something that isn't a game:
  128. > work on the binary at ~/bin/app.apk: map its classes and exported components
  129. The agent imports or opens the target, shows the live view, and uses the same tools you do. Behind it is
  130. `decomp mcp`, an MCP server that starts the app when needed. You can register it yourself:
  131. ```bash
  132. claude mcp add decomp -- decomp mcp
  133. ```
  134. | Agent | Install it as a package instead |
  135. | :-- | :-- |
  136. | **Claude Code** | `/plugin marketplace add giveen/decomp.anything`, then `/plugin install decomp-anything@decomp-anything` (adds "decompile" and "investigate" skills) |
  137. | **Codex, Antigravity CLI, opencode** | `decomp connect codex`, `decomp connect antigravity`, `decomp connect opencode` |
  138. ## How matching works
  139. <p align="center">
  140. <picture>
  141. <source media="(prefers-color-scheme: dark)" srcset=".github/assets/how-dark.png">
  142. <img alt="The target is split into functions. The agent writes C, the original compiler builds it, it is linked at its real address and compared byte for byte. If it doesn't match, the diff goes back to the agent." src=".github/assets/how-light.png">
  143. </picture>
  144. </p>
  145. 1. **Split the target.** splat and spimdisasm find game functions and data; the PE reader does the same for Windows
  146. programs from `.pdata`, symbols, exports and calls; the ELF reader uses the symbol table or `.eh_frame`. Other
  147. tools cover GameCube/Wii, DS, GBA and PlayStation targets.
  148. 2. **Add agents.** Each agent claims a different function and gets its assembly, the data it touches, callers, a
  149. machine-made draft and notes from earlier attempts.
  150. 3. **Compile and compare.** Every attempt is compiled with the original compiler and linked at the function's real
  151. address, or judged by objdiff inside the project's own build. A miss returns an instruction diff; a hit is saved,
  152. named and shared with every other agent.
  153. Score 0 means the bytes match. There is no approximate success.
  154. **When a match isn't possible, the code is still recovered.** A function that can't be built byte-exactly — the
  155. original compiler is proprietary or gone, or the target was patched past what the split describes — can be
  156. reconstructed by an agent with `write_source`. The code goes into the project's `recovered/` tree, is labelled
  157. reconstructed and unverified, and never counts as a match: **Overview → Sources** keeps verified matches and
  158. reconstructions apart, and **Export sources** writes the tree with a `RECONSTRUCTION.md` that names every verified,
  159. reconstructed and still-missing function. A later byte-exact match replaces the reconstruction.
  160. <p align="center">
  161. <img alt="decomp.anything at work: agents claim functions, attempts drop to score 0, and the map turns green." src=".github/assets/demo.webp" width="900">
  162. <br>
  163. <sub>The original decomp.wtf simulation, running on the demo ROM that ships with the app.</sub>
  164. </p>
  165. <details>
  166. <summary><b>What a match looks like</b></summary>
  167. <br>
  168. The assembly taken from the target:
  169. ```asm
  170. 800007D0 slt $v0, $a0, $a1
  171. 800007D4 bnez $v0, .L800007EC
  172. 800007D8 addu $v0, $a1, $zero
  173. 800007DC addu $v0, $a2, $zero
  174. 800007E0 slt $v1, $v0, $a0
  175. 800007E4 beql $v1, $zero, .L800007EC
  176. 800007E8 addu $v0, $a0, $zero
  177. .L800007EC:
  178. 800007EC jr $ra
  179. 800007F0 nop
  180. ```
  181. The C an agent wrote, which compiles to exactly those bytes with KMC GCC 2.7.2 at `-O2`:
  182. ```c
  183. s32 clamp_s32(s32 v, s32 lo, s32 hi) {
  184. if (v < lo) {
  185. return lo;
  186. }
  187. if (v > hi) {
  188. return hi;
  189. }
  190. return v;
  191. }
  192. ```
  193. </details>
  194. ## Inspect anything
  195. A binary that isn't a game or a matchable program still opens as a **project**, not a separate mode: the normal
  196. picker falls back to REA, its procedures become work items, and agents claim them exactly like functions in a game.
  197. The project dashboard shows analyzed items, findings, agent output and the live map; **Add task** covers areas that
  198. have no procedure of their own.
  199. An **archive** is a project too (ZIP, TAR and their common variants). REA inventories it and the **Contents**
  200. panel shows the tree with a preview of each file. Code that shipped as text — JavaScript, Python, C, Java, HTML,
  201. CSS, shell and the rest — is extracted byte for byte into the project's `recovered/` tree (verified, never
  202. reconstructed), so a ZIP of sources opens as code rather than as prose to write about. Compiled entries whose source
  203. didn't ship (`.pyc`, `.class`, `.luac`, …) become reconstruction work items, as does any text source the archive
  204. can't decode; everything else stays a regular work item. Analyze a binary or a nested archive from Contents to
  205. extract only that entry and open it as a linked child project; child targets appear under their parent in the
  206. sidebar, and their findings roll into the parent's `SUMMARY.md`. Text and assets stay readable in place. The extraction limits are deliberately generous for your own files: 2 GiB archive input, 20,000 entries,
  207. 1 GiB uncompressed, 1000:1 per-entry compression, 256 MiB per entry and 512 MiB extracted per project.
  208. **RE console** is the deep viewer behind a project, not a separate mode: click a procedure work item in an analysis
  209. project, or a function's **RE console** button in a PC project. It is also a manual front end for
  210. [REA](https://rea.tools) (Reverse Engineer Anything), covering REA's whole catalog: native programs, Android apps,
  211. .NET assemblies, JavaScript and Electron apps, web pages, firmware and plain files. Nothing has to be a game, and
  212. nothing has to match.
  213. - **Open a target** by path. Native code is analysed by Ghidra, Hopper, IDA or Rizin (pick the engine next to the
  214. path). The sidebar lists functions, strings and memory segments; the overview shows counts, a memory map and the
  215. largest functions.
  216. - **A function** opens as pseudocode next to its assembly, with clickable names and jumps that highlight their
  217. target. It also has a control-flow graph, a callers/callees graph, the strings and names it uses, and everything
  218. else REA reports.
  219. - **Every tool has a form**, built from REA's own schema and filled with its example. Results come back as tables,
  220. code or JSON, with the engine, confidence and limitations REA states. The full tool list is grouped by kind.
  221. - **A terminal** logs every call; click a line to see its result again. You can also type `open PATH`, `fn ADDRESS`,
  222. `tools WORD`, or any tool as `TOOL key=value` or `TOOL {json}`, with Tab completion and history.
  223. - **Two ways into matching:** **Decompile it** turns an open Windows or Linux program into a byte-matching project;
  224. in a PC project, a function's **RE console** button opens that function here.
  225. **Feature traces.** In a JavaScript or Electron project, **Trace a feature** takes one literal seed — a route,
  226. string, API, IPC channel, module or node id — and asks REA to walk the application graph from it. Every module,
  227. channel and endpoint the trace reaches becomes a work item grouped under `feature:<name>`, unless it already has
  228. one. Each agent's brief says how the trace reached its node and that static reachability is not proof it runs.
  229. Findings roll into `SUMMARY.md` under **Features**; **Remove** drops the feature and the work items nobody has
  230. analyzed yet, keeping finished findings.
  231. **Recovered and reconstructed code.** An app that shipped source maps starts with its original files in
  232. `recovered/`; modules no map covers become items agents reconstruct. In app, game and archive projects, **Overview →
  233. Sources** shows what is verified, what an agent reconstructed and what is still without code, and **Export sources**
  234. writes the tree plus a `RECONSTRUCTION.md` report. Verified and reconstructed code are never mixed up.
  235. **A binary can end in code too.** In a project opened with REA (a `.exe`, `.so`, firmware image, APK or .NET
  236. assembly), an agent can save the code it reconstructed for a procedure or task: claim the item, then
  237. `write_source`. Files land in `recovered/functions/`, `recovered/tasks/` or `recovered/features/`, the work item is
  238. marked analyzed, and any finding it already had is kept. There is no byte-exact tier for an analyzed target —
  239. the Sources panel and `RECONSTRUCTION.md` say so instead of implying verification — and reconstructed code never
  240. replaces a finding.
  241. **Setup.** The console finds REA by itself when it can, in this order:
  242. 1. the console's own saved settings
  243. 2. `DECOMP_REA`
  244. 3. `rea` on PATH
  245. 4. REA installed from **Compilers & tools** in the app
  246. 5. an `rea` server registered with Claude Code (`~/.claude.json`), with its environment
  247. 6. `npx -y rea-agents@6.7.0 mcp`
  248. **REA settings** in the console set the command, the native engine and environment variables such as
  249. `GHIDRA_INSTALL_DIR`, `JAVA_HOME` or `HOPPER_LAUNCHER_PATH`. They're saved in `.decomp/rea.json`, and the agents'
  250. `inspect_binary` uses them too. Values that look like secrets are never sent to the page.
  251. The console reports the connected server's version and command source. When REA reconnects, its tool catalog and
  252. forms refresh; a call prepared for an earlier connection must be reviewed and retried.
  253. **Safety.** The console runs its own REA process, so it never switches the target the agents are reading. Most tools
  254. only read. Tools that run or drive a program, browser or device, change a device, connect to pages, or write files run
  255. only after you confirm. The app enforces this, not only the page. Everything REA shows about a target is treated as
  256. untrusted text.
  257. ## Starting context at import
  258. The picker has an optional **Starting context** section, applied immediately after import:
  259. - **What is this?** — version, engine, focus, conventions; becomes the project's instructions.
  260. - **Debug/symbol file** — PDB, MAP, `symbol_addrs.txt`, or an ELF with DWARF.
  261. - **Type/header file** — C declarations, structs, enums and prototypes; goes into `context.h`.
  262. - **Reference source folder** — an existing decomp or port agents may read and search.
  263. - **Runtime trace** — coverage addresses/counts; imported before the first claim.
  264. - **Known libraries** — names to mark as library code and keep out of the work queue.
  265. PDB/DWARF imports now also add **function prototypes**, not just names and types. Drop the binary and its companion
  266. files together and they are applied automatically: **PDB/MAP**, `symbol_addrs.txt`, `coverage.csv`/`trace.csv`/
  267. `*.trace`, and `types.h`/`context.h`. A path import finds the same companions beside the file. The optional fields
  268. are only for files that are not beside the binary.
  269. The picker accepts several files at once; the largest non-companion file is the binary, the rest travel with it.
  270. Nothing extra is uploaded when you import by path.
  271. ## What the import found
  272. A PDB is not required, and most shipped binaries will not have one. That is normal for reverse engineering: the
  273. import still recovers every function boundary, compiler and flags, imports, strings, data and library/CRT code,
  274. then the autopilot and agents work from the instructions themselves. A shipped PDB/MAP is only a shortcut when the
  275. publisher left one in the build.
  276. Every import also writes an **INTAKE.md** report beside the project and shows it in **Overview → What was found**.
  277. It records what the import already established, so neither you nor an agent starts by rediscovering it:
  278. - the file, format, architecture, entry point, image base, sections and hashes;
  279. - the compiler and version, source language, inferred flags and the evidence for them;
  280. - debug information: source, names and type count;
  281. - functions, library/CRT code, data objects, strings and imported APIs;
  282. - most-called functions, and which functions use each imported API, string and data object;
  283. - subsystem hints (render, audio, input, network, file/registry, UI, memory, threading, crypto) from imports and
  284. strings, and C++ vtable/RTTI symbols when the target kept them;
  285. - the entry point, named functions and largest functions by instruction count;
  286. - runtime trace coverage and the questions that are still open (missing compiler, no debug names, packed program,
  287. no trace, mostly automatic names).
  288. Agents get the report's path in `project_info`, their session prompt and every function brief, with an instruction to
  289. read it first. The report is generated by decomp.anything's own parsers and the optional files above; it does not run
  290. every external REA/Ghidra tool on import.
  291. ## Debug information and versions
  292. A program often ships with names the compiler already knew. decomp.anything imports them instead of making agents
  293. guess:
  294. - **PDB** beside a Windows program (read with LLVM's `llvm-pdbutil`), **DWARF** inside a Linux program, a linker
  295. **MAP** file, or `symbol_addrs.txt`. Debug names replace automatic `sub_`/`func_`/`D_` names without breaking
  296. matches; data names are added; structs, unions, enums and typedefs go into the shared header. MAP, DWARF and
  297. `symbol_addrs.txt` need nothing extra; for PDB, **Compilers & tools → LLVM tools** shows whether `llvm-pdbutil`
  298. is present (it comes with LLVM, not with decomp.anything).
  299. - **Import later** from a project's **Settings → Symbols & types**, by path or with no path (the program's sidecar
  300. debug file). **Export** writes `symbol_addrs.txt`, `debug_types.h` and `debug_symbols.json` into the project
  301. folder, ready for other tools.
  302. - **Compare versions** in **Settings → Compare versions**: point at a patch, demo or port of the same Windows or
  303. Linux program. Functions are paired by normalized instructions (calls, globals and RIP-relative operands are
  304. blanked, internal branch targets stay relative), so moved code still matches. The report says same, moved,
  305. changed, added and removed, with a similarity score for changed functions.
  306. Agents get `import_debug_info`, `export_debug_info`, `compare_version`, `import_trace`, `list_hot`, `search_facts`
  307. and `list_subsystems` tools; the autopilot and the normal matching loop are unchanged.
  308. ## Runtime coverage
  309. **Settings → Runtime coverage** imports a trace from a debugger, emulator or profiler. Accepted shapes are a
  310. column of addresses (`0x401000`), `address,count` CSV, or JSON (`[{"address": "0x401000", "hits": 3}]`). Addresses
  311. can be virtual addresses or RVAs; function names are accepted too. Hit counts are added to the containing
  312. functions, shown in the **Coverage** filter and the Hits column, and `list_hot` ranks them for agents.
  313. ## Continue a public decomp
  314. Community projects already have a build and part of the code done. decomp.anything plugs agents into them as they
  315. are:
  316. 1. **Browse** the catalog the app bundles (or paste any decomp repository's address) and **fork** it. It's cloned to
  317. your computer on a local `decomp-wtf` branch.
  318. 2. **Add your copy of the game.** The app knows where common layouts expect it (dtk-template for GameCube/Wii,
  319. `configure.py` + ninja, splat + make) and runs the project's own setup. Anything else you set up by its README;
  320. decomp.anything picks it up once it builds.
  321. 3. **Add agents.** Each claims a function and gets the target assembly, objdiff's diff, the function's source file,
  322. matched look-alikes and a machine draft. Its code goes into the real source file, the project's build compiles it
  323. with the project's compilers, and [objdiff](https://github.com/encounter/objdiff) judges it.
  324. 4. **Every match is a git commit** on `decomp-wtf`, ready for you to review and, if the project welcomes it, send
  325. upstream. Nothing is sent anywhere by itself.
  326. Guard rails: agents write only C/C++ sources and headers, never targets, assembly or build scripts, and inline
  327. assembly is refused. A change that breaks an already-matched function is undone. The project's file layout and which
  328. files are linked are changed by the app itself, never typed by an agent, and kept only when the game still builds
  329. byte for byte.
  330. ### From matched to linked
  331. A function at 100% is matched. A file is **linked** when all of it, functions *and* data, matches: the project then
  332. builds the game from that C instead of from the original's code, and checks the whole game against its checksum.
  333. That's decomp.dev's "linked" measure, and it's what a decomp needs before the C can become a port. For GameCube and
  334. Wii projects (dtk-template) decomp.anything handles the steps between:
  335. - **Every function gets a source file.** Code no file covers can be given one; `split_file` divides a file where the
  336. game's original files divided.
  337. - **Files closest to done come first.** When a match finishes a file's functions, the agent is shown the file's data
  338. next to the original's, with what to fix. `file_status` shows it any time.
  339. - **Finished files link themselves.** The app marks the file Matching, builds the game and runs the project's
  340. checksum check, keeping the change only if it passes.
  341. ## Agents
  342. | Agent | How it connects |
  343. | :-- | :-- |
  344. | **Claude Code** | Runs headless against the app's local MCP server. |
  345. | **Codex CLI** | Same, with approvals limited to decomp.anything's tools. |
  346. | **Antigravity CLI** | Same, through the workspace's own MCP config. Google's successor to Gemini CLI (`agy`). |
  347. | **opencode** | Same, with any provider you've set up. opencode 1 and 2 both work: for opencode 2, the app writes its V2 config, turns Code Mode off and runs it `--standalone`. |
  348. | **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. |
  349. | **The agent you talk to** | `decomp connect` drives the app from your own terminal and can start helpers. |
  350. | **Anything else** | Point any MCP client (Cursor, Claude Desktop, your own) at `decomp mcp`, or at the app with **Connect another agent**. |
  351. Agents only get decomp.anything's tools: no shell, and no access to your files beyond a fork's own source tree and
  352. any reference folders you name. The app installs missing agents for you and tells you how to sign in. You pay your
  353. own provider.
  354. **Reference folders.** In a project's **Instructions for agents**, write the full path of a folder. Helpers on that
  355. project can then `read_file` and `search_code` there. It works for a matched decomp of the same game, symbol lists,
  356. notes, or specs for a non-game target. Reads stay inside the folder: symlinks out of it, dotfiles, `.git`, `build`
  357. and `orig` folders, binaries and your home folder itself are refused. Folders named in a room you joined are ignored.
  358. **Local models.** Start the model with at least 16K tokens of context (llama.cpp: `-c 16384`; Ollama:
  359. `OLLAMA_CONTEXT_LENGTH=16384`; LM Studio: Context Length), choose its preset under **Agents & models → API key**,
  360. and set the context size there if it isn't llama.cpp. Small models do the small functions; the big ones need a strong
  361. model.
  362. ## Decompile together
  363. A team, any size, each on their own computer with their own copy of the target and their own agents, working on one
  364. project. One computer is the room's **host**: it hands out functions so nobody does the same one twice, checks every
  365. match against its own copy, and shares names, structs and notes. Nothing goes through a central server: the people
  366. working together host the room and decide who's in.
  367. **On a home PC:** open the project, click **Decompile together**, **Open the room**. Send the link.
  368. **On a server:**
  369. ```bash
  370. decomp host mygame.z64 --own-copy --address http://my-server:6481 --service
  371. ```
  372. That runs the app in the background, imports your copy, opens the room and prints the link. **Joining:** paste the
  373. link into **Join a team's room** in the app, or `decomp join <link> <your copy> --name you`.
  374. | | |
  375. | :-- | :-- |
  376. | **Private or public** | Private rooms need the invite link; public rooms only the address. Optionally approve each new member. |
  377. | **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. |
  378. | **The host's controls** | Who's online and on what, remove members, a fresh invite link, stop sharing. |
  379. | **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. |
  380. | **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 original), build it with their own copy and tools, and follow every commit made in the room. |
  381. No original bytes or assembly ever cross the wire: everyone reads the code from their own copy, which must be
  382. identical to the host's.
  383. ## Targets and platforms
  384. | Target | Status | Matching | Notes |
  385. | :-- | :-- | :-- | :-- |
  386. | **GameCube · Wii** | ★ Recommended | ✓ | Disc (ISO, RVZ, WBFS…) or DOL; CodeWarrior 1.0–1.7; dtk-template projects; finished files link. |
  387. | **Nintendo 64** | ★ Recommended | ✓ | ROM; KMC GCC 2.7.2, IDO 5.3/7.1; rebuilds the ROM byte for byte. |
  388. | **PlayStation** | Beta | ✓ | Disc (.bin, .iso, .chd) or EXE; GCC 2.7.2/2.8.1. |
  389. | **PlayStation 2** | Beta | ✓ | Disc or ELF; EE-GCC 2.96. |
  390. | **Game Boy Advance** | Beta | ✓ | ROM; agbcc. |
  391. | **Nintendo DS** | Beta | ✓ | ROM (.nds); CodeWarrior 1.2–DSi 1.6; ds-decomp projects. |
  392. | **Windows (PC)** | Beta | ✓ | `.exe` / `.dll`, x86 and x86-64; MinGW-w64, clang-cl or your own MSVC. Exports a CMake/IDE project plus `judge.py`; the final PE link stays in your normal toolchain. |
  393. | **Linux (PC)** | Beta | ✓ | ELF executables and `.so`, x86 and x86-64; the GCC, G++, Clang and Clang++ on your machine. Exports a CMake/IDE project plus `judge.py`; the final ELF link stays in your normal toolchain. |
  394. | **Android · .NET · JavaScript/Electron · web · firmware · files** | Analysis | — | Drop it like a game: REA opens it as a normal project, procedures become work items and findings land on the dashboard. Add tasks for the rest. |
  395. | **3DS · PSP · Switch · Xbox · Xbox 360** | Coming | Public decomps | The catalog can fork community projects for these. |
  396. **From scratch.** splat and spimdisasm split MIPS games; decomp-toolkit analyses GameCube and Wii programs inside a
  397. generated [dtk-template](https://github.com/encounter/dtk-template) project; [ds-decomp](https://github.com/AetiasHax/ds-decomp)
  398. analyses DS ROMs (ARM9, ITCM, DTCM, overlays); Game Boy Advance ROMs are split by
  399. [luvdis](https://github.com/aarant/luvdis) plus this project's own pass for code nothing calls. Windows executables
  400. are split with the PE reader (`pe.py`) from `.pdata`, the COFF symbol table, exports, the entry point and call
  401. targets. Linux programs use the symbol table or `.eh_frame`. Every attempt is compiled with the target's compiler and
  402. checked byte for byte. PC imports also read the language and toolchain version the binary records: GCC and Clang in
  403. `.comment`, Rust in `.comment` or the standard library's `rustc-<version>` paths, and Go in `.go.buildinfo`. Rust and
  404. Go are identified, but only C and C++ are matched byte for byte.
  405. **Windows programs.** Function boundaries come from the x86-64 exception directory and the executable's symbol table
  406. where it has one, then exports, the entry point and every direct call target. Matching compiles your C to COFF and
  407. compares bytes with the original's, with address fields blanked on both sides: a call or RIP-relative load has to
  408. point at the same function or global. A PDB or MAP beside the program is imported automatically (PDB through LLVM's
  409. `llvm-pdbutil`); its names and types replace the automatic ones. Build flags are inferred from the image itself
  410. (security cookie, C++ frame handlers, RTTI, unwind tables, `.comment`, stack probes): the project's **Settings**
  411. shows the suggested flags and applies them in one click. CRT, compiler-runtime and static-library functions are
  412. marked and kept out of the work queue. `inspect_binary` can ask [REA](https://rea.tools) for pseudocode, signatures
  413. and callers. Matching a real binary byte for byte needs the compiler that built it; point the project's
  414. `[compiler] cmd` at MSVC if needed. `DECOMP_REA_DRAFTS=1` also lets claims start from REA's pseudocode (slower; off
  415. by default).
  416. **Linux programs.** Function bounds come from the symbol table or, in a stripped program, from `.eh_frame`. Calls
  417. into shared libraries go through PLT stubs named after the function, with their GOT slots named `memcpy@got`. The C
  418. library's start-up code is left out. DWARF in the program is imported automatically: function names, sizes and
  419. signatures, plus structs, unions, enums and typedefs for the shared header. The compiler is picked from what
  420. `.comment` says built it; position-independent programs compile with `-fPIE`. An exact match needs the same compiler
  421. version and flags. System headers can't be included: declare library functions yourself, and in C++ write the
  422. classes whose mangled names you need.
  423. **The base for ports and mods.** For ROM projects, *Export project* writes a normal decomp tree (matched functions
  424. as C, the rest as assembly, a linker script and `build.py`) and proves it rebuilds the target byte for byte.
  425. GameCube and Wii projects are dtk-template; DS projects are ds-decomp. Both rebuild on every build, and GameCube/Wii
  426. files link as they finish. For Windows and Linux programs, *Export IDE project* writes a normal **CMake** tree:
  427. verified C/C++ sources, `include/context.h`, `compile_commands.json` for clangd/IDEs, and `judge.py`,
  428. which compiles a function with the project's compiler and verifies it against the original bytes. Open it in VS
  429. Code, CLion, Visual Studio or your editor; full PE/ELF linking stays in your normal toolchain. Functions matched
  430. from the same shared submission use one source file. Export rechecks matches and resolves overlapping C submissions
  431. when it can verify the isolated functions. Unresolved definition conflicts stop export with an explanation and
  432. preserve the existing export. Code and data stay
  433. out of git: they're regenerated from your own copy.
  434. **Proprietary compilers** (IDO, CodeWarrior, CodeWarrior for DS) are only installed after you accept that. Heavy
  435. tools run with a memory cap.
  436. **Windows.** Several compilers (KMC GCC, the PlayStation GCCs, EE-GCC, agbcc) only exist as Linux programs, so
  437. decomp.anything runs inside WSL 2 there. The installer sets that up; you use the app in your browser as usual, and
  438. results are byte-identical to Linux. macOS isn't supported.
  439. **When something goes wrong.** A failed import stays on screen with the reason and what happened. **Copy for a bug
  440. report** puts the version, the error and the log on your clipboard. The full log is `.decomp/logs/decomp.log` in your
  441. projects folder (`~/Decomp`).
  442. ## Features
  443. | Feature | What you get |
  444. | :-- | :-- |
  445. | **Live view** | A map of every function in the target, each agent's tool calls, scores falling to zero, in real time. |
  446. | **Autopilot** | Free matches before agents spend a token: identical code from a matched twin, then every function's machine draft goes through the judge. |
  447. | **Permuter** | Near misses (95% and up) get rewritten in the background: statement and declaration order, casts, temporaries. |
  448. | **Fast agents** | Small functions come in batches, identical code is shown in the brief, and agents move on after four tries without progress. |
  449. | **Your agent, your terminal** | `decomp connect`, then ask Claude Code, Codex or Antigravity CLI to work on the target. |
  450. | **Edit it yourself** | Every function has an editor: write C or C++, press Ctrl+Enter, see the judge's diff. You count as an agent. |
  451. | **Byte-for-byte check** | Candidates are linked at the real address, so calls, globals, strings and jump tables are verified too. |
  452. | **Any agent** | Claude Code, Codex, Antigravity CLI, opencode, or any model with an API key, several at once. |
  453. | **Lean context** | Compact assembly, diffs that say what's wrong before showing where, close look-alikes' C up front, and short sessions. |
  454. | **Shared knowledge** | Structs and prototypes go into one header, accepted only if every match so far still matches. |
  455. | **Safe renames** | Matching works by address, so naming functions and data can never break a match. |
  456. | **Public decomps** | Fork community projects and keep going with agents, judged by objdiff. |
  457. | **Linked files** | GameCube and Wii files link into the game as soon as all of their code and data match. |
  458. | **Look-alikes** | `find_similar` spots copy-pasted and inlined code and starts agents from what already matches. |
  459. | **Drafts** | m2c for MIPS, PowerPC and ARM; optional Ghidra for x86, AArch64 and everything else. |
  460. | **Agent toolkit** | Data inspector, call graph, function splitting, and guides for MIPS, PowerPC, ARM, x86, AArch64, IDO, GCC, Metrowerks, agbcc, PSY-Q, C++ and objdiff. |
  461. | **Every binary is a project** | The normal picker accepts games and programs; unsupported formats fall back to REA automatically. Procedures become work items, tasks cover the rest, and the same dashboard, agents, notes and activity feed apply. |
  462. | **RE console** | REA's tools in the app: functions, pseudocode beside assembly, control-flow and call graphs, strings, memory map, a form for every tool and a terminal. |
  463. | **Feature traces** | Seed one route, string, IPC channel or module in a JavaScript/Electron app; REA walks the graph and the nodes it reaches become work items with their own report. |
  464. | **REA install** | Download and install REA from **Compilers & tools**; the console and agents pick it up automatically. |
  465. | **Debug symbols** | PDB, DWARF, MAP and `symbol_addrs.txt` names and types; export them again for other tools. |
  466. | **Version compare** | Patch/demo/port triage: same, moved, changed, added and removed functions, matched by normalized instructions. |
  467. | **Suggested flags** | Security cookie, EH/RTTI, unwind tables, comments and stack probes become the compiler flags that match, one click away. |
  468. | **Library code out** | CRT, compiler runtime and static-library functions are marked and never handed to agents. |
  469. | **Data inventory** | PC and ROM data symbols, strings and their addresses are listed in a Data tab and through `list_data`. |
  470. | **IDE export** | PC projects export a CMake/IDE tree with `compile_commands.json` and a `judge.py` byte-match checker. |
  471. | **Runtime coverage** | Import debugger/emulator traces (addresses or names, CSV/JSON/text); hit counts map onto functions, with a Coverage filter and `list_hot`. |
  472. | **Starting context** | Notes, symbols, type headers, reference source, trace and known libraries can be supplied before the first claim. |
  473. | **Intake report** | `INTAKE.md` records the target, compiler, flags, debug types, code/data/string/import inventory, trace and open questions; agents read it first. |
  474. | **Reference folders** | Name a folder in instructions and helpers can read and search it. |
  475. | **Every major disc format** | ROMs, PlayStation discs, GameCube and Wii discs (ISO, GCM, RVZ, WIA, WBFS, CISO, GCZ) and program files, streamed from disk. |
  476. | **Local-first** | No account, no telemetry, no server dependency. |
  477. ## Development
  478. Human and agent-authored PRs are welcome. Start with [CONTRIBUTING.md](CONTRIBUTING.md) for focused validation and
  479. review expectations; [AGENTS.md](AGENTS.md) routes agents to the relevant repository or target workflow.
  480. ```bash
  481. uv sync
  482. uv run decomp # opens the app; projects live in ~/Decomp (or $DECOMP_HOME)
  483. uv run pytest
  484. ```
  485. Python dependencies are locked in `uv.lock`. There is no website in this repository; the Linux and Windows
  486. installers live in `install/`.
  487. GitHub CI checks the lockfile, Ruff, workflow syntax, Python 3.12 and 3.14, Windows host behavior, and an
  488. installed wheel's resources and command-line entry points. The Python 3.12 job installs the pinned N64 compiler,
  489. m2c and objdiff, builds the shareable demo ROM, and exercises the decompilation pipeline. Both Linux jobs also
  490. install 32/64-bit MinGW and LLVM so PE, ELF and debug-information tests run. Tests requiring other period
  491. toolchains or private game files still skip, with their reasons listed in the run summary. JUnit reports and
  492. test fixtures are retained for seven days; built distributions are retained for fourteen days.
  493. The stable merge check is **CI passed**. It succeeds only when every required job succeeds, including the
  494. complete Python matrix. PR updates cancel superseded PR runs; branch pushes run CI on `main` only, avoiding
  495. duplicate checks for the same PR. Dependabot proposes weekly updates to the pinned GitHub Actions.
  496. Agents use a knowledge-first work loop: `discover_assistance(query, function)` finds relevant bundled guides,
  497. skills, shared findings and approved REA tools with their live schemas. `read_skill(id)` loads that guidance;
  498. `record_assistance(function, summary, fallback_reason)` shares the review with the next agent. Add a skill folder's
  499. full path to the project's instructions to expose its `SKILL.md` files through the existing read-only reference
  500. boundary. Discovery reuses a connected REA session; `connect=true` explicitly requests a potentially cold import.
  501. CLI and built-in API agents receive the same MCP-derived tool schemas. Repeated compile trials require a current
  502. review, and the background permuter only considers reviewed functions with a recorded fallback reason.
  503. <details>
  504. <summary><b>Repository layout</b></summary>
  505. <br>
  506. | Path | What it is |
  507. | :-- | :-- |
  508. | `src/decompnet/rom/` | Input reading (`n64.py`, `psx.py`, `pe.py` for Windows executables, `elfexe.py` for Linux programs), splitting with splat (`split.py`), debug information (`debuginfo.py`), version comparison (`bincompare.py`), the symbol table and the matchers (`match.py`, `match_arm.py`, `match_x86.py`). |
  509. | `src/decompnet/coffobj.py`, `rea.py` | COFF objects from Windows compilers, and the REA MCP client: settings, the agents' read-only bridge and the console's calls. |
  510. | `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), `references.py` (reference folders), `console.py` (the RE console's REA session), `server.py` (GUI API and MCP), `collab.py` (rooms), `static/` (GUI; `console.js`/`console.css` are the RE console), `guide/` (agent know-how). |
  511. | `src/decompnet/forks/` | Fork mode: catalog, project detection and setup, objdiff, source editing, m2c and Ghidra drafts, linking and file splits (`project.py`, `dtksplits.py`), and data diffs (`datadiff.py`). |
  512. | `src/decompnet/network.py` | The coordination core: claims, attempts, notes, the shared header. |
  513. | `src/decompnet/toolchains.py` | The pinned compilers and tools: verified downloads and installs, including npm-installed REA. |
  514. | `src/decompnet/hostenv.py`, `app/updates.py` | Where the app runs (Linux, its WSL 2 distribution on Windows, Docker) and what crosses to the computer around it; updates. |
  515. | `src/decompnet/app/twins.py`, `app/permute.py` | Free matches: identical code from a matched twin, and the background permuter for near misses. |
  516. | `install/install.sh`, `install/install.ps1`, `install/linux-base.sh`, `install/Dockerfile` | The installers: the app's own Linux (WSL on Windows, Docker on a server) is made by `linux-base.sh` on Debian. |
  517. | `projects/demo-rom/` | Builds Demo Quest 64. `tests/test_rom.py` proves the matcher on it. |
  518. | `projects/demo-psx/` | The same game as a PlayStation executable, for `tests/test_psx.py`. |
  519. | `projects/demo-fork/` | A small decomp project in the community's shape (objdiff.json, ninja), for `tests/test_forks.py`. |
  520. Rebuild the demo ROM with `uv run python projects/demo-rom/build.py` (needs `gcc-2.7.2-kmc` and `ld.lld`).
  521. </details>
  522. ## Pinned tools
  523. Every download is pinned by version and SHA-256 in `src/decompnet/toolchains.toml`. Install one from
  524. **Compilers & tools**, or with `decompnet toolchain install <id>`.
  525. | Tool | Pinned version |
  526. | :-- | :-- |
  527. | **KMC GCC 2.7.2** | decompals `mips-gcc-2.7.2 v0.1` + `mips-binutils-2.6 v0.3` |
  528. | **PlayStation GCC** | decompals `old-gcc 0.17` (GCC 2.7.2 and 2.8.1), with binutils 2.6 |
  529. | **EE-GCC** | Sony-era GCC 2.96 from `decompme/compilers` |
  530. | **IDO** | `ido-static-recomp v1.2` (5.3 and 7.1) |
  531. | **agbcc** | pret `agbcc release` |
  532. | **ARM GNU** | 14.3.Rel1 (for agbcc’s assembler path) |
  533. | **CodeWarrior** | `compilers_20251118.zip` (GameCube, Wii, ProDG, Xbox 360 MSVC); DS archive from `decompme/compilers` |
  534. | **objdiff-cli** | **v3.8.3** |
  535. | **decomp-toolkit** | v1.8.4 |
  536. | **wibo** | 1.2.0 |
  537. | **coddog** | 0.6.3 |
  538. | **Ghidra** | 12.1.4 |
  539. | **REA** | **rea-agents 6.7.0** |
  540. | **UPX** | **5.2.1** |
  541. | **cloudflared** | **2026.10.2** |
  542. | **ds-decomp** | v0.12.1 |
  543. | **binutils-mips** | decompals v0.10 |
  544. | **gc-wii-binutils** | 2.42-2 |
  545. | **sjiswrap** | v1.2.2 |
  546. | **m2c** | `708d2d2c` |
  547. | **maspsx** | `e85ecb3` |
  548. | **dtk-template** | `95a941f` |
  549. | **luvdis** | `ec3a4e3` |
  550. System tools (**Compilers & tools** shows whether they are present): **LLVM tools** (`llvm-pdbutil` for PDB names),
  551. **Rizin** (a lightweight REA provider) and **Detect It Easy** (`diec` fingerprints). They are optional; install them
  552. with the system package manager or the LLVM installer.
  553. The period compilers are deliberately held at the versions that reproduce the games’ original output. `maspsx` is
  554. also held at `e85ecb3`: newer upstream commits change assembly expansion and need a PlayStation matching corpus run
  555. before they can be adopted. The host’s GCC, Clang, MinGW and `clang-cl` are used as system toolchains, not pinned.
  556. ## Built on
  557. decomp.anything would not exist without [decomp.wtf](https://github.com/i12bp8/decomp.wtf) by Sam Wolfs, which
  558. provides the matching engine, project workflow, app and installers this fork extends.
  559. [splat](https://github.com/ethteck/splat) and [spimdisasm](https://github.com/Decompollaborate/spimdisasm) split
  560. ROMs, [objdiff](https://github.com/encounter/objdiff) judges forks, [m2c](https://github.com/matt-kempster/m2c) and
  561. [Ghidra](https://github.com/NationalSecurityAgency/ghidra) write first drafts (and [REA](https://rea.tools) supplies
  562. pseudocode, callers and strings over MCP, and drives the analysis projects for targets with no original build), the
  563. [decompals](https://github.com/decompals) recompiled period compilers do the building, and
  564. [decomp.dev](https://decomp.dev) lists the public projects. The look-alike finder follows the
  565. idea of [coddog](https://github.com/ethteck/coddog); [decomp-toolkit](https://github.com/encounter/decomp-toolkit),
  566. [maspsx](https://github.com/mkst/maspsx) and [wibo](https://github.com/decompals/wibo) are in the pinned toolbelt.
  567. Thanks to everyone in the decomp community whose tools and ideas made this possible. decomp.anything isn't affiliated
  568. with any of these projects, nor with Nintendo, Sony or Microsoft.
  569. ## Use it responsibly
  570. decomp.anything contains no game or application code and doesn't provide ROMs, executables or firmware. Only analyze
  571. software you own or are authorized to analyze. Don't use it to get around copy protection, and don't publish
  572. decompiled code whose rights you don't hold.
  573. When you continue a public decomp, follow that project's license and contribution rules; forking runs its build
  574. scripts on your computer, so fork projects you trust. Many community decomps don't accept AI-written contributions,
  575. and the ones that do expect a person to stand behind every line. decomp.anything never sends anything upstream: your
  576. agents' work stays on your local branch. Before you open a pull request, read the project's CONTRIBUTING (or ask its
  577. maintainers), review the code yourself, and say how it was made.
  578. ## License
  579. [MIT](LICENSE) © 2026 Sam Wolfs, and the decomp.anything contributors.
  580. decomp.anything is a fork of decomp.wtf and keeps its MIT license.

Ratings and comments

Sign in to rate this skill.

Sign in

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