OpenRAC Ratchet and Clank PS2: 98.38% of the Game Code Matches by Byte

By Indie Kings | October 21, 2026

Updated October 21, 2026: The OpenRAC project has decompiled 5,073 of the 5,124 functions in Ratchet & Clank for the PlayStation 2, which is 98.38% of the game's code by byte. Its eight contributors have made 2,453 commits, and the project tracks its progress on a website at openrac.dev.

Image: GitHub repository card for OpenRAC/rac1-decomp.

What OpenRAC is doing to Ratchet & Clank

Per the repository README, this is a work-in-progress matching decompilation of Ratchet & Clank, the 2002 Insomniac Games release, for the PlayStation 2, and it is part of the OpenRAC initiative. The target is the PAL version 2.00 release with the identifier SCES_509.16.

The objective is stated plainly: to produce C and C++ source code that, when compiled with the original toolchain, generates a byte-identical copy of the retail executable. Matched code is then refactored toward readable, idiomatic C++ with accurate types and naming, using matching builds as continuous regression tests. That second half is the part that distinguishes a decompilation from a translation exercise, and it is why the project keeps matched code in the build rather than setting it aside.

GitHub reports 59 stars, 8 forks and 8 contributors for the repository. The lead contributor accounts for 1,615 commits, with the next at 604, 136, 50, 25 and 11, and the eight contributors together account for 2,453. The source tree holds 1,072 entries, of which 1,013 are files, with the source at 426 entries, the not-yet-matching parts at 316, the tooling at 165, notes at 65 and documentation at 31. The GitHub language breakdown puts C at 16,794,806 bytes, which is 94.5% of the 17,777,782 bytes in the project, with Python at 905,346 bytes, Shell at 30,279 and Rust at 20,674. The licence is the GNU General Public License v3.0.

The match numbers and how they are measured

The project tracks progress on openrac.dev and through a ByteMatch report, and the numbers are current as of October 21, 2026.

The percentage covers the whole game, not the main executable. The overlay documentation states that the report's totals cover everything, so its percentage is that of the whole game's code, and the main executable on its own stands at 455,272 of 465,644 bytes matched, which is 97.77%.

Two more figures in that table need reading together. The function count is nearly complete, but the units figure of 125 out of 141 is the more honest measure of what a reader gets, because a unit is a whole source file and a single unmatched function inside it keeps the unit incomplete. The ByteMatch report puts complete code at 55.71%, which is a stricter measure still: a unit only counts as complete when its code matches exactly rather than fuzzily.

The README describes how the remaining gaps are handled. Every function links at its original retail address, and functions not yet decompiled are built from disassembly, which ensures the full binary always links and matches retail byte for byte outside the functions still in progress. The project calls this its continuous regression test, and it is why a build can be verified as matching while the decompilation is still running.

How the level overlays work

The project documents its overlay handling in a separate file, which matters because the levels in Ratchet & Clank are not part of the main executable. Each level carries its own build of the game program, which replaces the executable's main segment, made of literals, bss, data, three vtables and text, when that level loads. The executable's game code is a subset of every level's program, and all distinct game code comes to about 3.5 MB.

A level is not a single file either. It is seven records, named for the literal, bss, data, three vtables and text segments, stored under a directory named for the level index. The documentation lays out the layers of the effort, from the game data the tools dump, through a catalogue of every distinct function and where it appears, to generated assembly and C stubs. Today a level program is matched function by function, and linking each level's program from the same sources and comparing it with the level's records is listed as a later step in the plan.

The main executable itself is copied from a disc image into the project directory under its target identifier, with a SHA-1 of 79956931bd62fafd8d20fa2eae796dbaf2e15e83 to check it against. The README notes that on Windows the directory path should be kept short, to avoid path length limits in the legacy toolchain's make.

The toolchain and the container build

The project uses the SN Systems ProDG toolchain for PS2, version 3.01, together with the Sony PS2 SDK version 2.4, and both are fetched as community mirrors rather than from a vendor. The setup step clones the compiler and the SDK into a toolchain directory in the repository.

Building it works two ways. On Windows natively, the README asks for Git Bash, Python 3.10 or newer, and the community toolchain mirrors, then runs a build script. On Linux and macOS, a Docker or Podman container is used, with a prebuilt Wine container pulled from a GitHub Container Registry, and the same scripts run inside it. The project ships documentation for the compiler and assembler configurations, for what the build reproduces of the retail toolchain against what it models, and for the container workflow.

Contributions are the point of the setup. The README says contributions are warmly welcome whether a person is interested in decompiling functions, researching engine quirks or improving documentation, and it points to a contribution guide, a step-by-step function matching workflow, and a Discord community.

The sibling projects it stands on

The README credits a long list of prior work, and the details matter because they explain why this particular project can match at all.

