PlayStation 3 decomp guide

What this system is like

Every PS3 port we reviewed uses the same tool, ps3recomp. It turns the game's code into C++ that builds on a PC. Then it links that code to a stand-in for the PS3's system. All 15 projects worked this way.

The PS3 chip has two kinds of cores. The main core is a PowerPC. The helper cores, called SPUs, run their own small programs. You must find and convert both kinds. Missed SPU code is the most common reason a port shows a black screen.

Path A is real and fast now. In late 2026, several ports reached a first release or a full playthrough two to four weeks after their first dated work. Most were made by one person directing AI agents. The work runs on Windows. You need a lot of memory: 16 GB at least, 32 GB is better.

Path B is open ground. No PS3 game has a full decomp. One project matched a few dozen tiny functions byte for byte. The honest route is readable C that you check against the working recomp, one function at a time.

Two paths

Path A: Get it running on PC

You decrypt your own game file. ps3recomp turns the PPU code and the SPU programs into C++. That code links to a runtime that fakes the PS3's system, graphics and sound. Then you fix one crash or one missing call at a time. RPCS3 shows what the right result looks like.

1. Pick the game and pin the version

   You choose one game and one exact version. Ports only work on the version they were built for. You also look for prior work, so you do not repeat it. The result is a one-page SCOPE.md that you approve.

   • Search RecompLauncher and the ports table in the ps3recomp README for your game. Check sister games on the same engine too.
   • Write down the title ID from PS3_GAME/PARAM.SFO, such as BCUS98124. Write down the update version you will use.
   • Check that the game runs well in RPCS3. A game that fails there has no answer key.
   • Check your PC: 16 GB of memory at least, 32 GB is better. Several ports need a CPU with AVX2.
   • Write SCOPE.md: goal, title ID, version, check command, out of scope, and files Claude must never edit.
   Prompt for ClaudeCopy

   GOAL: Draft SCOPE.md for a Path A recomp of <GAME>, title ID <TITLE_ID>, version <VERSION>.
   READ FIRST: the ps3recomp README (https://github.com/sp00nznet/ps3recomp), docs/GAME_PORTING_GUIDE.md, and the RecompLauncher entry for <GAME> if one exists.
   FENCE: Write only SCOPE.md and notes/prior-work.md. Do not install anything. Do not touch game files.
   CHECK: Run `Select-String -Path SCOPE.md -Pattern 'Title ID:','Version:','Technique:','Milestone:','Check:','Out of scope:','Never edit:'`. Done means all seven lines are found and each has a real value, with the technique set to static recomp with ps3recomp.
   BUDGET: Stop after 45 minutes of research.
   IF BLOCKED: Stop. Tell me what you could not find and what you need.
   OTHER PROBLEMS: Write them in notes/parking-lot.md. Do not chase them.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste SCOPE.md. 3) List prior ports or sister games found, with links. 4) Open questions for me.

   Done whenSCOPE.md exists, names the title ID and version, and you approved it.

   Proof this works: Ratchet & Clank: Tools of Destruction Recompiled (docs/TRIAGE.md before any lift), Soulbrandt (docs/00 feasibility note and milestone roadmap), https://github.com/sp00nznet/ps3recomp/blob/master/docs/GAME_PORTING_GUIDE.md

2. Dump and decrypt your own copy

   You make a copy of your game and unlock the main file. The tools need the plain ELF inside EBOOT.BIN. You record its hash, so every later step can check it has the right file. Game files stay outside your repo.

   • Disc: use PS3 Disc Dumper with a supported Blu-ray drive. It makes a decrypted copy. A plain .iso from other disc tools is still encrypted.
   • PSN game: keep the .pkg and your .rap licence file.
   • Run rpcs3 --decrypt <dump>/PS3_GAME/USRDIR/EBOOT.BIN. Or use RPCS3's menu: Utilities, then Decrypt PS3 Binaries. It writes EBOOT.elf next to EBOOT.BIN. If it cannot unlock the file, it asks for a 32-digit KLIC key.
   • Copy the result to D:/ps3work/<TITLE_ID>/EBOOT.ELF, outside the repo.
   • Record the hash: python -c "import hashlib,sys;print(hashlib.sha256(open(sys.argv[1],'rb').read()).hexdigest())" D:/ps3work/<TITLE_ID>/EBOOT.ELF.
   Prompt for ClaudeCopy

   GOAL: Write tools/check_input.py, which proves D:/ps3work/<TITLE_ID>/EBOOT.ELF is the right decrypted file.
   READ FIRST: SCOPE.md. The ELF header facts in docs/GAME_PORTING_GUIDE.md of ps3recomp.
   FENCE: Edit only tools/check_input.py and config/target.json. Game files are read-only. Never copy game files into the repo.
   CHECK: Run `python tools/check_input.py`. Done means it prints the SHA-256, says ELF64 big-endian PowerPC, and prints OK when the hash matches config/target.json.
   BUDGET: Stop after 3 failed tries.
   IF BLOCKED: Stop. Do not try to decrypt anything yourself. Tell me what failed.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste the check output. 3) Files changed. 4) What is left.

   Done whenpython tools/check_input.py prints OK, the SHA-256, and ELF64 big-endian PowerPC.

   Proof this works: Soulbrandt (decrypts with RPCS3, confirms ELF64 big-endian PowerPC), inFAMOUS Reborn (checks EBOOT.elf SHA-256 before any work), Drakengard 3 Recompiled (PS3 Disc Dumper; encrypted ISOs refused), https://github.com/13xforever/ps3-disc-dumper

