The original Xbox is the newest frontier in recompilation, and the frontier is barely a year old. The tool that makes it possible, sp00nznet's XboxRecomp, only appeared in March 2026. In the months since, a wave of projects has begun lifting original Xbox games into native code, and the newest is from HodgkinsStudios: RollerCoaster Tycoon: Recompiled, translated into C++17 rather than run through an emulator. And in a scene that sometimes gets ahead of its own evidence, this project does something quietly remarkable: it refuses to.
The README opens with a blunt warning: “The game is not playable yet.” It goes further, stating that the launcher, the analysis tools, the startup traces and the diagnostic visualizer are not evidence of a successful boot, and that no authentic GPU Present, original framebuffer, or rendered game frame has been verified. That is not a hedge. It is the discipline the whole recompilation field runs on.
“An experimental Ubuntu / C++17 recompilation and diagnostic project for the original Xbox version of RollerCoaster Tycoon. It combines a native launcher, locally built XboxRecomp and Capstone tooling, an experimental Xbox runtime, original-XBE analysis, and regression tests.”
From the project README
Why the Original Xbox Is the Hard Case
Every console that has a healthy recompilation scene has a decompilation or an accessible architecture behind it. The Nintendo 64 runs MIPS, the GameCube and Wii run PowerPC, and the original Xbox runs good old x86, which sounds like it should make things easier and does not.
The Xbox is a Pentium III machine with a custom Nvidia GPU called the NV2A, an Xbox kernel with its own calling conventions, and DirectX 8 era graphics APIs. Being x86 means the code itself is already familiar, but it also means the port has to rebuild everything around the code: the kernel services, the storage layer, and above all the GPU, which on the Xbox works through the NV2A's own command streams. That is why original Xbox emulation is the least mature of the mainstream emulators, and why people have quietly accepted that the Xbox is simply where emulation stops being easy.
Recompilation changes the shape of the problem. Instead of simulating a console and hoping the timing lines up, you translate the game's own instructions into C or C++ and compile them for your PC, then provide a runtime that answers the hardware calls. The hard part moves from accuracy to integration, and it is a hard part that can be worked on piece by piece.
The Xbox Recomp Scene Is Only Months Old
It is worth being precise about where this sits, because calling it the first would be wrong. The original Xbox recompilation wave is real, and it is brand new. The tool that drives it, sp00nznet's XboxRecomp, appeared in March 2026 and has already passed 200 stars. What followed was a rapid and genuinely exciting gold rush:
- The original Xbox Dashboard itself (March 2026), rebuilt as a native PC application from build 3944.
- Burnout 2: Point of Impact (May 2026), a full static recompilation of the Xbox racer.
- Conker: Live and Reloaded (August 2026), an experimental bring-up.
- Half-Life 2 (the Xbox version from 2005), FIFA Street 2 and X-Men Legends (September 2026).
- StarCraft: Ghost, The Lord of the Rings: The Third Age, SSX Tricky and Splinter Cell: Double Agent (September 2026), all in some stage of recompilation.
- Def Jam: Fight for NY, BLACK, Spider-Man 2 and Gladius (October 2026).
So RollerCoaster Tycoon is not the first, and it is not the flashiest. It may, however, be the most careful. Where several of those projects are racing to show something moving on screen, this one is busy cataloging exactly which claims it can and cannot make, and refusing to blur the two.
What Has Actually Been Verified
Strip out the caveats and the numbers are still real, and they represent genuine work:
- 7,888 original functions and matching ABI entries were identified in the game's executable during private analysis.
- 1,778 of those functions have been selected, producing 1,869 generated native C bodies.
- 119 of 119 generated C translation files compiled in the latest private build.
- The build passed the original-title kernel-thunk preflight, 113 of 113.
- Regression suites are green: 25 focused CP36 tests, 42 at CP35, and 59 at CP34, plus the synthetic NV2A smoke test.
The project is also precise about the boundary it has reached. The owner's American XBE is identified by a specific SHA-256 hash, validated privately, and the analysis has arrived at a six-instruction boundary inside an original routine at 0x003CF3B4..0x003CF3C6. That routine is reached in the test runs, and it is explicitly reported as not selected, translated or executed in the current 1,778-function build.
The distinction the project insists on: those startup runs happen under what it calls guarded CPU compatibility conditions. In plain terms, the CPU side is being exercised and studied. That is progress on one axis, and the project refuses to let it stand in for progress on the other.
The GPU Wall
Here is the honest reason there are no screenshots in this article, and no gameplay to describe. On the Xbox, everything you see is drawn by the NV2A GPU consuming command buffers, which the console calls pushbuffers and manages through DMA and a PFIFO ring. Until those commands are decoded and executed, there is no picture.
In the project's own strict tests, the DMA pointer showed PUT = 0x2000 and GET = 0, with zero verified decoded pushbuffer segments, zero executed NV2A methods, and zero Presents. The project is careful about why that matters: a compatibility mode can move GET up to PUT without actually executing any GPU commands, and it warns, in bold, that acknowledging DMA is not rendering. To avoid guessing, it refuses to treat the range from 0 to PUT as a valid command stream without a confirmed ring base, and it uses the NV2A BAR absolute offset for the PFIFO register (a 0x2000 block base plus 0x122C, giving 0x322C) rather than assuming an address.
There is real engineering underneath this. One checkpoint includes a bounded NV2A command dispatcher, and a test that compiles the software NV2A executor and verifies that fully synthetic commands clear an 8x8 framebuffer in guest RAM. But the project labels those results exactly as they are: synthetic pixels are not an original-title Present, and a cleared 8x8 buffer is not a game.
The rules the project holds itself to, verbatim from the README: no fabricated GPU Presents, no host hardware port access, no silent function stubs, no security bypass, and no false claim that DMA GET == PUT means commands were executed.
The Tooling Behind It
The translation itself is not bespoke. The project bundles XboxRecomp, a tool whose own description is refreshingly direct: “Turn any Xbox game binary into a native Windows executable. No emulation. No interpreter. Just raw, recompiled C.” XboxRecomp comes from sp00nznet, the developer behind the pcrecomp toolchain that rebuilt Command & Conquer: Tiberian Sun and Star Wars: Knights of the Old Republic into millions of lines of native C, both of which we have covered here.
Around that core, the project adds Capstone 6 for disassembly, Python scripts for original-XBE analysis and function discovery, and an experimental Ubuntu runtime that stands in for the Xbox kernel, storage and NV2A. The repository is organized accordingly, with the launcher and diagnostics under src/, the analysis and native-linking scripts under scripts/, CPU, storage, ABI, D3D and NV2A regression tests under tests/, and its machine-readable evidence under reports/.
One more detail worth noting for anyone who follows this scene: the repository carries the XboxRecomp license alongside its own, and the project asks that bundled third-party notices stay intact. Even the tooling respects the chain of credit.
Why This Matters
Original Xbox emulation has always been the awkward one. The emulators have improved, but incompatibilities remain, and the Xbox library contains a lot of games that people simply cannot play today without original hardware. Recompilation offers a second road, and the fact that it is now being pointed at Microsoft's first console at all is the news.
RollerCoaster Tycoon is a smart first target. It is a simulation game rather than a 3D action title, it leans on 2D isometric rendering rather than heavy GPU effects, and its code is far more approachable than a Halo or a Jet Set Radio Future. Nobody should mistake it for the hard case. What it is, is the right case: a project small enough to finish the plumbing on, so the next attempt inherits a working runtime instead of a blank page.
And the discipline may matter more than the code. The README warns that its own repository still tracks an ExtractedISO/ folder, that a history rewrite would be required to purge it, and that its .gitignore can only prevent new mistakes. A project that audits its own hubris, in public, on the front page, is one worth trusting with a bigger game later.
Where this actually stands: functions are being translated, a runtime is being built, and the GPU is the wall. That is not a playable port, and it is not pretending to be. It is one entry in a wave that is only months old, and the most carefully documented one yet.
How to Build It
The project targets Ubuntu. Install a C++17 compiler, Make, Python 3, and the X11, PNG and libarchive development libraries, then build and run the diagnostics:
sudo apt update
sudo apt install build-essential python3 libx11-dev libpng-dev libarchive-dev
make -j2
make doctor
make cp39-tests
make cp38-tests
make cp37-tests
make cp36-tests
make test
./launch.shThe useful binaries include binaries/rct-xbox-launcher (a desktop launcher), binaries/rct1_bootprobe (an XBE preflight check), binaries/rct1_gueststep (bounded diagnostic CPU stepping), and binaries/rct1_visual (a diagnostic display, which the project explicitly notes is not authenticated game rendering). There is also a Code::Blocks workspace if that is your style.
One important condition: the project's policy is that you work only with lawfully obtained local input, and that extracted ISOs, XBE images, generated private native code, hard drive captures and save data stay out of Git.
Resources & Links
- Repository: HodgkinsStudios/RollerCoasterTycoonXbox-Recomp on GitHub
- Status document: CP36 checkpoint and rendering blockers
- Recompilation tool: sp00nznet/xboxrecomp on GitHub
- Related work by the same toolmaker: the
pcrecomprecompilations of Tiberian Sun and Knights of the Old Republic - Requirements: Ubuntu with a C++17 toolchain, plus your own lawfully obtained copy of RollerCoaster Tycoon for the original Xbox. MIT licensed. The game does not boot yet.