Xbox 360 decomp guide

What this system is like

The Xbox 360 runs on a PowerPC chip. Its games are big, modern programs. Each game keeps its main code in one file, default.xex. Two tools turn that file into C++ that a PC can build: ReXGlue and XenonRecomp. This is called static recompilation.

All 15 projects reviewed here used static recompilation. Several reached a first boot within a week. The hard part comes after that. You find functions the tool missed. You fill in console system calls. Then you fix graphics and timing bugs one at a time.

A full decomp is a different story. No Xbox 360 game has one yet. The furthest public effort, Dance Central 3, is about 54% done after 16 months. This guide shows a slow but real route. You grow readable code out of a working recomp, one function at a time.

Almost every step runs on Windows. You need WSL only for an optional Linux build or the port step.

Two paths

Path A: Get it running on PC

You point a recompiler at the game's default.xex. It writes C++ for every function it can find. You fix what it missed with hints in a TOML settings file. A runtime stands in for the console's kernel, graphics, sound and input. ReXGlue gives you that runtime ready to use.

1. Scope the game and pin the exact file

   Pick one game and one version. Check if someone already ported it, or a game on the same engine. Then write the Scope Contract. Every later session works on that same file.

   • Search RecompLauncher and GitHub for your game and its engine. FIFA World Cup 2010 started from the FIFA Street port.
   • Dump your own disc. Extract it with extract-xiso -s -x -d game/files <your.iso>. The -s flag skips the $SystemUpdate folder.
   • Record the hash of the main file. In PowerShell run Get-FileHash game/files/default.xex -Algorithm SHA256.
   • Note if a title update exists. Skate 3, Unleashed Recompiled and COGBox all build from one. Unleashed reads its patch as default.xexp.
   • List extra code modules, such as fifadllzf.xex.dll or EAWebkit.xex. Each one needs its own codegen.
   • Write SCOPE.md: game, region, hash, title update, recompiler, renderer plan, and what is out of scope.
   Prompt for ClaudeCopy

   GOAL: Draft SCOPE.md for a static recompilation of <GAME> on Xbox 360.
   READ FIRST: `notes/game-files.txt` (my file list and the `default.xex` hash), `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|Title update|Modules|Recompiler|Renderer|Milestone|Out of scope)$'`. Done means it prints 9 lines. The Hash section must hold the same SHA-256 that `Get-FileHash game/files/default.xex -Algorithm SHA256` prints. The Recompiler section names `ReXGlue` or `XenonRecomp` with 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 whenSCOPE.md names the default.xex hash and the title update, and you have approved it.

   Proof this works: SpeedBreaker, Skate 3 Recomp, FIFA World Cup 2010, https://github.com/XboxDev/extract-xiso

