Xbox decomp guide

What this system is like

The original Xbox runs x86 code, the same kind of code a PC runs. That makes it one of the easiest consoles to bring to a PC. Two free toolkits, xboxrecomp and XboxXBERecomp, turn a game's default.xbe into C or C++. Most of the 140 Xbox projects on RecompLauncher are recomps like these.

Path A is static recompilation. A tool translates every function ahead of time. You then fix one crash, one missing system call or one wrong picture at a time. Several dated projects with AI help reached a first release in three to four weeks. They started from a working toolkit.

Path B is harder. A matching decomp is possible. The Halo 1 decomp reports 99.5% of its bytes matching. Halo 2 has matched about 73% of its game code. But matching needs the exact Microsoft compiler from the Xbox SDK, called the XDK. Nobody may share it, and this guide cannot help you get it. Without it, you rewrite the recompiled functions as readable C, one at a time. You check each one by running it, not by its bytes.

Everything in this guide runs on Windows 11. Use WSL only for Linux builds and for project scripts written for bash. Keep your disc files outside the repo. The reviewed recomps ship no game code. They lift it on the player's PC from the player's own disc.

Two paths

Path A: Get it running on PC

A recompiler reads default.xbe and writes one C or C++ function for each x86 function. A runtime stands in for the kernel, Direct3D 8, DirectSound and the pad. You build the result into a Windows program. Then you fix one boot stop at a time until the game plays. Thirteen of the fifteen reviewed projects work this way.

1. Scope the game and pin the exact disc

   Pick one game and one release. Look for earlier ports, and for ports of sister games on the same engine. Pick the toolkit. Write the Scope Contract so every later session builds the same file.

   • Search RecompLauncher and GitHub for your game and its engine. Athelas ports four Lord of the Rings games from one shared SDK.
   • Extract your own disc with extract-xiso -x <your.iso> -d game_files.
   • Record the hash in PowerShell: Get-FileHash game_files/default.xbe -Algorithm SHA256.
   • Note the region. Most reviewed ports support one release only, such as USA for Def Jam or PAL for Finest Hour.
   • Count the .xbe files. Splinter Cell: Double Agent has two, and each needs its own recompiled image.
   • Pick XboxXBERecomp for a Windows port with Direct3D 12. Pick xboxrecomp if you also want Linux or macOS. Its README names both.
   • Write SCOPE.md: game, region, hash, toolkit and commit, milestone, and what is out of scope.
   Prompt for ClaudeCopy

   GOAL: Draft SCOPE.md for a static recompilation of <GAME> for the original Xbox.
   READ FIRST: `notes/game-files.txt` (my file list and the `default.xbe` SHA-256), `notes/prior-work.md` if it exists.
   FENCE: Edit only `SCOPE.md` and `notes/prior-work.md`. Everything else is read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `Select-String -Path SCOPE.md -Pattern '^## (Game|Region|Hash|Executables|Toolkit|Milestone|Out of scope)$'`. Done means it prints 7 lines. The Hash section holds the same SHA-256 that `Get-FileHash game_files/default.xbe -Algorithm SHA256` prints. The Toolkit section names `XboxXBERecomp` or `xboxrecomp`, a commit, and one reason.
   BUDGET: Stop after 30 minutes of searching for prior work.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the Select-String output and both hashes. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe Select-String check prints 7 lines, the Hash section equals the Get-FileHash output, and you have approved SCOPE.md.

   Proof this works: Athelas, Def Jam FFNY Recomp, SCDA XBE Recomp, Finest Hour Remastered, https://github.com/XboxDev/extract-xiso