3. Set up the repo, tools and one check

   You install the build tools and lay out the repo. You pin one version of ps3recomp, so it does not change under you. You write CLAUDE.md, the ledger and one check command. A guard stops game files from ever being committed.

   • Install tools: winget install --id LLVM.LLVM, winget install --id Kitware.CMake, winget install --id Ninja-build.Ninja, winget install --id Python.Python.3.12.
   • Install the C++ workload: winget install --id Microsoft.VisualStudio.2022.BuildTools --override "--passive --wait --add Microsoft.VisualStudio.Workload.VCTools --includeRecommended".
   • Run every build from the x64 Native Tools Command Prompt for VS 2022. Without it, clang-cl cannot find the Windows headers and CMake fails.
   • Pin the toolkit and keep its line endings: git -c core.autocrlf=false submodule add https://github.com/sp00nznet/ps3recomp third_party/ps3recomp, then git -C third_party/ps3recomp config core.autocrlf false, then git -C third_party/ps3recomp checkout v0.19.0. Changed line endings break patch files.
   • Make a venv: python -m venv .venv, then .venv/Scripts/python -m pip install -r third_party/ps3recomp/requirements.txt.
   • Copy third_party/ps3recomp/templates/project/ to port/. It will not configure until lifted code exists, so for now build only the toolkit's runtime library.
   • Write tools/build.ps1. It runs cmake --build with a job count set by free memory. Count about 8 GB per job for big lifted files.
   • Add tools/check_no_game_files.py as a pre-commit hook. Write tools/check.ps1 as the one check command.
   Prompt for ClaudeCopy

   GOAL: Lay out the repo so one command builds and one command checks, even with no game code yet.
   READ FIRST: SCOPE.md, third_party/ps3recomp/docs/GETTING_STARTED.md, third_party/ps3recomp/docs/BUILDING.md (Windows notes), third_party/ps3recomp/templates/project/CMakeLists.txt.
   FENCE: Edit only CLAUDE.md, PROGRESS.md, .gitignore, tools/, patches/ and port/. third_party/ps3recomp is read-only. Do not add features I did not ask for.
   CHECK: Run `powershell -File tools/check.ps1` from the x64 Native Tools Command Prompt. Done means it runs check_input.py, configures third_party/ps3recomp with clang-cl and Ninja into build/sdk, builds it, finds ps3recomp_runtime.lib, and prints CHECK OK. Also run `python tools/check_no_game_files.py` and show it fails on a test file named EBOOT.ELF.
   BUDGET: Stop after 4 failed tries or 60 minutes.
   IF BLOCKED: Stop. Tell me which install or command failed and paste the error.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste both check outputs. 3) Files changed. 4) What is left.

   Done whenpowershell -File tools/check.ps1 prints CHECK OK after building ps3recomp_runtime.lib, and the game-file guard rejects a file named EBOOT.ELF.

   Proof this works: Project Helghast (pinned submodule, numbered patches, ps3recomp-patched.sh, build script that caps jobs by free memory), Project Pyrrhus (clone with -c core.autocrlf=false), Code Veronica HD Recomp (winget install lines), Project Tourline Prologue (check_no_game_files.py as pre-commit hook), https://github.com/sp00nznet/ps3recomp/blob/master/docs/GETTING_STARTED.md, https://github.com/sp00nznet/ps3recomp/blob/master/docs/BUILDING.md

4. Map the game file

   You list every function, every firmware import and every SPU program. This map is your ledger. It tells you how big the job is. It also shows which imports ps3recomp does not cover yet.

   • Run python third_party/ps3recomp/tools/ppu_loader.py D:/ps3work/<TITLE_ID>/EBOOT.ELF -o analysis/. It writes the functions and imports files.
   • Add missed functions: python third_party/ps3recomp/tools/find_functions.py D:/ps3work/<TITLE_ID>/EBOOT.ELF --seed-json analysis/EBOOT.functions.json --output analysis/functions.json.
   • Check import coverage: python third_party/ps3recomp/tools/prx_analyzer.py D:/ps3work/<TITLE_ID>/EBOOT.ELF --stubs.
   • List SPU programs: python third_party/ps3recomp/tools/extract_spu_images.py D:/ps3work/<TITLE_ID>/EBOOT.ELF --output analysis/spu/.
   • Write docs/TRIAGE.md: hashes, entry, TOC values, function count, imports per library, and an SPU inventory.
   • Optional: load the ELF in Ghidra and connect GhidraMCP for read-only questions.
   Prompt for ClaudeCopy

   GOAL: Produce docs/TRIAGE.md and ledger/functions.tsv for <GAME> <TITLE_ID>.
   READ FIRST: SCOPE.md, third_party/ps3recomp/docs/TOOLS.md (ppu_loader.py, find_functions.py, prx_analyzer.py, extract_spu_images.py).
   FENCE: Write only docs/TRIAGE.md, ledger/, analysis/ and tools/ledger_check.py. The ELF and third_party/ps3recomp are read-only. Do not lift or build yet.
   CHECK: Write and run `python tools/ledger_check.py`. Done means it prints the row count of ledger/functions.tsv, that count equals the number of entries in analysis/functions.json, and no row lacks an address, size, source (opd or heuristic) or status. TRIAGE.md lists import coverage per library and every SPU program found, with how it was found.
   BUDGET: Stop after 90 minutes.
   IF BLOCKED: Stop. Paste the tool error and tell me what you need.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Function count, import count, missing imports, SPU program count. 3) Files written. 4) Risks you see.

   Done whenpython tools/ledger_check.py passes: one row per entry in analysis/functions.json, each with a status. docs/TRIAGE.md lists import coverage and every SPU program.

   Proof this works: Ratchet & Clank: Tools of Destruction Recompiled (docs/TRIAGE.md, docs/SPU_INVENTORY.md), Project Tourline Prologue (find_functions.py with --seed-json), https://github.com/sp00nznet/ps3recomp/blob/master/docs/TOOLS.md