• GFI, the Game Fuckery Inc. Discord community, gets special thanks for years of reverse engineering, game research and technical insights.
• Lombyte, a matching decompilation of the NTSC build of Ratchet & Clank, is called an invaluable reference for function pairing, struct definitions and symbol names.
• ReRAC, a native PC port of the US release, provided the format documentation for mobys, models and collision, the symbol names, and the overlay mechanics.
• rac3-uya-decomp, a matching decompilation of Ratchet & Clank: Up Your Arsenal, was the foundation for the SN Systems compiler flag discoveries and the build setup.
• Wrench provides the PS2 modding tools and asset format specifications.

The wider tooling is credited too, including splat and spimdisasm for splitting and disassembly, m2c and asm-differ for assembly-to-C translation and diffing, objdiff for object diffing, ByteMatch and decomp.wiki for progress tracking and documentation, and AngheloAlf for the PS2 toolchain mirrors.

The sibling decompilations matter more than a credits list usually does. A function's exact instruction selection depends on the compiler's view of the surrounding code, and a matching decompilation of a sibling game gives you a working hypothesis for what the original source looked like before you reverse it from scratch.

Licences and what the repository excludes

The README states the position in two sentences. Code written for the project is licensed under the GNU General Public License v3.0, and reconstructed libraries and third-party components retain their original licenses, with the details in a third-party notices file and a legal file. Ratchet & Clank is a registered trademark of Sony Interactive Entertainment, and the project is not affiliated with or endorsed by Sony or Insomniac Games.

The repository itself contains no game assets, retail executables or disassembly, and the README's note asks readers to review the legal file before contributing. To build, you must provide your own legally obtained copy of the game, which means the executable goes into the project directory and is checked against the SHA-1 above.

FAQ

Which version of Ratchet & Clank is being decompiled?
The PAL version 2.00 release with the target identifier SCES_509.16, covering the English, French, German, Spanish and Italian regions. The NTSC release is a separate decompilation by a different project, listed in the credits.

How close is the decompilation to complete?
Per the ByteMatch report, 5,073 of 5,124 functions match, which is 99.00% of functions and 98.38% of the code by byte, with 125 of 141 units complete. Complete code is a stricter measure at 55.71%, because a unit only counts when it matches exactly rather than fuzzily.

What does matching decompilation actually mean?
It means the source compiles with the original toolchain into a byte-identical copy of the retail executable. The README describes the objective as producing C and C++ source that, compiled with the original toolchain, generates a byte-identical copy, and matched code is then refactored toward readable, idiomatic C++.

How is the build verified when some functions are still undecoded?
Functions not yet decompiled are built from disassembly, so the full binary always links and matches retail byte for byte outside the functions still in progress. The README calls the matching build a continuous regression test for the refactoring work.

Do I need the original PlayStation 2 toolchain to contribute?
The README describes two routes. Windows uses Git Bash, Python 3.10 or newer and community toolchain mirrors for SN Systems ProDG 3.01 and the Sony PS2 SDK 2.4, while Linux and macOS use a Docker or Podman container with a prebuilt Wine image. The project also asks for documentation and research contributions, not only matching work.

Does the project include the Ratchet & Clank game files?
No. The README states the repository contains no game assets, retail executables or disassembly, and asks readers to review the legal file before contributing. To build you provide your own legally obtained copy, and the executable is checked against the SHA-1 given in the setup instructions.

Bottom Line

OpenRAC is one of the closest decompilations running anywhere. 5,073 of 5,124 functions match and 98.38% of the game's code matches by byte, and the build links and matches retail byte for byte outside the functions still in progress, with the functions not yet decompiled built from disassembly so the binary always verifies. The number that tells you how much of the game is readable is the unit count, 125 of 141, because complete code is a stricter 55.71%. The project is also an unusually well-documented one, with separate files for the toolchain, the build fidelity rules and the overlay mechanics, and it inherits a great deal from sibling work: an NTSC decompilation for function pairing, a PC port for the file formats, and a sequel decompilation for the compiler flag discoveries. The licence is GPL v3.0, the game files are not in the repository, and the Sony and Insomniac trademarks are disclaimed.

Sources

• OpenRAC/rac1-decomp repository README, docs/OVERLAYS.md and the linked documentation index, accessed October 21, 2026
• Repository metadata, language breakdown, contributor list and commit history via the GitHub API, accessed October 21, 2026
• ByteMatch report for OpenRAC/rac1-decomp and the openrac.dev project site, accessed October 21, 2026

Related: 24,515 Functions Later: The 3.3.5a Client Is 90 Percent Decompiled | ShadPS4 - The Future of PS4 Emulation | 7 Unofficial PC Ports Worth Knowing in September 2026 [2026]