2. Set up the repo, the toolkit and one check

   Make a repo that holds only your own code. Pin the toolkit to one commit. Write one script that builds and one that checks. Game files and generated code stay out of git.

   • Install Visual Studio 2022 with Desktop development with C++, C++ Clang tools for Windows, and C++ CMake tools for Windows.
   • Install Python 3.10 or newer, then run py -3 -m pip install capstone pytest.
   • For XboxXBERecomp, copy its templates/game folder and put the SDK in sdk/ at a pinned commit.
   • For xboxrecomp, clone it beside your project and copy templates/new-game to start your game repo.
   • Add assets/, game_files/, generated/ and src/recomp/gen/ to .gitignore.
   • Write tools/check.ps1. It builds, starts the game with a time limit, and prints PASS or FAIL.
   • Write CLAUDE.md, PROGRESS.md and notes/functions.csv with a status column.
   Prompt for ClaudeCopy

   GOAL: Make `pwsh tools/check.ps1` build the project and print PASS or FAIL for the current milestone.
   READ FIRST: `SCOPE.md`, the toolkit README at `<TOOLKIT_DIR>/README.md`, `CLAUDE.md`.
   FENCE: Edit only `tools/`, `CMakeLists.txt`, `build.bat`, `.gitignore` and `PROGRESS.md`. The toolkit folder and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1`. Done means it runs to the end, prints PASS or FAIL with a reason, and `git status --porcelain --ignored assets generated` shows those folders as ignored.
   BUDGET: Stop after 4 failed tries at the same error.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste the check output. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenpwsh tools/check.ps1 runs from a clean clone and prints PASS or FAIL, and no game file shows in git status.

   Proof this works: OpenShao, Darkwatch: Darker Edition, BLACK XBE Recomp, https://github.com/TGP482/XboxXBERecomp, https://github.com/sp00nznet/xboxrecomp

3. Map the XBE and find the library code

   Read the file's sections, library versions and functions. Mark every XDK, C runtime and middleware function so nobody decompiles it by hand. Save it all as a ledger.

   • For xboxrecomp: run py -3 -m tools.xbe_parser game_files/default.xbe --json game_files/default_analysis.json.
   • Then run py -3 -m tools.disasm game_files/default.xbe, then py -3 -m tools.func_id game_files/default.xbe -v.
   • Then run py -3 -m tools.abi_analysis game_files/default.xbe -v. Without it, every signature is a guess.
   • For XboxXBERecomp: run xbe_symbols assets/default.xbe sdk/xdk --library <Game>.dll --out config/game.toml. Misses stay at 0 and become trapping stubs.
   • Load the XBE into Ghidra 12.1.4 with the ghidra-xbe loader. It names library code with XbSymbolDatabase.
   • Write one row per function to notes/functions.csv: address, size, owner (game, XDK, CRT, middleware), status.
   Prompt for ClaudeCopy

   GOAL: Fill `notes/functions.csv` with every function in `default.xbe` and mark who owns it.
   READ FIRST: `SCOPE.md`, `<TOOLKIT_DIR>/tools/disasm/output/functions.json` or `config/game.toml`, `notes/ghidra-export.csv` if it exists.
   FENCE: Edit only `notes/functions.csv`, `notes/findings.md` and `tools/make_ledger.py`. Everything else is read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `py -3 tools/make_ledger.py --verify`. Done means it prints the function count, the count per owner, and zero rows with an empty owner or size.
   BUDGET: Stop after 90 minutes or 4 failed tries.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste the verify output. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whennotes/functions.csv lists every function with size, owner and status, and the verify script reports no empty rows.

   Proof this works: Ninja Gaiden Black Recomp, Finest Hour Remastered, JSRF Unleashed, https://github.com/XboxDev/ghidra-xbe

4. First light: lift everything and reach the first frame

   Run the recompiler over the whole file. Build it. Start it and fix only what stops the first frame. Expect it to crash many times first.

   • For xboxrecomp: run py -3 -m tools.recomp game_files/default.xbe --all --split 250 --gen-dir ../mygame/src/recomp/gen.
   • Then build: cmake -S . -B build and cmake --build build --config Release.
   • For XboxXBERecomp: run build.bat. The first build lifts the whole game and can take 30 to 90 minutes.
   • Run the game with a time limit and save the log to runs/<date>/log.txt.
   • Fix each stop with a toolkit setting or an override. Never edit the generated files.
   • Save a screenshot of the first frame as the first golden picture.
   Prompt for ClaudeCopy

   GOAL: Make the recompiled <GAME> open a window and draw its first frame.
   READ FIRST: `SCOPE.md`, `PROGRESS.md`, the last 50 lines of `runs/latest/log.txt`, `<TOOLKIT_DIR>/docs/GETTING_STARTED.md` or `sdk/README.md`.
   FENCE: Edit only `src/` (not generated folders), `config/` and `notes/`. `generated/`, `src/recomp/gen/`, the toolkit and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1 -Boot`. Done means it prints PASS and saves `runs/latest/frame0.png` that is not all one colour.
   BUDGET: Fix one stop per try. Stop after 6 tries with no new progress.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste the check output and the last log lines. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenpwsh tools/check.ps1 -Boot prints PASS and the saved first frame shows the game's own picture.

   Proof this works: JSRF Unleashed, BLACK XBE Recomp, https://github.com/sp00nznet/xboxrecomp