5. Lift the PPU code and boot to the first frame

   You turn all the main-core code into C++ and build it. Then you run it until a window opens. Most games stop early on a missing system call. That is normal. The goal here is one picture on screen.

   • Lift: python third_party/ps3recomp/tools/ppu_lifter.py D:/ps3work/<TITLE_ID>/EBOOT.ELF --functions analysis/functions.json --hle-stubs analysis/EBOOT.imports.json --output recompiled/.
   • Make the import table: python third_party/ps3recomp/tools/gen_hle_nids.py --all --out recompiled/ppu_hle_nids.cpp.
   • Configure from the x64 Native Tools Command Prompt: cmake -S port -B build -G Ninja -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_BUILD_TYPE=Release -DPS3RECOMP_DIR=<REPO>/third_party/ps3recomp -DRECOMP_DIR=<REPO>/recompiled. Use full paths for <REPO>.
   • Build with powershell -File tools/build.ps1. It caps the job count, since each lifted file can need several GB of memory.
   • Run it: set PS3_VFS_ROOT to your game folder, then start build/<GAME_EXE> D:/ps3work/<TITLE_ID>/EBOOT.ELF. Use a time limit and save the log.
   • Read the log. [HLE] UNIMPLEMENTED lines name missing firmware calls. unresolved indirect call -> 0x39800000 means --hle-stubs or the import table is missing.
   • Keep recompiled/ out of git. It is made by a tool.
   Prompt for ClaudeCopy

   GOAL: Lift the PPU code of <GAME>, build it, and reach the first rendered frame.
   READ FIRST: SCOPE.md, docs/TRIAGE.md, third_party/ps3recomp/docs/GETTING_STARTED.md steps 4 to 6.
   FENCE: Edit only port/, tools/ and patches/. recompiled/ is generated and read-only. third_party/ps3recomp is read-only; a toolkit fix goes in patches/ as a new numbered patch.
   CHECK: Run `powershell -File tools/check.ps1 -Boot 60`. Done means the build succeeds and the boot run saves a screenshot that is not black. Look at the screenshot before you say anything about the picture.
   BUDGET: Stop after 5 failed tries or 2 hours. Build only with tools/build.ps1.
   IF BLOCKED: Stop. Do not stub a call just to get further. Paste the last 40 log lines and tell me what you think is missing.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste the check output and the screenshot path. 3) Files changed. 4) Unimplemented calls seen, in order.

   Done whenThe build succeeds and a 60-second boot run saves a screenshot that shows a real first frame.

   Proof this works: God of War: Ascension PC (first lift, build and intro screens on the same day), Code Veronica HD Recomp (ppu_loader.py then ppu_lifter.py, Release build), https://github.com/sp00nznet/ps3recomp/blob/master/docs/GETTING_STARTED.md

6. Lift every SPU program

   You lift the helper-core programs too. Without them, many games hang on a black screen. Some SPU code only shows up while the game runs. You find it with the toolkit's interpreter stats and add it to the lift list.

   • Lift every SPU ELF inside the game file and write one registration file: python third_party/ps3recomp/tools/build_spu_workloads.py --input D:/ps3work/<TITLE_ID>/EBOOT.ELF --lifted spu --out spu/spu_workloads.c --constructor. Each image gets its own name prefix, so names do not clash.
   • Job modules are not ELF files, so that scan misses them. Run the game with SPU_DUMP_MISS=D:/ps3work/<TITLE_ID>/spu_miss set. It saves each SPU image the runtime does not know.
   • Lift the saved modules: python third_party/ps3recomp/tools/lift_jobmods.py --jobmods D:/ps3work/<TITLE_ID>/spu_miss --out spu. It also writes jobmods_register.c.
   • Run with SPU_INTERP_STATS=10 set. Every 10 seconds it prints the six busiest pages of SPU code that still run in the slow interpreter.
   • Lift what you find and run again. Repeat until the stats show no busy pages.
   • Put the SPU lift inside the one pipeline script. A manual step gets skipped.
   Prompt for ClaudeCopy

   GOAL: Lift every SPU program <GAME> runs, so the interpreter is only a fallback.
   READ FIRST: docs/TRIAGE.md (SPU inventory), third_party/ps3recomp/docs/SPU_LIFTER.md and docs/SPU_FALLBACK.md.
   FENCE: Edit only tools/lift_spu.ps1, config/spu_list.json and patches/. Generated SPU code is read-only.
   CHECK: Run `powershell -File tools/check.ps1 -Boot 120` with SPU_INTERP_STATS=10. Done means the log shows no SPU page in the interpreter for the last 60 seconds of the run, and the boot milestone count did not drop.
   BUDGET: Stop after 5 lift rounds or 2 hours.
   IF BLOCKED: Stop. List the image IDs still interpreted and where they come from.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste the interpreter stats before and after. 3) Files changed. 4) SPU programs still missing.

   Done whenA 120-second run with SPU_INTERP_STATS=10 shows no interpreted SPU pages at the end, and the boot milestones did not drop.

   Proof this works: Code Veronica HD Recomp (three SPURS jobs, a sound plug-in and a mixer added by hand), RACiT (109 of 144 job modules ran interpreted while lifting was a manual step), inFAMOUS Reborn (hand-written job-module entry map), https://github.com/sp00nznet/ps3recomp/blob/master/docs/GAME_PORTING_GUIDE.md

7. Fix one wall at a time

   Now you grind. Each session fixes one crash, one hang or one missing call. You compare against RPCS3 to see what should happen. Fixes go into the toolkit as patch files or into scripts that re-run after each lift. You never hand-edit lifted code.

   • Run RPCS3 with full logging on the same scene. Save its log as the reference.
   • Turn on the toolkit's trace switches for the port. Compare the call order with RPCS3's log.
   • Fix the cause, not the symptom. A forced wait only moves the crash.
   • Put toolkit fixes in patches/NNNN-name.patch. Put lifted-code fixes in a script that re-runs after every lift.
   • Add a host test that fails without the fix and passes with it.
   • Log the wall, the cause and the proof in PROGRESS.md. Log dead ends too.
   Prompt for ClaudeCopy

   GOAL: Find and fix the cause of <WALL: one crash, hang or missing call> at <WHERE IT HAPPENS>.
   READ FIRST: PROGRESS.md (dead ends), the last run log at <LOG PATH>, the RPCS3 reference log at <RPCS3 LOG PATH>.
   FENCE: Edit only port/, tools/post_lift/, tests/ and new files in patches/. recompiled/ and third_party/ps3recomp are read-only. Never copy RPCS3 code; read it for behaviour only.
   CHECK: Run `powershell -File tools/check.ps1 -Boot <SECONDS>`. Done means the run passes <WALL> and reaches <NEXT MILESTONE>, the new host test fails without the fix and passes with it, and no older milestone was lost.
   BUDGET: Stop after 3 failed fixes or 90 minutes. No fix until you can name the cause with log lines.
   IF BLOCKED: Stop. Do not stub or force the wait. Tell me the evidence you have and what you need.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) The cause, with log lines. 3) Paste the check output. 4) Files changed. 5) Parking-lot items.

   Done whenThe run passes the wall and reaches the next milestone, the new host test proves the fix, and no older milestone was lost.

   Proof this works: Soulbrandt (trace switches compared with RPCS3 Trace logs; forcing a wait only moved the crash), Project Helghast (one host test per runtime fix), God of War II Recomp (fixes as idempotent patch_*.py scripts), Project Tourline Prologue (post-lift scripts re-run after every lift)