2. Set up the Windows tools and the SDK

   Install the compiler, the build tools and the ReXGlue SDK. Make the repo and keep game files out of it. Write one build command and one check command.

   • Install Visual Studio 2022 with Desktop development with C++. Add C++ Clang Compiler for Windows (20 or newer) and MSBuild support for LLVM (clang-cl).
   • Install CMake 3.25 or newer and Ninja.
   • Get the SDK: git clone --recursive https://github.com/rexglue/rexglue-sdk.git. Inside it run git checkout v0.10.1, then git submodule update --init --recursive.
   • Open the x64 Developer PowerShell for VS 2022. AC6 warns that an x86 prompt breaks the build. Then run cmake --preset win-amd64 and cmake --build out/build/win-amd64 --target install.
   • Add the install folder's bin/ to your PATH. Then make your project: rexglue init --app_name <game> --app_root ./<game>.
   • Add assets/, generated/, game/ and out/ to .gitignore.
   • Write tools/check.ps1. It builds, boots the game under a time limit, and prints PASS or FAIL. Give it the switches later steps use: -CodegenOnly, -BootSeconds <N>, -Golden [<name>] and -All. Have it save logs to out/logs/codegen.txt and out/logs/boot.txt.
   Prompt for ClaudeCopy

   GOAL: Make `tools/check.ps1` build the <GAME> project and print PASS or FAIL.
   READ FIRST: `SCOPE.md`, the ReXGlue wiki page Getting Started (https://github.com/rexglue/rexglue-sdk/wiki/Getting-Started), `CMakePresets.json`.
   FENCE: Edit only `tools/`, `.gitignore` and `CLAUDE.md`. The SDK folder and `generated/` 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 configures, runs the `<game>_codegen` target, configures again, builds, then prints one line: PASS or FAIL with the reason. A failing boot is fine for now. Each switch (`-CodegenOnly`, `-BootSeconds <N>`, `-Golden [<name>]`, `-All`) must run. A switch with nothing to test yet prints SKIP.
   BUDGET: Stop after 3 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 last 20 lines of the check output. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenpwsh tools/check.ps1 runs from start to end and prints one PASS or FAIL line.

   Proof this works: https://github.com/rexglue/rexglue-sdk/wiki/Getting-Started, Fable 2 Recomp, Skate 3 Recomp

3. Map the executable in Ghidra

   You need a few addresses before the first codegen. You also need a function list to track progress. Ghidra, a free disassembler, reads default.xex with the right loader.

   • Install Ghidra. Then add the XEXLoaderWV zip that matches your Ghidra version with File, Install Extensions.
   • Import default.xex and its .xexp patch. Read the image base from the loader. Do not guess it.
   • Find setjmp and longjmp. The XenonRecomp README says you may find longjmp by its calls to RtlUnwind. setjmp often comes just after it.
   • For XenonRecomp only, find the eight register save and restore helpers by their byte patterns. __restgprlr_14 starts with e9 c1 ff 68.
   • Export every function to notes/functions.csv with address, size and a status column. Lost Odyssey keeps headless Ghidra export scripts for this in tools/ghidra.
   • Mark library code from the SDK, such as Direct3D and the C runtime, in the status column.
   Prompt for ClaudeCopy

   GOAL: Fill `notes/functions.csv` and the special addresses in `<game>_config.toml`.
   READ FIRST: `SCOPE.md`, the Ghidra export in `notes/ghidra/` (made with the XEX loader), the XenonRecomp README section on setjmp.
   FENCE: Edit only `notes/functions.csv`, `notes/findings.md`, `tools/ledger_check.py` and the `setjmp_address` and `longjmp_address` lines. Ghidra project files and `game/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Write `tools/ledger_check.py` if it is missing. It prints PASS when every row has address, size, status and a library flag, with no overlaps. Run `python tools/ledger_check.py notes/functions.csv` and `Select-String -Path <game>_config.toml -Pattern '^(setjmp|longjmp)_address = 0x'`. Done means PASS and 2 lines. Each address has one line of evidence in `notes/findings.md`.
   BUDGET: Stop after 60 minutes, or after 3 wrong guesses at one address.
   IF BLOCKED: Stop. Do not guess an address. 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: row count and the two addresses with evidence. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whennotes/functions.csv exists with a status column, and the config has both setjmp_address and longjmp_address.

   Proof this works: Forza Horizon 1: ReImagined, Lost Odyssey Recomp, https://github.com/hedge-dev/XenonRecomp, https://github.com/zeroKilo/XEXLoaderWV

4. Run the first codegen

   Now the recompiler writes C++ for the whole game. It will report missed functions and jump tables. A jump table is a list of addresses a switch statement jumps to. You fix these in the TOML file, never in the output.

   • Set file_path and patch_file_path in <game>_config.toml.
   • Run cmake --preset win-amd64-relwithdebinfo, then cmake --build --preset win-amd64-relwithdebinfo --target <game>_codegen.
   • Configure again so CMake sees the new sources, then build. Skate 3, Blue Dragon and AC6 all needed this second configure.
   • For each error, add a [functions] entry with size or end, or a [[switch_tables]] entry.
   • Put a comment on every hint saying which error it fixes. COGBox does this for every entry.
   • Add a script that fails if generated code still has unresolved calls. FIFA Street uses verify_direct_branches.py.
   Prompt for ClaudeCopy

   GOAL: Make `<game>_codegen` finish with no validation errors.
   READ FIRST: `SCOPE.md`, the last codegen log in `out/logs/codegen.txt`, the ReXGlue wiki page on the config file.
   FENCE: Edit only `<game>_config.toml` and files it includes. `generated/` is machine-made and read-only. Never pass `--force`. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1 -CodegenOnly`. Done means codegen exits 0 with no validation errors. Copy any 'Unresolved conditional branch' warnings into `notes/findings.md`. Fable 2 shows these warnings are not fatal.
   BUDGET: Fix at most 20 hints per session. Stop after 3 failed tries on one address.
   IF BLOCKED: Stop. Do not work around it. Tell me the address, 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: error count before and after, and the last log lines. 3) Files changed, with one comment per new hint. 4) What is left. 5) New parking-lot items.

   Done whenCodegen exits 0 without --force, and the game executable links.

   Proof this works: https://github.com/rexglue/rexglue-sdk/wiki/rexglue-CLI-Commands, Skate 3 Recomp, reblue, COGBox, ReStreet