5. Grind the boot stops, one at a time

   Each run stops somewhere new. Sort the stop into a type and apply the fix that type needs. Log every fix. This is where most Path A time goes.

   • Missing function: add its address as a seed ([functions] in game.toml, or the seed JSON), then run the recompiler again.
   • Missed indirect call: read the [ICALL] failure, add the target as a seed, then lift and build again. Ninja Gaiden Black automates this with tools/feedback.sh.
   • Recompiler bug: override that one function (X86_FUNC(sub_XXXXXXXX) or recomp_lookup_manual()). Report it upstream.
   • Missing kernel or XDK call: write it in the runtime. Check what xemu does first.
   • Check every seed. Takedawn found that log seeds split memcpy and sent the game down a dashboard path.
   • Write each fix to notes/boot-log.md with the stop address and the run that proved it.
   Prompt for ClaudeCopy

   GOAL: Get <GAME> past the stop at <ADDRESS or LOG LINE> without breaking any earlier golden run.
   READ FIRST: `PROGRESS.md`, `notes/boot-log.md`, the 50 log lines around the stop in `runs/latest/log.txt`, the row for <ADDRESS> in `notes/functions.csv`.
   FENCE: Edit only `config/`, `src/hooks/` or `src/game/`, and `notes/`. Generated code, the toolkit and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1 -Golden`. Done means every golden run prints PASS and the new run gets past <ADDRESS>.
   BUDGET: Stop after 2 runs that stop at the same place. Then compare the two logs and name the first difference before any new change.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste the check output. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenpwsh tools/check.ps1 -Golden prints PASS, and a run under one minute reaches the next natural event, such as the menu.

   Proof this works: Def Jam FFNY Recomp, Ninja Gaiden Black Recomp, Takedawn, DOAXVB RE

6. Make graphics and sound match the real game

   Most bugs now are wrong pictures and wrong sound. Use xemu running your own disc as the reference. Fix only what differs from xemu, not what you think looks wrong.

   • Run the same scene in xemu and in your build. Save a picture from each.
   • With XboxXBERecomp, set XBE_CAPTURE_DIR and press F3 to save one frame's textures, shaders and state.
   • Ninja Gaiden Black keeps the xemu renderer as a switch (NGB_RENDERER=xemu) to tell port bugs from game bugs.
   • Put each fix in src/, one feature per file, such as fov.cpp or fpsfixes.cpp.
   • Above 30 or 60 FPS, find the game's frame pacer. Darkwatch had a door that stayed shut at 144 FPS.
   Prompt for ClaudeCopy

   GOAL: Fix one graphics or sound difference: <SYMPTOM> in <SCENE>.
   READ FIRST: `notes/bugs.md` row <BUG_ID>, the capture summary in `runs/<RUN>/frame.txt`, the `xemu` reference picture `refs/<SCENE>.png`.
   FENCE: Edit only `src/gpu/`, `src/d3d/`, `src/audio/` or `src/game/`, and `notes/`. Generated code, the toolkit and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1 -Golden -Scene <SCENE>`. Done means it prints PASS and the compare score against `refs/<SCENE>.png` is within the limit in `tools/limits.json`.
   BUDGET: Stop after 4 tries, or if the cause is not proven after 45 minutes.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste the check output and both scores. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe scene's compare check passes against the xemu picture and every older golden run still passes.

   Proof this works: Ninja Gaiden Black Recomp, OpenShao, Darkwatch: Darker Edition, Midtown Madness 3

7. Harden: golden runs, regressions and headless tests

   Old fixes must stay fixed. Build runs that start, play by script and stop by themselves. Then you can trust every later change.

   • Feed pad input from a file and save frames at set times, as Ninja Gaiden Black does with RECOMP_PAD_LIVE and NV2A_CAPTURE.
   • Run tests with no window and no sound. Point saves at a scratch folder, never your real saves.
   • Keep a regression list: menu, first level, a save and load, a cutscene. Def Jam's full regression takes about an hour.
   • Add a hygiene check that fails if any game file or generated code is staged. Def Jam runs git add -A --dry-run before each commit.
   • Separate automated results from your own play tests in every report, as OpenShao requires.
   Prompt for ClaudeCopy

   GOAL: Add the scripted golden run <RUN_NAME> to `pwsh tools/check.ps1 -Golden`.
   READ FIRST: `tests/golden/README.md`, `notes/golden-runs.md`, one existing run in `tests/golden/<EXAMPLE>/`.
   FENCE: Edit only `tests/golden/<RUN_NAME>/`, `tools/check.ps1` and `notes/golden-runs.md`. Game code, generated code and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1 -Golden` twice. Done means both runs print PASS for <RUN_NAME>, and a run with the pad file removed prints FAIL.
   BUDGET: Stop after 4 failed tries.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste all three outputs. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe full golden set passes twice in a row on a clean checkout, and a broken input makes it fail.

   Proof this works: Ninja Gaiden Black Recomp, Def Jam FFNY Recomp, OpenShao, Midtown Madness 3

8. Package it so players build from their own disc

   Ship your code, never the game's. The player supplies the disc. Your launcher checks the hash, then builds the game code on the player's PC.

   • Check the player's default.xbe by SHA-256 before building. Darkwatch refuses any other file.
   • Build the game code on first start. A release made with XboxXBERecomp ships the recompiler, Clang and LLD for this, as SCDA's does.
   • Pin every dependency and the LLVM version. Finest Hour's build comes out byte for byte the same as its release.
   • Accept a full .iso, a trimmed .xiso, or a folder. Read the game part at offset 0x18300000 for a full image.
   • Expect antivirus warnings for an unsigned launcher. Say so in the README.
   Prompt for ClaudeCopy

   GOAL: Make `pwsh tools/package.ps1` produce a release folder that holds no game code or game data.
   READ FIRST: `SCOPE.md`, `tools/package.ps1`, `notes/release-checklist.md`.
   FENCE: Edit only `tools/package.ps1`, `launcher/` and `notes/release-checklist.md`. Game code, generated code and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/package.ps1 -Out dist/test` then `py -3 tools/hygiene.py dist/test`. Done means hygiene prints PASS, and a fresh install from `dist/test` boots to the menu with my disc.
   BUDGET: Stop after 4 failed tries.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste both outputs. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe hygiene check passes on the release folder and a clean install boots to the menu from your own disc.

   Proof this works: Darkwatch: Darker Edition, Finest Hour Remastered, SCDA XBE Recomp, The Warriors Recomp

Path B: Full decomp for porting