8. Harden: golden runs, hashes and a clean build

   You make old fixes stay fixed. A script plays the game to known points and checks the log. Hash lists prove a fresh lift gives the same files. Then you test a full build from a clean checkout. After that comes speed, settings and an installer.

   • Write tools/golden.ps1. It runs the game with scripted pad input, waits for milestone log lines, saves a screenshot and kills the game at the end.
   • Record a hash for each generated file in generated.lock. Fail the build if one differs.
   • Copy the idea of the toolkit's gate in docs/REGRESSION_GATE.md. It records the order of first firmware calls, system calls and draw paths, then fails on lost ones. Its regress.py only runs ports listed in the toolkit, so write your own.
   • Throw away the first run after a build as a warm-up. Record each golden twice and keep what both runs share.
   • Delete the build folder and rebuild from scratch. Some failures hide in stale objects.
   • Ship an installer that lifts and builds on the player's PC from their own copy. Never ship game code.
   Prompt for ClaudeCopy

   GOAL: Build a regression set that proves every fixed wall stays fixed.
   READ FIRST: PROGRESS.md (all fixed walls), third_party/ps3recomp/docs/REGRESSION_GATE.md.
   FENCE: Edit only tools/golden.ps1, tests/golden/ and generated.lock. Game code and port code are read-only in this task.
   CHECK: Delete build/, run `powershell -File tools/check.ps1 -Full`. Done means a clean rebuild passes, every golden run reaches its milestone, and the generated files match generated.lock.
   BUDGET: Stop after 3 hours.
   IF BLOCKED: Stop. Tell me which golden run fails and paste its log tail.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste the full check output. 3) Files changed. 4) Walls with no golden run yet.

   Done whenA rebuild from a clean checkout passes, every golden run reaches its milestone, and all generated files match generated.lock.

   Proof this works: T5DR Online (smoke suite with scripted pads after every merge), inFAMOUS Reborn (generated.lock hashes before and after patches), Resistance 2 Port (SSIM screenshot regression and soak runs), https://github.com/sp00nznet/ps3recomp/blob/master/docs/REGRESSION_GATE.md

Path B: Full decomp for porting

No PS3 game has a full decomp. The workable route starts from your finished Path A port. You replace lifted functions with readable C, one at a time. A check mode runs your C and the lifted code side by side and compares the results. Byte matching is only possible when the game used a GCC whose source is public.

1. Choose matching or non-matching

   You find out which compiler built the game. Each compiled file leaves a stamp in the .comment section. A Sony GCC stamp with public source makes matching possible. An SNC game, or no stamp, means non-matching only.

   • Count the stamps per revision: python -c "import sys,re,collections;d=open(sys.argv[1],'rb').read();[print(n,s.decode()) for s,n in collections.Counter(re.findall(rb'GCC: [^\x00]+',d)).most_common()]" D:/ps3work/<TITLE_ID>/EBOOT.ELF.
   • Look for more than one revision. Tools of Destruction mixes two: 24 objects from revision 1826 and 8 from 1830.
   • Read the llesieur99/rac6-totd-decomp compiler notes. They show how a stamp was traced to published GCC source.
   • Write the choice, the reason and the check into SCOPE.md.
   Prompt for ClaudeCopy

   GOAL: Decide whether <GAME> can be byte-matched, and write the Path B scope.
   READ FIRST: SCOPE.md, docs/TRIAGE.md, https://github.com/llesieur99/rac6-totd-decomp/blob/master/docs/COMPILER.md.
   FENCE: Write only SCOPE.md and docs/COMPILER.md. The ELF is read-only. Do not download any compiler or SDK.
   CHECK: Run the stamp-count command from this step. Done means its output matches the table in docs/COMPILER.md line for line, the file states matching or non-matching with the reason, and SCOPE.md names the Path B check command.
   BUDGET: Stop after 60 minutes.
   IF BLOCKED: Stop. Tell me what the stamps say and what you could not confirm.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste the stamp counts. 3) The decision and why. 4) Open questions.

   Done whendocs/COMPILER.md lists every stamp with its count, and SCOPE.md states matching or non-matching with the check command.

   Proof this works: https://github.com/llesieur99/rac6-totd-decomp (compiler read from .comment stamps), https://en.wikipedia.org/wiki/ProDG_(software)