5. Boot to the first screen

   Run the game until it stops. Most early stops name a function that was never found. You add that address as a hint, rebuild and run again. You repeat this until a screen shows.

   • Run the game with its data folder: <game>.exe --game_data_root=<path>. Hell's Gate found this must be a command-line flag. With no flag, the runtime looks in assets/ next to the exe.
   • Look in the log for Call to invalid or unregistered function at guest address 0x....
   • Add that address to the config and rebuild. COGBox runs this loop with tools/boot_loop.ps1.
   • Stub a missing kernel call with REX_EXPORT_STUB_RETURN(<name>, <value>) only to get past it. Use REX_STUB_RETURN for a game function. List each stub in notes/stubs.md.
   • Run every boot under a time limit. Stop only your own process, by its process ID.
   Prompt for ClaudeCopy

   GOAL: Get <GAME> past its next boot stop at guest address <ADDRESS>.
   READ FIRST: `SCOPE.md`, the last 50 lines of `out/logs/boot.txt`, `notes/stubs.md`.
   FENCE: Edit only `<game>_config.toml`, `src/kernel/` and `notes/stubs.md`. `generated/` is read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1 -BootSeconds 120`. Done means the log no longer stops at <ADDRESS>. Paste the new last log line.
   BUDGET: One stop per session. Stop after 3 failed tries.
   IF BLOCKED: Stop. Do not skip the call or fake its result to move on. 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: old and new last log lines. 3) Files changed. 4) Any stub added, and why. 5) New parking-lot items.

   Done whenpwsh tools/check.ps1 -BootSeconds 120 prints PASS: the log shows the title-screen line you picked, within the time limit, and out/shots/boot.png exists.

   Proof this works: Hell's Gate, COGBox, Forza Horizon 1: ReImagined, FIFA World Cup 2010, https://github.com/rexglue/rexglue-sdk/wiki/Function-Overrides

6. Fix one bug at a time, with evidence

   Now play forward. Each crash, hang, wrong picture or missing sound is one unit of work. Find the cause first. Compare with the Xenia Canary emulator or a real console before you change code.

   • Log each bug in notes/bugs.md with exact steps to see it.
   • Run the same scene in Xenia Canary on a copy of your install. If it breaks there too, it may be a bug in the original game.
   • Change behavior with REX_HOOK, REX_HOOK_RAW or a [[midasm_hook]] entry. Never edit generated/.
   • Keep one TOML hook file per feature, as Blue Dragon does in config/hooks/.
   • Use RenderDoc for graphics bugs. It captures one frame so you can inspect each draw.
   • Give each fix its own on and off setting, as AC6 does. Then you can test with one fix off.
   Prompt for ClaudeCopy

   GOAL: Find and fix the cause of bug <BUG-ID> in <GAME>.
   READ FIRST: `notes/bugs.md` entry <BUG-ID>, `notes/findings.md`, the log and capture files named in the bug.
   FENCE: Edit only `src/` and `config/hooks/`. `generated/`, `game/` and the SDK 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 the bug's repro run passes and every older golden run still passes. Show the cause with evidence before you change any code.
   BUDGET: Stop after 2 failed fixes, or 45 minutes with no new evidence.
   IF BLOCKED: Stop. Do not hide the crash by skipping the call. 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 cause with its evidence, then the check output. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe bug's repro run passes in the check script, and all older golden runs still pass.

   Proof this works: Lost Odyssey Recomp, FIFA World Cup 2010, reblue, AC6 Recomp, Unleashed Recompiled

7. Build golden runs

   Playing by hand does not scale. Script runs that load a scene, play fixed input and check the result. Run them after every change. Then old fixes stay fixed.

   • Make a read-only save file to start from. Copy it to a fresh folder for each run, as Pinyon Shift does.
   • Launch each level by a command-line flag. Run it for a set time, take a screenshot, and record ran, stopped or crashed. COGBox's chapter_sweep.ps1 does this.
   • Compare screenshots with saved baselines. Forza Horizon ReImagined checks six render scenes this way.
   • Add a debug-only local port so a script can press buttons and read game state. Fable 2 does this and leaves it out of release builds.
   • Wrap it all in one command, such as tools/prerelease.ps1, that prints PASS or FAIL for each check.
   Prompt for ClaudeCopy

   GOAL: Add golden run <NAME> that loads <SCENE> and checks it.
   READ FIRST: `SCOPE.md`, `tools/check.ps1`, `tests/golden/README.md`.
   FENCE: Edit only `tests/golden/` and `tools/`. Never touch my real save folder. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1 -Golden <NAME>` three times. Done means it passes all three times on the current build. It must also FAIL when I swap in the screenshot from <OTHER-SCENE>.
   BUDGET: Stop after 3 failed tries.
   IF BLOCKED: Stop. Do not loosen the image threshold to make it pass. 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 three passing runs and the one forced failure. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenOne command runs every golden run on a clean checkout and prints PASS for each.

   Proof this works: Pinyon Shift, COGBox, Forza Horizon 1: ReImagined, Fable 2 Recomp