You start from your working Path A build. You rewrite one recompiled function at a time as readable C. Each rewrite must act exactly like the lifted function, checked by running both. When no lifted game code is left, you drop the recompiler and port the code. If you lawfully own the right XDK compiler, you can match bytes instead, as Halo 2 does.

1. Scope: matching or non-matching

   Find out which XDK built your game. Decide how each function will be checked. Matching needs Microsoft's compiler for that exact XDK. Without it, use the behaviour check.

   • Read the library versions with py -3 -m tools.xbe_parser game_files/default.xbe --json game_files/default_analysis.json.
   • Look for an existing decomp first. Halo 1 (punpckhdq/halo) and Halo 2 (kirklandsig/halo2-decompiled) exist.
   • Check for RTTI class names. The xboxrecomp docs say Half-Life 2 for Xbox yields 2,336 class names.
   • Write the check method into SCOPE.md: byte match, or behaviour match against the lifted function and xemu.
   • Write down that SDK, Bink and other library code is replaced, not decompiled, as Halo 2 and DOAXVB do.
   Prompt for ClaudeCopy

   GOAL: Add a Path B section to SCOPE.md that names the check every rewritten function must pass.
   READ FIRST: `SCOPE.md`, `game_files/default_analysis.json` (library versions), `notes/prior-work.md`.
   FENCE: Edit only `SCOPE.md` and `notes/prior-work.md`. Everything else is read-only. Do not add features, refactors, tools or cleanups I did not ask for. Do not search for, download or link any XDK or SDK file.
   CHECK: Run `Select-String -Path SCOPE.md -Pattern '^## (Path B check|XDK build|Library code|Out of scope B)$'`. Done means it prints 4 lines, and the XDK build matches the version in the analysis JSON.
   BUDGET: Stop after 30 minutes.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the Select-String output and the version line. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe Select-String check prints 4 lines, the XDK build matches the analysis JSON, and you approved SCOPE.md.

   Proof this works: https://github.com/kirklandsig/halo2-decompiled, https://github.com/punpckhdq/halo, DOAXVB RE, https://github.com/sp00nznet/xboxrecomp/blob/main/docs/DECOMP.md

2. Set up the per-function checks

   Build the tools that judge one function. Split the XBE into one file per function. Make the conformance check run. Make a way to swap in your C for one function.

   • Split the code: py -3 -m tools.split game_files/default.xbe --out build/split. Each .s file holds the exact bytes.
   • Run the conformance check once: py -3 -m tools.conformance. It runs real x86 code and lifted C on the same inputs.
   • Pick the swap method. DOAXVB registers hand-written functions in recomp_lookup_manual(). Ninja Gaiden Black uses tools/take_function.py and src/manual_functions.json.
   • Write tools/fncheck.ps1 <ADDR>. It builds with your C swapped in, then runs the golden runs.
   • Matching only: Halo 2 uses python tools/check.py, which builds the whole game and compares every function's bytes.
   Prompt for ClaudeCopy

   GOAL: Make `pwsh tools/fncheck.ps1 <ADDR>` judge one rewritten function by behaviour.
   READ FIRST: `SCOPE.md` (Path B check), `<TOOLKIT_DIR>/docs/DECOMP.md`, `build/split/manifest.json` entry for <ADDR>.
   FENCE: Edit only `tools/fncheck.ps1`, `tools/` helpers and `notes/`. Game sources, generated code and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/fncheck.ps1 <KNOWN_GOOD_ADDR>` and `pwsh tools/fncheck.ps1 <ADDR> -Broken`. Done means the first prints PASS and the second, with one constant changed on purpose, prints FAIL.
   BUDGET: Stop after 4 failed tries.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste both outputs. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe check passes a known-good function and fails a function you broke on purpose.

   Proof this works: DOAXVB RE, Ninja Gaiden Black Recomp, https://github.com/sp00nznet/xboxrecomp/blob/main/docs/DECOMP.md

3. Map the game code and pick an order

   Only game-owned code gets rewritten. Order the work so callees come before callers. Group functions by the data they share.

   • Copy the owner column from notes/functions.csv. Drop XDK, C runtime, Bink and other middleware rows.
   • Use called_by and calls_to in build/split/manifest.json to list leaf functions first.
   • Group by data clusters. DOAXVB found that lifted neighbours depend on fixed addresses and layouts.
   • Trust detection_method. A function found by prologue is real. One found by imm_ref_target is a guess.
   • Add columns: cluster, rewrite status, check result, and who holds it.
   Prompt for ClaudeCopy

   GOAL: Add cluster and order columns to `notes/functions.csv` for every game-owned function.
   READ FIRST: `notes/functions.csv`, `build/split/manifest.json`, `SCOPE.md` (Library code section).
   FENCE: Edit only `notes/functions.csv`, `notes/clusters.md` and `tools/order.py`. Everything else is read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `py -3 tools/order.py --verify`. Done means every game-owned row has a cluster and an order number, no library row has one, and every function comes after all its game-owned callees.
   BUDGET: Stop after 90 minutes or 4 failed tries.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste the verify output. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe order check passes and the ledger shows how many game functions are left to rewrite.

   Proof this works: DOAXVB RE, https://github.com/sp00nznet/xboxrecomp/blob/main/docs/DECOMP.md, https://github.com/kirklandsig/halo2-decompiled

4. First light: one function, end to end

   Prove the whole loop on one small leaf function. Rewrite it, swap it in, and pass the check. Then the loop is ready for many workers.

   • Pick a leaf with no calls that the conformance check can run.
   • Read its .s file in build/split/asm/text/. The bytes are data and the instructions are comments.
   • Write clear C in src/decomp/<cluster>/. Register it as an override of the lifted function.
   • Run pwsh tools/fncheck.ps1 <ADDR> and the full golden set.
   • Matching only: the function counts when python tools/check.py <va> reports it as matched.
   Prompt for ClaudeCopy

   GOAL: Rewrite `sub_<ADDR>` as readable C that acts exactly like the lifted version.
   READ FIRST: `build/split/asm/text/sub_<ADDR>.s`, its row in `notes/functions.csv`, `include/game/`.
   FENCE: Edit only `src/decomp/<CLUSTER>/<NAME>.c` and the override list. Generated code, the toolkit and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/fncheck.ps1 <ADDR>` and `pwsh tools/check.ps1 -Golden`. Done means both print PASS and the function no longer calls its lifted copy.
   BUDGET: Stop after 5 tries with no gain.
   IF BLOCKED: Stop. Keep the last passing version. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: both outputs. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenOne game function runs from your C, its check passes, and all golden runs still pass.

   Proof this works: DOAXVB RE, Ninja Gaiden Black Recomp, https://github.com/kirklandsig/halo2-decompiled/blob/main/docs/START_HERE.md