2. Set up the side-by-side check

   Your Path A port becomes the answer key. You add a way to swap in a hand-written function for a lifted one. A check mode runs both on the same input and compares the results. This is the test every Path B unit must pass.

   • Keep the lifted body next to your version. The soyjxck/ps3recomp fork has ppu_lifter.py --hook <ADDR>, which emits func_<ADDR>_lifted and leaves func_<ADDR> to you.
   • Upstream ppu_lifter.py has --weak instead. Your strong function of the same name then wins at link time, but the lifted body is gone.
   • Add an env switch per function: 0 uses lifted code, 1 uses yours, check runs both and compares memory and return values.
   • Make src/ for hand-written C, one file per unit. Keep recompiled/ as the fallback.
   • Matching route only: build Sony's old PPU GCC from its published source, as the rac6 notes describe. It needs an old host compiler. rac6 used a Docker container with Debian jessie. Then install objdiff.
   Prompt for ClaudeCopy

   GOAL: Add a check mode that runs a hand-written function and its lifted twin on the same input and compares results.
   READ FIRST: SCOPE.md, port/, the --hook option in https://github.com/soyjxck/ps3recomp/blob/master/tools/ppu_lifter.py, the check switches in https://github.com/soyjxck/dod3-recomp/blob/main/docs/DEBUGGING.md.
   FENCE: Edit only port/check_mode/, tools/ and CMakeLists.txt. recompiled/ and third_party/ps3recomp are read-only.
   CHECK: Run `powershell -File tools/check.ps1 -Unit <DEMO_ADDR> -Mode check`. Done means a test function that copies the lifted body passes, and a version with one changed constant fails with the address and the first differing value.
   BUDGET: Stop after 4 failed tries or 2 hours.
   IF BLOCKED: Stop. Tell me what the hook system cannot do.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste both check outputs, pass and fail. 3) Files changed. 4) What is left.

   Done whenThe check mode passes a correct copy and fails a broken copy, naming the address and first differing value.

   Proof this works: Drakengard 3 Recompiled (--hook keeps func_<addr>_lifted; check switches such as DOD3_GC_NATIVE=check), Soulbrandt (--override-funcs replaced malloc and free), God of War II Recomp ([[functions_override]] in the lifter config), https://github.com/llesieur99/rac6-totd-decomp/blob/master/docs/COMPILER.md (old GCC built in a container)

3. Build the function ledger

   You sort all functions into work piles. SDK and middleware code is marked so nobody writes it by hand. Names start as guesses and need proof. The ledger is the single list every worker reads.

   • Start from analysis/functions.json. Add columns: status, owner, size, callers, name, proof.
   • Mark library code by its strings: Lua, zlib, the C++ library, SPURS, WWS, Edge or Unreal Engine 3.
   • Find shared code in sister games. The rac6 project found 721 functions with a twin in the next Ratchet game. Half of the 20 pairs it compared were byte for byte the same.
   • Give each name a proof: a string, a caller, or a data use. Mark the rest hypothesis.
   Prompt for ClaudeCopy

   GOAL: Build ledger/functions.tsv for Path B with a status, owner, size, name and proof column.
   READ FIRST: SCOPE.md, analysis/functions.json, docs/TRIAGE.md.
   FENCE: Write only ledger/ and docs/LIBRARIES.md. Use Ghidra through GhidraMCP read-only. Do not rename anything in generated code.
   CHECK: Run `python tools/ledger_check.py`. Done means every function has one row, library code is marked with the string that proves it, and every name has a proof or the word hypothesis.
   BUDGET: Stop after 3 hours.
   IF BLOCKED: Stop. Tell me which ranges you could not classify.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Counts by status. 3) Library code found and its size. 4) Files written.

   Done whenpython tools/ledger_check.py passes: one row per function, library code marked with proof, every name proven or marked hypothesis.

   Proof this works: https://github.com/llesieur99/rac6-totd-decomp (22,212 addresses, names as hypotheses, cross-game list), Project Tourline Prologue (static analysis helpers xref.py, vtab.py, rtti.py)

4. Replace one small function, end to end

   You prove the whole loop on one tiny function. You write readable C for it. The check mode passes. A golden run still reaches its milestones. Then you know the loop works before you scale it.

   • Pick a leaf function under 40 instructions that runs every frame.
   • Write it in src/<addr>.c. Keep the original address in a comment, such as // @0x00123abc.
   • Run the check mode on it during a golden run.
   • Matching route: also compile with the old GCC and compare bytes with objdiff. rac6 needed -O1 or -O2 with -falign-functions=4 for most of its 34 matches.
   • Mark it done in the ledger with the check output.
   Prompt for ClaudeCopy

   GOAL: Replace function <ADDR> with readable C that passes the check mode.
   READ FIRST: ledger/functions.tsv row <ADDR>, the lifted body in recompiled/ (read-only), its callers in Ghidra via GhidraMCP.
   FENCE: Edit only src/<ADDR>.c and its ledger row. No inline assembly. No copying of the lifted C. No new globals.
   CHECK: Run `powershell -File tools/check.ps1 -Unit <ADDR> -Mode check` and then `powershell -File tools/golden.ps1`. Done means zero mismatches in check mode and every golden milestone reached.
   BUDGET: Stop after 5 tries with no gain.
   IF BLOCKED: Stop. Report the first mismatch and your best version.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste both check outputs. 3) Files changed. 4) What you learned for the next unit.

   Done whenCheck mode shows zero mismatches for the function, and every golden run still reaches its milestones.

   Proof this works: https://github.com/llesieur99/rac6-totd-decomp (module_init, 44 bytes, byte-exact), Drakengard 3 Recompiled (native replacements behind check switches)

5. Grind the PPU functions in parallel

   Workers each take one function in their own worktree. Easy and library-adjacent functions go first. Each one must pass check mode and the golden runs. Failures go to a hard pile with notes.

   • Make one worktree per worker: git worktree add ../w1 -b w1.
   • A lead session picks the next units from the ledger. One owner per function.
   • After three tries with the same mismatch, park the unit with its first difference.
   • Merge often. Re-run check mode and golden runs on the merged branch, not just in the worktree.
   Prompt for ClaudeCopy

   GOAL: Replace function <ADDR> with readable C that passes the check mode.
   READ FIRST: ledger/functions.tsv row <ADDR>, src/ files of similar finished functions, the callers in Ghidra via GhidraMCP.
   FENCE: Work only in this worktree. Edit only src/<ADDR>.c and its ledger row. No inline assembly, no forced registers, no edits to recompiled/, tools/ or the check script.
   CHECK: Run `powershell -File tools/check.ps1 -Unit <ADDR> -Mode check`. Done means zero mismatches over a full golden run.
   BUDGET: Stop after 3 tries with the same mismatch, or 45 minutes.
   IF BLOCKED: Stop. Write the first difference and your best attempt to nonmatching/<ADDR>.md.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste the check output. 3) Files changed. 4) Parking-lot items.

   Done whenThe ledger shows the planned batch done, and check mode plus golden runs pass on the merged branch.

   Proof this works: https://github.com/llesieur99/rac6-totd-decomp (AGENTS.md: three attempts, then park; one writer in the clone), Project Helghast (one worktree and owned paths per agent)

