# Reverse-engineering case studies · Page 6

> Page 6 of 21, cases 1,001–1,200. 4,025 case studies from 5,191 curated resources, with documented reconstruction methods, scope, and original evidence.

- HTML: <https://awesomerea.org/cases/page/6/>
- 简体中文: <https://awesomerea.org/zh/cases/page/6/index.md>

## Games (200)

- [ZONE OF THE ENDERS: an early game decompilation](https://awesomerea.org/resources/zone-of-the-enders-2001-case/index.md): Case study · zoe1 is an early decompilation of the 2001 game ZONE OF THE ENDERS. Its source implements the game's string-hash routine and sketches cache-system functions, many of which are still marked for decompilation.
- [Zuma Deluxe: decompiling the Mac and Windows game](https://awesomerea.org/resources/zuma-deluxe-decompilation-case/index.md): Case study · The project reconstructs Zuma Deluxe's game logic from Mac and Windows executables as buildable C++ source. It combines a patched open-source SexyAppFramework with game-specific code and supports comparison of compiled assembly against the original using the Visual Studio .NET 2002 toolchain.
- [.hack//Recompilation: native recompilation of the .hack//IMOQ games](https://awesomerea.org/resources/dothack-recompilation-case/index.md): Case study · .hack//Recompilation is a native recompilation of the PlayStation 2 .hack//IMOQ games, using PS2Recomp. Current work is .hack//INFECTION, US product SLUS-20267. The README says that game boots through the logo and OPENING movie. MUTATION, OUTBREAK, and QUARANTINE are listed as not started.
- [007: Agent Under Fire — an Xbox static recompilation port](https://awesomerea.org/resources/007-agent-under-fire-recomp-case/index.md): Case study · 007: Agent Under Fire becomes a native Windows port by statically recompiling the original Xbox game's x86 XBE programs. The project includes game-specific hooks and findings for the launcher, on-foot and driving executables, and builds game code from a user-provided USA or European disc.
- [007: Everything or Nothing — an Xbox static recompilation for Windows](https://awesomerea.org/resources/007-everything-or-nothing-recomp-case/index.md): Case study · 007eon-recomp builds a native Windows port of the original Xbox release of 007: Everything or Nothing. Xbox XBE Recomp translates its separate on-foot and driving executables, while native Direct3D, XAudio2 and SDL components replace console services; findings document game-specific code and rendering behavior.
- [007: From Russia with Love: an original Xbox recompilation for PC](https://awesomerea.org/resources/007-from-russia-with-love-xbe-recomp-case/index.md): Case study · 007: From Russia with Love - XBE Recomp ports the original Xbox game to Windows using Xbox XBE Recomp. It compiles code from the user's USA or European game files for PC on first start, with a runtime that adds display, graphics and input options.
- [007: NightFire - XBE Recomp — a native port of the Xbox game](https://awesomerea.org/resources/nightfire-recomp-case/index.md): Case study · 007: NightFire XBE Recomp is a native PC port of the original Xbox game. Xbox XBE Recomp statically recompiles the game's x86 code into Windows executables, and the Xbox graphics, sound, and system libraries are reimplemented with Direct3D 12 or 11, XAudio2, and SDL.
- [007: Nightfire - XBE Recomp: an Xbox game recompiled for PC](https://awesomerea.org/resources/007-nightfire-xbe-recomp-case/index.md): Case study · 007: Nightfire - XBE Recomp ports the original Xbox game to native Windows through Xbox XBE Recomp. It builds from the user's USA or Europe game files and adds configurable graphics, keyboard and mouse input, controller support, and texture dumping.
- [2014 FIFA World Cup Brazil: a ReXGlue Windows recompilation](https://awesomerea.org/resources/fifa-world-cup-2014-recompiled-case/index.md): Case study · 2014 FIFA World Cup Brazil Recompiled translates the Xbox 360 game code to C++ with ReXGlue and builds a native Windows port. A launcher selects and checks the user’s disc image or game folder; the repository contains game fixes, SDK patches and build instructions while generating translated code locally.
- [3 on 3 NHL Arcade: an Xbox 360 static recompilation for PC](https://awesomerea.org/resources/3-on-3-nhl-arcade-recomp-case/index.md): Case study · 3 on 3 NHL Arcade is ported to Windows by translating its Xbox 360 PowerPC executable to C++ with ReXGlue and compiling it for the PC. A launcher prepares files from the user's XBLA package, while an Android arm64 build is described as reaching the title screen and menus.
- [AC4-Port: native Windows port of Armored Core 4](https://awesomerea.org/resources/ac4-port/index.md): Case study · AC4-Port is an unofficial native Windows build of ARMORED CORE 4 for the PS3 USA release BLUS30027. The README describes static recompilation of about 3.6 million PowerPC instructions into C++, with SPU programs translated ahead of time, RSX commands drawn through Direct3D 11, and shaders converted to HLSL. The repository leaves out game data, game code, and keys.
- [AC6Recomp: static recompilation of Ace Combat 6](https://awesomerea.org/resources/ac6-recomp/index.md): Case study · AC6Recomp is a native PC port of Ace Combat 6: Fires of Liberation built with the ReXGlue SDK. The README says the Xbox 360 PowerPC game code is statically recompiled to x86-64, while visible rendering stays in the vendored RexGlue/Xenia graphics backend. It describes the project as a work in progress that can boot and run in game.
- [Ace Combat 3: Electrosphere — a Japanese-disc setup host](https://awesomerea.org/resources/ace-combat-3-japan-psxrecomp-case/index.md): Case study · Ace Combat 3: Electrosphere Recompiled is a psxrecomp setup host for the Japanese PlayStation game. It takes the user's disc image and builds the translated game locally through recomp-ui. The author reports gameplay in a private package, while exact-package setup and startup checks remain open.
- [Ace Combat 3: Electrosphere — a local PlayStation static recompilation](https://awesomerea.org/resources/ace-combat-3-electrosphere-recomp-case/index.md): Case study · The Ace Combat 3: Electrosphere project configures psxrecomp and recomp-ui to generate a native build of the USA PlayStation release from a user's disc image. It includes title-specific symbols, configuration and a setup host that collects local inputs. The author reports gameplay in a private package, with exact release-package checks still open.
- [Ace Combat 3: Electrosphere: PlayStation recompilation and Android port](https://awesomerea.org/resources/ace-combat-3-electrosphere-case/index.md): Case study · Ace Combat 3: Electrosphere is a PlayStation game reconstruction that documents the European and US discs, asset formats and executable code, then translates MIPS code to C for native builds. It also provides an Android APK that reads a player's own disc image through an interpreter. The author reports function-level validation and playable missions while native recompilation remains in progress.
- [Ace Combat 3: static recompilation for Windows](https://awesomerea.org/resources/ace-combat-3-recomp/index.md): Case study · This is a native Windows port of Ace Combat 3: Electrosphere. The MIPS code is translated to C ahead of time and linked against rewritten Psy-Q libraries. ac3.exe draws in software. ac3_enhanced.exe adds a Vulkan renderer with higher resolution, 16:9, and a longer draw distance.
- [Ace Combat 5: a PS2 static recompilation with native rendering](https://awesomerea.org/resources/ace-combat-5-static-recompilation-case/index.md): Case study · Ace Combat 5 statically translates the US PlayStation 2 game's main executable into C and compiles it with a Windows runtime. The project renders aircraft, terrain and other 3D scenes through native Vulkan meshes while remaining menus and effects use a GS path; runtime components cover audio, movies, controllers and storage. Generated game code and assets come from the user's disc.
- [ActRaiser Recomp: statically recompiling the SNES game](https://awesomerea.org/resources/actraiser-recomp/index.md): Case study · This recompiles ActRaiser for the Super Nintendo, USA. The cartridge dump is named internally ACTRAISER-USA, 1,048,576 bytes, with no copier header. The internal checksum is 0x83DB. SHA-256 is b8055844825653210d252d29a2229f9a3e7e512004e83940620173c57d8723f0. SHA-1 is e8365852cc20178d42c93cd188a7ae9af45369d7. CRC32 is 0xEAC3358D. The Builder verifies the file before it continues. macOS, Windows, Linux, and Steam Deck packages are listed.
- [adam: an N64 recompilation of Neon Genesis Evangelion](https://awesomerea.org/resources/adam-evangelion-recomp-case/index.md): Case study · adam recompiles the Japanese N64 release of Neon Genesis Evangelion into a native Windows program using N64Recomp and RT64. It provides an ahead of time build pipeline and a live build that translates code from the player's ROM at startup, with game-specific overlay, audio and input support.
- [Advanced Daisenryaku PC: a native Windows port of the Mega Drive game](https://awesomerea.org/resources/advanced-daisenryaku-pc-case/index.md): Case study · Advanced Daisenryaku PC ports the Sega Mega Drive strategy game to native Windows in C/C++ using statically translated game logic. It reconstructs cartridge flow, turn-based combat, campaign state, graphics and input around a user-supplied ROM. Its development reports describe ROM differential tests and selected presentation comparisons.
- [Adventure Island II: a static recompilation of the NES game](https://awesomerea.org/resources/adventure-island-ii-nes-static-recomp-case/index.md): Case study · Adventure Island II is statically recompiled from its NES ROM into a generated C catalog of fixed bank and program-counter identities for a native Windows frontend. The runtime includes NES CPU bus, PPU, APU, DMA, controls and MMC3B mapper behavior, validates a user-supplied USA ROM by SHA-256, and stops on unknown execution identities.
- [Aegis Wing: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/aegis-wing-xbla-pc-case/index.md): Case study · Aegis Wing XBLA PC Recomp builds a native Windows version of the Xbox 360 game through ReXGlue static recompilation. Its launcher imports game data from the user's package, while project code adds PC input, display settings, local scores, and LAN multiplayer.
- [AeroGauge: Recompiled — a native Nintendo 64 game build](https://awesomerea.org/resources/aerogauge-recomp/index.md): Case study · AeroGauge: Recompiled is a native build of the Nintendo 64 game AeroGauge. Supported targets are Windows 10 or later with Direct3D 12, Linux x64 or ARM64 with Vulkan, and Android 9 or later on ARM64 with Vulkan. macOS is unsupported. Accepted ROMs are USA and Japanese revision A.
- [AfroSamuraiRecomp: an Xbox 360 static recompilation of Afro Samurai](https://awesomerea.org/resources/afrosamurairecomp-case/index.md): Case study · AfroSamuraiRecomp statically translates the Europe Xbox 360 release of Afro Samurai into a native Windows x64 program using ReXGlue. The repository supplies game-specific function boundaries, hooks, a launcher and GPU and audio patches; the author reports playable 30 FPS operation on one PC.
- [Alien Resurrection Recompilation: a disc-local PlayStation static recompilation](https://awesomerea.org/resources/alien-resurrection-recompilation-case/index.md): Case study · Alien Resurrection Recompilation turns the user's USA PlayStation disc image into a native build by generating C# with a RecompOne fork and compiling it locally. Its launcher manages first-run compilation, cached builds, saves, and game-specific fixes to disc, memory-card, and audio behavior.
- [Alien Resurrection: Recompiled — native PlayStation game port](https://awesomerea.org/resources/alien-resurrection-recomp-case/index.md): Case study · Alien Resurrection: Recompiled is a native macOS, Windows, and Linux port of Alien Resurrection for the PlayStation, USA SLUS-00633. The MIPS code is statically recompiled, and a runtime stands in for the PlayStation BIOS and hardware.
- [Alone in the Dark: The New Nightmare — a two-disc PlayStation recompilation](https://awesomerea.org/resources/alone-in-the-dark-new-nightmare-recomp-case/index.md): Case study · Alone in the Dark: The New Nightmare Recompiled configures psxrecomp to build a native program from the European two-disc PlayStation release. Its setup host validates both disc images, handles their shared executable and uses a user-supplied regional BIOS. The author reports separate startup tests for both discs; an in-game disc change remains to be tested.
- [Alundra Recompiled: a PlayStation setup host for local recompilation](https://awesomerea.org/resources/alundra-recompiled-case/index.md): Case study · Alundra Recompiled provides a PlayStation game configuration and setup host that uses psxrecomp to generate a native build from the user's disc. The repository also carries title-specific symbol mappings and a knowledge report for the European release.
- [Animaniacs: The Great Edgar Hunt: a GameCube static recompilation](https://awesomerea.org/resources/animaniacs-great-edgar-hunt-recomp-case/index.md): Case study · The Animaniacs: The Great Edgar Hunt port translates the USA GameCube game's PowerPC code into a native module with DolRecomp, while ModernGekko supplies graphics, audio, input and timing. Its scripts validate the user's disc and build the module; the author reports gameplay with a narrow interpreter fallback.
- [AnyPS3: static recompilation of Ratchet & Clank: A Crack in Time](https://awesomerea.org/resources/anyps3-ratchet-clank-case/index.md): Case study · AnyPS3 converts PPU and SPU code from Ratchet & Clank: A Crack in Time into C++ ahead of execution and links it with an LV2 service runtime and Vulkan RSX renderer for Linux x86-64. The author reports that the original menu and first level render, while the full import-to-play workflow remains experimental.
- [ApeEscapeRecomp: an Ape Escape PlayStation static recompilation](https://awesomerea.org/resources/ape-escape-recomp-case/index.md): Case study · ApeEscapeRecomp translates Ape Escape's PlayStation MIPS code into native C ahead of time with PSXRecomp. The repository provides game-specific configuration, Ghidra-derived function seeds, overlay preparation and optional enhancements for a native PC build.
- [Apocalypse Recompiled: a PlayStation setup recipe for static recompilation](https://awesomerea.org/resources/apocalypse-recompiled-case/index.md): Case study · Apocalypse Recompiled packages a PSXRecomp setup recipe for the SLES-00460 PlayStation game. Its title configuration and function seeds support local generation and compilation from the user's disc and European BIOS; the release candidate documents pending setup and gameplay checks.
- [Arizona Vamp Recomp: a static recompilation of Darkwatch](https://awesomerea.org/resources/arizona-vamp-darkwatch-recomp-case/index.md): Case study · Arizona Vamp Recomp builds a native Windows port of the original Xbox Darkwatch by statically translating its executable to x86-64 code. A host runtime maps Direct3D 8 calls to Direct3D 12 and DirectSound to XAudio2, while game files come from the user's copy. The author reports a playable beta with campaign progress into the first chapter.
- [ARMORED CORE for Answer: native Windows port by static recompilation](https://awesomerea.org/resources/acfa-port-case/index.md): Case study · This is a native Windows port of ARMORED CORE for Answer for the PlayStation 3, USA release BLUS30187. A recompiler turns the game's PowerPC code into C++, about 71,000 functions, and the PC compiler builds a 64-bit Windows program. SPU programs are translated ahead of time, and the RSX command stream becomes Direct3D 11.
- [Armored Core Recomp: a PlayStation static-recompilation recipe](https://awesomerea.org/resources/armored-core-recomp-case/index.md): Case study · Armored Core Recomp supplies a PSXRecomp project for the USA PlayStation release of Armored Core. Its title configuration records executable layout, disc fingerprints and seed addresses, and the build generates game code locally from the user's disc.
- [Armored Core: a European-disc recompilation setup host](https://awesomerea.org/resources/armored-core-pal-psxrecomp-case/index.md): Case study · Armored Core Recompiled packages a psxrecomp setup host for the European PlayStation release of Armored Core. It accepts the user's disc image and generates and builds the translated game locally with recomp-ui. The author reports private-package gameplay while exact-package acceptance checks remain open.
- [Army of Two Recompilation: a ReXGlue native port](https://awesomerea.org/resources/army-of-two-rexglue-port-case/index.md): Case study · Army of Two Recompilation translates the player's Xbox 360 Army of Two executable into C++ with a game-specific ReXGlue SDK fork and builds a native host. Its Windows build uses a Direct3D 12 renderer; the author reports testing the opening areas, while Linux and macOS builds remain experimental.
- [Army of Two: The 40th Day — an Xbox 360 recompilation](https://awesomerea.org/resources/army-of-two-40th-day-rexglue-case/index.md): Case study · Army of Two: The 40th Day Recomp translates the Xbox 360 game's PowerPC default.xex into C++ with ReXGlue for a Windows x64 port. Game-specific patches and configuration support the proof of concept. The author reports early menus and Shanghai gameplay, while later engine functions, boss scripts and saves remain unfinished.
- [Army of Two: The 40th Day — an Xbox 360 static recompilation preview](https://awesomerea.org/resources/army-of-two-40th-day-recomp-case/index.md): Case study · Army of Two: The 40th Day Recomp translates the Xbox 360 game's default.xex PowerPC code to C++ with ReXGlue for a Windows x64 build. The repository adds title-specific function configuration, fixes and launch settings. The author reports menus, the first Shanghai chapter and a Highrise combat segment working, while later gameplay requires more engine functions, boss scripts and saves.
- [Ascension: statically recompiling God of War: Ascension](https://awesomerea.org/resources/gow-ascension-pc/index.md): Case study · Ascension is a static recompilation of the PlayStation 3 game God of War: Ascension. The recompiler and runtime live in a ps3kit fork of ps3recomp. The source layout expects the disc under work/disc and EBOOT.ELF before the C++ is generated. scripts/windows/build.ps1 builds with Visual Studio 2022, clang-cl, CMake, and Ninja. The RSX renderer is compiled first by build-gpu.ps1 and comes from RPCS3. A from-scratch build is listed at 20 to 40 minutes and 16 GB of RAM. Saves go in gamedata/dev_hdd0.
- [Aster Native: a Green Lantern Xbox 360 recompilation port](https://awesomerea.org/resources/aster-native-green-lantern-case/index.md): Case study · Aster Native is an experimental port framework whose first game module targets the Xbox 360 release of Green Lantern: Rise of the Manhunters. It prepares user-supplied game data, generates a ReXGlue port locally and applies game-specific runtime and graphics patches; the author reports reaching early gameplay on Linux.
- [Astral Chain PC: a Switch static-recompilation port](https://awesomerea.org/resources/astral-chain-pc-case/index.md): Case study · Astral Chain PC translates the Switch game's ARM64 code to C for a native Windows x64 build. Its host runtime supplies Switch services, while a modified NVN layer maps graphics to Vulkan; the build extracts and translates files from the player's own game dump.
- [Astral Chain: statically recompiling the Switch game for macOS](https://awesomerea.org/resources/astral-chain-recomp/index.md): Case study · This statically recompiles Astral Chain for the Nintendo Switch, version 1.0.0 with no update, to macOS. Apple silicon is the preview target and uses Vulkan through MoltenVK. The README says the opening, character creation, and the File 01 motorcycle chase run, with the chase measured at a stable 30 fps on an Apple M5 Pro. A build from a real dump translates 1,332 shaders. Linux and Windows reach that same chase and are marked early. Saving and reloading are untested.
- [Asura's Wrath Recompiled: a static Xbox 360 recompilation](https://awesomerea.org/resources/asuras-wrath-recompiled-case/index.md): Case study · Asura's Wrath Recompiled ports the Xbox 360 game by statically translating its PowerPC executable to C++23 with ReXGlue. Its build instructions cover Linux, Windows and Android, while runtime setup reads extracted files from the user’s ISO.
- [Automobili Lamborghini: Recompiled](https://awesomerea.org/resources/automobili-lamborghini-recomp/index.md): Case study · Automobili Lamborghini: Recompiled is a native port of the North American Nintendo 64 game Automobili Lamborghini. Release packages are provided for Windows x64 and Linux x64. An Android ARM64 path exists and is described as experimental.
- [Azazel6: an experimental Tekken 6 PSP static recompilation for Android](https://awesomerea.org/resources/azazel6-case/index.md): Case study · Azazel6 researches a native Android ARM64 port of Tekken 6 for PSP by translating selected Allegrex/MIPS code ahead of time to C++ and building a PSP service host. It includes executable analysis, an import inventory and bounded startup probes. The author reports that translated startup reaches graphics initialization; the game remains unplayable.
- [Azura: a native Gears of War 3 port from static recompilation](https://awesomerea.org/resources/azura-case/index.md): Case study · Azura builds a native macOS, Linux or Windows version of Gears of War 3 by translating the user's Xbox 360 PowerPC executable to C++ with ReXGlue. Its runtime replaces console services and graphics with Metal or Vulkan backends, while a Tauri launcher prepares the user's game files.
- [B2recomp: static recompilation of Bayonetta 2](https://awesomerea.org/resources/b2recomp/index.md): Case study · B2recomp is an unofficial static recompilation of the Nintendo Switch version of Bayonetta 2 for Windows. The README says it translates that version's AArch64 program code to C on the user's PC from the user's dumped copy, then runs it with a reimplemented system layer and maps the NVN graphics API to Vulkan.
- [B3-Express: statically recompiling Bayonetta 3 for Windows](https://awesomerea.org/resources/b3-express-case/index.md): Case study · B3-Express ports Bayonetta 3 v1.2.0 to Windows by recompiling its ARM64 code to x86 with a modified ScarletNX runtime. An NVN-level Vulkan renderer draws the game, and a launcher checks an extracted game dump, copies its files and compiles the code on the user's PC. The repository also contains diagnostic notes on rendering and runtime issues.
- [BakuganBB-recomp: an accessible PC recompilation of Bakugan Battle Brawlers](https://awesomerea.org/resources/bakuganbb-recomp-case/index.md): Case study · BakuganBB-recomp is an early PC recompilation project for the Xbox 360 game Bakugan Battle Brawlers, with Linux as its first target. Its code includes speech and spatial-audio components intended to improve accessibility for blind players, while investigation notes document the executable, runtime imports and game interfaces.
- [band3 recompiled: an early Rock Band 3 recompilation](https://awesomerea.org/resources/band3-recompiled-case/index.md): Case study · band3 recompiled is an early ReXGlue recompilation of Rock Band 3 title update 5. Its C++ hooks and build configuration cover parts of the game's runtime, and the author describes the current build as barely playable.
- [Banjo-Tooie (XBLA): a ReXGlue PC port](https://awesomerea.org/resources/banjo-tooie-xbla-recomp-case/index.md): Case study · The Banjo-Tooie XBLA port uses ReXGlue to translate the Xbox 360 game's PowerPC code into C++ for Windows and Linux. It supplies game-specific recompilation settings, a host harness and a launcher that extracts data from the user's XBLA package. The author reports gameplay on Windows and Steam Deck, while later areas remain lightly tested.
- [Banjo-Tooie: Scurvy Dog Port — a static PC recompilation](https://awesomerea.org/resources/banjo-tooie-scurvy-dog-port-case/index.md): Case study · Banjo-Tooie: Scurvy Dog Port translates the game's Nintendo 64 code with N64Recomp and renders a native Windows port with RT64. Game-specific patches and runtime adapters handle behavior and presentation, including widescreen rendering and interpolation. The author describes the current release as alpha.
- [Banjo: Recompiled — an N64Recomp Banjo-Kazooie native port](https://awesomerea.org/resources/banjo-recompiled-case/index.md): Case study · Uses N64Recomp to statically recompile the US 1.0 Nintendo 64 release of Banjo-Kazooie into a native port on N64ModernRuntime, rendered by RT64 and extended with mod support. Like Zelda 64: Recompiled, it is built through static recompilation; a symbols repository generated from the Banjo-Kazooie decompilation supplies function names for locating code in the ROM and writing patches.
- [Battle Arena Toshinden Recompiled: a PlayStation static recompilation](https://awesomerea.org/resources/battle-arena-toshinden-recompiled-case/index.md): Case study · Battle Arena Toshinden Recompiled generates native code from the USA PlayStation release using psxrecomp and a user-supplied 14-track disc. It adds title-specific widescreen, frame blending and roster mods, with a launcher for disc setup and two-player rollback netplay.
- [Battlefield: Bad Company — statically recompiling the Xbox 360 game](https://awesomerea.org/resources/bad-company-recomp/index.md): Case study · This recompiles Battlefield: Bad Company for the Xbox 360, USA, title ID 454107F9, to Windows with ReXGlue. The README says 54,126 PowerPC functions are translated to C++23 and the build opens a window. It stops while Frostbite calibrates the disc cache, so the game is not playable yet. The default frame cap is 30 fps.
- [BattleTanx: Global Assault: an N64 static recompilation port](https://awesomerea.org/resources/battletanx-global-assault-recomp-case/index.md): Case study · BattleTanx: Global Assault is ported to PC by statically recompiling its Nintendo 64 code with N64Recomp and running it on N64ModernRuntime with RT64 rendering. The repository includes a corrected function-boundary map, game-specific runtime changes and a log of the investigations behind them.
- [Beetle Adventure Racing Recomp: an N64 static recompilation port](https://awesomerea.org/resources/beetle-adventure-racing-recomp-case/index.md): Case study · Beetle Adventure Racing Recomp builds a native PC port of the USA Nintendo 64 game using N64Recomp and a modern runtime. Continuing an earlier port, it adds widescreen and HUD work, extended draw distance, diagnostics and a technical reference on the ROM, relocatable modules and rendering. The author reports playable races on Windows; the Linux build is still in progress.
- [BeetleRecomp: a static recompilation of Beetle Adventure Racing!](https://awesomerea.org/resources/beetlerecomp-case/index.md): Case study · BeetleRecomp translates the USA N64 release of Beetle Adventure Racing! from MIPS machine code into C with N64Recomp and runs it through a native host using RT64. It uses a symbol-rich ELF and overlay metadata built from BeetleDecomp, and includes game-specific C hooks, a launcher and runtime services for input, audio and saves.
- [Bigodão: statically recompiling Wario Land: Super Mario Land 3](https://awesomerea.org/resources/bigodao/index.md): Case study · Bigodão statically recompiles Wario Land: Super Mario Land 3 for Linux, Windows, and Android. The World ROM SHA-256 is ac1682f17abcf590311a233289ee325214c2d71ab3a5aa175004002d85075e56. The IPS patch Wario Land - Super Mario Land 3 DX (World).ips v1.2 has SHA-256 599d9f59090df3e1e77c1678e069290a2cd9ce59c71cf58d66c4dc3db8b7facd. Widescreen 16:9 is on by default. The OpenGL renderer can run at 120 fps. The patch is applied in memory.
- [Black - XBE Recomp: native Windows port of Black](https://awesomerea.org/resources/black-xbe-recomp/index.md): Case study · This is a native Windows port of the original Xbox game Black, made with Xbox XBE Recomp. An ISO or extracted files from the USA or Europe release go in assets. A source build needs default.xbe from the USA release in that folder. build.bat recompiles the game, and the executable is out/build/release/BLACK.exe. The first launch compiles the game code once. The minimum system is Windows 10 64-bit, a CPU with SSE4.2 and POPCNT, and a Direct3D 12 GPU.
- [Black 2006 Recomp: Windows recompilation of BLACK](https://awesomerea.org/resources/black-2006-recomp/index.md): Case study · Black 2006 Recomp is an experimental Windows recompilation of the original Xbox release of BLACK (2006), built with XboxRecomp. The README lists a Direct3D 11 renderer, keyboard and mouse, XInput, video settings, a PC launcher, and native audio, and says movies are enabled by default.
- [Black Ops II Recompiled: separate Xbox 360 game codegen targets](https://awesomerea.org/resources/black-ops-ii-recompiled-case/index.md): Case study · Black Ops II Recompiled configures ReXGlue to generate native builds from the Xbox 360 game's single-player default.xex and multiplayer default_mp.xex. Separate configurations and scripts handle code generation, CMake setup and builds using the user's extracted game files.
- [Black: an Xbox static recompilation for Apple Silicon macOS](https://awesomerea.org/resources/black-macos-recomp-case/index.md): Case study · black-recomp ports the Xbox game Black to Apple Silicon macOS by statically lifting its x86 functions to C and compiling them for arm64. It supplies game-specific host code, handwritten guest functions, analysis seeds and reproduction scripts, while a sibling xboxrecomp runtime provides Xbox kernel, graphics and audio services. The author reports first-mission interaction with unresolved boot instability, camera drift and silent game audio.
- [BlackKnightRecomp: recompiling Sonic and the Black Knight for Windows](https://awesomerea.org/resources/black-knight-recomp/index.md): Case study · This recompiles Sonic and the Black Knight for the Wii to Windows x64. One executable contains the USA release RENE8P, the European RENP8P, and the Japanese RENJ8P, and the installed disc selects which one runs. It draws with Direct3D 11 at 3x resolution and 16:9. The Linux and Steam Deck steps use Proton.
- [Blake Stone: static recompilation of Aliens of Gold and Planet Strike](https://awesomerea.org/resources/blakestone-case/index.md): Case study · Blakestone statically recompiles Blake Stone: Aliens of Gold and Planet Strike from user-supplied DOS executables into native Windows, Linux and macOS programs. Its lift driver uses pcrecomp to translate 16-bit x86 functions to C, while a local runtime implements the DOS, video, audio and input services the games expect.
- [Blast Corps: Recompiled — a native port of Blast Corps](https://awesomerea.org/resources/blastcorps-recomp-case/index.md): Case study · Blast Corps: Recompiled uses N64: Recompiled to statically recompile Blast Corps into a native port, with RT64 for rendering. It accepts only the US 1.1 Nintendo 64 ROM.
- [BLiNX 2: Masters of Time & Space — Xbox static recompilation](https://awesomerea.org/resources/blinx2-recomp/index.md): Case study · This recompiles BLiNX 2: Masters of Time & Space for the original Xbox. The supported release is title ID 0x4D530065, version 1, region-free. default.xbe has one of two SHA-256 values: 0c57fd72053077bc938876d1f2477b937e1f70566500c0e020bb45bbfa4ddc5e or aa186954c47d9f0a98f8690948e8c43bae15201aa49c3457a42402a142b0c60e. Scripted runs reach every stage and boss, at 30 fps and 4:3. Windows uses Direct3D 11, Steam Deck and Linux use Direct3D 11 through Proton, and Apple silicon uses Metal.
- [Blocksphere: a native Tetrisphere port through static recompilation](https://awesomerea.org/resources/blocksphere-tetrisphere-case/index.md): Case study · Blocksphere ports the Nintendo 64 game Tetrisphere to Linux and Windows x86-64 through static CPU and RSP recompilation. It uses RT64 for rendering and adds game-specific fixes for widescreen HUDs, audio timing, input prompts and saved settings. Users import their own US NTPE revision 0 ROM.
- [Blood Wake Recomp: a native Windows static recompilation of the Xbox game](https://awesomerea.org/resources/blood-wake-recomp-case/index.md): Case study · Blood Wake Recomp translates the original Xbox game's code into C from a user-owned disc and compiles it into a native Windows build with xboxrecomp. Its runtime provides graphics, audio, controls, and Original and Remastered editions; the author reports that every game function translates and all story missions are playable.
- [bloodborne-recomp: statically recompiling Bloodborne](https://awesomerea.org/resources/bloodborne-recomp/index.md): Case study · This static recompiler reads Bloodborne for the PlayStation 4, CUSA03173 update 1.09, and writes its functions as C. The project page counts 181,521 of 181,570 functions recompiled and 10,284,725 of 10,691,122 instructions. The player's launcher builds that library on the player's own device. Code that is not recompiled yet still runs in the bbcpu translator.
- [Bloody Roar Extreme: an original Xbox XBE recompilation](https://awesomerea.org/resources/bloody-roar-extreme-recomp-case/index.md): Case study · Bloody Roar Extreme Recomp builds a native Windows x64 port of the original Xbox fighting game with the Xbox XBE Recomp toolchain. It supplies configurations for the USA, European and Japanese executables and a host with Vulkan rendering, audio and controller support.
- [Blue Stinger Recompiled: a Dreamcast static recompilation](https://awesomerea.org/resources/blue-stinger-recompiled-case/index.md): Case study · Blue Stinger Recompiled translates the Dreamcast game's SH-4 code instruction by instruction into C++20 for a Windows x64 port. Its builder extracts a user-supplied CDI disc image and generates the executable, while native PC implementations replace file, input, save, movie, audio and graphics services; the author compares behavior with Flycast.
- [BlueWake: static recompilation of The Wind Waker](https://awesomerea.org/resources/bluewake/index.md): Case study · BlueWake is a static recompilation of the GameCube game The Legend of Zelda: The Wind Waker that runs natively on iPhone, iPad, Mac, Windows, and Linux. The README describes touch controls, controller support, and mods, and it names Windows 10 or 11 ready-made builds plus repository builds for Apple platforms and x86-64 Linux.
- [Body Harvest: Recompiled — static recompilation of the Nintendo 64 game](https://awesomerea.org/resources/body-harvest-recomp/index.md): Case study · Release 0.1.0 statically recompiles Body Harvest for the Nintendo 64, USA, with N64Recomp. The ROM SHA-1 is bbb6666f5014a473747ee4145f036d9fb25d7348. It accepts .z64, .n64, .v64, or a ZIP. The port boots and plays the start of Greece. Windows runs body-harvest-recomp.exe. Linux runs ./body-harvest-recomp.sh. Widescreen follows the window, and the frame rate can follow the display refresh.
- [Bomberman 64: Recompiled — an N64 static recompilation](https://awesomerea.org/resources/bomberman-64-recompiled-case/index.md): Case study · Bomberman 64: Recompiled statically recompiles the US Nintendo 64 release of Bomberman 64 into a native port with N64: Recompiled. RT64 supplies rendering, while headers and selected functions from the separate decompilation project support patches and enhancements.
- [Bomberman Hero: Recompiled: an N64 static recompilation](https://awesomerea.org/resources/bmhero-recompiled-case/index.md): Case study · Bomberman Hero: Recompiled uses N64Recomp to translate the North American Nintendo 64 game into a native port rendered through RT64. It loads assets from the user's ROM and adds game-specific patches, display options and mod support.
- [BombermanRecomp: statically recompiling Super Bomberman for Windows](https://awesomerea.org/resources/bomberman-recomp-case/index.md): Case study · BombermanRecomp statically recompiles the North American SNES release of Super Bomberman into a native Windows program. A pinned snesrecomp engine generates C from a hash-checked user ROM; the project adds an interactive Win32 host with video, audio and SRAM persistence plus a deterministic headless host. Its changelog reports battle gameplay in a 3,000-frame test.
- [BOTW Compiled: an experimental Wii U recompilation port](https://awesomerea.org/resources/botw-compiled-case/index.md): Case study · BOTW Compiled is an experimental Windows x64 port of the Wii U release of The Legend of Zelda: Breath of the Wild. It uses generated PowerPC code, a native runtime and an experimental GX2/Latte graphics path; the source reports an opening screen and introductory text while character and environment rendering remain incomplete.
- [BotW Recompiled for Windows: Wii U Breath of the Wild](https://awesomerea.org/resources/botw-native/index.md): Case study · BotW Recompiled for Windows runs the Wii U version of Breath of the Wild on Windows 10 and 11. The README says the PowerPC game code is statically recompiled to C++ on a Cafe OS runtime, and that Cemu's Latte GPU layer draws through Vulkan. It says the project is a work in progress and not a full-game release.
- [BotW Recompiled: a Wii U Breath of the Wild port for Apple Silicon](https://awesomerea.org/resources/botw-recompiled-case/index.md): Case study · BotW Recompiled ports the Wii U release of The Legend of Zelda: Breath of the Wild to iPhone and Apple Silicon Macs by translating U-King.rpx PowerPC functions into C++. A project Cafe OS runtime supplies system services, while a modified Cemu Latte layer renders through Metal.
- [BOTWRecomp: a native Apple Silicon recompilation of Breath of the Wild](https://awesomerea.org/resources/botwrecomp-case/index.md): Case study · BOTWRecomp builds a native Apple Silicon version of the Wii U Breath of the Wild from a user's dump. It translates the game's PowerPC code into C ahead of time, adapts Cafe OS services in a native runtime, and renders GX2 graphics through Metal.
- [BOTWRecompAndroid: Android port of Breath of the Wild](https://awesomerea.org/resources/botwrecomp-android/index.md): Case study · BOTWRecompAndroid is an Android port of The Legend of Zelda: Breath of the Wild for Switch versions 1.0.0, 1.6.0, 1.8.2, and 1.9.0. The README says the game code can be recompiled into C on the phone, or run directly on the phone's ARM64 CPU in an experimental Native Mode, with the NVN graphics API translated to Vulkan. It is built on LAS Recomp and LASRecompAndroid.
- [Brawl Recompiled: native Windows port of Super Smash Bros. Brawl](https://awesomerea.org/resources/brawl-recompiled/index.md): Case study · Brawl Recompiled is a native Windows port of Super Smash Bros. Brawl made by statically recompiling the game's PowerPC code, main.dol and all 126 REL modules, to C++ with WiiCompiled. The README says boot, saves, the menus tested so far, VS battles, attract demos, the start of Classic mode, and the opening of the Subspace Emissary work, and that the project is unfinished.
- [Breakdown Recompilation: an Xbox game rebuilt for Windows](https://awesomerea.org/resources/breakdown-recompilation-case/index.md): Case study · Breakdown Recompilation builds a native Windows version of the original Xbox game from the user's disc image. Its launcher extracts the ISO, uses an XboxRecomp fork to lift XBE code into C, and applies game-specific overrides before building.
- [Breath of Fire III Recompiled: a PlayStation overlay recompilation](https://awesomerea.org/resources/breath-of-fire-iii-recompiled-case/index.md): Case study · Breath of Fire III Recompiled translates the Japanese PlayStation game's MIPS code and disc-extracted overlays into C for a native build. Its documentation maps overlay loading, text and game systems; the author reports play through the opening areas while dynamic overlay entry-point coverage remains in progress.
- [BT2 Recomp: a Budokai Tenkaichi 2 PS2 static recompilation](https://awesomerea.org/resources/bt2-recomp-case/index.md): Case study · BT2 Recomp translates the North American PlayStation 2 release of Dragon Ball Z: Budokai Tenkaichi 2 to native Windows C++ with PS2Recomp. Its runtime supplies memory, system services and Vulkan GS rendering for the translated game code. The author reports playable versus battles and runs of story mode, Ultimate Battle Z, tournaments and training lessons without input; memory-card saving remains unconfirmed.
- [BT3-Recomp: a PlayStation 2 static recompilation of Budokai Tenkaichi 3](https://awesomerea.org/resources/bt3-recomp-case/index.md): Case study · BT3-Recomp translates the USA PlayStation 2 release of Dragon Ball Z: Budokai Tenkaichi 3 from MIPS code to C++ at build time. It combines game-specific function maps and patches with a recompiler, PS2 runtime, OpenGL renderer and launcher for native desktop builds.
- [Buffy the Vampire Slayer: Chaos Bleeds — an Xbox static recompilation for PC](https://awesomerea.org/resources/buffy-chaos-bleeds-pc-case/index.md): Case study · Buffy the Vampire Slayer: Chaos Bleeds — PC Port turns the 2003 Xbox game's code into a native Windows program with xboxrecomp. It replaces console graphics and input with Vulkan or Direct3D 11 rendering and XInput support, and provides an Android build. The launcher installs game data from the user's own PAL or NTSC Xbox disc image.
- [BullyRecomp: a static recompilation of Bully: Scholarship Edition](https://awesomerea.org/resources/bully-recomp-case/index.md): Case study · BullyRecomp translates the Xbox 360 Bully: Scholarship Edition executable to C++ with ReXGlue and runs it on Windows with a Direct3D 12 backend. Game-specific configuration repairs function boundaries, initializers and jump tables, while local patches adjust graphics and timing. The author reports gameplay in the opening tutorial; missions and wider areas remain untested.
- [Bunghole in One: statically recompiling a Win32 mini-golf game](https://awesomerea.org/resources/bunghole-in-one-case/index.md): Case study · Bunghole in One statically recompiles the 1998 Windows mini-golf game's EXE and DLL into C with pcrecomp, generating the lifted code from a user's own disc. A 32-bit host binds the modules and provides software DirectDraw, while a conformance harness tracks boot and play milestones.
- [Burnout 2: static recompilation of the original Xbox game](https://awesomerea.org/resources/burnout2-recomp/index.md): Case study · This is a static recompilation of the original Xbox game Burnout 2: Point of Impact. The Windows build is the main target. Linux, Steam Deck, and macOS builds are described as experimental and still needing gameplay, sound, and performance checks. Release 1.14 adds a camera field-of-view slider, texture-pack installation, and initial scripting.
- [Burnout 3: Takedown — native Windows port](https://awesomerea.org/resources/burnout3-pc/index.md): Case study · A native Windows port of the PlayStation 2 game Burnout 3: Takedown. The README says the game's program is translated to C++ and compiled for the PC, with 60 frames per second or the display refresh rate, up to four times the PlayStation 2 resolution, widescreen, and controller rumble.
- [Burnout 3: Takedown — Xbox static recompilation](https://awesomerea.org/resources/burnout3-xbox-recomp-case/index.md): Case study · This repository is a static recompilation of the Xbox version of Burnout 3: Takedown into a native Windows executable. The README says xboxrecomp lifts the game's x86 code to C, and the game boots through its own entry point on that toolkit's Xbox runtime.
- [Burnout CRASH!: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/burnout-crash-recomp-case/index.md): Case study · Burnout CRASH! translates the Xbox 360 XBLA game's PowerPC executables into C++ with ReXGlue for a native Windows build. Its configuration identifies additional engine functions and EASharp switch tables, while native hooks replace a few failing guest functions.
- [Burnout Dominator Reversed: a PS2 static recompilation](https://awesomerea.org/resources/burnout-dominator-reversed-case/index.md): Case study · Burnout Dominator Reversed builds a native PC port of the European PS2 release by translating its main CPU code with PS2Recomp and its vector-unit programs into C++. It uses paraLLEl-GS for graphics and supplies I/O and audio subsystems; the author reports play through the last World Tour event.
- [Burnout Recompilation: building a Windows port from an Xbox disc](https://awesomerea.org/resources/burnout-recompilation-case/index.md): Case study · Burnout Recompilation builds a native Windows version of the original Xbox Burnout from the user's disc image. Its launcher extracts the image, translates XBE code to C with xboxrecomp and compiles the result locally, using game-specific seed lists and manual overrides. The author reports playable races in the early 0.1.0 release.
- [Burnout Revenge: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/burnout-revenge-recomp-case/index.md): Case study · The Burnout Revenge port recompiles the USA Xbox 360 game for native macOS and Linux execution with XenonRecomp and a project runtime. It installs game content from the player's disc image and adds PC display, control and save options.
- [Bushido Blade 2: a disc-local PlayStation static recompilation](https://awesomerea.org/resources/bushido-blade-2-recomp-case/index.md): Case study · Bushido Blade 2 Recomp configures psxrecomp to generate and compile the US PlayStation release from the player's SLUS-00663 disc image and SCPH-1001 BIOS. Its recomp-ui setup host creates normal and diagnostic builds on the player's machine.
- [C2C: hybrid recompilation and hand decompilation of Crash Bandicoot 2](https://awesomerea.org/resources/c2c-crash2-hybrid-recompilation-case/index.md): Case study · An early reverse-engineering effort on PlayStation Crash Bandicoot 2 that converts the engine’s MIPS machine code directly into a very large C file and runs it against a modified PCSX-R emulator library for hardware I/O. Translated functions are meant to be decompiled by hand and moved into ordinary C, gradually replacing the mechanical translation.
- [Call of Duty 3: a multiplayer ReXGlue recompilation checkpoint](https://awesomerea.org/resources/call-of-duty-3-multiplayer-recomp-case/index.md): Case study · Call of Duty 3 Recompilation applies ReXGlue to the game's multiplayer executable. Its code defines PowerPC hooks and network-service stubs, while a function table names game routines for code generation. The project represents an early game-specific recompilation checkpoint.
- [Call of Duty: Modern Warfare 2 (2009) — statically recompiling the Xbox 360 game](https://awesomerea.org/resources/mw2-recompiled-case/index.md): Case study · This repository runs Call of Duty: Modern Warfare 2 (2009) for the Xbox 360 natively on Linux and Windows by recompiling the game's executables ahead of time. The README lists campaign and multiplayer, including split screen for up to four controllers.
- [Captain America Super Soldier Recompiled: a title-screen build](https://awesomerea.org/resources/captain-america-super-soldier-recompiled-case/index.md): Case study · Captain America Super Soldier Recompiled configures ReXGlue v0.4 to build the Xbox 360 game as a native program. The repository includes a title manifest and host application source. The author reports a title-screen boot followed by a crash when story mode loads because addresses remain missing from the configuration.
- [Carbon: an Xbox 360 static recompilation and renderer investigation](https://awesomerea.org/resources/nfs-carbon-recomp-case/index.md): Case study · Carbon is a ReXGlue recompilation project for Need for Speed: Carbon with native renderer and Android host code. Its investigation notes describe Vulkan rendering work and report per-frame GPU command-processor measurements from an Android run on an Adreno device.
- [Cars Race-O-Rama Recompiled: an Xbox 360 recompilation](https://awesomerea.org/resources/cars-race-o-rama-recompiled-case/index.md): Case study · Cars Race-O-Rama Recompiled uses ReXGlue v0.3 to recompile the Xbox 360 game into a native executable. It runs with game data extracted from the user's ISO into an assets folder beside the executable. The author reports that it can be played from start to finish, with slowdowns and lighting errors.
- [Castlevania 64: Recompiled — a beta static-recompilation port](https://awesomerea.org/resources/cv64-recompiled-case/index.md): Case study · Uses N64Recomp to statically recompile the US 1.0 Nintendo 64 release of Castlevania into a native PC port rendered with RT64. Game-specific C patches build against headers from a separate Castlevania 64 decompilation. A beta release tagged at the reviewed commit reports a working build with known issues, while the README there still describes an unfinished project.
- [Castlevania Chronicles: a cross-platform recompilation](https://awesomerea.org/resources/castlevania-chronicles-recomp/index.md): Case study · This recompiles Castlevania Chronicles for Windows, macOS, and Linux with RecompOne. Release 0.3.10 has packages for Windows x64, macOS on Apple Silicon, and Linux x64, and each package includes the .NET runtime. The player selects a USA SLUS-01384 disc image, CUE/BIN or CHD. The first launch prepares the game code.
- [Castlevania: Curse of Darkness — a native PC port by static recompilation](https://awesomerea.org/resources/castlevania-curse-of-darkness-pc-case/index.md): Case study · Castlevania: Curse of Darkness is ported from PlayStation 2 to Windows by translating its MIPS code to C++ and rebuilding PS2 hardware functions as PC code. The project includes a recompiler, a VU1 microprogram compiler, graphics and I/O implementations, and game hooks for widescreen display, a minimap and sprinting. Game-derived code is generated locally from the user's European disc image.
- [Castlevania: The Adventure ReBirth: a PowerPC lifted PC port](https://awesomerea.org/resources/castlevania-adventure-rebirth-port-case/index.md): Case study · Castlevania: The Adventure ReBirth is translated from its WiiWare PowerPC executable into C++ for a native PC runtime. The project supplies a lifter, SDL2 and OpenGL runtime, audio and input replacements, and hand-written readable game functions; the author reports that the port reaches Stage 1.
- [Celosia: statically recompiling Shadow of the Colossus for Mac and Vita](https://awesomerea.org/resources/celosia/index.md): Case study · Celosia is a native port of Shadow of the Colossus for PlayStation 2, USA SCUS-97472, to macOS on Apple Silicon and to the PlayStation Vita. PS2Recomp translates the MIPS code to C++. The Mac renderer is Metal and the Vita renderer is OpenGL ES.
- [Chameleon Twist 2: a native port by static recompilation](https://awesomerea.org/resources/chameleon-twist-2-recompiled-case/index.md): Case study · Statically recompiles the Japanese Nintendo 64 release of Chameleon Twist 2 into a native port using N64Recomp and RSPRecomp, with RT64 rendering. The build uses a user-provided ROM and includes menus, input configuration, and graphics options.
- [Chameleon Twist: Recompiled — a native port of Chameleon Twist](https://awesomerea.org/resources/chameleon-twist-recomp-case/index.md): Case study · Chameleon Twist: Recompiled uses N64: Recompiled to statically recompile the Japanese Nintendo 64 release of Chameleon Twist, with RT64 for rendering.
- [Champions: Return to Arms: PS2 code research and native recompilation](https://awesomerea.org/resources/champions-return-to-arms-re-case/index.md): Case study · Champions: Return to Arms research maps the US PS2 game's executable, symbols, level scripts, file formats and online behavior. Its tools disassemble and compare original functions, then translate a player-supplied executable to C++ for a native runtime and Godot host; the author maintains an address-based findings ledger.
- [Chaves Kart (El Chavo Kart) Recompiled: Xbox 360 game statically recompiled for PC](https://awesomerea.org/resources/chaves-kart-recompiled-case/index.md): Case study · Chaves Kart (El Chavo Kart) Recompiled brings the Xbox 360 game to native Windows and experimental Linux builds through static recompilation with ReXGlue. Its launcher installs files from the user's El Chavo Kart (USA) disc image and accepts the specified default.xex version. The project also documents findings from static analysis of the game and adds PC graphics options and online multiplayer.
- [Children and Dog go Pew Pew (CadgPP): an N64 static recompilation port](https://awesomerea.org/resources/cadgpp-n64-port-case/index.md): Case study · Children and Dog go Pew Pew builds a native Windows and Linux port of an N64 game with N64Recomp and RT64. It uses the player's revision 0 ROM to generate translated code locally and adds modern controls, widescreen rendering, save states and locally generated textures.
- [Civilization III: Conquests — static recompilation of the Steam release](https://awesomerea.org/resources/civilization-iii-conquests-recomp-case/index.md): Case study · Civilization III: Conquests statically recompiles the user's Steam Win32 game executable into C with pcrecomp and builds native Windows and Linux hosts. The repository supplies lift scripts, runtime shims and scripted tests; the author reports matching original game state across 19 turns in one differential run.
- [ClayFighter 64: recompiling and combining two N64 ClayFighter games](https://awesomerea.org/resources/clayfighter64-case/index.md): Case study · ClayFighter 64 builds a native Linux and Windows game from statically recompiled ClayFighter 63⅓ CPU and RSP audio code, adding four characters from ClayFighter: Sculptor's Cut. Its installer checks both user-supplied USA ROMs and assembles the combined game data locally; RT64 handles rendering.
- [Clockwork: native Yo-kai Watch 3DS games by static recompilation](https://awesomerea.org/resources/clockwork-yo-kai-watch-case/index.md): Case study · Clockwork builds native PC versions of the Yo-kai Watch Nintendo 3DS games by translating each game's ARM code to C ahead of time. Its SDL3 runtime replaces console hardware and services, while the launcher unpacks and builds modules from a player's decrypted cartridge dumps. The repository also documents findings from Yo-kai Watch 2: Psychic Specters.
- [COD3 Reborn: continuing a Call of Duty 3 static recompilation](https://awesomerea.org/resources/cod3-reborn-case/index.md): Case study · COD3 Reborn builds a native Windows port of Call of Duty 3 by translating its Xbox 360 PowerPC executable and level libraries with XenonRecomp. It links the generated code to a kernel, graphics and audio runtime inherited from an earlier port, then adds title-specific investigation and fixes. The author reports that individual levels load and render, while campaign-wide play and several graphics and input issues remain unresolved.
- [CoD3Recomp: static recompilation of Call of Duty 3](https://awesomerea.org/resources/cod3recomp/index.md): Case study · CoD3Recomp is a static recompilation of Call of Duty 3 for Xbox 360 to native x86-64, using XenonRecomp. The README says the PowerPC code translates to C++, that 19,462 functions are translated, and that all 179 Xbox 360 kernel imports are implemented. It says the project is still in development.
- [COD6-NX: Xbox 360 Modern Warfare 2 recompilation for Switch](https://awesomerea.org/resources/cod6-nx-modern-warfare-2-case/index.md): Case study · COD6-NX ports the Xbox 360 Call of Duty: Modern Warfare 2 to Nintendo Switch by recompiling game code for ARM64 with ReXGlue. Its custom Vulkan renderer consumes the game's PM4 command ring and manages textures, pipelines and render targets; development notes record observed rendering failures.
- [COGBox: static recompilation ports of Xbox 360 Gears of War games](https://awesomerea.org/resources/cogbox-gears-native-case/index.md): Case study · COGBox packages native Windows ports of Gears of War 2, Gears of War 3, and Gears of War: Judgment built by translating Xbox 360 code to C++ ahead of time. A launcher imports the user's game copies and required title updates; the project supplies a Direct3D 12 renderer and experimental Vulkan option.
- [Colin McRae Rally 2.0 Recompiled: a disc-local PlayStation build](https://awesomerea.org/resources/colin-mcrae-rally-2-recomp-case/index.md): Case study · Colin McRae Rally 2.0 Recompiled configures psxrecomp to generate and build the US PlayStation game from a player's disc image. It includes a setup host and title-specific symbol mapping; the author reports gameplay in a private package and a local Windows build, with exact-package checks pending.
- [Colin McRae Rally 2005: an Xbox XBE recompilation for Windows](https://awesomerea.org/resources/colin-mcrae-rally-2005-recomp-case/index.md): Case study · A Colin McRae Rally 2005 port recompiles the US original-Xbox game for native Windows execution using Xbox XBE Recomp. The bundled runtime supplies Xbox kernel and XDK replacements, Direct3D 12 rendering, audio and controller support, while game code and assets come from the user's own copy. The port adds display settings and rendering fixes.
- [Colony Wars: Red Sun — a local PSXRecomp build](https://awesomerea.org/resources/colony-wars-red-sun-recomp-case/index.md): Case study · Colony Wars: Red Sun uses PSXRecomp and recomp-ui to generate and compile a native build from the user's USA PlayStation disc and BIOS. Its title kit includes configuration, symbol seeds and a movie-centering hook. The author reports Windows setup and headless-start checks and play testing on a private build.
- [Comix Zone XBLA: Xbox 360 binary analysis and static recompilation](https://awesomerea.org/resources/comix-zone-xbla-recompiled-case/index.md): Case study · Comix Zone XBLA analyzes the Xbox 360 release's XEX2 binary and reports translating its PowerPC code to C++ with XenonRecomp. The investigation maps PE sections, imports and an embedded Genesis emulator with 68K, Z80, YM2612 and video components. Function-boundary fixes and ReXGlue runtime implementation remain pending.
- [Conker's Bad Fur Day: Recompiled — an N64Recomp native port](https://awesomerea.org/resources/cbfd-recompiled-case/index.md): Case study · Statically recompiles the US Nintendo 64 release of Conker’s Bad Fur Day with N64Recomp into a native Windows, Linux and macOS port on N64ModernRuntime and RT64. Function names and boundaries come from a vendored, still mostly assembly decompilation, while the recompiled code is taken from the user’s ROM so unmatched decompiled C cannot change behavior. The author reports heavy use of Claude Code across the project.
- [Conker's Bad Fur Day: Reloaded — native PC port](https://awesomerea.org/resources/conker-bfd-reloaded-case/index.md): Case study · Conker's Bad Fur Day: Reloaded is a native Windows and Linux port of the Nintendo 64 game, statically recompiled with N64: Recompiled and drawn with RT64. The README describes a Classic mode and a Modern mode with widescreen, high frame rates, and mouse, keyboard, and controller support.
- [Conker: Live & Reloaded — native recompilation for Switch, Linux and Windows](https://awesomerea.org/resources/conker-lr-native/index.md): Case study · This statically recompiles Conker: Live & Reloaded for the original Xbox to Nintendo Switch, Linux, and Windows. The retail NTSC default.xbe has SHA-1 2232a1b3874d67b4bb4cf53a940420d2dab59535. Single player is playable. The Switch build is reported at a stable 30 fps, with true 16:9 and an experimental 60 fps mode. Linux and Windows use OpenGL 3.3. Multiplayer and Xbox Live do not work.
- [Conker: Live & Reloaded — static recompilation of the Xbox game](https://awesomerea.org/resources/conker-live-reloaded-recomp-case/index.md): Case study · Conker: Live & Reloaded translates the European original Xbox game's x86 XBE code into C++ for a native Windows x64 build. Game-specific configuration and hooks work with an Xbox runtime that replaces kernel, graphics, sound, and input services; technical notes document fixes for inlined Direct3D state.
- [CPS-2 Recomp: static recompilation of Capcom CPS-2 and CPS-1 arcade games](https://awesomerea.org/resources/cps2recomp-arcade-static-recomp-case/index.md): Case study · Translates the 68000 game programs and Z80 sound programs of Capcom arcade boards ahead of time into C++ and runs them on a machine model written for the project, with an interpreter for code that has not been translated. One launcher covers Street Fighter Alpha and Alpha 2, Super Puzzle Fighter II Turbo, Vampire Savior and its variants, Vampire Hunter 2, Alien vs. Predator and the CPS-1 Cadillacs and Dinosaurs, adding training modes, widescreen and three-player options. Translated code is generated from the user’s own ROM sets, and a check build compares it block by block with the interpreter.
- [Crackdown 2: Xbox 360 static recompilation](https://awesomerea.org/resources/crackdown2-recomp/index.md): Case study · This is a static recompilation of Crackdown 2 using ReXGlue SDK 0.5.0. The Windows debug preset is win-amd64-debug. The README says the result is in-game but not playable yet.
- [Crackdown Recompiled: native PC port of Xbox 360 Crackdown](https://awesomerea.org/resources/crackdown-recompiled-case/index.md): Case study · Native PC recompilation of the Xbox 360 game Crackdown. Static recompilation with the ReXGlue SDK produces a Windows build using Direct3D 12 and an experimental native Linux and Steam Deck build using Vulkan. The repository does not contain the game files, and the recompiled C++ is generated from the user's own disc.
- [Crackdown: Xbox 360 static recompilation](https://awesomerea.org/resources/crackdown-recomp/index.md): Case study · This recompiles Crackdown title update 0 for the Xbox 360 with ReXGlue SDK 0.2.2. The README says the project is unfinished.
- [Crash Bandicoot 2 Recompiled: a PSXRecomp native build](https://awesomerea.org/resources/crash2recomp-case/index.md): Case study · A Windows launcher that uses the PSXRecomp recompiler and runtime to translate the user’s Crash Bandicoot 2: Cortex Strikes Back disc to C and compile it locally, so the game runs as native code with an emulated PlayStation hardware layer. The repository holds the launcher, a patched vendored runtime and a long bring-up log; it distributes no game code or data.
- [Crash Bandicoot 3: Warped Recompiled: a PSXRecomp setup host](https://awesomerea.org/resources/crash-bandicoot-3-warped-recompiled-case/index.md): Case study · Crash Bandicoot 3: Warped Recompiled packages a PSXRecomp setup recipe for generating a native build from the user's PlayStation disc and BIOS. The recomp-ui wizard collects those inputs; the author reports a Windows development build while package setup and gameplay acceptance remain pending.
- [Crazy Taxi: an Xbox 360 XBLA static recompilation for PC](https://awesomerea.org/resources/ctxbla-crazy-taxi-case/index.md): Case study · ctxbla statically recompiles the 2010 Xbox 360 XBLA release of Crazy Taxi into native x86-64 PC code with XenonRecomp and ReXGlue. The repository documents STFS and XEX extraction, executable-section analysis, game-specific stubs, and input and timing fixes. The author reports that the runtime reaches gameplay, while in-game audio is absent and some gameplay events can crash.
- [crazytaxi-ps3: statically recompiling Crazy Taxi for Windows](https://awesomerea.org/resources/crazytaxi-ps3-case/index.md): Case study · crazytaxi-ps3 statically recompiles the PS3/PSN release of Crazy Taxi for native Windows using ps3recomp. Its scripts prepare a user-supplied EBOOT, lift PPU and SPU code, and build against the shared runtime; the author reports the title screen and in-engine attract demo rendering while gameplay remains unreached.
- [crazytaxi: statically recompiling the Dreamcast game](https://awesomerea.org/resources/crazy-taxi-static-recomp-case/index.md): Case study · crazytaxi statically translates the Dreamcast game Crazy Taxi from SH-4 machine code to native x86-64 C using dcrecomp and the user's disc image. Its repository adds game-specific entry points, bring-up code and a smoke test; the author reports that initialization reaches a persistent wait loop before any frame is drawn.
- [Crimson Skies: static recompilation and runtime bring-up](https://awesomerea.org/resources/crimson-skies-recomp-case/index.md): Case study · Crimson Skies statically translates the game's x86 Win32 executable to C and connects it to native MFC and DirectX libraries through import bridges and callbacks. The repository contains game-specific function maps, a generation pipeline and runtime code; the author reports reaching the GOS game shell, while asset loading, gameplay and a modern renderer remain pending.
- [Cristalis: statically recompiling Crystal Defenders for Windows](https://awesomerea.org/resources/cristalis-crystal-defenders-case/index.md): Case study · Cristalis ports the Xbox 360 game Crystal Defenders to native Windows by translating its PowerPC code to C++ ahead of time with XenonRecomp and running it on a game-specific runtime. It reads images, audio, music, and text from the user's own game copy; the author reports finishing the game on a small number of machines. A Linux version is experimental.
- [ct-recomp: statically recompiling Chrono Trigger](https://awesomerea.org/resources/ct-recomp-case/index.md): Case study · ct-recomp statically translates Chrono Trigger US 1.0's 65816 routines into C and runs them with a C runtime, interpreter fallback and SDL2 front end. Its tools compare memory, images and instruction traces with Mesen 2. The author reports 1,414 of 2,036 known functions compiled to C.
- [dantes-inferno-nx: porting Dante's Inferno to Nintendo Switch](https://awesomerea.org/resources/dantes-inferno-nx-case/index.md): Case study · dantes-inferno-nx statically recompiles Dante's Inferno Xbox 360 PowerPC code to C++ for a Nintendo Switch homebrew build. Its Switch runtime renders through deko3d, and its shader tools translate Xenos shader containers through HLSL and SPIR-V. The build uses the user's supported disc and Title Update 2 or a supported Games on Demand install.
- [Daytona USA: Xbox Live Arcade static recompilation](https://awesomerea.org/resources/daytona-xbla-recomp/index.md): Case study · This statically recompiles the 2011 Xbox 360 Arcade release of Daytona USA with ReXGlue. The package is an STFS arcade title, XA-2845, media ID 3CA562D4, 240058368 bytes, SHA-256 db2381451a15a4e537154712213a0309e9ddc33d20bdc03421d80c9939893cef. python3 scripts/extract_game.py extracts it and copies default.xex. The SDK submodule is the daytonaxbla branch. Linux uses cmake --preset linux-amd64 and Clang 20 or newer. Windows uses cmake --preset win-amd64 and Visual Studio 2022 with Clang 20 or newer. The Linux binary is daytona and takes --game_data_root pointing at the extracted folder.
- [DBZ Budokai 1 HD Collection: a Windows static recompilation and mod pipeline](https://awesomerea.org/resources/dbz-budokai-1-hd-recomp-case/index.md): Case study · DBZ Budokai 1 HD Collection builds a Windows port by statically recompiling the Xbox 360 game's PowerPC code with ReXGlue SDK. Its launcher selects USA or EU assets, and its mod tools overlay AFS entries and convert character models between Budokai releases.
- [DBZ Budokai 3 HD Collection: recompiling Dragon Ball Z: Budokai 3 HD Collection](https://awesomerea.org/resources/dbz-budokai-3-hd-recomp/index.md): Case study · This is a native port of the Xbox 360 game Dragon Ball Z: Budokai 3 HD Collection, built with the ReXGlue SDK. The PowerPC code is statically recompiled. The v1.5.6 Windows release is DBZ-Budokai-3-HD-Collection-v1.5.6.zip. dbz3.exe accepts the original ISO, or default.xex with the US and EU data archives. Linux builds use Vulkan and SDL3 and start with ./dbz3. baserom.md lists sizes and checksums. Generated code is produced locally and is not uploaded.
- [ddg-recomp: a static recompilation of Densha de GO! FINAL](https://awesomerea.org/resources/ddg-recomp-case/index.md): Case study · ddg-recomp builds native ports of the PC game Densha de GO! FINAL by translating x86 functions from the user's perfect.exe into C. Replacement SDL3 code supplies Windows and Direct3D 8 services across desktop and ARM handheld targets. The author reports playable driving but lists missing movies and untranslated library paths.
- [DDR 1st Mix: static recompilation and freeze analysis](https://awesomerea.org/resources/ddr-1st-mix-recomp-case/index.md): Case study · DDR 1st Mix recompiles the PlayStation release SLPM-86222 by translating its MIPS code to C with PSXRecomp and building a native executable. Game-specific hooks address runtime behavior, and the author documents tracing an animation error into a cyclic display list that caused freezes.
- [Dead Rising 2: Case West — a sibling Xbox 360 XBLA static recompilation port](https://awesomerea.org/resources/dead-rising-2-case-west-recomp-case/index.md): Case study · Builds a native Windows, Linux, Steam Deck and Apple Silicon port of the XBLA epilogue Dead Rising 2: Case West by statically recompiling its Xbox 360 code with patched XenonRecomp and translating its shaders with patched XenosRecomp. It shares most of its runtime with the author’s separate Case Zero port, executing the console GPU command stream on Vulkan with XMA audio and keyboard/mouse input. Completion and platform results are project-reported.
- [Dead Rising 2: Case Zero — an Xbox 360 XBLA static recompilation port](https://awesomerea.org/resources/dead-rising-2-case-zero-recomp-case/index.md): Case study · Builds a native Windows, Linux, Steam Deck and Apple Silicon port of the XBLA game Dead Rising 2: Case Zero by statically recompiling its Xbox 360 code with patched XenonRecomp and translating its shaders with patched XenosRecomp. A purpose-built runtime supplies a Vulkan renderer, XMA audio, keyboard/mouse input and online co-op through the author’s XenonLive service. Completion and platform results are project-reported.
- [DEArmoredcoreV: statically recompiling Armored Core V for Linux](https://awesomerea.org/resources/dearmoredcorev-case/index.md): Case study · DEArmoredcoreV develops a Linux port of the Xbox 360 game Armored Core V by translating PowerPC instructions to C++ through ReXGlue. Its tools inspect BHD5/BDT, BND3, FLVER, TPF and Xbox 360 texture resources, while research notes track reconstructed behavior by address and function. The author reports an existing Linux package and an unresolved Mission 2 black-screen hang.
- [Deep Sea: a native Windows recompilation of The Wind Waker](https://awesomerea.org/resources/deep-sea-wind-waker-case/index.md): Case study · Deep Sea builds a native Windows port of The Legend of Zelda: The Wind Waker from the user's USA GameCube disc. Its setup kit checks disc hashes, translates main.dol and 415 REL modules with DolRecomp, and compiles a local game DLL for the ModernGekko runtime. Game-specific additions include widescreen, frame interpolation and cutscene skipping.
- [Def Jam Vendetta Recompiled: statically recompiling the PS2 game for Windows](https://awesomerea.org/resources/def-jam-vendetta-recomp/index.md): Case study · Def Jam Vendetta Recompiled turns the PlayStation 2 game into a native Windows program with PS2Recomp. paraLLEl-GS redraws the graphics chip on Vulkan. The target is the USA disc, SLUS-20639, as an ISO or CHD.
- [Def Jam: Fight for NY XBE Recomp: a native Linux port](https://awesomerea.org/resources/def-jam-fight-for-ny-linux-case/index.md): Case study · Def Jam: Fight for NY XBE Recomp builds a native Linux port of the original Xbox game by translating its x86 XBE into C++ ahead of time. The port implements Xbox kernel and XDK services at the API level, renders through Vulkan, and uses SDL3 for sound and input. The author reports booting through menus and into fights while gameplay testing continues.
- [Def Jam: Fight for NY — statically recompiling the Xbox game](https://awesomerea.org/resources/defjam-ffny/index.md): Case study · This statically recompiles Def Jam: Fight for NY for the original Xbox, USA version, to Windows. The installer checks the ISO and refuses the European disc. DJFFNY.exe is the single-window installer. A hand install uses Installer.bat. The MSVC package is about 2 MB and can use DLSS on an NVIDIA RTX card. The built-in Clang package is about 100 MB. The install needs about 4 GB free and an XInput controller.
- [defjam-sw: a static recompilation of Def Jam: Fight for NY](https://awesomerea.org/resources/defjam-sw-case/index.md): Case study · defjam-sw lifts the original Xbox executable of Def Jam: Fight for NY instruction by instruction into C for native Nintendo Switch and Linux builds. Its runtime supplies Xbox kernel, graphics, audio and controller behavior, with game-specific replacements for lifted functions.
- [Demon's Souls PC: a PS3 static recompilation for Windows](https://awesomerea.org/resources/demons-souls-pc-case/index.md): Case study · Demon's Souls PC ports the North American PS3 release of Demon's Souls to Windows x64 by lifting PowerPC and SPU code to C and linking it with replacements for PS3 system libraries. It uses Direct3D 12, WASAPI and a .NET launcher; the author reports booting through Boletarian Palace 1-1 on one reference machine.
- [Demon's Souls: native Windows port of the PS3 game](https://awesomerea.org/resources/demons-souls-recomp-case/index.md): Case study · This is a native Windows build of Demon's Souls for the PlayStation 3, USA release BLUS-30443. The README says PPU and SPU code is statically recompiled to C and C++ with ps3recomp and rendered with Direct3D 12.
- [Destruction Derby 2 Recompiled: a PlayStation setup host for local static recompilation](https://awesomerea.org/resources/destruction-derby-2-recomp-case/index.md): Case study · Destruction Derby 2 Recompiled provides a setup host and game-specific configuration for locally generating a PlayStation static recompilation from the user's USA disc. It uses PSXRecomp and recomp-ui, with function seeds and symbol mapping. Project notes document a multi-BIN disc identity correction, and the author reports gameplay in a private build.
- [Destruction Derby Raw: a local PSXRecomp build](https://awesomerea.org/resources/destruction-derby-raw-recomp-case/index.md): Case study · Destruction Derby Raw uses PSXRecomp and recomp-ui to generate and compile a native build from the user's USA PlayStation disc and BIOS. The title kit contains configuration and symbol seeds. The author reports Windows setup and headless-start checks and playable private-build testing with menu and movie artifacts.
- [Devil May Cry: an experimental PS2 static recompilation](https://awesomerea.org/resources/dmc-recomp-case/index.md): Case study · dmc-recomp translates the PlayStation 2 PAL release of Devil May Cry into native PC code through PS2Recomp and a project runtime. Its pipeline rebuilds generated code locally from the user’s own game executable, while research notes and patches track boot, CD services, MPEG playback, rendering and gameplay behavior.
- [Devil Within Co-op: statically recompiling Tekken 5's Devil Within mode](https://awesomerea.org/resources/devil-within-coop-case/index.md): Case study · Devil Within Co-op statically recompiles the Devil Within mode from a user's Tekken 5 USA disc into generated Rust, then runs it through a Rust PS2 runtime and Bevy application. Its pipeline extracts the compressed ELF, exports Ghidra analysis and generates code locally; added hooks provide cooperative play, a mod menu and reconstructed developer menus.
- [Dicing Knight. — a native port by static recompilation](https://awesomerea.org/resources/dicing-knight-static-recomp-case/index.md): Case study · Dicing Knight. — Native Recompilation translates the WonderSwan Color game’s V30 MZ machine code into C11 ahead of time and compiles it with a recreated hardware layer. Its Python recompiler discovers code from entry seeds and execution traces; the C layer models video, timers, input, EEPROM, and audio. The author reports playable Windows sections through the tower, while the ending and Android device build remain unverified.
- [Diddy Kong Racing Recompiled: a native Windows port by static recompilation](https://awesomerea.org/resources/diddy-kong-racing-recompiled-case/index.md): Case study · Diddy Kong Racing Recompiled turns the N64 game's code and audio microcode into native Windows build inputs with N64Recomp and RSPRecomp, then renders through RT64. The author reports that the alpha build reaches Adventure mode and races Ancient Lake, including four-player network play.
- [Die Hard Trilogy Recompiled: a PlayStation setup and static recompilation](https://awesomerea.org/resources/die-hard-trilogy-recompiled-case/index.md): Case study · Die Hard Trilogy Recompiled supplies a PSXRecomp setup host for generating a native build from a user-owned PlayStation disc. The repository includes title-specific symbols and a documented correction for verifying the USA Rev 1 multi-BIN disc.
- [Digimon World 2003 Recompiled: a local PSXRecomp setup host](https://awesomerea.org/resources/digimon-world-2003-recompiled-case/index.md): Case study · Digimon World 2003 Recompiled provides a psxrecomp setup host for the European PlayStation game. Its title recipe, symbols and seed data support local code generation from the user's disc and BIOS; the author reports gameplay in a private package while exact-package gates remain open.
- [Dimensions Recompiled: native Windows build of LEGO Dimensions](https://awesomerea.org/resources/dimensions-recomp/index.md): Case study · Dimensions Recompiled is a native Windows build of the Xbox 360 game LEGO Dimensions. ReXGlue translates the PowerPC executable to C++ ahead of time, and the GPU command stream is translated to Direct3D 12 at runtime. DimensionsRecompiled-Setup.exe takes an extracted original-release folder that contains Default.xex, GAME.DAT, and GAME.HDR, plus Title Update 23. The installer refuses a different build or another title update. A companion app can stand in for the Toy Pad, and the Wii U, PlayStation 3, PlayStation 4, Xbox 360, and Xbox One pads are also supported. Releases are built from the toypad-ui branch of NeverCookFirst/rexglue-sdk.
- [Dino Crisis - Modern Edition: a disc-built Windows recompilation](https://awesomerea.org/resources/dino-crisis-modern-edition-case/index.md): Case study · Dino Crisis - Modern Edition rebuilds the PlayStation game Dino Crisis as a native Windows program from the user's disc image. Its installer recompiles the game code to C and combines it with a runtime supplying a new renderer, camera, controls and mod support; the repository includes build scripts and hooks for supported disc versions.
- [Dino Crisis 2 Recompiled: a PSXRecomp setup candidate](https://awesomerea.org/resources/dino-crisis-2-recompiled-case/index.md): Case study · Dino Crisis 2 Recompiled provides a PSXRecomp configuration and portable setup candidate for the SLUS-01279 PlayStation game. The setup wizard takes a user-supplied disc image and BIOS, then generates and rebuilds the program; gameplay acceptance remains pending.
- [Dino Crisis Recompiled: a PSXRecomp setup host](https://awesomerea.org/resources/dino-crisis-recompiled-case/index.md): Case study · Dino Crisis Recompiled packages a PSXRecomp setup recipe for generating a native build from the user's PlayStation disc and BIOS. Its recomp-ui wizard collects the inputs and runs generation; the author lists package setup and gameplay acceptance as pending.
- [Dinosaur Planet: Recompiled — static recompilation of the 2000 prototype](https://awesomerea.org/resources/dino-recomp/index.md): Case study · Dinosaur Planet: Recompiled statically recompiles the December 2000 Dinosaur Planet prototype with N64: Recompiled and renders it with RT64. The README says that prototype, released by Forest of Illusion on 20 February 2021, is the only ROM it accepts. A Direct3D 12 Shader Model 6 or Vulkan 1.2 GPU is required, plus a CPU with SSE4.1. A file named portable.txt beside the executable keeps saves, config, and mods in that folder. --4x3 launches at 1280x960. Build steps are in BUILDING.md.
- [DinoTale: a static-recompilation port of Yoshi's Story](https://awesomerea.org/resources/dinotale-case/index.md): Case study · DinoTale statically recompiles Yoshi's Story with N64Recomp for Windows and Linux, using N64ModernRuntime and RT64 for execution and rendering. Its game-specific work maps overlays and functions and adds display modes, controls and renderer fixes.
- [Disruptor Recompiled: rebuilding the PlayStation game for Windows](https://awesomerea.org/resources/disruptor-recomp-case/index.md): Case study · Disruptor Recompiled translates the USA PlayStation release of Disruptor into C with PSXRecomp and builds a native Windows executable from the player's disc image. Its repository adds framework patches and game-specific code for widescreen display, input and presentation changes.
- [DisruptorRecomp: statically recompiling Disruptor for PC](https://awesomerea.org/resources/disruptor-recomp-recompteam-case/index.md): Case study · DisruptorRecomp turns the PlayStation game Disruptor into a native Windows and Linux program using PSXRecomp and a patched runtime. Its launcher reads the player's USA disc image; the project adds PC display and control options while retaining an alpha status.
- [DK64Recomp-NX: a Switch port of Donkey Kong 64](https://awesomerea.org/resources/dk64recomp-nx-case/index.md): Case study · DK64Recomp-NX brings Donkey Kong 64 to Switch by translating its N64 MIPS code to C ahead of time. It adapts the existing PC recompilation with a GLideN64 OpenGL renderer, Switch OS services and a different threading model.
- [DKB Recomp: static recompilation of Donkey Kong Bananza](https://awesomerea.org/resources/dkb-recomp-case/index.md): Case study · DKB Recomp statically translates Donkey Kong Bananza's Switch 2 ARM64 code to C and builds a native Windows x86-64 application. A Horizon host, NVN 2 implementation, shader translation, and Vulkan renderer handle game services and graphics. The author reports title-screen and tutorial rendering, with crashes and missing effects.
- [DKC1Recomp: static recompilation of Donkey Kong Country](https://awesomerea.org/resources/dkc1-recomp-case/index.md): Case study · Statically recompiles the North American v1.0 SNES release of Donkey Kong Country into native Windows, macOS and iOS applications with a pinned fork of snesrecomp, which translates 65816 code to C and links it against a modelled SNES hardware runtime. Function boundaries, entry flag states and jump-table targets are ingested from a byte-identical community disassembly instead of discovered heuristically, and the game code is generated locally from the user’s verified ROM. Optional widescreen, CRT filters, MSU-1 music and a Dixie Kong Country variant are host-side additions to what the README calls a playable bring-up.
- [DKC3Recomp: a SNES static recompilation of Donkey Kong Country 3](https://awesomerea.org/resources/dkc3recomp-case/index.md): Case study · DKC3Recomp translates Donkey Kong Country 3's SNES code into C with snesrecomp, using game-specific bank configuration derived from a public disassembly. Native macOS and Windows hosts run the result, while the shared runtime interprets code the static analysis cannot resolve. The project also documents widened presentation and limited bring-up checks.
- [DKR-R: statically recompiling Diddy Kong Racing](https://awesomerea.org/resources/dkr-r/index.md): Case study · DKR-R is a native static recompilation of Diddy Kong Racing. Release v1.0.14 takes a US v1.0 or US Rev A/v1.1 ROM in the Play page. Current packages cover Windows x64, Linux x86_64, Linux ARM64, and Steam Deck. Windows starts DKR-R.exe from the extracted package. Linux and Steam Deck launch the AppImage. Escape, F1, or Back/View opens the overlay. Online lobbies allow four racers and eight spectators. Some legacy xdelta mods install only against a clean US v1.0 ROM.
- [DOA2U Native PC Port: an Xbox game static recompilation](https://awesomerea.org/resources/doa2u-native-pc-port-case/index.md): Case study · DOA2U Native PC Port lifts the DOA2 Xbox executable from the user's Disc 2 copy to C and links it with a native runtime. That runtime replaces Xbox kernel, Direct3D 8, DirectSound, and input services for Windows, macOS, and Linux builds.
- [DOA3: an Android port of Dead or Alive 3](https://awesomerea.org/resources/doa3-android-port-case/index.md): Case study · DOA3 adapts statically recompiled Dead or Alive 3 Xbox code for Android ARM64. Its runtime uses OpenGL ES 3 for graphics and SDL3 for audio and input, while the launcher reads resources directly from the user's USA ISO; the author reports startup, menus and a fight on one device.
- [DOAXVB Native PC Port: statically recompiling Dead or Alive Xtreme Beach Volleyball](https://awesomerea.org/resources/doaxvb-native-port-case/index.md): Case study · Lifts the original Xbox executable of Dead or Alive Xtreme Beach Volleyball to C with a fork of xboxrecomp and links it with a hand-written runtime that replaces kernel imports, audio and key Direct3D 8 and DirectSound APIs. Setup builds the runner locally from the user’s USA disc image and checks generated files against hashes in an authenticated recipe; releases carry only tools and source. Rewriting game logic as readable source has so far reached only the startup thread entry.
- [Donkey Kong 64: Recompiled — an N64Recomp native port](https://awesomerea.org/resources/dk64-recompiled-case/index.md): Case study · Uses N64Recomp to statically recompile the US Nintendo 64 release of Donkey Kong 64 into a native port, with RT64 as the renderer. The port borrows headers and some functions from the in-progress DK64 decompilation for patches and enhancements. Its build uses a checked-in symbol dump and the ROM, with no decompilation ELF or decompiled source as the build input.
- [Doom SNES: a SNESRecomp native PC port](https://awesomerea.org/resources/doom-snes-recomp-case/index.md): Case study · DoomSNESRecomp ports the SNES release of Doom to native Windows, Linux and macOS builds using SNESRecomp. Bank configuration and symbol maps guide code generation from the user’s ROM; the host renderer captures Super FX scene state for higher resolution and widescreen presentation. Optional controls and gameplay changes sit alongside the recompilation.
- [DQ8Recomp: an experimental Dragon Quest VIII static recompilation](https://awesomerea.org/resources/dq8recomp-case/index.md): Case study · DQ8Recomp translates Dragon Quest VIII's PlayStation 2 MIPS code to C++ locally with PS2Recomp and links it to a runtime implementing the services the game uses. The source includes function maps, Ghidra analysis tooling and an SDL3 GPU renderer; the author reports that the NTSC-U build reaches field gameplay.
- [Dr. Mario 64 Recomp: a native N64 recompilation with rendering changes](https://awesomerea.org/resources/dr-mario-64-recomp-plus-case/index.md): Case study · Dr. Mario 64 Recomp builds a modernized native version of the US Nintendo 64 game using N64Recomp and RSPRecomp on a user-supplied ROM. Its changes include GPU pill rendering, interpolated motion, four-player controllers and CRT effects. The author describes the release as lightly tested.
- [Dragon Age: Origins — Recompiled](https://awesomerea.org/resources/dao-recomp-case/index.md): Case study · Dragon Age: Origins — Recompiled is a static recompilation of the Xbox 360 game into a native x86-64 Windows program, with a Direct3D 12 renderer based on Xenia's.
- [Dragon Ball GT: Final Bout Recompiled — a Windows recompilation](https://awesomerea.org/resources/db-final-bout-recomp/index.md): Case study · This recompiles Dragon Ball GT: Final Bout for the PlayStation, USA SLUS-00493, to Windows with PSXRecomp. Release v0.2.1 is a compiled package. The player selects a disc on first launch. Widescreen is optional, and OpenBIOS is included.
- [Dragon Ball GT: Final Bout: a native static recompilation of the PS1 game](https://awesomerea.org/resources/dragon-ball-gt-final-bout-recomp-case/index.md): Case study · Dragon Ball GT: Final Bout statically translates MIPS code from the user's NTSC-U PlayStation disc into C and compiles it for Windows or Linux. Its own runtime handles GPU, GTE, SPU, MDEC/XA, CD, and memory-card functions. The author reports playing the main game modes on Windows; Linux builds and launches but has not received equivalent gameplay testing.
- [Dragon Ball Z on the Nintendo 64: recompiling two GBA games for N64](https://awesomerea.org/resources/dbz64-case/index.md): Case study · Dragon Ball Z on the Nintendo 64 statically recompiles ARM and Thumb code from The Legacy of Goku II and Buu's Fury into C for N64 builds. Its runtime supplies GBA graphics, sound, DMA, timers, interrupts and saves, with an RDP renderer and wider field view. The author reports both games playable on real hardware.
- [Dragon Ball Z: Super Saiya Densetsu — recompiling the SNES game in Rust](https://awesomerea.org/resources/dbz-ssd-rust/index.md): Case study · This Rust project plays Dragon Ball Z: Super Saiya Densetsu for the SNES in Classic, recompiled, and remastered modes. Classic runs the 65816 code in a vendored jgenesis core and checks Rust routines in lockstep against 28 reference replays. crates/ssd-recomp writes one Rust function per entry address and register width. cargo run --release -p xtask -- recompile generates that code from the local ROM. The checksum-fixed Klepto v1.02 image is 1,048,576 bytes, CRC-32 A8CF4F2A, SHA-1 6b612f6d99f2efc26f26fb22290bc732ada0ea6f. Japanese Rev 1 is CRC-32 ADE7B968, SHA-1 6b5725765ddde078350ec61221ddb9bb252066a7.
- [Drakengard 3: a Windows port through static recompilation](https://awesomerea.org/resources/drakengard-3-recompile-case/index.md): Case study · Drakengard 3 Recompile translates the PS3 release of Drakengard 3 into native Windows x64 code and replaces platform services in a local runtime. It targets NPUB31251 version 1.01 and builds from the user's game files; the author reports intro, audio, menu and story-scene milestones, with controlled gameplay still unconfirmed.
- [Drakengard: an experimental PAL PlayStation 2 static recompilation](https://awesomerea.org/resources/drakengard-1-europe-case/index.md): Case study · A source-only Drakengard project statically recompiles the European PlayStation 2 release toward a native PC port, with a runtime for original hardware and service behavior. The author reports a diagnostic runner reaching Chapter I scenes and rendering Caim, terrain, objects, radar and HUD; sustained gameplay remains unfinished.
- [DriftDroid: an Android port of statically recompiled Mario Kart Wii](https://awesomerea.org/resources/driftdroid-case/index.md): Case study · DriftDroid adapts WiiCompiled's static recompilation of Mario Kart Wii into a native Android app. It adds touch and motion controls, Vulkan and OpenGL ES rendering paths, and disc import for game data from the user's PAL RMCP01 copy; a separate builder handles Switch builds and optional Android game packs.
- [Driver Recompiled: a psxrecomp setup host that builds the game locally](https://awesomerea.org/resources/driver-recomp-setup-host-case/index.md): Case study · Packages a psxrecomp static-recompilation project for Driver (PlayStation, USA) as a setup host: releases carry the recompiler, runtime and a recomp-ui launcher, and the player’s machine generates and compiles the game from the user’s own disc image. The repository holds configuration, Ghidra-derived function seeds and release automation rather than game code. Its documented status is thin: an operator-confirmed private build reaches gameplay, while package release gates remain open.
- [drmario64_recomp: an experimental Dr. Mario 64 recompilation](https://awesomerea.org/resources/dr-mario-64-recomp-case/index.md): Case study · drmario64_recomp is an experimental native port of Dr. Mario 64 built with N64Recomp and RSPRecomp from a user-supplied US ROM. The project includes recompilation configuration, game patches and an RT64-based renderer.
- [DS Kart Recompiled: statically recompiling Mario Kart DS for PC](https://awesomerea.org/resources/ds-kart-recompiled-case/index.md): Case study · DS Kart Recompiled is a native PC port of the European Mario Kart DS, game code AMCP, made by static recompilation of the ARM9 and ARM7 code. A runtime supplies memory, interrupts, timers, the 2D and 3D engines, sound, saving, and controls.
- [DuckHuntNESRecomp: a Duck Hunt static recompilation with mouse Zapper](https://awesomerea.org/resources/duck-hunt-nes-recomp-case/index.md): Case study · DuckHuntNESRecomp runs the NES game Duck Hunt on PC using NESRecomp, compiling seeded 6502 code paths to C and running unseen code through a cycle interpreter. The shared runner maps mouse input to the Zapper; a project note records fixes to trigger polarity and crosshair defaults. The author reports working menus and gameplay, while audio mixing remains unfinished.
- [Duke Nukem Zero Hour: Recompiled — a native Nintendo 64 game port](https://awesomerea.org/resources/dnzh-recomp/index.md): Case study · Duke Nukem Zero Hour: Recompiled statically recompiles the US Nintendo 64 ROM with N64Recomp and renders it with RT64. The main menu loads that ROM. Formats other than z64 are converted when the ROM is the US release. It needs a GPU with Direct3D 12.0 shader model 6, Vulkan 1.2, or Metal argument buffers tier 2. x86-64 CPUs need SSE4.1. ARM64 builds run on ARM64 CPUs. Releases include a Linux binary and a Flatpak, including Steam Deck. A portable.txt file beside the executable keeps saves, config, and mods in that folder. Build steps are in BUILDING.md.
- [Earthworm Jim 2 Recompiled: a PlayStation static recompilation](https://awesomerea.org/resources/earthworm-jim-2-recomp-case/index.md): Case study · Earthworm Jim 2 Recompiled converts the PlayStation game's MIPS boot loader and 19 executables to C with psxrecomp for a Windows build made from the user's disc. It includes game-specific setup scripts and an optional partial widescreen patch. The author reports that all 17 levels load and play; transitions and the ending still lack end-to-end validation.