5. Grind: rewrite functions in parallel

   Now many workers each take one function or one small cluster. Each works in its own worktree. A lead merges only work that passes on the merged branch.

   • Hand out the next functions with no open callees, smallest first.
   • One worker per function or cluster, in its own git worktree. Halo 2 lets contributors claim ranges of up to 0x2000 bytes.
   • Run the full golden set after every merge, not only in the worktree.
   • Never keep a change that makes an earlier passing function fail. Halo 2's prompt makes this a hard rule.
   • Send functions that fail five tries to a hard-job queue.
   Prompt for ClaudeCopy

   GOAL: Rewrite the next <N> ready functions in cluster <CLUSTER> as readable C.
   READ FIRST: `notes/functions.csv` rows with status `ready` in <CLUSTER>, `notes/clusters.md`, the `.s` files in `build/split/asm/`.
   FENCE: Edit only `src/decomp/<CLUSTER>/` and the override list. Generated code, other clusters, the toolkit and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: For each function run `pwsh tools/fncheck.ps1 <ADDR>`. At the end run `pwsh tools/check.ps1 -Golden`. Done means every kept function prints PASS and the golden set passes.
   BUDGET: Stop after 5 tries per function. Skip it and mark it `hard`.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the per-function results and the golden output. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenpwsh tools/check.ps1 -Golden prints PASS on the merged branch, and the ledger shows the cluster's functions as rewritten.

   Proof this works: https://github.com/kirklandsig/halo2-decompiled, DOAXVB RE