6. Rewrite the SPU programs

   The SPU jobs need their own C versions. You record real jobs while the game runs. Then you replay each job outside the game and compare the output bytes. A job is done when the bytes match on all recorded inputs.

   • Record inputs and outputs of one SPU job while playing a golden run.
   • Write the job in C. Put it behind an env switch.
   • Replay all recorded jobs through both versions. Compare every output byte.
   • Only then make your version the default. Keep the switch for rollback.
   Prompt for ClaudeCopy

   GOAL: Write SPU job <JOB_ID> in C and prove its output matches the lifted job on recorded inputs.
   READ FIRST: docs/TRIAGE.md SPU inventory, the recorded jobs in D:/ps3work/<TITLE_ID>/jobs/<JOB_ID>/, the lifted job in spu/ (read-only).
   FENCE: Edit only src/spu/<JOB_ID>.c and its switch in port/. Recorded jobs are read-only.
   CHECK: Run `powershell -File tools/replay_job.ps1 <JOB_ID>`. Done means every recorded job gives byte-identical output, and the count of jobs checked is printed.
   BUDGET: Stop after 5 failed tries or 2 hours.
   IF BLOCKED: Stop. Report the first differing byte, its job and offset.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste the replay output. 3) Files changed. 4) What is left.

   Done whentools/replay_job.ps1 <JOB_ID> reports byte-identical output on every recorded job.

   Proof this works: God of War: Ascension PC (replay.ps1: identical on 12 million checked calls), Project Pyrrhus (native SPU jobs must give the same output bits)

7. Remove the lifted fallback

   You turn off lifted code one file at a time. Each step must still pass every golden run. At the end, the game builds with no lifted code at all. A fresh agent then hunts for cheats in the work.

   • Remove one lifted file from the build. Run the full check.
   • Keep a list of any function that still needs the lifted body.
   • Have a fresh session review src/ for copied lifted C, inline assembly or disabled checks.
   Prompt for ClaudeCopy

   GOAL: Remove lifted file <RECOMP_FILE> from the build and prove the game still passes.
   READ FIRST: ledger/functions.tsv, PROGRESS.md, CMakeLists.txt.
   FENCE: Edit only CMakeLists.txt and the ledger. Do not change src/, tools/ or tests/ in this task.
   CHECK: Delete build/, run `powershell -File tools/check.ps1 -Full`. Done means a clean build without <RECOMP_FILE> passes every golden run.
   BUDGET: Stop after 2 failed runs.
   IF BLOCKED: Stop. List the missing symbols or failing milestones.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste the check output. 3) Files changed. 4) Functions still lifted.

   Done whenA clean build with no lifted files passes every golden run.

   Proof this works: Soulbrandt (legacy renderer retired only after identical frames), https://github.com/sp00nznet/ps3recomp/blob/master/docs/REGRESSION_GATE.md

8. Port it to a new system

   You move the readable code to a new target. The PS3 parts sit behind an interface. You fix byte order where data is read from game files. Then you run the same golden runs on the new system.

   • Put graphics, sound, input and files behind one interface each.
   • Use the toolkit's other backends as a start: Vulkan for Linux, Metal for Mac.
   • Swap big-endian reads of game data for helper functions.
   • Run every golden run on the new system and compare screenshots.
   Prompt for ClaudeCopy

   GOAL: Build <GAME> for <NEW SYSTEM> and pass the golden runs there.
   READ FIRST: SCOPE.md, port/ interfaces, third_party/ps3recomp/docs/PLATFORM_ABSTRACTION.md.
   FENCE: Edit only port/platform/<NEW SYSTEM>/ and build files. src/ game logic is read-only unless a byte-order bug is proven.
   CHECK: Run `tools/golden.sh` on <NEW SYSTEM>. Done means every golden run reaches its milestones and the screenshots match the Windows ones.
   BUDGET: Stop after 4 hours or 5 failed builds.
   IF BLOCKED: Stop. Tell me the first failing interface and the error.
   OTHER PROBLEMS: Write them in notes/parking-lot.md.
   REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste the golden run output. 3) Files changed. 4) What is left.

   Done whenEvery golden run passes on the new system and its screenshots match the Windows ones.

   Proof this works: Drakengard 3 Recompiled (Windows, macOS Metal and Linux Vulkan from one tree), God of War II Recomp (macOS, with iOS and Android builds)

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

In Path A, one unit is one wall: a crash, a hang, a missing call or a wrong draw. Each unit has a golden run that must reach the next milestone. In Path B, one unit is one function or one SPU job. Each has a check mode that compares it with the lifted twin. Toolkit fixes are their own units, one numbered patch each, with a host test.

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 files in recompiled/ or spu/. They are generated. Fix the lifter, a post-lift script, or a patch in patches/, then lift again.
- third_party/ps3recomp is pinned and read-only. Every change is a new numbered file in patches/.
- The one check is `powershell -File tools/check.ps1`. Done means it prints CHECK OK. A clean build alone is not proof.
- Never say something works unless you ran it. Look at the screenshot before you claim anything about the picture.
- Build only with tools/build.ps1, which caps jobs by free memory. Never run cmake --build -jN on lifted code.
- Never commit game files: EBOOT, .elf, .psarc, .pkg, .rap, dumps or lifted code. Never use git add -A or git commit --no-verify.
- Read RPCS3 for behaviour only. Never copy, translate or closely paraphrase its code.
- Mark any value not yet proven from the game file as ASSUMPTION:. Keep the original address in a comment, such as // @0x00123abc.
- Kill the game by its PID after every run. Only one game process at a time.
- Set verbose logging off when you measure. It changes thread timing.
- Record findings and dead ends in PROGRESS.md, newest first, with the date and the proof.
- In a worktree, use absolute paths for game files: D:/ps3work/<TITLE_ID>/.