8. Package it without game data

   Players must use their own copy. The repo must hold only your code. Most projects build on the player's PC from the player's own disc.

   • Check the player's default.xex by SHA-256 against a list of known versions. Reject the rest with a clear reason.
   • Keep generated/, assets/ and extracted files out of git. Add a check that fails if game files slip in, like Pinyon Shift's check-repository-boundary.ps1.
   • Pin every tool the build downloads by version and hash.
   • Write a status page that lists what was tested, and on which hardware.
   • Check the license of any code you borrow. Xenia uses BSD-3-Clause. Unleashed Recompiled uses GPL-3.0.
   Prompt for ClaudeCopy

   GOAL: Make the installer accept only supported copies of <GAME> and keep game data out of the repo.
   READ FIRST: `SCOPE.md`, `installer/`, `config/supported-versions.json`.
   FENCE: Edit only `installer/`, `config/supported-versions.json` and `tools/check-boundary.ps1`. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check-boundary.ps1` and `pwsh installer/test.ps1`. Done means both print PASS. A changed `default.xex` must be rejected with a reason.
   BUDGET: Stop after 3 failed tries.
   IF BLOCKED: Stop. Do not weaken the hash check. 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, plus the rejection message. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenA clean clone plus your own disc image builds and boots through the installer, and the boundary check passes.

   Proof this works: Pinyon Shift, ReStreet, Forza Horizon 1: ReImagined, SpeedBreaker

Path B: Full decomp for porting

No Xbox 360 game has a full decomp yet. The furthest public one, Dance Central 3, is about 54% done. The route here starts from your Path A port. You replace machine-made functions with readable C++, one at a time. A test compares each new function with its machine-made twin.

1. Choose matching or non-matching

   Decide how you will prove each function is right. Matching means your C++ builds to the exact original bytes. That needs Microsoft's PowerPC compiler from the closed Xbox 360 SDK. Non-matching uses your working recomp as the reference instead.

   • Look for prior work on GitHub and decomp.dev. Dance Central 3 and Banjo-Kazooie XBLA are the known Xbox 360 efforts.
   • Find the compiler version. Dance Central 3 uses X360/16.00.11886.00. decomp.me offers msvc_ppc_14.00.2110 and msvc_ppc_16.00.11886.00.
   • If you cannot get that compiler legally, take the non-matching route. The rest of this path covers that route only.
   • For matching, start from jeff-template: run python configure.py, then ninja, and compare units in objdiff. Its build downloads a compiler pack from files.decomp.dev. Check what is inside before you rely on it.
   • Read the community's AI rules. Dance Central 3 and Marathon Recomp both turn away AI-made work.
   • Update SCOPE.md with the route, the check, and what done means.
   Prompt for ClaudeCopy

   GOAL: Recommend matching or non-matching decompilation for <GAME> and update SCOPE.md.
   READ FIRST: `SCOPE.md`, `notes/prior-work.md`, https://github.com/rjkiv/jeff, https://github.com/rjkiv/jeff-template. I read the Dance Central 3 repo myself, because its owners ask AI agents not to use it.
   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 '^## (Route|Per-function check|Compiler|AI policy|First unit)$'`. Done means it prints 5 lines, and every claim under them has a link.
   BUDGET: Stop after 45 minutes.
   IF BLOCKED: Stop. Do not suggest ways to get the compiler that may break its license. 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 new SCOPE.md section. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenSCOPE.md states the route, the per-function check and the compiler (or why there is none), and you approved it.

   Proof this works: https://github.com/rjkiv/dc3-decomp, https://github.com/banjo360/bk360, https://github.com/decompme/decomp.me, Marathon Recomp

2. Freeze the recomp as your reference

   Your Path A build is the oracle. An oracle is a trusted source of right answers. Every rewritten function must act the same as its machine-made twin. So you pin that build and never let it drift.

   • Tag the working port, for example git tag reference-v1.
   • Pin the SDK tag and the config. Any change to them means you rerun every check.
   • Save the golden runs and their screenshots from Path A.
   • Keep each machine-made function callable. In ReXGlue, sub_X always has a twin named __imp__sub_X.
   Prompt for ClaudeCopy

   GOAL: Freeze the <GAME> recomp build as the Path B reference.
   READ FIRST: `SCOPE.md`, `tools/check.ps1`, `tests/golden/`.
   FENCE: Edit only `notes/reference.md` and git tags. Code, config and `generated/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/check.ps1 -Golden` on a clean clone of the tag. Done means every golden run passes, and `notes/reference.md` lists the tag, SDK tag, config hash and run results.
   BUDGET: Stop after 2 failed clean builds.
   IF BLOCKED: Stop. Do not change code to make a run pass. 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. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whengit tag shows the reference tag, and every golden run passes on a clean clone of it.

   Proof this works: https://github.com/rexglue/rexglue-sdk/wiki/Function-Overrides, Forza Horizon 1: ReImagined, COGBox

3. Map and name functions

   A decomp needs names and types. Trace which functions run during each game moment. Then record every finding with how you know it.

   • Log every function entry, as Fable 2's call tracer does. Play one moment and list the unnamed sub_ functions that ran.
   • Record each name in notes/functions.csv with address, role, evidence and a confidence: confirmed, probable or guess.
   • Write down what an address does not do, too. Pinyon Shift asks for this so nobody repeats a dead end.
   • Check names before each commit. Fable 2 lost its sound when a name matched a kernel function.
   • Mark library code, such as Direct3D and the C runtime. Leave it machine-made for now.
   Prompt for ClaudeCopy

   GOAL: Name the functions that run during <GAME MOMENT> in <GAME>.
   READ FIRST: `notes/functions.csv`, `notes/findings.md`, the trace file `out/traces/<TRACE>.txt`.
   FENCE: Edit only `notes/functions.csv`, `notes/findings.md`, `tools/check_names.py` and the `name` fields in `<game>_config.toml`. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: If `tools/check_names.py` is missing, write it first, like Fable 2's `tools/check_manifest_collisions.py`. Run `python tools/check_names.py`. Done means it prints PASS (no name clashes with kernel exports), and each new name has evidence and a confidence in the ledger.
   BUDGET: Name at most 25 functions. Stop after 60 minutes.
   IF BLOCKED: Stop. Mark the function as guess instead of inventing a role. 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 a count by confidence. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenEvery function in the target area has a name, a status and an evidence note, and the name check passes.

   Proof this works: Fable 2 Recomp, Pinyon Shift