6. Name things and recover the data types

   Working C with sub_ names is not yet a readable decomp. Give functions, fields and files real names based on what the code does. Do not change behaviour while you rename.

   • Name by what the code does, or keep function_<va>. Halo 2 bans names from leaked symbols or debug builds.
   • Build structs from the fields functions read. Check each size and offset against the code.
   • OpenCE generates headers from a PDB and checks every struct size and offset. Use that only if your PDB is lawful.
   • Move functions into files named after their subsystem.
   • Run the full check after every rename batch. Nothing may change.
   Prompt for ClaudeCopy

   GOAL: Give the functions and structs in cluster <CLUSTER> real names and types without changing behaviour.
   READ FIRST: `src/decomp/<CLUSTER>/`, `notes/clusters.md`, `notes/findings.md`.
   FENCE: Edit only `src/decomp/<CLUSTER>/`, `include/game/` and `notes/findings.md`. Generated code and `assets/` are read-only. Do not use names from leaked source, PDBs or maps. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1 -Golden` and `py -3 tools/struct_check.py <CLUSTER>`. Done means both print PASS, and every new name has a line in `notes/findings.md` saying how you know it.
   BUDGET: Stop after 90 minutes.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: both outputs. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe cluster has no sub_ names left, the struct check passes and the golden set passes.

   Proof this works: https://github.com/kirklandsig/halo2-decompiled, OpenCE

7. Harden: compare a whole playthrough

   Per-function checks miss bugs between functions. Replay recorded input in your build and in xemu, then compare frames. Make the game deterministic first so frames can match.

   • Futurama replays full playthroughs on the port and the original, and reports all 752,000 frames matching.
   • Turn off fused multiply-add with -ffp-contract=off on Clang. Fix timing and random seeds.
   • Find original bugs that read uninitialised memory. Give them fixed values and list each in a bug table.
   • Keep a list of original bugs you left alone, so nobody fixes them by mistake.
   Prompt for ClaudeCopy

   GOAL: Make the replay of `tests/replays/<LEVEL>.pad` match the `xemu` reference frames.
   READ FIRST: `tests/replays/README.md`, `refs/<LEVEL>/` frame list, `notes/original-bugs.md`.
   FENCE: Edit only `src/decomp/`, `tests/replays/` and `notes/`. `refs/`, generated code and `assets/` are read-only. Do not edit reference frames or loosen limits. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `py -3 tools/replay_compare.py <LEVEL>`. Done means it prints PASS and 0 differing frames.
   BUDGET: Stop after 3 tries on the same first differing frame.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste the compare output and the first differing frame number. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenpy -3 tools/replay_compare.py --all prints PASS with 0 differing frames on a clean checkout.

   Proof this works: Futurama: The Game, OpenCE

8. Port: replace the console layer

   Once no lifted game code remains, drop the recompiler. Put a thin layer under the game that does Direct3D 8, DirectSound and the pad on the new system. Keep the game sources almost unchanged.

   • OpenCE builds the Halo CE decomp nearly unchanged. Its d3d8_gl.c does Direct3D 8 on OpenGL, and SDL3 does sound and input.
   • Mark every change to decompiled files with a fixed comment, such as port:.
   • Keep 32-bit struct layouts. OpenCE builds with Clang in MSVC's style: -fms-extensions -fshort-wchar -malign-double -fcommon.
   • Read assets from the player's disc image at run time, as Futurama does with its Xdvdfs reader.
   • Run the same replays on the new system. Use WSL with Ubuntu 24.04 for the Linux build.
   Prompt for ClaudeCopy

   GOAL: Build <GAME> for <TARGET> with the console layer and no recompiled code.
   READ FIRST: `SCOPE.md`, `port/README.md`, `notes/port-plan.md`.
   FENCE: Edit only `port/` and lines in `src/decomp/` marked `port:`. Every other game source line is read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `py -3 tools/ci_build.py <TARGET> release` then `py -3 tools/replay_compare.py --all --target <TARGET>`. Done means the build has no recomp sources and every replay prints PASS.
   BUDGET: Stop after 4 tries at the same error.
   IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
   OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste both outputs. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe new build contains no lifted code and passes the same replays as the PC build.

   Proof this works: OpenCE, Futurama: The Game

Tools you need

Skills and add-ons

Read any skill before you install it. A skill is a set of instructions that Claude will follow. See Tools and Skills for the full list and safety notes.

Claude setup for this system

Cut Path A by stop point. One unit is one boot stop, one missed call target, or one wrong picture, each with a repro run. Cut Path B by function or small data cluster. One unit is one rewritten function with its behaviour check. Keep XDK, C runtime and middleware out of every unit. A unit ends with the golden runs, never with a build alone.

Which model and effort for each job

The model and effort names come from one shared table, so they stay the same on every guide. See Claude Setup for the reasons.

How many sessions at once

Lines for this project's CLAUDE.md

- Read `SCOPE.md` and `PROGRESS.md` at the start of every session.
- Never edit generated code in `generated/` or `src/recomp/gen/`. Fix the recompiler config, a seed or an override instead.
- `assets/`, `game_files/` and the toolkit folder are read-only. Never commit an XBE, disc image, lifted code, saves or captures. Run `git add -A --dry-run` before every commit.
- The only proof is `pwsh tools/check.ps1 -Golden`. A clean build or a crash-free run is not progress.
- Report what you saw happen. Forcing the game into a state is a guess, not a result.
- After two runs stop at the same place, stop changing things. Compare both logs and name the first difference.
- Never read a whole run log. Use `py -3 tools/triage.py` with `--tail`, `--grep` or `--around`.
- Run the game only under a time limit, with no window on my desktop and no sound. Stop only your own process, by its ID.
- Record every finding in `notes/findings.md`: address, what it does, how you know, and confidence. Record dead ends too.
- Do not move the toolkit pin unless I ask. Play-test the new pin before anything else.
- In a worktree, use absolute paths and run the full check before you report.
- Start every report with DONE, PARTIAL or BLOCKED, then paste the check output.

Keep the context small

• Never let Claude list or read the generated folder. Point it at one function by name.
• Give the stop address and 50 log lines, not the whole log. Def Jam's logs reach hundreds of megabytes.
• Store Ghidra results as short conclusions, such as an address and what it does. OpenShao keeps only text notes.
• Add Read(./assets/**) and Read(./game_files/**) to permissions.deny in .claude/settings.json.
• Keep a code map that lists which file holds each feature, as Darkwatch does in CODE_MAP.md.
• Use /clear between units. The state lives in the ledger files, not the chat.

More prompts for this system

Each step above has its own prompt. These extra prompts cover the rest of the work. Fill in the parts in <ANGLE_BRACKETS>.

GOAL: Tell me if <GAME> can be ported with an existing Xbox recompiler, and draft SCOPE.md.
READ FIRST: `notes/game-files.txt` (file list and `default.xbe` SHA-256), the output of `py -3 -m tools.xbe_parser game_files/default.xbe --json game_files/default_analysis.json`.
FENCE: Edit only `SCOPE.md` and `notes/prior-work.md`. Everything else is read-only. Do not download any game file, BIOS, key or SDK. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `Select-String -Path SCOPE.md -Pattern '^## (Game|Region|Hash|Executables|XDK build|Toolkit|Prior work|Risks|Milestone)$'`. Done means it prints 9 lines, the Hash section equals what `Get-FileHash game_files/default.xbe -Algorithm SHA256` prints, and Prior work gives a URL for every project.
BUDGET: Stop after 45 minutes.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the section list and the hash line. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Produce `notes/functions.csv` with one row per function in `default.xbe`.
READ FIRST: `<TOOLKIT_DIR>/tools/disasm/output/functions.json`, `<TOOLKIT_DIR>/tools/func_id/output/`, `notes/ghidra-export.csv`.
FENCE: Edit only `notes/functions.csv`, `notes/findings.md` and `tools/make_ledger.py`. Everything else is read-only. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `py -3 tools/make_ledger.py --verify`. Done means it prints the total, the count per owner (game, XDK, CRT, middleware, unknown), and zero empty rows.
BUDGET: Stop after 90 minutes.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the verify output. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Get past the stop at <ADDRESS>.
READ FIRST: the triage summary from `py -3 tools/triage.py runs/latest --tail 80`, `notes/boot-log.md`, the ledger row for <ADDRESS>.
FENCE: Edit only `config/`, `src/hooks/`, `src/game/` and `notes/boot-log.md`. Generated code, the toolkit and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `pwsh tools/check.ps1 -Golden`. Done means all golden runs pass and a new run gets past <ADDRESS>.
BUDGET: Stop after 2 runs that stop at the same address.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the check output and the new stop. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Rewrite `sub_<ADDR>` as readable C that acts exactly like the lifted version.
READ FIRST: `build/split/asm/text/sub_<ADDR>.s`, its row in `notes/functions.csv`, `include/game/`.
FENCE: Edit only `src/decomp/<CLUSTER>/<NAME>.c` and the override list. Generated code and `assets/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `pwsh tools/fncheck.ps1 <ADDR>` and `pwsh tools/check.ps1 -Golden`. Done means both print PASS and the function no longer calls its lifted copy.
BUDGET: Stop after 5 tries with no gain.
IF BLOCKED: Stop. Keep the last passing version. Tell me what blocked you, what you tried, and what you need from me.
OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: both outputs. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Start one worker for each of the next <N> ready units and collect their reports.
READ FIRST: `notes/functions.csv` (status `ready`), `notes/claims.md`, the unit loop prompt in `prompts/unit-loop.md`.
FENCE: Edit only `notes/claims.md` and `PROGRESS.md`. Workers edit only their own unit's files, each in its own worktree. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: After merging, run `pwsh tools/check.ps1 -Golden` on the main branch. Done means it prints PASS, and `notes/claims.md` shows each unit as merged, failed or hard.
BUDGET: At most <N> workers at once. Each worker has 5 tries.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the check output after merge. 3) Files changed. 4) A table of units and results. 5) New parking-lot items.