Keep the context small

• Never paste lifted C++ into the chat. One game's lift can fill 300 to 600 MB. Give the address and let Claude read the few lines it needs.
• Hand Claude the last 40 log lines and the RPCS3 log path, not the whole log.
• Use a subagent to search big logs or Ghidra output and report back a short summary.
• Keep CLAUDE.md short. Put facts per area, such as SPU or graphics, in their own files under docs/.
• Clear the chat after each wall or each function. The ledger holds the state.

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> (<TITLE_ID>, version <VERSION>) can be ported with ps3recomp, and draft SCOPE.md.
READ FIRST: https://github.com/sp00nznet/ps3recomp README and docs/GAME_PORTING_GUIDE.md. RecompLauncher's list for PS3. RPCS3's compatibility notes for <GAME>.
FENCE: Write only SCOPE.md and notes/feasibility.md. Do not install tools. Do not touch game files.
CHECK: Run `Select-String -Path notes/feasibility.md -Pattern 'Prior ports:','Engine:','RPCS3:','SPU load:','Memory:','Verdict:'`. Done means all six lines are found, each has a real answer, and the verdict is yes, risky or no with reasons.
BUDGET: Stop after 45 minutes.
IF BLOCKED: Stop. Tell me what you could not find.
OTHER PROBLEMS: Write them in notes/parking-lot.md.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) The verdict. 3) Paste SCOPE.md. 4) Links you used.

GOAL: Map <GAME>'s EBOOT.ELF into ledger/functions.tsv and docs/TRIAGE.md.
READ FIRST: SCOPE.md, third_party/ps3recomp/docs/TOOLS.md.
FENCE: Write only analysis/, ledger/ and docs/TRIAGE.md. The ELF and third_party/ps3recomp are read-only.
CHECK: Run ppu_loader.py, find_functions.py --seed-json, prx_analyzer.py --stubs and extract_spu_images.py, then `python tools/ledger_check.py`. Done means the ledger has one row per entry in analysis/functions.json, each with a status, and TRIAGE.md lists TOC values, import coverage per library, and every SPU program with how it was found.
BUDGET: Stop after 90 minutes.
IF BLOCKED: Stop. Paste the failing command and its error.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Function, import and SPU counts. 3) Missing imports. 4) Files written.

GOAL: Get past <WALL> at <WHERE>.
READ FIRST: PROGRESS.md dead ends, <RUN LOG>, <RPCS3 LOG> for the same scene.
FENCE: Edit only port/, tools/post_lift/, tests/ and new files in patches/. recompiled/ and third_party/ps3recomp are read-only.
CHECK: Run `powershell -File tools/check.ps1 -Boot <SECONDS>`. Done means the run reaches <NEXT MILESTONE>, a new host test proves the fix, and no older milestone is lost.
BUDGET: Stop after 3 failed fixes or 90 minutes.
IF BLOCKED: Stop. Do not stub, skip or force the wait. Give me the evidence and what you need.
OTHER PROBLEMS: Write them in notes/parking-lot.md.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Cause with log lines. 3) Check output. 4) Files changed. 5) Parking-lot items.

GOAL: Replace function <ADDR> with readable C that passes check mode.
READ FIRST: ledger row <ADDR>, finished functions in src/ with similar callers, the callers in Ghidra.
FENCE: Edit only src/<ADDR>.c and its ledger row. No inline assembly, no copied lifted C, no edits to tools/, tests/ or recompiled/.
CHECK: Run `powershell -File tools/check.ps1 -Unit <ADDR> -Mode check`. Done means zero mismatches over a full golden run.
BUDGET: Stop after 3 tries with the same mismatch.
IF BLOCKED: Stop. Save your best attempt and first difference in nonmatching/<ADDR>.md.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Check output. 3) Files changed. 4) Name and proof for the function.

GOAL: Pick the next <N> units from ledger/functions.tsv and start one worker per unit.
READ FIRST: ledger/functions.tsv, PROGRESS.md, notes/parking-lot.md.
FENCE: Edit only the owner and status columns of the ledger. Do not do unit work yourself. Each worker gets its own worktree made with `git worktree add ../w<K> -b w<K>`.
CHECK: Each worker report starts with DONE, PARTIAL or BLOCKED and pastes its check output. Before you mark a unit done, run `powershell -File tools/check.ps1 -Full` on the merged branch and see it pass.
BUDGET: Stop when <N> reports are in, or after 4 hours.
IF BLOCKED: Stop. Tell me which workers failed and why.
REPORT: 1) Table of units with outcome. 2) Merged-branch check output. 3) Units moved to the hard pile. 4) Ledger counts.

GOAL: Find the cause of <SYMPTOM>. Do not fix it yet.
READ FIRST: <RUN LOG>, <RPCS3 LOG>, PROGRESS.md dead ends.
FENCE: You may add temporary trace switches in port/ only. Remove them before you report. Change no game logic.
CHECK: Run `powershell -File tools/check.ps1 -Boot <SECONDS>` and show the symptom in its log. Give one cause backed by evidence: the first call that differs from RPCS3, a memory watch hit, or a frame capture. Then run one test that would prove you wrong, and show its result.
BUDGET: Stop after 90 minutes.
IF BLOCKED: Stop. List each idea you ruled out and the proof.
OTHER PROBLEMS: Write them in notes/parking-lot.md.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Cause and evidence. 3) The falsifying test and its result. 4) Suggested fix, not applied.

GOAL: Check that the work in branch <BRANCH> is real.
READ FIRST: SCOPE.md, CLAUDE.md, `git diff main...<BRANCH>`.
FENCE: Read only. Change nothing.
CHECK: Delete build/ and run `powershell -File tools/check.ps1 -Full`. Then look for: edits in recompiled/ or third_party/ps3recomp, edits to generated.lock or golden files, new stubs that return success, forced waits, disabled tests, copied RPCS3 code, game files staged, and changes outside the fence.
BUDGET: Stop after 60 minutes.
IF BLOCKED: Stop. Tell me what you could not check.
REPORT: 1) PASS or FAIL. 2) Paste the check output. 3) Each problem with file and line. 4) What you did not check.