4. Build the per-function check

   Write one tool that runs a function both ways and compares the results. Every worker will use it. No reviewed project has published one, so you write it yourself.

   • Declare REX_EXTERN(__imp__sub_X) and wrap the function with REX_HOOK_RAW(sub_X). Save the registers and memory it touches. Run __imp__sub_X, then your version from the same saved state, and compare.
   • Borrow a test format. The rexglue recompile-tests command checks recompiled code against register and memory values given in the assembly file.
   • Feed it inputs recorded from real golden runs, not made-up values.
   • Make it print one line: PASS, or FAIL with the first difference.
   • Test the tester. Break a known-good function on purpose and confirm the check fails.
   Prompt for ClaudeCopy

   GOAL: Write `tools/fncheck.ps1` that compares a rewritten function with its machine-made twin.
   READ FIRST: `SCOPE.md`, the ReXGlue wiki page Function Overrides, `notes/reference.md`.
   FENCE: Edit only `tools/fncheck.ps1` and `src/fncheck/`. `generated/` and `src/decomp/` are read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/fncheck.ps1 sub_<ADDR>` on an exact copy: it must print PASS. Then change one constant in the copy: it must print FAIL with the first difference.
   BUDGET: Stop after 3 failed designs.
   IF BLOCKED: Stop. Do not compare only the return value. 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 PASS run and the forced FAIL run. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whentools/fncheck.ps1 sub_<ADDR> prints PASS on an exact copy and FAIL on a broken one.

   Proof this works: https://github.com/rexglue/rexglue-sdk/wiki/Function-Overrides, https://github.com/macabeus/asmlift/blob/main/.claude/commands/dogfood-klonoa.md, https://github.com/rexglue/rexglue-sdk/wiki/rexglue-CLI-Commands

5. First light: one readable function

   Take one small function that calls nothing else. Copy its machine-made body as an override, line for line. Then rewrite it as plain C++. Prove it still acts the same.

   • Copy the body word for word into src/decomp/<area>/<name>.cpp and build. Fable 2's /hotfunc skill does this step.
   • Then remove goto labels and use real types. Keep every memory read and write in the same order, as Fable 2's /cleanuphotfunc does.
   • Run the function check and the golden runs.
   • Mark the file with a first line such as // Hand-tuned override.
   Prompt for ClaudeCopy

   GOAL: Rewrite `sub_<ADDR>` (<NAME>) as readable C++ that acts the same.
   READ FIRST: `generated/` file holding `sub_<ADDR>` (read only that function), `notes/functions.csv` row for it.
   FENCE: Edit only `src/decomp/<AREA>/<NAME>.cpp`. `generated/` is machine-made and read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `pwsh tools/fncheck.ps1 sub_<ADDR>` and `pwsh tools/check.ps1 -Golden`. Done means both print PASS, the file never calls `__imp__sub_<ADDR>`, and `rg "goto |loc_"` on the file finds nothing.
   BUDGET: Stop after 5 tries with no gain.
   IF BLOCKED: Stop. Keep the verbatim copy. 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 check outputs and the rg result. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe function check and golden runs print PASS, and rg "goto |loc_" finds nothing in the file.

   Proof this works: Fable 2 Recomp, Forza Horizon 1: ReImagined

6. Grind through each area in parallel

   Now repeat for many functions. Do small leaf functions first, then the ones that call them. Each worker takes one function in its own git worktree. A worktree is a second copy of the repo on its own branch.

   • A lead session picks the next units from the ledger and writes one task card each.
   • Start each worker with claude -w <name> so it gets its own worktree.
   • A new worktree has no ignored files, so generated/ and game/ are missing. Link them in with the worktree.symlinkDirectories setting.
   • Merge only when the function check and the golden runs pass on the merged branch.
   • Send functions that fail three tries to a hard job. Record what was tried in the ledger.
   Prompt for ClaudeCopy

   GOAL: Rewrite the next <N> functions from the ledger in area <AREA>, one worker each.
   READ FIRST: `notes/functions.csv` (status todo, area <AREA>), `CLAUDE.md`.
   FENCE: You are the lead. Edit only `notes/functions.csv` and `notes/dispatch.md`. Workers each edit one file in `src/decomp/`. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: After each merge, run `pwsh tools/fncheck.ps1 <FUNC>` and `pwsh tools/check.ps1 -Golden` on main. Done means every merged unit passes both, and the ledger shows each unit as done, hard or failed.
   BUDGET: At most <WORKERS> workers at once. Each worker stops after 3 tries.
   IF BLOCKED: Stop dispatching. 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 ledger counts before and after, and the last check output. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe ledger shows the area's functions as done, and the full golden run passes on main.

   Proof this works: Lost Odyssey Recomp, https://github.com/cdlewis/nigel, https://code.claude.com/docs/en/worktrees.md, https://code.claude.com/docs/en/settings-reference.md, https://github.com/macabeus/asmlift/blob/main/.claude/commands/dogfood-klonoa.md

7. Recover the data structures

   Readable code needs real structs, not raw offsets. Write headers for the game's objects. Let the compiler catch wrong layouts for you.

   • Write one header per struct with its fields, offsets and size.
   • Add static_assert checks for every offset and the total size. Marathon Recomp requires these in its game headers.
   • Read game memory through helpers that swap bytes, since the game is big-endian.
   • Swap raw offsets in rewritten functions for struct fields. Then rerun each function check.
   Prompt for ClaudeCopy

   GOAL: Write a header for struct <STRUCT> and use it in the rewritten functions that touch it.
   READ FIRST: `notes/findings.md` entries for <STRUCT>, the rewritten files listed in `notes/functions.csv` for it.
   FENCE: Edit only `include/game/<STRUCT>.h` and the rewritten files that use it. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `cmake --build --preset win-amd64-relwithdebinfo`. It must pass with every `static_assert`. Then run `pwsh tools/fncheck.ps1 <FUNC>` on each touched function. Done means the build passes and all print PASS.
   BUDGET: Stop after 3 failed layouts.
   IF BLOCKED: Stop. Use a padding field marked unknown instead of guessing. 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: build output and each function check. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe headers build with every assert on, and every rewritten function still passes its check.

   Proof this works: Marathon Recomp, Unleashed Recompiled

8. Harden the decomp

   Check that the progress is real. A fresh session hunts for cheats. Then everything must pass from a clean clone.

   • Run a fresh verify session on each merged batch. It looks for rewrites that just call __imp__, stubs, and changed checks.
   • Run rg __imp__ src/decomp and confirm each hit is listed as allowed.
   • Run every function check and golden run from a clean clone in one command.
   • Track the share of rewritten functions in PROGRESS.md.
   Prompt for ClaudeCopy

   GOAL: Verify the last batch of rewritten functions in <AREA> is real work.
   READ FIRST: `git log` since tag <TAG>, `notes/functions.csv`, `CLAUDE.md`.
   FENCE: Read-only review. Edit only `notes/verify-<DATE>.md`. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: On a clean clone, run `pwsh tools/check.ps1 -All`. Done means you list each claimed unit as OK or SUSPECT. Look for: calls to `__imp__`, stubs, edited checks or baselines, loosened thresholds, and changes outside the fence.
   BUDGET: Stop after 90 minutes.
   IF BLOCKED: Stop. 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 OK and SUSPECT lists. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenOn a clean clone, one command runs all checks and prints PASS, and the verify note lists no unexplained __imp__ call.

   Proof this works: Lost Odyssey Recomp, https://github.com/i12bp8/decomp.wtf/wiki

9. Port to a new system

   Put the console parts behind clear interfaces. Then build for the new system. Run the same golden runs there.

   • Keep kernel, graphics, sound and input code in their own folders.
   • Turn PowerPC sync, lwsync and eieio into real memory barriers. Lost Odyssey crashed on ARM without them.
   • Watch the memory page size. Apple Silicon uses 16 KiB pages, which broke memory tricks in Lost Odyssey.
   • Build with Clang for the new target. For Linux, run cmake --preset linux-amd64-relwithdebinfo, then cmake --build --preset linux-amd64-relwithdebinfo in WSL. Blue Dragon pins its Linux build to an ubuntu:24.04 container.
   • Run the golden runs on the new system.
   Prompt for ClaudeCopy

   GOAL: Make <GAME> build and boot on <TARGET>.
   READ FIRST: `SCOPE.md`, `notes/port-<TARGET>.md`, the build log from the last try.
   FENCE: Edit only `src/platform/<TARGET>/`, `CMakePresets.json` and `notes/port-<TARGET>.md`. Decomp code in `src/decomp/` is read-only. Do not add features, refactors, tools or cleanups I did not ask for.
   CHECK: Run `<TARGET BUILD COMMAND>` then the golden runs on <TARGET>. Done means it boots and the first golden run passes.
   BUDGET: One build error or one crash per session. Stop after 3 failed tries.
   IF BLOCKED: Stop. 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: build and golden run output. 3) Files changed. 4) What is left. 5) New parking-lot items.

   Done whenThe game boots on the new system and passes the same golden runs as on Windows.

   Proof this works: Lost Odyssey Recomp, reblue, SpeedBreaker, Skate 3 Recomp

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 crash, or one wrong picture, each with a repro run. Cut Path B by function. One unit is one rewritten function with its compare check. Keep library code, such as Direct3D, out of the units. Every 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 anything in `generated/`. Change the config TOML or write an override in `src/` instead.
- `game/`, `assets/` and the SDK folder are read-only. Never commit game files, extracted data or screenshots of the game.
- The only proof is `pwsh tools/check.ps1 -Golden`. A green build alone is not done.
- Every new config hint gets a comment saying which error or run it came from.
- Before adding an override for `sub_X`, search `src/` to see if it is already hooked. One function gets one override.
- After any change to a hook TOML, rerun codegen before you build.
- Record every finding in `notes/findings.md` with address, name, how you know it, and confidence: confirmed, probable or guess. Record dead ends too.
- Run the game only under a time limit. Stop only your own process, by its process ID.
- 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 all of generated/. Point it at one function by name.
• Give the last 50 log lines and the stop address, not the whole log.
• Have scripts summarize RenderDoc captures and traces. Lost Odyssey's rule is to read the summary and pick five rows at most.
• Add Read(./game/**) to permissions.deny in .claude/settings.json. Do not deny generated/, because Path B reads one function there at a time.
• 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> (Xbox 360, title ID <TITLE ID>) is a good recomp target, and draft SCOPE.md.
READ FIRST: `notes/game-files.txt`, https://github.com/rexglue/rexglue-sdk/wiki, RecompLauncher's list for my game.
FENCE: Edit only `SCOPE.md` and `notes/prior-work.md`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `Select-String -Path SCOPE.md -Pattern '^## (Prior work|Modules|Title update|Risks)$'`. Done means it prints 4 lines: prior ports of this game or its engine (with links), the `.xex` module count, title update needs, and risks. Each fact has a link or a file path.
BUDGET: Stop after 45 minutes of research.
IF BLOCKED: Stop. Say what you could not find. 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 links. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Build `notes/functions.csv` for `default.xex` of <GAME>.
READ FIRST: `notes/ghidra/functions.txt` (headless export), `<game>_config.toml`.
FENCE: Edit only `notes/functions.csv` and `notes/findings.md`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `python tools/ledger_check.py`. Done means it prints PASS: every row has address, size, area, library flag and status, with no overlaps.
BUDGET: Stop after 60 minutes.
IF BLOCKED: Stop. 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 row counts by status. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Get past the boot stop at guest address <ADDRESS>.
READ FIRST: last 50 lines of `out/logs/boot.txt`, `notes/stubs.md`.
FENCE: Edit only `<game>_config.toml` and `notes/stubs.md`. `generated/` is read-only. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `pwsh tools/check.ps1 -BootSeconds 120`. Done means the stop at <ADDRESS> is gone and the new last log line is pasted.
BUDGET: One address. Stop after 3 tries.
IF BLOCKED: Stop. Do not fake a return value. 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: old and new last log lines. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Rewrite `sub_<ADDR>` as readable C++ that acts the same.
READ FIRST: only `sub_<ADDR>` in `generated/`, its row in `notes/functions.csv`, `include/game/`.
FENCE: Edit only `src/decomp/<AREA>/<NAME>.cpp`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `pwsh tools/fncheck.ps1 sub_<ADDR>` and `pwsh tools/check.ps1 -Golden`. Done means both print PASS and the file does not call `__imp__sub_<ADDR>`.
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 <N> workers on the next units from the ledger.
READ FIRST: `notes/functions.csv` or `notes/bugs.md`, `CLAUDE.md`.
FENCE: Edit only `notes/dispatch.md` and the status column of the ledger. Each worker runs in its own worktree. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: After each merge, run `pwsh tools/check.ps1 -Golden` on main. Done means it prints PASS each time, and each worker returned DONE, PARTIAL or BLOCKED with pasted proof.
BUDGET: At most <N> workers at once. Pick units that touch different files.
IF BLOCKED: Stop dispatching. 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: a table of unit, worker result and main check. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Find the cause of <SYMPTOM> at <WHERE IN GAME>. Do not fix it yet.
READ FIRST: `notes/bugs.md` entry <BUG-ID>, the crash log, the RenderDoc capture summary.
FENCE: Read-only, except `notes/findings.md` and debug-only logging in `src/debug/`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `git diff --stat`. It must list only `notes/findings.md` and `src/debug/`. Then run `pwsh tools/check.ps1 -Golden <BUG-ID>`. It must still fail the same way, since this is not a fix. Done means you show the cause with proof: a log line, a trace, a watchpoint hit, or the same scene in Xenia Canary. Mark each claim verified or guess.
BUDGET: Stop after 60 minutes with no new evidence.
IF BLOCKED: Stop. Report what you ruled out. 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. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Check that the work since <COMMIT> is real.
READ FIRST: `git diff <COMMIT>..HEAD --stat`, `PROGRESS.md`, `CLAUDE.md`.
FENCE: Read-only. Edit only `notes/verify-<DATE>.md`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: On a clean clone, run `pwsh tools/check.ps1 -All`. Done means you list each claim as OK or SUSPECT. Look for edits to `generated/`, new stubs, skipped calls, loosened image checks, changed baselines, calls to `__imp__` in rewrites, and changes outside the fence.
BUDGET: Stop after 90 minutes.
IF BLOCKED: Stop. 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 OK and SUSPECT lists. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Give me a numbers-only status of the <GAME> project.
READ FIRST: `PROGRESS.md`, `notes/functions.csv`, `notes/bugs.md`, `notes/stubs.md`.
FENCE: Read-only. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `pwsh tools/check.ps1 -Golden`. Done means you give: golden runs passed out of total, open bugs, stubs, functions named and rewritten, and the furthest point reached in the game.
BUDGET: 15 minutes.
IF BLOCKED: Stop. Tell me what blocked you, what you tried, and what you need from me.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the check output. 3) Files changed (none). 4) What is left. 5) New parking-lot items.

GOAL: Write what the next session needs into the ledger files.
READ FIRST: this session's work, `PROGRESS.md`.
FENCE: Edit only `PROGRESS.md`, `notes/findings.md` and `notes/handoff/<DATE>.md`. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `Select-String -Path notes/handoff/<DATE>.md -Pattern '^## (Folder and branch|Base commit|Active unit|Last check|Evidence|Guesses|Dead ends|Next step)$'`. Done means it prints 8 lines, and each section is filled in.
BUDGET: 10 minutes.
IF BLOCKED: Stop. Tell me what blocked you, what you tried, and what you need from me.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the handoff file path. 3) Files changed. 4) What is left. 5) New parking-lot items.

GOAL: Tell me plainly whether <UNIT> can be done with the current tools.
READ FIRST: `notes/bugs.md` or `notes/functions.csv` entry for <UNIT>, all past attempts in `notes/findings.md`.
FENCE: Read-only. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `git status --porcelain`. It must print nothing, since this task changes no files. Done means you answer CAN, CANNOT YET or UNKNOWN. Give the exact reason, the evidence, and two or three options with their cost.
BUDGET: 30 minutes.
IF BLOCKED: Stop. Tell me what blocked you, what you tried, and what you need from me.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the evidence. 3) Files changed (none). 4) What is left. 5) New parking-lot items.

GOAL: Ask me before you leave the fence for <UNIT>.
READ FIRST: `SCOPE.md`, the current task card.
FENCE: Make no edits. Do not add features, refactors, tools or cleanups I did not ask for.
CHECK: Run `git status --porcelain`. It must print nothing, since you make no edits. Done means you list: the files you want to touch, why the fence is not enough, the risk to other work, and how you will check it.
BUDGET: 10 minutes.
IF BLOCKED: Stop. Tell me what blocked you, what you tried, and what you need from me.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Proof: the evidence that the fence is too small. 3) Files changed (none). 4) What is left. 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 port of a game on the same engine. FIFA World Cup 2010 reached gameplay in days by starting from FIFA Street.
• How many functions the recompiler misses. Forza Horizon needed 577 extra hints; a small arcade game needs far fewer.
• Extra code modules and title updates. Each one adds its own codegen and address checks.
• Your renderer choice. The built-in emulated GPU is quick to start. A custom renderer adds months.
• For Path B, the size of the code. Dance Central 3 alone has about 12 MB of code.

The facts behind these numbers

Projects reviewed (15)

We took the project with the most stars for each of the top 12 games on RecompLauncher. We added the three biggest projects whose makers say they used AI. RecompLauncher lists 269 projects for 207 Xbox 360 games. Forza Horizon shows up twice, because two teams ported it.

What each project teaches

What we could not check

• No reviewed project has published a per-function compare check like the one in Path B step 4. The idea follows the ReXGlue override docs, but you must build and test it yourself.
• The jeff-template and Dance Central 3 builds download a compiler pack from files.decomp.dev. Whether it holds the Xbox 360 compiler was not checked, since this review downloaded nothing. Whether you may legally use that compiler is your call.
• XEXLoaderWV's newest zip targets Ghidra 12.1.3, while GhidraMCP 2.0 targets Ghidra 12.1.4. Building the loader for 12.1.4 with gradle buildExtension was not tested.
• Whether the ReXGlue v0.10.1 Windows release zip can replace building the SDK from source was not tested.
• Whether the 15 libmspack symlinks at v0.10.1 still break a Windows build was not tested.
• Linking generated/ and game/ into worktrees with worktree.symlinkDirectories was not tested with a ReXGlue build.
• The tools/check.ps1 switches, tools/ledger_check.py, tools/check_names.py and tools/fncheck.ps1 are scripts you write. They are modeled on the projects' tools, not copied from one.
• How much of each AI-flagged project was written by AI is not stated, except for Lost Odyssey Recomp.
• The real start dates of GoldenEye, SpeedBreaker and COGBox are hidden, because their public history was reset or squashed.
• Hours per week spent on any project are unknown, so the time ranges are estimates.
• No build in this guide was run here. Commands come from the projects' docs and the tools' READMEs.

Sources

• ReXGlue SDK README
• ReXGlue wiki: Getting Started
• ReXGlue wiki: CLI Commands
• ReXGlue wiki: CLI Configuration File
• ReXGlue wiki: Function Overrides
• XenonRecomp README
• XenosRecomp README
• extract-xiso README
• XEXLoaderWV README
• GhidraMCP README
• Xenia Canary README
• objdiff README
• jeff README
• jeff-template README
• Dance Central 3 decomp README
• Dance Central 3 progress on decomp.dev
• Banjo-Kazooie XBLA decomp research
• decomp.me platform list (Xbox 360 entry)
• Xbox 360 technical specifications
• Free60: XEX file format
• xbox360-decomp skill README
• Lost Odyssey Recomp AI workflow
• Ghidra releases
• LLVM releases
• ReXGlue wiki: ReXApp (game_data_root default)
• jeff-template configure.py (pinned tool tags)
• Ubuntu 24.04 package: clang-20
• Install PowerShell on Windows
• Get-FileHash reference
• ripgrep README
• Claude Code docs: worktrees
• Claude Code docs: settings reference (worktree.symlinkDirectories)
• Melee decomp: last function PR