GOAL: Find the proven cause of <BUG>. Do not fix it yet.
READ FIRST: `notes/bugs.md` row <BUG_ID>, `py -3 tools/triage.py runs/<RUN> --around <ADDRESS>`, the matching `xemu` run notes.
FENCE: Read-only, except `notes/bugs.md` and `notes/findings.md`. You may add logging in `src/hooks/debug_<BUG_ID>.c`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `git status --porcelain`. Done means it shows changes only in `notes/` and `src/hooks/debug_<BUG_ID>.c`. You name one cause, show the log lines or capture that prove it, and describe a test that would fail if you are wrong.
BUDGET: Stop after 3 runs, or 60 minutes.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
OTHER PROBLEMS: Write them in `notes/parking-lot.md`. Do not fix them.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the evidence lines. 3) Files changed. 4) The fix you suggest. 5) New parking-lot items.

GOAL: Check that the work in branch <BRANCH> is real.
READ FIRST: `git diff main...<BRANCH>`, the worker's report, `CLAUDE.md`.
FENCE: Read-only. Write only `notes/reviews/<BRANCH>.md`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `pwsh tools/check.ps1 -Golden` on the branch. Done means you list: any edit to generated code, the toolkit, `refs/` or `tools/check.ps1`; any new stub or forced state; any loosened limit or skipped test; any file outside the fence.
BUDGET: Stop after 45 minutes.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
REPORT: 1) PASS or FAIL. 2) Proof: the check output. 3) Each problem with file and line. 4) What to fix. 5) New parking-lot items.

GOAL: Give me the project status in numbers.
READ FIRST: `PROGRESS.md`, `notes/functions.csv`, `notes/bugs.md`, the last golden output in `runs/golden/latest.txt`.
FENCE: Read-only, except the Status section of `PROGRESS.md`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `py -3 tools/make_ledger.py --verify` and `pwsh tools/check.ps1 -Golden`. Done means every number in your report matches those outputs or a named file. No number is guessed.
BUDGET: Stop after 15 minutes.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Milestone and how far along. 3) Golden runs passing out of total. 4) Open bugs by type. 5) Path B functions rewritten out of total.