GOAL: Give me a status report from the files only.
READ FIRST: PROGRESS.md, ledger/functions.tsv, notes/parking-lot.md, the last golden run output.
FENCE: Read only. Change nothing.
CHECK: Run `git log --since="7 days ago" --oneline` and `python tools/ledger_check.py`. Every number must come from a file or a command you ran. Name the source for each.
BUDGET: Stop after 15 minutes.
IF BLOCKED: Stop. Tell me which file is missing.
REPORT: 1) Milestones reached, with dates. 2) Walls fixed this week. 3) Open walls. 4) Path B counts by status. 5) Top three risks. No padding.

GOAL: Write down everything the next session needs.
READ FIRST: PROGRESS.md, `git status`, `git log -5`.
FENCE: Edit only PROGRESS.md and notes/handoff.md.
CHECK: Run `git status --short` and `powershell -File tools/check.ps1`, and paste both into notes/handoff.md. Done means the note also says what works, what is half done with file paths, the branch, dead ends found today, and the next three steps. A new session must be able to start from it alone.
BUDGET: Stop after 15 minutes.
IF BLOCKED: Stop. Tell me what you could not record.
REPORT: 1) DONE, PARTIAL or BLOCKED. 2) Paste notes/handoff.md.

GOAL: Tell me plainly whether <TASK> can be done with what we have.
READ FIRST: PROGRESS.md, the last three reports on <TASK>.
FENCE: Read only. Change nothing.
CHECK: Run the last failing check again, such as `powershell -File tools/check.ps1 -Boot <SECONDS>`, and paste its result. Answer with CAN, CANNOT or CAN WITH CHANGES. Back it with that output and the evidence you have.
BUDGET: Stop after 20 minutes.
IF BLOCKED: Say what information would settle it.
REPORT: 1) CAN, CANNOT or CAN WITH CHANGES. 2) Why, with evidence. 3) Two or three options with cost and risk. 4) What you would pick.

GOAL: Ask me before you leave the fence for <TASK>.
READ FIRST: SCOPE.md, the current task card.
FENCE: Change nothing until I answer.
CHECK: Run `git status --short` and show that nothing outside the fence has changed yet. The request names the files you want to touch, why, the risk, and how we would check it.
BUDGET: One message.
IF BLOCKED: Wait for my answer.
REPORT: 1) What you want to change. 2) Why it is needed. 3) Files outside the fence. 4) Check for the change. 5) What happens if I say no.

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

• How much the game leans on SPU jobs. Heavy SPU use means more programs to find and more races to fix.
• Whether a port of a sister game already exists. Shared engines let you reuse patches and addresses.
• How many firmware calls the toolkit does not cover yet. Each one is a runtime task.
• Your PC's memory. A full lifted build takes 10 minutes on a big PC and over an hour on a small one.
• For Path B, the compiler. SNC games cannot be byte-matched, and every function count is in the tens of thousands.

The facts behind these numbers

Projects reviewed (16)

We took the top-starred project for each of the top 12 PS3 games on RecompLauncher. We added three more where the developer says AI was used. We added one outside project, because it is the only PS3 matching decomp we found.

What each project teaches

What we could not check

• rpcs3.net, wiki.rpcs3.net and psdevwiki.com blocked our page reader. RPCS3 download and firmware steps come from its GitHub source and the cards, not its site.
• We did not check whether RPCS3 needs PS3 firmware installed before --decrypt works. We also did not check how it finds the licence for a PSN game. Its source asks for a KLIC key when it cannot unlock a file.
• We did not run any ps3recomp tool. Commands and flags were checked against its docs and its tool source code on 2026-11-13. Its docs disagree on prx_analyzer.py for an EBOOT: the porting guide uses it with --stubs, but docs/TOOLS.md says it finds nothing there.
• The x64 Native Tools Command Prompt step comes from the toolkit's docs/BUILDING.md. That page shows the path for Visual Studio Community, not Build Tools.
• Building Sony's old GCC in Docker comes from the rac6 notes only. We did not try it.
• Code Veronica HD Recomp's history starts with the toolkit's own first commit in 2026-03. The port's repo was made on 2026-10-13.
• The source of Sony's old PPU GCC, sagemono/ps3gcc, returned not found on 2026-11-13. We know it only from the rac6 notes and one card.
• We do not know which games used SNC and which used GCC. Check the stamps in your own file.
• SPU support in Ghidra needs a third-party module such as GhidraSPU. We did not test it.
• The REA tool's Ghidra support on Windows is marked experimental by its own README. We did not test it.
• The check-mode and replay scripts named in Path B are patterns from Drakengard 3 and God of War: Ascension. You must write your own versions.
• Most reviewed ports hid their early history, so their true start dates and hours are unknown.
• Star counts are from the review cards. The older catalog snapshot shows 291 for God of War: Ascension PC and 145 for Project Pyrrhus. GitHub showed 440 and 146 on 2026-11-13, the same as the cards.

Sources

• ps3recomp README
• ps3recomp game porting guide
• ps3recomp tools reference
• ps3recomp getting started
• ps3recomp building notes (Windows developer prompt)
• ps3recomp SPU lifter notes
• ps3recomp project template CMakeLists.txt
• ps3recomp regression gate
• ps3recomp RSX graphics notes
• RPCS3 source: decrypt option
• RPCS3 source: decrypt output file names
• RPCS3 Windows builds
• RPCS3 developer information (Cell, SPU, RSX, LV2 documents)
• PS3 Disc Dumper
• Ghidra
• GhidraMCP
• REA
• objdiff
• RenderDoc
• vcpkg get started
• rac6-totd-decomp README
• rac6-totd-decomp compiler notes
• rac6-totd-decomp gates
• rac6-totd-decomp agent rules
• Docker Desktop for Windows
• ProDG (SN Systems, SNC compiler)
• Drakengard 3 Recompiled debugging notes
• Project Helghast building notes
• GhidraSPU