NocturneRecomp: statically recompiling the Xbox 360 build of Symphony of the Night into a native PC binary

A static recompilation, not an emulator

NocturneRecomp is a static recompilation of the Xbox Live Arcade version of Castlevania: Symphony of the Night for Windows and Linux, built on the ReXGlue SDK. The README explains the mechanism precisely: it converts the Xbox 360 PowerPC `default.xex` into native x86_64 code at build time, then wraps it with a small host runtime for logging, overlays and hooks, so the game runs natively and can be modded like a PC port.

The user is someone who owns the XBLA release and wants to play it natively on PC, with the modding and performance benefits that native code brings over emulation. This is not for someone looking for a free copy: the README states in bold that you must own the game, that the project ships no copyrighted code, data or assets, and that you provide your own legally dumped game.

The distinction from emulation is the whole point. An emulator interprets or JIT-compiles the console's instructions at runtime; a static recompilation translates them ahead of time into a native binary, so the result is a real PC executable rather than a program pretending to be a console. That is what makes native-level modding and performance possible.

How the PowerPC binary becomes a native one

The pipeline is a build-time translation. The README describes taking the `default.xex`, the Xbox 360 executable, and converting its PowerPC code to x86_64 through the ReXGlue SDK, then linking it against a host runtime that provides the services the game expects. The host runtime is where logging, overlays and hooks live, which is also the seam that makes modding practical.

Because the translation happens at build time rather than runtime, the game's own code is present as native code you compile and link, not interpreted on the fly. The README is careful about the legal boundary this creates: the project distributes only the host-side source in `src/`, the build scripts and the CI config, all under MIT. It distributes none of the game. The `assets/default.xex` extracted from your own dump must exist before codegen runs, which is the step that injects the copyrighted binary you legally own into an otherwise content-free build.

That separation, MIT host code plus your own game dump, is the standard shape of a legitimate recompilation project, and NocturneRecomp follows it deliberately. The ReXGlue SDK it depends on is a separate project that does the general PowerPC-to-native work, with NocturneRecomp providing the game-specific configuration and host glue.

Building it from your own dump

Building requires installing a toolchain, then feeding in your legally dumped game. The README gives platform-specific dependency installs; on Arch-based Linux:

paru -S clang20 cmake ninja vulkan-headers

and on Windows via Scoop:

scoop install llvm cmake ninja

After cloning, you fetch the pinned SDK and provide the game. The README pins the SDK version explicitly:

python scripts/download-sdk.py --pinned

You then place your legally dumped XBLA package, the LIVE or STFS file, into `game/` and extract it so `assets/default.xex` exists, which the README does with a script:

python scripts/extract_game.py

With the game binary in place, the build runs codegen and compilation:

python scripts/build.py

The README notes a Title Update variant, `python scripts/build.py --tu /path/to/TU_*`, for applying the game's title update. For people who do not want to build, prebuilt stable releases and nightly CI artifacts are offered; extracting a prebuilt archive and running the executable prompts you to extract the game, the same content-free approach in binary form. The Linux dependencies include `vulkan-headers`, reflecting a Vulkan-based host renderer.

The limitations: one game, one source version, your own dump

The honest limitations are inherent to what a per-game recompilation is. NocturneRecomp targets specifically the Xbox Live Arcade version of Symphony of the Night, not the PlayStation original or the Saturn version. The recompilation is tied to that particular `default.xex`, so the project's behavior, quirks and mods are all relative to the XBLA build, which differs from the versions many players remember.

The hard requirement to supply your own legally dumped game is a real barrier, and correctly so. There is no way to use this without owning and dumping the XBLA release, which means the audience is limited to people who both own that specific version and can extract it. That is the price of the project staying on the right side of the content line, and the README does not pretend otherwise.

The dependency on the ReXGlue SDK is the other consideration. The recompilation is only as capable as the SDK's PowerPC translation, and the SDK is pinned to a specific version by `download-sdk.py --pinned`, so the project moves when the SDK does. As a young project centered on one game, its longevity and mod ecosystem are still forming, and support is via its Discord rather than a formal channel.

Against emulating the game with RPCS3 or an original-hardware emulator

The alternative is emulation: running the XBLA version under an Xbox 360 emulator, or playing the PlayStation original under a PS1 emulator. Emulators are general, they run many games, and they need no per-game build, which is a large convenience advantage.

What a static recompilation offers instead is a native binary. Because NocturneRecomp translates the game to x86_64 ahead of time and links it against a host runtime with hooks and overlays, the result runs as native PC code and can be modded like a port, with performance and integration an emulator's runtime translation does not match. The cost is that it works for exactly one game and requires you to build from your own dump or run a content-free prebuilt that extracts your game. Choose an emulator when you want breadth and minimal setup across many titles. Choose NocturneRecomp when you specifically want the XBLA Symphony of the Night as a native, moddable PC executable and you own the game, accepting the per-game, dump-required workflow that makes native recompilation possible.

MIT host code, a pinned SDK, and what to check first

NocturneRecomp's host-side source, build scripts and CI are MIT, which is what lets the project be public and forkable without distributing any game content. The license covers only the glue and tooling; the game itself remains yours to supply, and the copyrighted binary never enters the repository.

Upgrade cost is tied to the pinned ReXGlue SDK: because `download-sdk.py --pinned` fixes a specific SDK version, a build is reproducible, but adopting SDK improvements means the project updating its pin. Prebuilt stable and nightly artifacts exist for people who would rather not track the toolchain at all.

The concrete first step is to confirm you can legally dump your XBLA copy before anything else, since without `assets/default.xex` from your own dump, codegen cannot run and nothing works. If you have that, decide between a prebuilt release, which prompts you to extract your game, and a source build, which needs the clang, cmake, ninja and Vulkan-headers toolchain the README lists. Either way, the game data comes from you, and the project supplies only the native recompilation around it.

Editorial conclusion

Reach for NocturneRecomp if you own the Xbox Live Arcade Symphony of the Night and want it as a native, moddable PC executable rather than an emulated one: the build-time PowerPC-to-x86_64 translation via the ReXGlue SDK and the host runtime's hooks and overlays are what make native modding possible. It is useless without a legally dumped copy, since assets/default.xex must come from your own game, and it targets only the XBLA version, not the PlayStation or Saturn originals. Before starting, confirm you can dump your XBLA copy, then choose a prebuilt release that prompts you to extract the game or a source build using the clang, cmake, ninja and vulkan-headers toolchain the README lists.

Frequently asked questions

Official sources

1. birabittoh/NocturneRecomp on GitHub
2. License: MIT
3. Project website
4. README
5. Releases