GOAL: Write what the next session needs into the ledger files.
READ FIRST: `PROGRESS.md`, `notes/boot-log.md`, `git status`, `git log -5 --oneline`.
FENCE: Edit only the Handoff section of `PROGRESS.md` and `notes/findings.md`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `Select-String -Path PROGRESS.md -Pattern '^### (Works|In progress|Next command|Open questions|Dead ends)$'`. Done means it prints 5 lines, Works holds the last check output, and Next command holds one exact command.
BUDGET: Stop after 10 minutes.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: paste the new Handoff section. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Tell me plainly whether <TASK> can be done with what we have.
READ FIRST: `notes/findings.md`, the last three reports for <TASK>, `SCOPE.md`.
FENCE: Read-only, except `notes/blocked.md`. Do not try another fix. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `Select-String -Path notes/blocked.md -Pattern '^## (Cannot do|Proof|Tried|Options)$'`. Done means it prints 4 lines, and Options lists two or three choices with their cost.
BUDGET: Stop after 20 minutes.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
REPORT: 1) BLOCKED or NOT BLOCKED. 2) Proof: the key evidence. 3) Files changed. 4) The options. 5) New parking-lot items.

GOAL: Ask me before you leave the fence for <TASK>.
READ FIRST: `SCOPE.md`, the current task card, the file you want to change.
FENCE: Read-only. Write only `notes/scope-requests.md`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `git status --porcelain` and `Select-String -Path notes/scope-requests.md -Pattern '^## (File|Change|Why|Undo)$'`. Done means only `notes/scope-requests.md` changed and the search prints 4 lines: the file, the change, why the fence cannot do it, and the undo plan.
BUDGET: Stop after 15 minutes.
IF BLOCKED: Stop. Do not work around it. Tell me what blocked you, what you tried, and what you need from me.
REPORT: 1) Request written: yes or no. 2) The file and change. 3) The reason. 4) The undo plan. 5) New parking-lot items.

Keep Claude on task

These are the detours Claude tends to take on this system, and the rule that stops each one. The full method is on Stay on Task.

Problems other projects hit

How long it takes

What makes it faster or slower

• A toolkit that already ran a game on the same engine. Athelas ports four games from one shared SDK.
• How many indirect calls the analysis misses. Each one is a run, a seed and a rebuild.
• Graphics style. Standard Direct3D 8 calls are easier than custom push buffer code.
• Link-time optimised builds. They give functions odd calling rules, for both the recompiler and matching.
• For Path B, the number of game functions. Halo 2 has about 11,300, plus Havok.

The facts behind these numbers

Projects reviewed (15)

We took the top-starred project for each of the top 12 games on RecompLauncher. We added the three biggest projects whose makers say they used AI. RecompLauncher lists 140 projects for 108 Xbox games. For Path B we also read two decomps outside the list: Halo 1 and Halo 2.

What each project teaches

What we could not check

• The Xbox CPU and RAM facts come from the XboxXBERecomp README and the xboxrecomp memory doc. They are not from the Xbox dev wiki. The wiki returned an error (HTTP 429) when read.
• The plugin file name inside the GhidraMCP release download. The README names it, but the zip was not opened.
• The claude mcp add line for GhidrAssistMCP. It follows Claude Code's own MCP docs; the GhidrAssistMCP README gives only the URL.
• Whether extract-xiso reads every full two-part disc dump. Its README talks about XISO files. DOAXVB and Def Jam use it on their dumps.
• How long Futurama took. Its repo is an export with hidden history.
• Which compiler most retail Xbox games used. Only Halo 1 and Halo 2 state theirs.
• The real hours behind any project's dates. Several repos hide their early history, such as Finest Hour, Darkwatch and Futurama.
• Whether the Halo 1 decomp used AI. Its README does not say.
• Which emulator Futurama used for its frame compare. The repo does not say.
• Whether the GhidrAssistMCP build for Ghidra 12.1 loads in Ghidra 12.1.4.
• The tools/fncheck.ps1, tools/check.ps1, tools/triage.py and similar scripts in the prompts are scripts you write. Their names follow the reviewed projects, but no toolkit ships them.
• That objdiff or reccmp can check Xbox code. reccmp says it supports only old MSVC versions on PE files, so this guide does not use either.
• How XboxLLR compares in practice. Only its README was read.
• Whether every reviewed port checks the disc hash in code. Some cards could not confirm it.

Sources

• xboxrecomp README (v0.17.0)
• xboxrecomp: Using xboxrecomp for Decompilation
• xboxrecomp: Lessons Learned
• xboxrecomp: XBE File Format Reference
• xboxrecomp: Memory Layout Reproduction
• Xbox XBE Recomp README
• extract-xiso README and releases
• ghidra-xbe README and releases
• XbSymbolDatabase README
• xemu releases
• xemu required files
• Ghidra releases
• GhidraMCP README
• GhidrAssistMCP README
• llvm-mingw releases
• XboxLLR README
• Halo 2 decompilation README
• Halo 2 decompilation: Start here
• Halo 1 decompilation (punpckhdq)
• Halo 1 decompilation (bnunu fork)
• RalliSport Challenge 2 recomp README
• reccmp README
• capstone on PyPI
• Claude Code: connect to MCP servers
• Claude Code: permissions
• Install PowerShell on Windows
• Install Git on Windows
• Install WSL
• Def Jam FFNY Recomp
• DOAXVB RE
• Ninja Gaiden Black Recomp
• OpenCE
• Futurama: The Game