Repository navigation
How It Works
If you understand one thing about this project, understand this page. It is the mental model everything else hangs off.
A traditional decompilation is stuck at 0% until enough of the game is rewritten to do anything. This project is not, because of one move:
The entire retail binary is mechanically lifted to C and boots from our own source today. It runs 552,653 real instructions to the renderer's doorstep before it needs a GPU.
That lifted C is not readable and not moddable — it is a faithful, machine-generated transcription of the PowerPC. But it is correct, and it runs. That gives us a living program to work against instead of a pile of disassembly.
The shipped binary is lifted C for everything, with hand-verified clean C swapped in function by function. The program boots and runs the whole time. Each time a human (or an AI swarm) writes a readable C version of a function and the Verification-Harness proves it behaves identically to the retail bytes, that clean function replaces its lifted stub.
So every release is strictly more native and more moddable than the last. Ship early, ship often, get more native each release. There is no big-bang rewrite and no "it does nothing until it's done" phase.
These are two different outputs from the same living program, and they advance independently:
| Track | What it is | What produces it |
|---|---|---|
| Playable | A frame on screen | The Renderer — reimplementing the RSX command consumer so the already-emitting game can draw. It does not require decompiling the renderer. |
| Moddable | Engine-level source control | The verified-function count climbing. Each verified function is one more piece of the game you can read and change. See Status. |
A newcomer's instinct is that you must decompile the renderer to see a frame. You do not. The lifted game already emits valid RSX GPU commands; what's missing is something on the other end to consume them. That reframe is what makes a first frame a bounded engineering task instead of a years-long renderer decomp. See Renderer.
Three facts, all measured, not assumed:
-
The compiler is CELL GCC 4.1.1, not Sony's SNC. GCC is open and buildable, so its codegen is understood and byte-exact matching is feasible. This is the single most important finding in the project.
-
SPU is 100% middleware, 0% game logic. The SPURS/SPU-dispatch wall that kills most PS3 recomps does not exist here — all 8 SPU images are middleware.
-
The binary is one statically-linked executable. No
.prx/.sprx/.selfon disc. The scope is bounded by one file of ~20,298 functions.
See Foundations for the full list of what's already built on top of these facts, and Verification-Harness for how "behaves identically" is actually proven.