# Reverse-engineering case studies · Page 7

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

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

## Games (200)

- [EdgeOfTimeRecompiled: statically recompiling Spider-Man: Edge of Time](https://awesomerea.org/resources/edge-of-time-recomp/index.md): Case study · EdgeOfTimeRecompiled statically recompiles the US Xbox 360 version of Spider-Man: Edge of Time, including its title update. ReXGlue turns the PowerPC into C++, and a XenosRecomp fork turns the shaders into static shader code. The installer accepts Xbox 360 containers or images. Releases are REEOT-Windows.zip, REEOT-Linux.appimage, and REEOT-macOS.dmg. The minimum system is Windows 10 version 1909, Linux with glibc 2.41, or macOS 13.3, with AVX and Direct3D 12 or Vulkan 1.2. Build steps are in docs/BUILDING.md.
- [Egg of Time: a static-recompilation port of Chrono Trigger DS](https://awesomerea.org/resources/egg-of-time-chrono-trigger-ds-case/index.md): Case study · Egg of Time builds a native PC port of Chrono Trigger for Nintendo DS by statically translating its ARM9 code to C. Its pipeline extracts a user-supplied ROM, derives function and relocation data with ds-decomp, and links generated code with a runtime for DS hardware behavior.
- [Einhander: a PlayStation static recompilation project](https://awesomerea.org/resources/einhander-recompiled-case/index.md): Case study · Einhander configures psxrecomp to generate a native build of the PlayStation game from a user-supplied disc. Its repository includes game configuration, function seeds, symbol synchronization and trace analysis scripts, with recomp-ui used for the launcher.
- [EmeraldRecomp: statically recompiling Pokémon Emerald](https://awesomerea.org/resources/emerald-recomp-case/index.md): Case study · EmeraldRecomp is a static recompilation of Pokémon Emerald for the Game Boy Advance, built on gbarecomp. Version 0.0.1 boots through the BIOS intro to the title screen and into gameplay. Paths the static recompiler has not covered run in an interpreter the first time, then are JIT-compiled and remembered.
- [EoWRecomp: static recompilation of Echoes of Wisdom](https://awesomerea.org/resources/eowrecomp-case/index.md): Case study · EoWRecomp translates The Legend of Zelda: Echoes of Wisdom's Switch ARM64 modules into C ahead of time and runs them with native Horizon-service and NVN replacements. Its renderer uses Vulkan, including MoltenVK on macOS; the author reports that the Linux build reaches the opening and first controllable scene.
- [Eternal Darkness Recomp: native port of Sanity's Requiem](https://awesomerea.org/resources/eternal-darkness-recomp-case/index.md): Case study · Eternal Darkness Recomp is a native Mac, Windows, and Linux port of Eternal Darkness: Sanity's Requiem for the GameCube. The README says DolRecomp translates the game's PowerPC code to C, which is then compiled for the machine and run on GXRuntime.
- [Eternal Sonata Reprise: statically recompiling Eternal Sonata for PC](https://awesomerea.org/resources/eternal-sonata-reprise-case/index.md): Case study · Eternal Sonata Reprise is a static recompilation of Eternal Sonata for PC. The README says both the Xbox 360 and PlayStation 3 versions can be played in any region, while building the executable requires the Xbox 360 PAL version.
- [Extreme-G Recompiled: an incomplete N64 static recompilation](https://awesomerea.org/resources/extreme-g-recompiled-case/index.md): Case study · Extreme-G Recompiled analyzes the N64 game's custom LZSS ROM blocks and prepares its MIPS code for N64Recomp translation to C for a native Windows build. The project includes function symbols and an SDL2/RT64 runtime scaffold; the author reports that startup reaches audio initialization before crashing because a data section is uninitialized.
- [F-Zero Recomp: statically recompiling F-Zero](https://awesomerea.org/resources/fzero-recomp-case/index.md): Case study · F-Zero Recomp is a native widescreen static recompilation of F-Zero (USA). It runs on Linux x86_64, macOS on Apple Silicon, and Windows x64. Display modes include the original 8:7, 16:9, and 32:9.
- [F.E.A.R. NX: statically recompiling the Xbox 360 game for Switch](https://awesomerea.org/resources/fear-nx-case/index.md): Case study · F.E.A.R. NX statically recompiles the Xbox 360 release of F.E.A.R. from PowerPC to AArch64 for Nintendo Switch. A native Vulkan renderer runs through Mesa/NVK on Horizon, and the browser installer packages the user's supported Xbox 360 files locally.
- [Fable2Recomp: static recompilation of Fable 2](https://awesomerea.org/resources/fable2recomp-case/index.md): Case study · Fable2Recomp is an in-progress static recompilation of Fable 2 GOTY TU1 using ReXGlue, with a host runtime intended for Windows and Linux. Its configuration identifies game functions, while the host loads the game's XEX image and supplies content paths and selected function replacements.
- [FableDroid: statically recompiling Fable II for Android](https://awesomerea.org/resources/fabledroid/index.md): Case study · FableDroid statically recompiles Fable II to arm64 Android and renders Xbox 360 GPU commands with Vulkan. Release 0.6.3 beta is FableDroid-0.6.3-beta.apk. The reference Game of the Year USA/Europe ISO has SHA-256 685a0d3bea9718812f17bcd155907a5359a548b6d3d8342dd2a6c944f45e35ff. On a Snapdragon 8 Gen 2 with Adreno 740 and Android 13, the measured median is 29.9 fps at native 720p under the game's 30 fps cap.
- [Fallout-NV-MacOS: static recompilation of Fallout: New Vegas for Apple Silicon](https://awesomerea.org/resources/fallout-nv-macos-case/index.md): Case study · Fallout-NV-MacOS translates the 32-bit Windows executable of Fallout: New Vegas through Ghidra P-code into C for native Apple Silicon builds. A host supplies Win32 and COM shims plus Direct3D 9-to-Metal rendering, while a differential tester compares translated functions with the original x86 instructions in Unicorn. The author reports an hour of scripted play; audio, Bink video, and gamepad support remain unfinished.
- [Far Cry Instincts Recomp: a static recompilation of the Xbox game for Windows](https://awesomerea.org/resources/far-cry-instincts-recomp-case/index.md): Case study · Far Cry Instincts Recomp translates the original Xbox game's x86 code from a user's default.xbe into C++ and compiles it into a Windows x64 DLL. Its runtime replaces Xbox kernel, Direct3D 8 and DirectSound services, with graphics rendered through Direct3D 11.
- [fc3-nx: an experimental Far Cry 3 static recompilation](https://awesomerea.org/resources/fc3-nx-far-cry-3-case/index.md): Case study · fc3-nx uses ReXGlue to translate the Xbox 360 Far Cry 3 PowerPC executable into C++ for a planned Nintendo Switch port. It contains game-specific manifests, analysis and renderer adaptations; the documented PC build links but stops during boot at a guest-memory access.
- [fci-recomp: static recompilation of Far Cry Instincts and Evolution](https://awesomerea.org/resources/fci-recomp-case/index.md): Case study · fci-recomp builds Windows ports of the original Xbox games Far Cry Instincts and Far Cry Instincts: Evolution by translating their disc code to C ahead of time. A project runtime supplies Xbox kernel, graphics and audio behavior, while a reverse-engineering layer records symbols and game-system findings.
- [fefw-recomp: a static recompilation of Fire Emblem: Fortune's Weave](https://awesomerea.org/resources/fefw-recomp-case/index.md): Case study · fefw-recomp translates the Nintendo Switch 2 game Fire Emblem: Fortune's Weave into C++ for a native Windows port. Its AArch64 recompiler processes game modules, and a companion runtime supplies console services and Vulkan graphics. A launcher prepares the program from the user's decrypted game dump.
- [ff-recomp: Freedom Fighters statically recompiled for native hosts](https://awesomerea.org/resources/ff-recomp-freedom-fighters-case/index.md): Case study · ff-recomp statically translates the Windows x86 executable of Freedom Fighters into C for a native host runtime. The runtime loads the player's executable and game data, while shims supply Windows APIs, Direct3D 8, sound and input services. The author reports that the macOS build reaches the title screen; the PlayStation Vita build remains unfinished. Its function-rewrite plan uses Ghidra through ReVa and REA MCP servers.
- [FFTARecomp: static recompilation of Final Fantasy Tactics Advance](https://awesomerea.org/resources/fftarecomp-gba-static-recomp-case/index.md): Case study · Recompiles the user’s Final Fantasy Tactics Advance (USA) Game Boy Advance ROM ahead of time into native code for Windows, Linux and Steam Deck, building on JRickey’s gba-recomp toolkit. ARM and Thumb code is translated to C and compiled locally, while a Rust runtime models the console’s graphics, sound, DMA, timers and BIOS calls. The port adds widescreen, zoom, fast-forward and remappable controls.
- [FH2 Recompiled: static recompilation of Forza Horizon 2](https://awesomerea.org/resources/fh2-recompiled-case/index.md): Case study · FH2 Recompiled is a static recompilation of Forza Horizon 2 for the Xbox 360, targeting Android and Linux. The README says the repository and its release APKs contain no game files or game code.
- [FIFA 09 PC: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/fifa-09-pc-case/index.md): Case study · FIFA 09 PC translates the Xbox 360 release of FIFA 09 to native Windows code with the ReXGlue SDK. The repository provides game hooks, SDK patches, a launcher and file-format tools; online matches use NOBK.Online servers. Users generate game-derived code from their own matching disc files.
- [FIFA Street 2: an early Xbox static recompilation for Windows](https://awesomerea.org/resources/fifastreet2-recomp-case/index.md): Case study · fifastreet2-recomp attempts a native Windows port of the Xbox version of FIFA Street 2 through static recompilation with xboxrecomp. Its documented pipeline parses and disassembles the user's XBE, classifies functions, generates C, and starts a host runtime that reaches the recompiled entry point.
- [Final Fantasy Crystal Chronicles: Echoes of Time: a Wii static recompilation for PC](https://awesomerea.org/resources/pc-ffcceotwii-case/index.md): Case study · pc-ffcceotwii statically recompiles the European Wii release of Final Fantasy Crystal Chronicles: Echoes of Time into C++ for PC on the wiikit runtime. Game-specific tools name the stripped DOL using related executables and signatures, while an input layer maps keyboard and mouse controls to Wii Remote, Nunchuk and pointer actions. The author reports reaching gameplay.
- [Final Fantasy IX Recompiled: a PSXRecomp setup candidate](https://awesomerea.org/resources/final-fantasy-ix-recompiled-case/index.md): Case study · Final Fantasy IX Recompiled provides a title-specific setup candidate for rebuilding the PlayStation game with PSXRecomp and the recomp-ui launcher. Its wizard takes a user-supplied SLUS-01251 disc and specified European BIOS, then runs generation and rebuilding. The author reports that package setup and gameplay acceptance are still pending.
- [Final Fantasy Tactics Recompiled: a local PlayStation recompilation](https://awesomerea.org/resources/finfantac-recomp-case/index.md): Case study · Final Fantasy Tactics Recompiled uses PSXRecomp to generate and compile the USA PlayStation game's code from a user-supplied disc. Its setup kits target Windows, Linux and macOS and include a game-specific framework patch and optional 16:9 battle view. The author reports validation of the title, church scenes and first battle; full-game behavior remains untested.
- [Final Fantasy VIII Recompiled: a PlayStation setup and recompilation candidate](https://awesomerea.org/resources/final-fantasy-viii-recompiled-case/index.md): Case study · Final Fantasy VIII Recompiled packages a title-specific PSXRecomp recipe and recomp-ui setup host for building from the user's SLUS-00892 PlayStation disc. The candidate includes game configuration and seed functions; first-run setup and gameplay checks remain pending.
- [FireRedLeafGreenRecomp: recompiling Pokémon FireRed and LeafGreen for PC](https://awesomerea.org/resources/firered-leafgreen-recomp/index.md): Case study · This statically recompiles Pokémon FireRed and Pokémon LeafGreen, USA version 1.0, to native PC with gbarecomp. FireRed SHA-1 is 41cb23d8dccc8ebd7c649cd8fbb58eeace6e2fdc. LeafGreen SHA-1 is 574fa542ffebb14be69902d1d36f1ec0a4afd71e. The README says both games boot through the BIOS intro into gameplay. Code the static recompiler has not covered runs in an interpreter the first time, then is JIT-compiled and remembered.
- [flOw: static recompilation of the PS3 game for Windows](https://awesomerea.org/resources/flow-ps3-recomp-case/index.md): Case study · flOw lifts PowerPC functions from the PS3 game's EBOOT.elf to C and links them against ps3recomp host libraries for a Windows executable. The author reports a host-driven frame loop and D3D12 rendering through a host-side scene builder; the game state machine still blocks full gameplay.
- [FM4-Recomp: a Forza Motorsport 4 static recompilation](https://awesomerea.org/resources/fm4-recomp-case/index.md): Case study · FM4-Recomp statically recompiles the Xbox 360 release of Forza Motorsport 4 for Windows x64 using ReXGlue. Based on Pinyon Shift, it provides game-specific analysis configurations, runtime hooks, SDK patches and a disc-verifying launcher. Its 0.1.0 changelog reports a playable Windows preview.
- [FNC Reborn: a Fight Night Champion static-recompilation port](https://awesomerea.org/resources/fnc-reborn-case/index.md): Case study · FNC Reborn builds a Windows port of Fight Night Champion from the player's Xbox 360 disc using ReXGlue static recompilation. Its game-specific code adds frame-rate controls, a boxer-following camera and a settings tab, while its installer extracts the disc and builds the executable locally.
- [FNV-nx: an experimental Fallout: New Vegas PC-to-Switch recompilation](https://awesomerea.org/resources/fnv-nx-case/index.md): Case study · FNV-nx investigates a native Nintendo Switch port of Fallout: New Vegas by translating PC x86 code ahead of time and implementing Windows ABI services and a Vulkan graphics path. The repository documents Ghidra analysis and diagnostic tests; the author reports a Switch hardware test that reached the game menu and opening movie, while gameplay loading remains unverified.
- [Folklore: a PS3 static recompilation for Windows](https://awesomerea.org/resources/folklore-recompiled-case/index.md): Case study · Folklore statically recompiles the PS3 game's PowerPC and SPU code from a player-supplied disc into C++ and a native Windows executable. The port uses ps3recomp with project patches, reimplements the SPURS job system and renders through Direct3D 12. The author reports that it boots and plays on the author's PC, with rough edges.
- [Forza Horizon 2 Recompiled: an experimental Xbox 360 static recompilation](https://awesomerea.org/resources/forza-horizon-2-recompiled-case/index.md): Case study · Forza Horizon 2 Recompiled uses a vendored ReXGlue SDK to translate the Xbox 360 game's XEX code into C++ for a native Windows build. Game-specific hooks address two boot crashes; the author reports that the current build stalls at the loading screen while waiting on a kernel semaphore.
- [Forza Horizon 2: an experimental Xbox 360 recompilation for Android](https://awesomerea.org/resources/forza-horizon-2-android-recomp-case/index.md): Case study · Forza Horizon 2 Recomp Android targets an ARM64 Android port of the Xbox 360 game using XenonRecomp for PowerPC code and XenosRecomp for shaders. It contains a mobile runtime, JNI bridge, setup screen and touch HUD; the author reports offline translation of the executable and partial shader conversion, while gameplay integration remains unfinished.
- [Forza Motorsport 2 ReGPU: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/forza2-regpu-case/index.md): Case study · Forza Motorsport 2 ReGPU is a native Windows port of Forza Motorsport 2 for the Xbox 360. XenonRecomp statically recompiles the PowerPC executable to x64 C++, 51,034 functions, and a Direct3D 12 renderer replaces Xenos GPU emulation.
- [Forza Motorsport 3: Xbox 360 static recompilation for PC](https://awesomerea.org/resources/hl360-forza3-case/index.md): Case study · Forza Motorsport 3 is being statically recompiled from its Xbox 360 PowerPC executable into C++ for a native Windows port. ReXGlue generates the code, while the project supplies console services and a launcher that installs and checks data from the user's two discs.
- [Forza Motorsport 4: a native PC static recompilation](https://awesomerea.org/resources/forza-motorsport-4-native-pc-recompilation-case/index.md): Case study · Forza Motorsport 4 is brought to Windows by translating the Xbox 360 USA Rev 1 game's PowerPC code into C++ with ReXGlue. A project runtime supplies graphics, audio, input and storage services, while a launcher installs data from the player's discs and configures controls; the author reports local menu and race runs.
- [Free Riders Recompiled: a static recompilation of Sonic Free Riders](https://awesomerea.org/resources/free-riders-recompiled-case/index.md): Case study · Free Riders Recompiled ports the Xbox 360 version of Sonic Free Riders to Windows, Linux and Android by translating PowerPC code with XenonRecomp and Xenos shaders with XenosRecomp. Its native runtime replaces console kernel, graphics, audio, input and Kinect services, while a launcher installs game data from the user's disc image. The author reports working menus and playable races, with other content still incompletely explored.
- [FrontierVM 3: a 68000-to-native Frontier: Elite II port](https://awesomerea.org/resources/glfrontier-elite-ii-case/index.md): Case study · FrontierVM 3 translates a separately supplied 68000 disassembly of the Atari ST Frontier: Elite II into native C or i386 assembly. The repository includes assembler, disassembler and host code, plus an experimental OpenGL renderer alongside the original software rendering path.
- [Frontschweine Recompiled: a Hogs of War PlayStation recompilation](https://awesomerea.org/resources/frontschweine-recompiled-case/index.md): Case study · Frontschweine Recompiled translates the German PAL Hogs of War PlayStation code to C with psxrecomp and builds it as a Windows program. Game-specific symbols, overlay configuration and native plugin code support the port, while the translation and game data come from the owner's disc during local generation.
- [Fukami: a Ridge Racer V static-recompilation port](https://awesomerea.org/resources/fukami-ridge-racer-v-case/index.md): Case study · Fukami builds native Windows, Apple silicon macOS and Steam Deck versions of Ridge Racer V by translating its PS2 MIPS code to C++ ahead of time. Its runtime models PS2 timing and services, recompiles VU microcode and integrates a PCSX2-derived GS renderer, using the player's own disc image.
- [FuseRecomp: a native static recompilation of FUSE](https://awesomerea.org/resources/fuse-recomp-case/index.md): Case study · FuseRecomp statically recompiles the Xbox 360 game FUSE to native x86-64 for Windows and Linux using ReXGlue. Game-specific hooks and patches run with the user's extracted disc files, while configuration covers graphics, input and local split-screen play.
- [Future Cop: L.A.P.D.: a PlayStation static recompilation kit](https://awesomerea.org/resources/future-cop-lapd-recomp-case/index.md): Case study · Future Cop: L.A.P.D. configures PSXRecomp and a setup host to generate and compile the European PlayStation game locally from a user's disc and BIOS. The repository contains game identity, symbol seeds and build files; the author reports a Windows clean setup, compilation and headless start check.
- [Gears of War 2: a Windows static recompilation with a console runtime](https://awesomerea.org/resources/gears-of-war-2-pc-port-case/index.md): Case study · The Gears of War 2 PC port translates the user's Xbox 360 executable to C++ ahead of time with XenonRecomp and runs it on a Windows runtime with kernel and Direct3D 12 graphics components. Its game-specific notes map executable functions, data layouts and file formats; the author reports scripted coverage of all 29 campaign chapter entry points.
- [Gears of War 3: a native Windows recompilation](https://awesomerea.org/resources/gow3-recomp-case/index.md): Case study · This is an in-progress native Windows recompilation of retail Xbox 360 Gears of War 3. ReXGlue translates the player's default.xex from PowerPC to C++, which is compiled for x64. The GPU side uses ReXGlue's Xenos renderer on Direct3D 12.
- [Gears of War 3: a XenonRecomp PC port from the Xbox 360 disc](https://awesomerea.org/resources/gears-of-war-3-pc-port-case/index.md): Case study · Gears of War 3 — PC port builds a native Windows version from a user-owned Xbox 360 disc image. Its pipeline unpacks the XEX and translates PowerPC code to C++ with XenonRecomp, then runs it on a replacement kernel and Xenia graphics components. Research notes map functions, data layouts and game file formats.
- [Gears of War: Judgment for PC: an Xbox 360 static recompilation](https://awesomerea.org/resources/gears-of-war-judgment-pc-case/index.md): Case study · Gears of War: Judgment for PC translates the Xbox 360 game's PowerPC program to C++ ahead of time and compiles it as a native Windows application on ReXGlue. The port adds keyboard and mouse input, graphics options and save support; the author reports that early single-player campaign play works.
- [Genma Recomp: an Xbox port with REA investigations of Warlords HD](https://awesomerea.org/resources/genma-recomp-case/index.md): Case study · Genma Recomp statically translates the original Xbox Genma Onimusha executable to C++ for a native Windows port and experimental Linux build. Separate investigations use REA, Ghidra and Frida to examine controls and loading in the Onimusha: Warlords HD executable, with findings documented alongside the port.
- [gh3: statically recompiling Guitar Hero III for Windows](https://awesomerea.org/resources/gh3-guitar-hero-iii-case/index.md): Case study · gh3 statically recompiles the PS3 disc release of Guitar Hero III: Legends of Rock with ps3recomp for native Windows execution. Its build scripts lift the game, apply import handling and run it against the user's dumped disc; the author reports playable Quickplay songs while guitar input and timing work remain.
- [GHMetalRecomp: a Windows static recompilation of Guitar Hero: Metallica](https://awesomerea.org/resources/ghmetalrecomp-case/index.md): Case study · GHMetalRecomp statically recompiles the Xbox 360 Guitar Hero: Metallica executable for native Windows play using ReXGlue and the user's disc. Its game-specific code and launcher add controller and microphone support, display options and fixes described in per-issue engineering notes.
- [Ghost in the Shell: a PlayStation recompilation setup host](https://awesomerea.org/resources/ghost-in-the-shell-psxrecomp-case/index.md): Case study · Ghost in the Shell Recompiled is a PSXRecomp setup host for the European PlayStation game. The wizard accepts the user's CUE disc and BIOS, then generates and builds the translated code locally. The author records acceptance of a corrected Windows development build and leaves package setup, gameplay and save checks open.
- [GHVanHRecomp: a native Guitar Hero: Van Halen port](https://awesomerea.org/resources/ghvanhrecomp-case/index.md): Case study · GHVanHRecomp statically recompiles the Xbox 360 release of Guitar Hero: Van Halen into a native Windows port. Its launcher installs game data from the user's ISO, while the project supplies the runtime, renderer integration, controls and display adaptations. The author describes the current release as beta.
- [GLOVER-R: a native recompilation of Glover](https://awesomerea.org/resources/glover-r-case/index.md): Case study · GLOVER-R recompiles Glover for Windows and Linux from a user-supplied Nintendo 64 ROM, using a game-specific patch pipeline that checks hooks against original instructions. It adds widescreen rendering, frame interpolation, configurable controls and a modern camera. The author reports Windows gameplay testing; Linux and Steam Deck gameplay testing remains pending.
- [God Hand Recompiled: statically recompiling God Hand for Windows](https://awesomerea.org/resources/godhand-recomp/index.md): Case study · This recompiles God Hand for the PlayStation 2, USA SLUS-21503, into a Windows program with PS2Recomp. The README says play has been tested from the opening through stage 3, past the Gorilla Mask and Mad Midget Five fights, at 60 fps and 3x resolution. Later stages and the ending have not been played.
- [God of War II: an Android arm64 static recompilation build kit](https://awesomerea.org/resources/god-of-war-ii-android-case/index.md): Case study · God of War II is the target of an Android arm64 build kit that translates the PS2 game's Emotion Engine executable to C++ with PS2Recomp. The kit adds an Android host layer, an ISO importer and a raw Vulkan Graphics Synthesizer backend. The author reports that the APK builds, while boot, graphics, input and audio work on a physical device remains pending.
- [God of War II: static recompilation for Windows](https://awesomerea.org/resources/gow2-native/index.md): Case study · This statically recompiles God of War II for the PlayStation 2, NTSC-U SCUS-97481 v1.01, into a Windows executable with PS2Recomp. The function map has 6,607 functions, 76 Sony library stubs, and 240 hardware-register accesses. The current build reaches the first playable area, Rhodes, with sound, cutscenes at 30 fps, and memory-card save and load. The menu is reported at 60 fps, and combat in that area at about 44 to 59 fps.
- [God of War PS2 static recompilation: a native Windows port via PS2Recomp](https://awesomerea.org/resources/god-of-war-ps2-recomp-case/index.md): Case study · Statically recompiles the MIPS R5900 code of the NTSC-U PlayStation 2 God of War executable (SCUS-97399) to C++ with PS2Recomp and builds it as a native Windows program. Since October 2026 the port builds on Waffle565’s runtime, which replaces the PS2 hardware with native code: VU1 microprograms and, optionally, the game’s IRX modules are compiled ahead of time, and an OpenGL renderer stands in for the GS. The repository holds only the game-specific function map, recompiler configuration, overrides and runtime patches; the README reports gameplay on the opening ship level, with sustained 60 fps and a full playthrough still pending.
- [God of War — Native PC: static recompilation of the PS2 game](https://awesomerea.org/resources/gow-native-pc-case/index.md): Case study · God of War — Native PC is a native Windows port of God of War for the PlayStation 2, NTSC-U SCUS-97399, built by statically recompiling MIPS R5900 code to C++. The README also describes an experimental Linux and Steam Deck launcher and build pipeline.
- [God of War — Native Port: a PS2 static recompilation with native hardware services](https://awesomerea.org/resources/god-of-war-native-port-case/index.md): Case study · God of War — Native Port translates the NTSC-U PlayStation 2 game's executable into C++ with PS2Recomp and supplies native replacements for graphics, sound, input, memory cards, and other PS2 services. The repository provides configurations, overrides, code generators, build instructions, and zone tests for its Windows port.
- [God of War — Tobiichi Port: statically recompiling God of War for PC](https://awesomerea.org/resources/tobiichi-gow-case/index.md): Case study · God of War — Tobiichi Port is a native Linux and Windows port of God of War for the PlayStation 2, NTSC-U SCUS-97399. The game's MIPS code is statically recompiled to C++ with PS2Recomp. Rendering uses OpenGL, and the launcher uses Qt 6.
- [God of War: Ascension — static recompilation of the PS3 game](https://awesomerea.org/resources/god-of-war-ascension-recompiled-case/index.md): Case study · Statically recompiles God of War: Ascension's PS3 code into a native Windows executable with ps3recomp's PPU and SPU lifters. The repository supplies game-specific runtime hooks, analysis scripts and build guidance; users provide their own game dump and decrypted ELF. The author describes the result as an early, nonplayable research build.
- [God of War: Chains of Olympus: an experimental PSP hybrid recompilation](https://awesomerea.org/resources/god-of-war-chains-of-olympus-hybrid-recomp-case/index.md): Case study · The God of War: Chains of Olympus project combines game-specific ahead-of-time translated Allegrex blocks with an interpreter fallback for PSP code. Its runtime implements partial PSP system services, graphics display lists and SDL2 audio, while diagnostic logs and traces track the game's startup and rendering behavior.
- [God of War: statically recompiling the 2005 PlayStation 2 game for PC](https://awesomerea.org/resources/gow-2005-pc/index.md): Case study · This port statically recompiles the USA PlayStation 2 game God of War, product SCUS-97399, into C++. A Rust recompiler translates the MIPS code. The Windows launcher or portable zip runs a setup wizard that reads the ISO or a CHD, extracts the disc, and builds gow-2005. Linux install.sh, a deb, and an AppImage are experimental. The renderer is OpenGL 4.6, from 1x to 8x internal resolution. The game logic stays at 60 Hz, with 120 and experimental 240 frame-rate limits. Saves use a PCSX2-compatible Mcd001.ps2 card.
- [Goemon 64: Recompiled — a native Mystical Ninja Starring Goemon port](https://awesomerea.org/resources/goemon64-recomp/index.md): Case study · Goemon 64: Recompiled statically recompiles the North American Nintendo 64 release of Mystical Ninja Starring Goemon. The menu loads assets from that ROM, including .z64 and other formats of the same image. Rendering uses RT64. A Direct3D 12 Shader Model 6, Vulkan 1.2, or Metal Argument Buffers Tier 2 GPU is required. x86-64 also needs SSE4.1. macOS 13 or newer covers Apple Silicon and Intel 7th-generation CPUs. ARM64 builds run on ARM64 CPUs. Build steps are in BUILDING.md.
- [Golden Sun Recompiled: native ports of two GBA games](https://awesomerea.org/resources/golden-sun-recompiled-case/index.md): Case study · Golden Sun Recompiled builds native Windows and Linux ports of Golden Sun and Golden Sun: The Lost Age from user-supplied GBA ROMs. A modified gbarecomp engine translates ARM and Thumb code to C++, while separate game configurations and shared port code support both titles.
- [GoldenEye 007 PC Recompilation: an Xbox 360 game port](https://awesomerea.org/resources/goldeneye-360-recomp-case/index.md): Case study · GoldenEye 007 PC Recompilation ports the Xbox 360 version of GoldenEye 007 to a native PC executable using ReXGlue. The repository contains game-specific hooks and patches, plus keyboard and mouse, graphics and online-play support. The player supplies the game files in an assets folder.
- [GoldenEye 007: Reloaded — Xbox 360 static recompilation for PC](https://awesomerea.org/resources/goldeneye-007-reloaded-recomp/index.md): Case study · This recompiles GoldenEye 007: Reloaded for the Xbox 360, 2011, to native PC with ReXGlue. The PowerPC code is translated to C++. The README says it boots to the main menu and that training and the first mission play. The expected retail dump has title ID 415608AF, media ID 40583A82, module hash 065D6021C0BDD535, and XEX timestamp 4E88BBE7.
- [GoldenEye Metal: an Xbox 360 recompilation with native Metal rendering](https://awesomerea.org/resources/goldeneye-metal-case/index.md): Case study · GoldenEye Metal ports GoldenEye 007's Xbox 360 game code to Apple Silicon Macs through ahead-of-time ARM64 recompilation. Its compatibility runtime supplies Xbox 360 APIs, and its Metal backend translates Xenos shaders and renders the game's GPU commands.
- [GoldenEye64Recomp: a macOS and Linux static recompilation port](https://awesomerea.org/resources/goldeneye64-recomp-case/index.md): Case study · GoldenEye64Recomp ports the GoldenEye 007 recompilation to macOS and Linux with N64Recomp and RT64, using a user-supplied Nintendo 64 ROM. A standard build generates game code during compilation; a clean build recompiles functions in memory at launch. The project documents platform changes and fixes to runtime messaging, rendering and recompilation behavior.
- [GoldenPad: GoldenEye 007 rebuilt for Apple devices](https://awesomerea.org/resources/goldenpad-case/index.md): Case study · GoldenPad runs GoldenEye 007 on iPhone, iPad and Apple Silicon Mac using statically recompiled game code from GoldenEye64Recomp. Its Apple host adds touch and controller input, saves and audio, while RT64 presents graphics through Metal. Users generate the game-bearing build from their own US retail ROM.
- [GoldenRecomp: statically recompiling GoldenEye 007](https://awesomerea.org/resources/goldenrecomp/index.md): Case study · GoldenRecomp is a recompilation of GoldenEye 007 built with a modified N64Recomp. It needs ge007.tlbfree.elf and ge007.tlbfree.z64 from the TBLFREE_NOCOMPRESSION branch of kholdfuzion/goldeneye_src. That branch removes the TLB and leaves the ROM decompressed, so a console build of the ROM needs 8 MB of RAM. N64Recomp.exe us.toml and RSPRecomp.exe aspMain.us.toml generate the code. Visual Studio then builds GoldenRecomp.exe. The reviewed page says the game runs stably and the sound works. Multiplayer UI, the dam and frigate sky and water, and some weapon fire rates are still open.
- [Gow2HD-Windows: a Windows static recompilation of God of War II HD](https://awesomerea.org/resources/gow2hd-windows-case/index.md): Case study · Gow2HD-Windows translates the PPU and SPU code of the PS3 release of God of War II HD into C/C++ for a Windows x64 build. A PS3 library reimplementation supplies Direct3D 12 rendering, WASAPI audio and XInput or keyboard input, while the launcher builds from the user's game files.
- [Gran Turismo 5 Prologue Recompiled: a PS3 boot investigation](https://awesomerea.org/resources/gran-turismo-5-prologue-recompiled-case/index.md): Case study · Gran Turismo 5 Prologue Recompiled lifts the PS3 game's PowerPC code with ps3recomp and builds a native Windows x86-64 executable. Game-specific scripts cover SELF decryption, function discovery, SPU workloads and a longjmp patch. The author reports repeatable loading of 116 assets during boot, before any frame is drawn.
- [Grand Theft Auto: a Windows static recompilation of the 1997 game](https://awesomerea.org/resources/grand-theft-auto-1997-recomp-case/index.md): Case study · Grand Theft Auto translates the 1997 Windows game's x86 executable into C and links it with modern replacements for Win32, DirectDraw and sound services. The repository supplies a runtime, import bridges and analysis tools; the author reports that the translated game reaches its title screen and city-selection menu. Related executables for GTA London and GTA2 are also investigated.
- [GT2 RecompOne: Gran Turismo 2 static recompilation with multiplayer](https://awesomerea.org/resources/gt2-recompone-case/index.md): Case study · GT2 RecompOne translates Gran Turismo 2's PlayStation MIPS code into C# ahead of time and runs it as a .NET program with replacement console services. Game-specific hooks and symbol maps support an added multiplayer mode with LAN discovery, direct UDP connections and a relay.
- [GT5 Native Recomp: an early Gran Turismo 5 static recompilation](https://awesomerea.org/resources/gt5-native-recomp-case/index.md): Case study · GT5 Native Recomp is an early static recompilation of Gran Turismo 5 for Windows x86-64. Its pipeline lifts PS3 PPU and SPU code ahead of time into a native runtime that supplies PS3 services and uses Vulkan for RSX commands; the author reports reaching audio and controller initialization without a game frame.
- [GTA IV Recompiled: an Xbox 360 static recompilation](https://awesomerea.org/resources/gta-iv-recompiled-case/index.md): Case study · GTA IV Recompiled translates the Xbox 360 version of Grand Theft Auto IV from PowerPC code to C++ ahead of time with rexglue and builds a native Windows program. Its configurations add constructor, callback and thunk entry points, while its notes trace a failure in streamed static world collision. The author reports that the game reaches interactive play, although the player falls through the ground.
- [Guitar Hero II Recompiled: an Xbox 360 static recompilation](https://awesomerea.org/resources/guitar-hero-ii-xbox-recomp-case/index.md): Case study · Guitar Hero II Recompiled translates the Xbox 360 game's executable to native C++ with XenonRecomp and ReXGlue, then builds a Windows program with D3D12 graphics. The repository contains game-specific extraction tools, analysis notes and runtime hooks; the author reports playable menus and gameplay.
- [Guitar Hero II: a proof-of-concept Xbox 360 recompilation](https://awesomerea.org/resources/gh2-recomp/index.md): Case study · This is a proof-of-concept recompilation of Guitar Hero II for the Xbox 360, using the ReXGlue SDK. The README says performance is poor and the build is prone to crashes.
- [Guitar Hero III: Legends of Rock — Recomp: Xbox 360 code on PC and Android](https://awesomerea.org/resources/guitar-hero-iii-recomp-case/index.md): Case study · Guitar Hero III: Legends of Rock — Recomp translates the Xbox 360 game's PowerPC code to C++ for PC and Android builds using a ReXGlue-derived toolchain. It keeps generated code local to the user's disc, adds a launcher that checks the executable hash, and documents the QB script archive format used for translation work.
- [Halo 3 Delta: reconstructing halo3_cache_release.xex](https://awesomerea.org/resources/halo3-cache-release-recomp-case/index.md): Case study · The Halo 3 Delta project targets halo3_cache_release.xex from build 08172.07.03.08.2240.delta for ReXGlue-based recompilation. The repository contains C++ game source modules and a CMake configuration that includes them in the executable target.
- [HaloPad: Halo on Apple devices through a decompilation port and x86 recompilation](https://awesomerea.org/resources/halopad-project-reach-case/index.md): Case study · Brings Halo: Combat Evolved to iPhone, iPad and Apple silicon Macs through two engines. The Xbox edition builds a pinned OpenCE port of the community Xbox decompilation, while Custom Edition translates the user’s own haloce.exe 1.10 from x86 to ARM64 ahead of time, with HaloPad supplying Windows, Direct3D 9, input, audio and network services. The project discloses substantial AI assistance and records device results in a status log.
- [Harvest Moon 64 PC Port / Recomp: a work-in-progress native build](https://awesomerea.org/resources/aitdd-harvest-moon-64-recomp-case/index.md): Case study · Harvest Moon 64 PC Port / Recomp uses N64Recomp and RT64 to build a native port of Harvest Moon 64 from locally provided ROM and ELF files. The author reports playable boot, audio, input and SRAM saves, and documents fixes for controller input, save type and display flicker.
- [Harvest Moon 64: Recompiled — native port](https://awesomerea.org/resources/harvest-moon-64-recomp-case/index.md): Case study · Harvest Moon 64: Recompiled uses N64: Recompiled to statically recompile Harvest Moon 64 into a native port, with RT64 for rendering. The README lists mod support and Linux and Steam Deck support among its features.
- [Haze Recomp: an experimental PlayStation 3 static recompilation](https://awesomerea.org/resources/haze-recomp-case/index.md): Case study · Haze Recomp uses ps3recomp to lift the PlayStation 3 game Haze and supporting firmware code into a native Windows build from a user-supplied disc image. Its scripts handle disc extraction, executable decryption, PPU and SPU translation, and runtime building. The author reports working menus, opening-scene gameplay, audio and checkpoint saves, while campaign coverage remains in development.
- [Heavy Metal: FAKK2: an x86-to-C static recompilation](https://awesomerea.org/resources/heavy-metal-fakk2-recomp-case/index.md): Case study · Heavy Metal: FAKK2 lifts the original Windows game executable from x86 instructions to compilable C and builds a native 32-bit Windows program. Its pipeline discovers functions, maps the original image addresses, and bridges Win32 imports and callbacks; the author reports that engine initialization reaches a runtime fault before rendering.
- [Hell Night: Dark Messiah Recompiled: a PlayStation PC build](https://awesomerea.org/resources/hellnight-recompiled-case/index.md): Case study · Hell Night: Dark Messiah Recompiled builds a native PC version of the European PlayStation game Hellnight by generating game code locally with PSXRecomp. It supplies disc identity settings, a setup launcher and patches for video positioning, tiled filtering and supersampling; the author reports early gameplay and save/load checks on Windows.
- [Hell's Gate: a static recompilation of Dante's Inferno](https://awesomerea.org/resources/hells-gate-recomp/index.md): Case study · PC port of Dante's Inferno from the Xbox 360, built with the ReXGlue SDK. The README says the PowerPC executable is translated ahead of time into portable C++ and compiled into a native program. It says the project replaces the game's Direct3D layer with its own renderer.
- [hl2-recomp: statically recompiling Xbox Half-Life 2](https://awesomerea.org/resources/half-life-2-xbox-recomp-case/index.md): Case study · hl2-recomp translates the Xbox Half-Life 2 XBE to C with xboxrecomp and links it to a native Windows runtime. Its game-specific tools recover RTTI classes, function boundaries and datamaps, while technical notes trace boot, controller and NV2A rendering paths; the author reports a title screen and partial level loading.
- [Hobbit Recompiled: an Apple Silicon recompilation of LEGO The Hobbit](https://awesomerea.org/resources/hobbit-recompiled-case/index.md): Case study · Hobbit Recompiled translates the 32-bit Intel Mac release of LEGO The Hobbit into C and builds an Apple Silicon app. Its analysis records functions, imports and switch tables. The runtime replaces macOS imports and uses SDL2 in place of the game's Cocoa front end; setup reads the player's Steam copy.
- [Hookshot: static recompilation of the Switch 2 Ocarina of Time remake](https://awesomerea.org/resources/hookshot-oot-switch2-case/index.md): Case study · Hookshot statically recompiles the Switch 2 remake of The Legend of Zelda: Ocarina of Time into a native Windows or Linux program using the user's game files. Its pipeline lifts AArch64 game code to C, implements Horizon OS and NVN2 natively, and renders GPU work with Vulkan.
- [HotelMarioRecomp: an early Philips CD-i static recompilation](https://awesomerea.org/resources/hotel-mario-cdi-recomp-case/index.md): Case study · HotelMarioRecomp builds a native Hotel Mario program on the cdirecomp static-recompilation engine using a locally supplied CD-i BIOS and game disc image. Its game-specific build configuration generates modules and sets runtime checks; the author reports clearing the first three Hotel 1 stages, while full campaigns remain unverified.
- [Hover!: statically recompiling the Windows 95 game to native C](https://awesomerea.org/resources/hover-static-recompilation-case/index.md): Case study · Hover! statically recompiles the Windows 95 game Microsoft Hover! from the owner's HOVER.EXE into generated C and builds a 32-bit native host. Its pcrecomp pipeline catalogs functions, lifts game code and binds Windows imports; the author reports playable level-one runs and conformance checks, while host code adds presentation and multiplayer features.
- [HPCOS GC: Harry Potter and the Chamber of Secrets recompiled for PC](https://awesomerea.org/resources/hpcos-gc-recomp-case/index.md): Case study · HPCOS GC uses DolRecomp to translate the GameCube PowerPC code of Harry Potter and the Chamber of Secrets for a native PC runtime based on ModernGekko. Its title-specific additions include dynamic widescreen, field-of-view controls and a PC settings menu; subsequent development moved to GekkoAOT.
- [Hybrid Heaven: a native port through N64 static recompilation](https://awesomerea.org/resources/hybrid-heaven-recompiled-case/index.md): Case study · Hybrid Heaven: Recompiled ports the N64 game to Windows, Linux and Android by statically recompiling its code with N64: Recompiled. It uses N64ModernRuntime and RT64 for execution and rendering, and loads game data from the user's USA retail ROM.
- [Hybrid Heaven: Recompiled: a native N64 port](https://awesomerea.org/resources/hybrid-heaven-n64-port-case/index.md): Case study · Hybrid Heaven: Recompiled statically recompiles the USA release of Hybrid Heaven with N64Recomp into a Windows and Linux port. It supplies game-specific code loading, widescreen presentation and controller support; the author reports progress through the first battles.
- [HydroThunderPORT: recompiling Hydro Thunder Hurricane for PC](https://awesomerea.org/resources/hydro-thunder-port/index.md): Case study · This is a Windows and Linux port of Hydro Thunder Hurricane, release BETA 1.1 (1.1.0), in Standard and PGO builds. It uses ReXGlue for static recompilation and Vulkan for rendering. The Windows launcher is Launcher-Config.exe, and the game is HydroThunder.exe. Linux releases are an AppImage. The README says the 0.0.2.1 title-update configuration is supported. Generated game code is not in the repository.
- [I COULD HAVE GIVEN YOU THE WORLD: a native 007 N64 port](https://awesomerea.org/resources/i-could-have-given-you-the-world-case/index.md): Case study · I COULD HAVE GIVEN YOU THE WORLD ports the N64 game 007: The World Is Not Enough to PC and Steam Deck. Its first launch compiles native game code locally from the user's ROM; the project adds widescreen rendering, modern controls and save features.
- [Imabikisō: an experimental PS3-to-PC static recompilation](https://awesomerea.org/resources/imabikiso-pc-recompilation-case/index.md): Case study · Imabikisō uses ps3recomp to run locally generated PS3 game code as a Windows program. Its repository adds runtime patches, a native runner and tools for extracting, inspecting and patching script archives; the author reports rendering the opening and first classroom text.
- [In Cold Blood Recompiled: a PlayStation setup host](https://awesomerea.org/resources/in-cold-blood-recompiled-case/index.md): Case study · In Cold Blood Recompiled configures PSXRecomp and recomp-ui to generate a native build from the user's PlayStation disc. It includes title configuration, symbol seeds and a setup host. The author reports gameplay in a private package, while exact-package setup and release gates remain open.
- [inFAMOUS 2: a static recompilation for Apple-silicon macOS](https://awesomerea.org/resources/infamous2-macos-recomp-case/index.md): Case study · inFAMOUS 2 translates the PS3 digital release NPUA80638's PowerPC and SPU code to C/C++ and compiles it into a native Apple-silicon macOS game with Metal graphics. Built on ps3recomp and a community fork, the port rebuilds from the player's own copy. The author reports menus, cutscenes, and early New Marais gameplay in an alpha build.
- [inFAMOUS 2: recompiling the PS3 game for Linux](https://awesomerea.org/resources/infamous2-pc/index.md): Case study · This recompiles inFAMOUS 2 for the PlayStation 3, BCUS98125 version 01.00, to native Linux with ps3recomp. PowerPC and SPU code are translated to C, and the game's RSX shaders run on Vulkan. The README says play continues from Empire City to New Marais, with sound, controls, saves, and a Portuguese dub.
- [inFamous PC: a PlayStation 3 static recompilation for Windows](https://awesomerea.org/resources/infamous-pc-case/index.md): Case study · inFamous PC builds a native Windows port of the European PlayStation 3 release of inFamous by statically recompiling its PPU and SPU code with ps3recomp. Its installer reads the player's disc, generates the code, applies game-specific patches and compiles the result.
- [Infinite Undiscovery Recomp: native Xbox 360 game recompilation](https://awesomerea.org/resources/infinite-undiscovery-recomp-case/index.md): Case study · Infinite Undiscovery Recomp is a native Windows x64 recompilation of Infinite Undiscovery for Xbox 360 (2008), built with ReXGlue and XenonRecomp. The public release candidate is v1.0.0-rc1. The README says development is frozen.
- [Initial D Arcade Stage 3: experimental NAOMI 2 static recompilation](https://awesomerea.org/resources/initial-d-arcade-stage-3/index.md): Case study · This is an experimental static recompilation of Initial D Arcade Stage 3 for NAOMI 2, disc GDS-0033, aimed at 64-bit Windows. The reviewed public demo is v2489. Its zip SHA-256 is 6AF00678196E9E54AC1C625866D08D2CD9855D0F43866B5DE1EDCBD7DCE0EF93. The launcher takes gds-0033.chd and 317-0384-com.pic, checks them, and extracts what the recompilation needs. The executable is BIOS-free and renders submitted ELAN/PVR work with Vulkan. The default mode is 60 Hz. First-run extraction needs about 1.3 GB of temporary space.
- [International Rally Championship: an x86-to-C native recompilation](https://awesomerea.org/resources/international-rally-championship-recomp-case/index.md): Case study · ircrecomp statically translates International Rally Championship's RAL.EXE x86 functions into C and compiles a native 64-bit Windows game from the user's CD image. An SDL3 runtime replaces Windows 98 and DirectX 5 interfaces; analysis covers code discovery, relocations and jump tables.
- [iPod Click Wheel Recomps: statically recompiling six iPod games](https://awesomerea.org/resources/ipod-clickwheel-recomps/index.md): Case study · iPod Click Wheel Recomps translates six iPod click-wheel games from their ARM code into C++ that builds on current hardware. Mini Golf, Cubis 2, Hold 'Em, and the other listed games share a runtime. Mini Golf also targets Nintendo Switch and Android.
- [IsaacRecomp: translating Flash game bytecode to native C++](https://awesomerea.org/resources/isaacrecomp-case/index.md): Case study · Translates The Binding of Isaac’s Flash AVM1 bytecode into C++ functions and supplies a native rendering/input runtime. The project reads graphics and audio from the user’s original game and documents deterministic input, headless runs and screenshot regression checks.
- [ISSD Native: recompiling International Superstar Soccer Deluxe](https://awesomerea.org/resources/issd-native/index.md): Case study · ISSD Native recompiles International Superstar Soccer Deluxe for the Super Nintendo, USA release, into C. The supported dump is a headerless SFC of 2,097,152 bytes, internal title SUPERSTAR SOCCER 2, SHA-256 d2fe66c1ce66c65ce14e478c94be2e616f9e2cad374b5783a6a64d3c1a99cfa9. Release v0.6.0-beta.1 covers Windows, Linux, Steam Deck, and Android 8.0 or newer. Gameplay advances at 60 Hz.
- [Jade Empire: a native port by x86-to-Odin static recompilation](https://awesomerea.org/resources/jade-empire-recomp-case/index.md): Case study · A native Jade Empire: Special Edition port statically translates the user's x86 game executable into Odin. It replaces Windows, Direct3D 9, DirectSound and Bink services with SDL3, OpenGL and FFmpeg and adds controller support and two-player co-op.
- [James Pond 2: Codename RoboCod — an Amiga static recompilation](https://awesomerea.org/resources/james-pond-2-robocod-recomp-case/index.md): Case study · James Pond 2: Codename RoboCod — Recompiled turns the Amiga game's 68000 instructions into native C++ using a user-provided disk image. Its runtime models Amiga memory, display, audio, and disk behavior, with an interpreter for code the recompiler has not reached; the port also adds widescreen rendering and save controls.
- [Jet Force Gemini Recomp: a native Windows recompilation](https://awesomerea.org/resources/jet-force-gemini-recomp-case/index.md): Case study · Jet Force Gemini Recomp provides a native Windows x64 recompilation of the Nintendo 64 game that loads game data from an imported North American ROM. It includes a rendering, audio and save runtime, a launcher and optional modern controls. The author reports a campaign verification run using testing mods and a prepared save; console accuracy remains under validation.
- [Jet Force Gemini: Recompiled — an N64 static recompilation port](https://awesomerea.org/resources/jet-force-gemini-recompiled-case/index.md): Case study · Jet Force Gemini: Recompiled translates the US N64 game's code from a user-supplied ROM into C with N64Recomp and runs it with N64ModernRuntime and RT64. The native port supports Windows, Linux and Steam Deck, with revised controls, display options and mod loading. The repository also contains game-specific source and build scripts.
- [Jet Moto 2 Recompiled: a PlayStation game statically recompiled for PC](https://awesomerea.org/resources/jet-moto-2-recompiled-case/index.md): Case study · Jet Moto 2 Recompiled turns the PlayStation release of Jet Moto 2: Championship Edition into a native Windows program by translating its MIPS code with RecompOne from the user's disc. It provides overlay function maps and patches for CD status, GPU readback, frame pacing, steering and widescreen rendering.
- [Juiced 2 Recompiled: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/juiced-2-recompiled-case/index.md): Case study · Juiced 2 Recompiled builds a native Windows port of the Xbox 360 Juiced 2: Hot Import Nights by statically translating the user's executable with ReXGlue. It supplies a game-specific function fix list, SDK patches for code generation, texture layout and music, and a launcher with a heap workaround. The author reports that the preview boots, plays through Career league 7 and saves, while graphics and performance faults remain.
- [Juiced: static recompilation of the Windows game executable](https://awesomerea.org/resources/juiced-recomp-case/index.md): Case study · Juiced documents an x86-32 static recompilation of the 2005 Windows game executable into portable C using pcrecomp. Ghidra analysis, PE-section findings, build scripts, a runtime entry point and differential-test work accompany the pipeline. The original executable and generated lifted units stay outside the repository.
- [JUS Decomp: a native port of the Nintendo DS game JUS](https://awesomerea.org/resources/jus-decomp-case/index.md): Case study · JUS Decomp statically recompiles the Nintendo DS game JUS into a native Windows and Linux port using ndsrecomp and a ROM supplied by the player. Its repository includes ARM9 and ARM7 decompilation metadata, runner patches, a reference-checking pipeline and runtime mod support.
- [KameoRecomp: a Windows static recompilation of Kameo](https://awesomerea.org/resources/kameorecomp-case/index.md): Case study · KameoRecomp ports the Xbox 360 game Kameo: Elements of Power to Windows by statically translating its code to C++ and compiling it with the ReXGlue SDK. A Vulkan renderer draws the game's graphics calls, while a launcher installs the required files from the user's ISO. The release adds widescreen display and higher frame-rate options.
- [KartPad: platform integration for a Mario Kart Wii recompilation](https://awesomerea.org/resources/kartpad-case/index.md): Case study · Builds Apple and Android integration around WiiCompiled’s ahead-of-time translation of Mario Kart Wii, with native graphics, input and optional Retro Rewind support. Its status and rights documents distinguish platform acceptance, unresolved device defects and game-content requirements.
- [Killzone for Windows: native port of the PS2 game](https://awesomerea.org/resources/killzone-recomp-case/index.md): Case study · Killzone for Windows is a native Windows port of Killzone for the PlayStation 2. The README says the game's code is recompiled to C++ with PS2Recomp and runs with mouse and keyboard aim, high frame rates, higher resolutions, and ultrawide support.
- [Killzone: Liberation — Windows static recompilation](https://awesomerea.org/resources/killzone-liberation-recomp/index.md): Case study · This Windows static recompilation of Killzone: Liberation targets the US v1.20 image UCUS-98646. That image is 568,498,176 bytes, SHA-1 5bc4fc8cd8d72c9c2e7c1c03a4325a29bed6e69a. The Redump retail USA disc is a different image: 581,632,000 bytes, SHA-1 dda1a72c28ccdd8ddd2f3cbfd2fa3188962b0458. extract.py checks the image, gen.py writes the translated C, and cmake --preset clang-cl builds kzl_driver. The boot path rechecks the ISO size and SHA-1.
- [King Kong Recompiled: an AI-developed Xbox 360 static recompilation](https://awesomerea.org/resources/king-kong-recompiled-case/index.md): Case study · Translates the Xbox 360 release of Peter Jackson's King Kong into native Windows code with the ReXGlue static-recompilation SDK, adding a launcher and display, control and graphics options. Project code completes streamed disc reads the way the console does, which README credits with getting past an opening freeze seen under Xenia. The author discloses that the port was made almost entirely with Claude Code, directed and tested by the repository owner.
- [King's Field 2: a PS1 static recompilation for PC](https://awesomerea.org/resources/kings-field-2-pc-case/index.md): Case study · King's Field PC ports King's Field 2 from PlayStation to PC through PS1Recom MIPS-to-C static recompilation. Its game-function sources run with a PsyX-based PlayStation compatibility layer, CD handling and keyboard, mouse and gamepad input.
- [Kirby 64: Recompiled — a ROM-based native port](https://awesomerea.org/resources/kirby-64-recompiled-case/index.md): Case study · Kirby 64: Recompiled builds a native executable for Kirby 64 from a user-provided NK4E.z64 ROM. The repository includes C++ host code and a build configuration, and directs users to build with Make and Clang.
- [Know Your Role Recomp: a native PlayStation wrestling game port](https://awesomerea.org/resources/know-your-role-recomp-case/index.md): Case study · Know Your Role Recomp builds a native Windows port of the 2000 PlayStation wrestling game from the user's NTSC-U disc image. RecompOne translates the game's MIPS code to C#, and its runtime replaces graphics, sound, CD-ROM, controller and BIOS services. The author reports reaching all 14 disc programs in testing.
- [Konami Viper: statically recompiling Thrill Drive 2 and GTI Club 2](https://awesomerea.org/resources/konami-viper-recomp-case/index.md): Case study · Konami Viper statically recompiles PowerPC code from Thrill Drive 2 and GTI Club 2 arcade dumps into C for native executables. Its shared runtime models the Viper board's Voodoo3 graphics, sound, I/O, CF card and timekeeper, with game profiles for several regional versions.
- [Koudelka Recompiled: a local PlayStation recompilation setup host](https://awesomerea.org/resources/koudelka-recompiled-case/index.md): Case study · Koudelka Recompiled configures psxrecomp and a setup host to build the PlayStation game from a user's disc image. Its research records four European disc identities with one shared boot program; the author reports a clean Windows package build and earlier Disc 1 gameplay.
- [L4D PC Recomp: a Left 4 Dead Xbox 360 boot harness](https://awesomerea.org/resources/l4d-pc-recomp-case/index.md): Case study · L4D PC Recomp uses XenonRecomp to lift Left 4 Dead's Xbox 360 PowerPC modules into C++ for a Windows x64 boot harness. The repository provides per-module configs, a guest-memory arena, dispatch table and kernel stubs. Its documented progress reaches launcher and filesystem initialization; rendering and gameplay remain unfinished.
- [LARecomp: statically recompiling Midnight Club: Los Angeles](https://awesomerea.org/resources/larecomp-case/index.md): Case study · LARecomp statically recompiles the Xbox 360 release of Midnight Club: Los Angeles Complete Edition into native C++ for Windows with ReXGlue. Game-specific hooks adjust frame timing, camera behavior and presentation, while technical notes document disassembly and runtime measurements behind the changes.
- [LASRecomp: Link’s Awakening static recompilation](https://awesomerea.org/resources/lasrecomp/index.md): Case study · A native desktop reconstruction of the 2019 Switch version of Link’s Awakening using static recompilation. The author attributes most code, tooling and reverse-engineering work to Claude Code with human direction and review.
- [Lazarus: a Mass Effect 2 static recompilation for Nintendo Switch](https://awesomerea.org/resources/lazarus-mass-effect-2-case/index.md): Case study · Lazarus translates the Xbox 360 version of Mass Effect 2 with Title Update 2 from PowerPC code into C++ for Nintendo Switch. It converts Xenos shaders ahead of time and uses a deko3d renderer that handles the game's Direct3D calls. The repository includes game-specific hooks, native function replacements and build documentation for user-supplied discs.
- [Legendary Wings: a ROM-local NESRecomp Windows port](https://awesomerea.org/resources/legendary-wings-nes-to-pc-case/index.md): Case study · Legendary Wings NES to PC builds a native Windows port by running NESRecomp on a user-supplied Legendary Wings ROM and compiling game-specific C code. It adds presentation, animation and collision hooks; the remastered artwork currently concentrates on the first level.
- [LegendOfZeldaNESRecomp: static recompilation of The Legend of Zelda](https://awesomerea.org/resources/zelda-nes-recomp/index.md): Case study · LegendOfZeldaNESRecomp is a static recompilation of The Legend of Zelda for the NES, built with nesrecomp and described as an in-development preview. The Windows quick start asks for a Legend of Zelda (USA) ROM, and the cycle build uses the original USA PRG0 ROM. Project code covered by the README is under the PolyForm Noncommercial License 1.0.0.
- [Let's Go Recomp: statically recompiling Pokémon Let's Go for Windows](https://awesomerea.org/resources/lets-go-recomp-case/index.md): Case study · Let's Go Recomp ports the Nintendo Switch games Pokémon: Let's Go, Eevee! and Let's Go, Pikachu! to Windows through static recompilation. It translates their ARM64 code to C and provides a runtime for Switch services, NVN graphics through Vulkan, audio and controllers. The build uses the player's extracted game files.
- [Libre40: a static-recompilation port of Army of Two: The 40th Day](https://awesomerea.org/resources/libre40-case/index.md): Case study · Libre40 builds a native Windows host for the Xbox 360 release of Army of Two: The 40th Day using ReXGlue static recompilation. Its extraction and code-generation scripts use the player's disc image to produce local game files and recompiled source; the author reports playable single-player gameplay.
- [Link's Awakening DX: static recompilation of the Game Boy Color ROM](https://awesomerea.org/resources/links-awakening-dx-static-recomp-case/index.md): Case study · LinksAwakening converts a user-supplied The Legend of Zelda: Link's Awakening DX Game Boy Color ROM into C and builds a native Windows program. It uses gb-recompiled for code translation and runtime support, with an interpreter fallback for unresolved jumps and tools that compare hardware traces against SameBoy.
- [Little Planet: Sonic CD recompiled from a matching disassembly](https://awesomerea.org/resources/little-planet-sonic-cd-recomp-case/index.md): Case study · Disassembles every executable file on the Sonic CD disc from runtime coverage and recursive descent, reassembles them byte-identically, and translates the code statically to C on a from-scratch Mega-CD runtime that replaces the BIOS with a high-level implementation. Recompiled blocks run only where memory still holds the code they came from, and a script compares 96 stage runs frame by frame against the interpreter. The project also patches in widescreen and per-zone saves; results remain project-reported.
- [Live & Recompiled: recompiling Conker: Live & Reloaded for PC](https://awesomerea.org/resources/conker-live-recompiled/index.md): Case study · Live & Recompiled is a native Windows and Linux port of the original Xbox game Conker: Live & Reloaded, built on Xbox XBE Recomp. It renders with Vulkan and supports single-player and multiplayer. The supported USA disc default.xbe has SHA-1 2232a1b3874d67b4bb4cf53a940420d2dab59535. The Microsoft Store backwards-compatible release is also accepted.
- [LMA Manager 2007: an Xbox 360 static recompilation in Rust](https://awesomerea.org/resources/lma-2007-static-recomp-case/index.md): Case study · LMA Manager 2007 statically translates the Xbox 360 game's PowerPC code into Rust from a user's disc image. A native runtime replaces console kernel, graphics and audio services, and the repository includes XEX loading, decoding, translation and application crates. The author reports that the game plays with career mode, 3D matches, saves and sound.
- [Lost Odyssey Recomp: statically recompiling an Xbox 360 RPG into native ports](https://awesomerea.org/resources/lost-odyssey-recomp-case/index.md): Case study · Translates Lost Odyssey’s Xbox 360 PowerPC executable with patched XenonRecomp tooling and runs the generated code on a native runtime that renders through Direct3D 12, Vulkan or Metal. Windows, Linux, macOS and Android packages import the user’s own disc data. The maintainer documents development with Claude Code and Codex CLI and records each release separately from validation and acceptance.
- [Lufia II Recompiled: a native SNES recompilation](https://awesomerea.org/resources/lufia-ii-recompiled-case/index.md): Case study · Lufia II Recompiled builds a native version of the SNES game from a user-supplied US ROM with snesrecomp. Game-specific control-flow files guide compilation, while the host supplies input, saves, audio, and SDL or OpenGL rendering; Vulkan is an optional build choice.
- [Luigi's Mansion: a GameCube static recompilation and boot investigation](https://awesomerea.org/resources/luigis-mansion-recomp-case/index.md): Case study · Luigi's Mansion uses gcrecomp to translate the GameCube game's PowerPC DOL into C++ and supplies a Windows host with DOL loading, symbol import and GameCube OS replacements. Its boot trace records startup through static constructors and video interrupts, then an unresolved run-queue stall.
- [Luigi's Mansion: a PS5 port of the static recompilation](https://awesomerea.org/resources/luigis-mansion-ps5-port-case/index.md): Case study · Luigi's Mansion for the PlayStation 5 ports an existing static recompilation of the GameCube game to PS5 homebrew. Its builder translates code from the user's USA disc into C++ and compiles it for the console, while this repository supplies PS5 platform shims, input, build scripts and builder apps. The author reports play through file selection into the game.
- [Mabecs International Superstar Soccer 2000: a three-version N64 static recompilation](https://awesomerea.org/resources/iss2000-recomp-case/index.md): Case study · Mabecs International Superstar Soccer 2000 turns three N64 releases into native Windows and Linux builds through N64Recomp, N64ModernRuntime and RT64. Its own symbols, overlay work, hooks and runtime patches support widescreen rendering, player detail and online matches. Generated game code is produced locally from a user-supplied ROM.
- [Marble Knights Recompiled: an iOS game port by static recompilation](https://awesomerea.org/resources/marble-knights-recompiled-case/index.md): Case study · Marble Knights Recompiled ports the iOS game to Windows by translating ARM64 functions in its UnityFramework into C and compiling them into a GameAssembly.dll for the Unity 2019.4.17f1 Windows player. A compatibility layer replaces iOS services, while preparation scripts process the player's own game data; the project also describes an Android path using a Mach-O loader.
- [Marchwind 64: statically recompiling Super Robot Wars 64](https://awesomerea.org/resources/srw64-recomp/index.md): Case study · Marchwind 64 is a native recompilation of Super Robot Wars 64, the 1999 Nintendo 64 game. It runs on Windows, macOS, Linux, Steam Deck, Android, and Nintendo Switch, with English, Simplified Chinese, Traditional Chinese, and Korean text, plus widescreen and an optional HD art pack.
- [Mario Kart 64: a native port through N64 static recompilation](https://awesomerea.org/resources/mario-kart-64-recompiled-case/index.md): Case study · Mario Kart 64: Recompiled uses N64: Recompiled to make a native port of Mario Kart 64, with RT64 providing rendering and graphical enhancements. The project includes game-specific configuration, patches and desktop build support.
- [Mario Kart Wii PC Builder: statically recompiling Mario Kart Wii](https://awesomerea.org/resources/mkwii-pc-builder/index.md): Case study · Version 1.2.0 builds a native Windows game from a PAL Mario Kart Wii disc, RMCP01. The installer is MKWii-PC-Builder.exe and the game is Mario Kart Wii.exe. It includes 15 languages, up to four local players, and online play for one or two players per PC. Retro Rewind 6.13.4 supplies extra tracks and character variants. Dolphin texture packs can be PNG, DDS, ZIP, or 7z.
- [Mario Kart: Double Dash!!: a GameCube static recompilation port](https://awesomerea.org/resources/mario-kart-double-dash-recomp-case/index.md): Case study · Mario Kart: Double Dash!! is ported by translating its GameCube PowerPC code to C ahead of time and linking it with gcn-recomp's graphics, audio, disc and controller runtime. The repository contributes game function metadata, hooks and build scripts; the author reports reaching a Grand Prix race with sound from a blank memory card.
- [Mario Paint Recomp: a static recompilation of Mario Paint](https://awesomerea.org/resources/mario-paint-recomp-case/index.md): Case study · Mario Paint Recomp ports the SNES game Mario Paint to PC by translating 65816 routines into C while snesrecomp supplies SNES hardware behavior and interpreter fallback. Its headless tour and conformance tool compare selected routines with the original ROM; the author reports 57 of 103 hand-ported routines reached by the tour pass the checks.
- [MarioKart 64: Recompiled — a native port through N64Recomp static recompilation](https://awesomerea.org/resources/mariokart64-recompiled-case/index.md): Case study · Statically recompiles the US Nintendo 64 release of Mario Kart 64 into a native Windows, Linux and macOS application with N64Recomp, rendering through RT64. The README distinguishes this from a source port: game code is translated from the user’s ROM, while headers and some functions from a decompilation fork support patches and enhancements. Enhancement, fidelity and input-lag claims are project-reported.
- [Marvel Nemesis: an original Xbox static recompilation port](https://awesomerea.org/resources/marvel-nemesis-recomp-case/index.md): Case study · Marvel Nemesis: Rise of the Imperfects is ported from original Xbox to Windows by recompiling the user's XBE locally with XboxXBERecomp. The repository includes a game-specific host and compatibility changes to the bundled SDK, with Direct3D 12 rendering, local Versus and added PC settings.
- [masseffect-nx: statically recompiling Mass Effect for Nintendo Switch](https://awesomerea.org/resources/masseffect-nx-case/index.md): Case study · masseffect-nx ports the Xbox 360 release of Mass Effect to Nintendo Switch by translating PowerPC code from default.xex to C++ with ReXGlue and compiling it for ARM64. A project Vulkan renderer handles the game's GPU commands, while its installer converts Xenos shader microcode from the user's game files to SPIR-V.
- [Max Payne 3 RePrescribed: an Xbox 360 to PS5 recompilation](https://awesomerea.org/resources/max-payne-3-represcribed-case/index.md): Case study · Max Payne 3 RePrescribed recompiles the Xbox 360 Max Payne 3 Title Update 9 executable for a native PS5 port. Its build applies game-specific patches to a PS5 framework, runs ReXGlue code generation and packages the runtime and installer, with original discs and update files supplied by the owner.
- [Max Payne Recomp: an Apple Silicon port through static recompilation](https://awesomerea.org/resources/max-payne-recomp-case/index.md): Case study · Max Payne Recomp ports Max Payne 1.05 to Apple Silicon macOS by translating its 32-bit x86 executable and DLLs into C and compiling them for arm64. A native host maps Windows calls to Metal, SDL3, and AVFoundation; the user's own game files supply the binaries and assets.
- [mcdub3-nx: recompiling Midnight Club 3 for modern platforms](https://awesomerea.org/resources/mcdub3-nx-case/index.md): Case study · mcdub3-nx lifts the original Xbox code of Midnight Club 3: DUB Edition and Remix into C with xboxrecomp. It provides native versions for Nintendo Switch, Linux, macOS, Windows and Android, with game-specific runtime and graphics fixes. Players supply their own disc files; the Android APK loads extracted game files.
- [mcg-recomp: statically recompiling MechCommander Gold for Windows](https://awesomerea.org/resources/mcg-recomp-case/index.md): Case study · mcg-recomp statically translates MechCommander Gold's MCX.EXE into C and runs the generated code in a native Windows host. It extracts CodeView function information, bridges imports, and provides graphics, sound, movie, and conformance support; the author reports playing the first campaign mission through its debriefing.
- [MCX360 Edition: recompiling Minecraft: Xbox 360 Edition for iPhone](https://awesomerea.org/resources/mcx360-edition-case/index.md): Case study · MCX360 Edition recompiles Minecraft: Xbox 360 Edition Title Update 9 ahead of time with ReXGlue for an iPhone app. The port uses Vulkan over Metal through MoltenVK and includes an iOS app manifest, build scripts and SDK patch; players supply the matching disc and title-update files.
- [MechAssault 2: Lone Wolf: an Xbox static recompilation for Windows](https://awesomerea.org/resources/mechassault-2-recomp-case/index.md): Case study · MechAssault2-recomp builds a native Windows port of the original Xbox game MechAssault 2: Lone Wolf. It uses xboxrecomp to translate the user's ma2.xbe into C, then links that code with an Xbox runtime and game-specific input, display and behavior hooks.
- [Medal of Honor: Frontline: a multi-image GameCube static recompilation](https://awesomerea.org/resources/moh-frontline-gc-recomp-case/index.md): Case study · Medal of Honor: Frontline GC Recomp translates the USA GameCube game's PowerPC executable chain into a native host module with DolRecomp. ModernGekko supplies memory, graphics, audio and input services, while runtime hashes distinguish the boot and restart stub images that overlap in guest memory.
- [MediEvil Recomp: a PlayStation static recompilation to C#](https://awesomerea.org/resources/medievil-recomp-case/index.md): Case study · Statically recompiles the North American PlayStation release of MediEvil into C# with the RecompOne recompiler and runtime. The runtime stands in for BIOS, GPU, CD-ROM and other hardware services, and project patches change rendering, widescreen and terrain behavior. README describes the project as a recompilation and labels it an open beta.
- [MediEvil Recompiled: building the PlayStation game through psxrecomp](https://awesomerea.org/resources/medievil-psxrecomp-setup-case/index.md): Case study · MediEvil Recompiled supplies a setup host for statically recompiling the US PlayStation release of MediEvil with psxrecomp and building it with recomp-ui. Its configuration, symbols and diagnostics guide support local generation from the user's disc and retail BIOS. The author reports a successful Release build and short startup run; gameplay checks remain open.
- [Mega Man Legends 2: a PlayStation static recompilation setup kit](https://awesomerea.org/resources/mega-man-legends-2-recomp-case/index.md): Case study · Mega Man Legends 2 provides a setup kit that generates and compiles a PlayStation static recompilation from the user's European SLES-03556 disc and SCPH-5552 BIOS. Its game configuration, function seeds and setup code work with psxrecomp and recomp-ui. The author reports a Windows setup and headless start check for version 0.1.0.
- [Mega Man Legends Recompiled: a European PlayStation setup host](https://awesomerea.org/resources/mega-man-legends-psxrecomp-case/index.md): Case study · Mega Man Legends Recompiled provides a Windows setup host that uses psxrecomp to generate and build the European PlayStation game on the user's computer. Its game profile and disc verifier recognize the supported release, including the canonical split-track layout. The author reports gameplay in a private package, while exact public-package startup checks remain open.
- [Mega Man X Recompiled: a snesrecomp static recompilation](https://awesomerea.org/resources/megaman-x-snes-recomp-case/index.md): Case study · Statically translates the 65816 CPU code of the SNES Mega Man X (USA Rev 1) to C with the snesrecomp framework; the PPU, audio, DMA and other hardware run in the framework’s runtime, and a LakeSnes-derived interpreter executes whatever the static pass cannot prove. The C is generated locally from the user’s ROM, with function names imported from community DiztinGUIsh annotations. Playable Zero, co-op and rollback netplay, X2/X3 boss weapons and adaptive widescreen are layered on top, using assets extracted locally from the user’s own sequel ROMs.
- [Mega Man X4 Recompiled: a native PSXRecomp build with co-op](https://awesomerea.org/resources/mega-man-x4-recompiled-case/index.md): Case study · Mega Man X4 Recompiled uses PSXRecomp to generate a native Windows or Linux build from the player's original Mega Man X4 USA PlayStation disc. The title-specific runtime and launcher add optional local and networked two-player co-op, display options and game-specific modifications.
- [MegaManX2SNESRecomp: statically recompiling Mega Man X2](https://awesomerea.org/resources/megaman-x2-recomp-case/index.md): Case study · MegaManX2SNESRecomp is a static recompilation of Mega Man X2 (USA) built on snesrecomp. Version 0.1.5 is a playable Windows release. The ROM file is mmx2.sfc, headerless, CRC32 0x947B0355.
- [MegaManX3SNESRecomp: a Mega Man X3 static recompilation](https://awesomerea.org/resources/mega-man-x3-snes-recomp-case/index.md): Case study · MegaManX3SNESRecomp applies snesrecomp to the US SNES release of Mega Man X3, running covered 65816 paths natively and falling back to an interpreter elsewhere. Its game-specific code handles startup and display behavior, while symbol annotations and coverage data guide regeneration. The author reports opening scenes and early gameplay, with wider stage coverage and audio checks still open.
- [MegaManX5Recomp: statically recompiling Mega Man X5 for Windows](https://awesomerea.org/resources/megaman-x5-recomp-case/index.md): Case study · MegaManX5Recomp is a native Windows build of Mega Man X5, USA SLUS-01334, statically recompiled with PSXRecomp. It includes an experimental simultaneous X and Zero co-op mode that uses OpenGL.
- [MegaManZeroRecomp: statically recompiling Mega Man Zero](https://awesomerea.org/resources/megaman-zero-recomp/index.md): Case study · MegaManZeroRecomp statically translates the Mega Man Zero USA revision 0 ROM, SHA-1 193b14120119162518a73c70876f0b8bffdbd96e, from ARM and Thumb into native C++. The runtime hash-gates the ROM. The ROM file is roms/megaman_zero_usa.gba. The repository is cloned beside gbarecomp, gba_recompile regenerates the translation units, and cmake --build build --target MegaManZeroRecomp builds the Windows program.
- [Melee Unlocked: a Windows source port and static recompilation of Melee](https://awesomerea.org/resources/melee-unlocked-case/index.md): Case study · A beta Windows build of Super Smash Bros. Melee (NTSC 1.02) with two engines: a source port that compiles the doldecomp decompilation as a native library, and a static recompilation that translates the retail DOL's PowerPC code and Slippi's Gecko codes into C++. Both run on a native runtime with Direct3D rendering, unlocked display rates and natively implemented Slippi rollback play. The user's own ISO supplies all game data, and the README says the work was AI-assisted.
- [MeleePad: a native Apple static recompilation of Super Smash Bros. Melee](https://awesomerea.org/resources/meleepad-melee-port-case/index.md): Case study · MeleePad ports Super Smash Bros. Melee to iPhone, iPad and Apple Silicon Mac by compiling PowerPC code translated from a player-supplied GameCube disc into ARM64 code ahead of time. It joins a Dolphin-derived runtime to Metal, UIKit, Apple audio and touch or physical controls.
- [Metal Gear Solid Recompiled: static recompilation of Metal Gear Solid](https://awesomerea.org/resources/mgs-recomp/index.md): Case study · This is a release candidate that recompiles Metal Gear Solid with PSXRecomp and the recomp-ui launcher. It expects the European disc SLES-01370 and a European BIOS, SCPH-5502 or SCPH-5552. The BIOS must be 524,288 bytes, SHA-256 1faaa18fa820a0225e488d9f086296b8e6c46df739666093987ff7d8fd352c09. The README says gameplay acceptance is still pending.
- [Metal Slug XX: recompiling the game with ReXGlue](https://awesomerea.org/resources/metal-slug-xx-recomp/index.md): Case study · A modified ReXGlue SDK tree for running Metal Slug XX. The README says the repository stores no Metal Slug XX files and that a legal copy has to be supplied. It also marks the project as early development, with breaking public API changes expected.
- [metal-slug-x-recomp: a Neo Geo static recompilation and native runtime](https://awesomerea.org/resources/metal-slug-x-recomp-case/index.md): Case study · metal-slug-x-recomp maps Metal Slug X's 68000 code with recursive disassembly and MAME traces, translates instructions to C, and implements Neo Geo video, sound and memory services in a native Windows runtime. Personal builds generate translated code from the user's game files; distributed builds use an interpreter.
- [Metroid Dread: a native PC recompilation from Switch game files](https://awesomerea.org/resources/metroid-dread-recomp-pc-case/index.md): Case study · Metroid Dread Recomp builds a native Windows or Linux version of Metroid Dread 2.1.0 from a player's Switch ExeFS and RomFS. SwitchRecomp translates ARM64 game code to C, game-specific anchored patches modify generated code, and a PC runtime supplies graphics, audio, input and system services.
- [Metroid Prime Remastered: a Switch static recompilation for Windows](https://awesomerea.org/resources/metroid-prime-remastered-recomp-case/index.md): Case study · Metroid Prime Remastered Recomp builds a Windows port from the user's Switch version 1.0.0 dump by translating game code to C++ ahead of time. Its runtime replaces Switch services and maps NVN graphics to Vulkan; the repository includes game-specific build files, symbols and validation notes.
- [MetroidPrimeHuntersRecomp: a native Metroid Prime Hunters recompilation](https://awesomerea.org/resources/metroid-prime-hunters-recomp-case/index.md): Case study · MetroidPrimeHuntersRecomp builds a native alpha of Metroid Prime Hunters USA revision 0 with ndsrecomp and a player-supplied ROM. It includes game-specific execution coverage, controls and rendering work. A separate investigation documents the game's Wi-Fi datagram framing and typed messages.
- [MGS2 for Android: statically recompiling Sons of Liberty HD](https://awesomerea.org/resources/mgs2-android-case/index.md): Case study · This project statically recompiles Metal Gear Solid 2: Sons of Liberty HD from the NVIDIA SHIELD TV, a 32-bit ARM game, into ARM64 for Android phones. It translates the ARM32 functions to C and supplies a runtime for memory, libc, OpenGL, audio, and JNI. The README says about 22,000 game functions and about 3,000 C++ library functions are recompiled.
- [mh3u-port: statically recompiling MH3U for PC](https://awesomerea.org/resources/mh3u-port-case/index.md): Case study · mh3u-port statically recompiles the USA v32 Wii U release of MH3U for Windows and Linux. It translates the game's PowerPC functions into C, runs them with a Rust replacement for Wii U system libraries, and converts GPU shader programs to WGSL. The author reports that it reaches the village and runs quests, with some graphics effects unfinished.
- [MH4UltimateDC: static recompilation and PC port of MH4U](https://awesomerea.org/resources/mh4ultimatedc-case/index.md): Case study · MH4UltimateDC recompiles the Nintendo 3DS game MH4U from a player's own code dump into C for a native PC port. Its generated code runs with Azahar's 3DS core, while hand-written hooks replace selected game functions for display, input, and frame pacing changes.
- [MHForever: statically recompiling Monster Hunter Freedom Unite for PC](https://awesomerea.org/resources/mhforever-case/index.md): Case study · MHForever is a native PC port of Monster Hunter Freedom Unite for the PSP, made by static recompilation. The README says the European, North American, and Japanese releases are supported and complete.
- [Midnight Club: Los Angeles - Recompiled: an Xbox 360 PC port](https://awesomerea.org/resources/midnight-club-los-angeles-recompiled-case/index.md): Case study · Midnight Club: Los Angeles - Recompiled translates the Xbox 360 game's PowerPC default.xex to native Windows code with ReXGlue. The port adds a DirectX 12 graphics path and launcher; its Ghidra research identifies the projection matrix function and instruction relevant to ultrawide rendering.
- [Midnight Club: Los Angeles Recomp: an experimental Android ARM64 port](https://awesomerea.org/resources/midnight-club-la-android-recomp-case/index.md): Case study · Midnight Club: Los Angeles Recomp adapts ReXGlue's static translation of the Xbox 360 game's PowerPC code into C++ for Android ARM64. The fork adds Android packaging, private game-data import, C++ integration and ReXGlue patches. The README reports that a user test reached car selection; development and testing centered on a Galaxy S23.
- [Midnight Club: Los Angeles — RECOMP: an Xbox 360 static recompilation for PC](https://awesomerea.org/resources/midnight-club-los-angeles-recomp-case/index.md): Case study · Midnight Club: Los Angeles — RECOMP translates the Xbox 360 game's PowerPC executable into native x64 C++ for Windows using ReXGlue. The repository supplies game hooks, executable patches and a documented map of Xenos register state; its native graphics path currently reads and logs that state in shadow mode.
- [Midnight Club: Los Angeles — static recompilation of the Xbox 360 game](https://awesomerea.org/resources/mcla-recomp/index.md): Case study · This statically recompiles Midnight Club: Los Angeles Complete Edition for Xbox 360, title id 545407F8, with the ReXGlue SDK. Only the USA and Europe disc image is supported. On Windows, scripts/make_pc.ps1 takes that ISO and builds mcla.exe with Direct3D 12. Career, races, and the garage play at 30 FPS by default, and the frame-rate option also lists 60 and 120. The Linux build uses Clang 20, Vulkan 1.3, and ReXGlue v0.10.0, then scripts/play_linux.sh. A separate build targets a PS5 that already runs homebrew.
- [Midnight Ghost Stone: a native Metal Gear Solid recompilation](https://awesomerea.org/resources/midnight-ghost-stone-case/index.md): Case study · Midnight Ghost Stone builds a native PC version of the PlayStation Metal Gear Solid from its USA v1.0 discs. It statically recompiles most MIPS game logic, substitutes selected decompiled C routines checked against the executable, and presents locally imported meshes and textures through Vulkan. The author labels the Linux and Windows alpha packages experimental and unqualified for a complete campaign.
- [Midtown Madness 3: static recompilation for PC](https://awesomerea.org/resources/mm3-recomp/index.md): Case study · This statically recompiles Midtown Madness 3 for the original Xbox to a native executable with xboxrecomp. Windows x64 gameplay has been checked with Direct3D 12 or Vulkan, both through SDL3. Linux x64 has a build path. The builder does not support macOS. Check SHA in the Windows builder reports whether the disc matches a tested dump. The command-line program is mm3_recomp.exe.
- [midway: statically recompiling Midway Arcade Origins for Windows](https://awesomerea.org/resources/midway-ps3-case/index.md): Case study · midway statically recompiles the PS3 disc release of Midway Arcade Origins for native Windows using ps3recomp and a user-supplied game dump. Its scripts lift the EBOOT and two SPURS render jobs, then build against the shared runtime. The author reports that the front end reaches an arcade ROM set and displays the Vindicators Part II attract loop.
- [Mind over Recomp: rebuilding Crash: Mind over Mutant for PC](https://awesomerea.org/resources/mind-over-recomp-case/index.md): Case study · Mind over Recomp translates Crash: Mind over Mutant's Xbox 360 program to C++ with ReXGlue for native Windows and Linux builds. It adds a Vulkan renderer and game-specific service replacements, with investigation notes documenting the disc, recompilation, boot and rendering work.
- [minecraft: a Minecraft Xbox 360 recompilation prototype](https://awesomerea.org/resources/minecraft-xbox-360-recomp-case/index.md): Case study · minecraft configures ReXGlue to recompile Minecraft: Xbox 360 Edition into a native program using extracted game files. It includes a title configuration, build wiring and an application entry point. The author reports that the current build displays only a black screen.
- [mk8-recomp: a native Mario Kart 8 Deluxe static recompilation](https://awesomerea.org/resources/mk8-recomp-case/index.md): Case study · mk8-recomp develops a native Mario Kart 8 Deluxe application that connects statically recompiled CPU modules to native graphics, audio, input and storage services. The author reports completion of a four-course Mushroom Cup sequence and documents runtime measurements and remaining compatibility work. Public outputs are limited to authored source and game-free tooling.
- [MKSM Recomp: a PS2 static recompilation of Mortal Kombat: Shaolin Monks](https://awesomerea.org/resources/mksm-recomp-case/index.md): Case study · MKSM Recomp statically recompiles the NTSC-U PS2 release of Mortal Kombat: Shaolin Monks toward native PC execution. It combines ELF analysis, MIPS and VU to C++ generation, an EE and IOP runtime, Ghidra scripts, tests and game-specific investigation notes. The author reports progress through menus and the opening movie to distorted scene drawing.
- [MKVDCU-Recomp: a Windows recompilation of Mortal Kombat vs. DC Universe](https://awesomerea.org/resources/mkvdcu-recomp-case/index.md): Case study · MKVDCU-Recomp builds a Windows port of the Xbox 360 game Mortal Kombat vs. DC Universe by statically recompiling the player's retail executable with ReXGlue. Its launcher manages local builds, while a game-specific host supplies settings, telemetry and mod loading. The author reports full Arcade matches on one PC.
- [MLB Power Pros 2008 Recomp: a Wii static recompilation and mixed analysis workflow](https://awesomerea.org/resources/mlb-power-pros-2008-recomp-case/index.md): Case study · MLB Power Pros 2008 Recomp translates the Wii game's main.dol and ovl_main.rel from PowerPC to C++ with Wiicompiled for Windows and Linux builds. It adds title-specific runtime patches and editing tools for rosters, textures and stadiums. Its analysis workflow uses REA through MCP, which supports x86/x64 PE executables.
- [MojoRecomp: native ports of the Crash Bandicoot Titans games](https://awesomerea.org/resources/mojorecomp-crash-titans-case/index.md): Case study · MojoRecomp recompiles Xbox 360 game code for a native Windows runtime and launcher focused on the Crash Bandicoot Titans games. Crash of the Titans is listed as playable using a user-provided ISO; Crash: Mind Over Mutant remains in development. The repository contains runtime code, recompiler patches and localization deltas.
- [Monster Truck Madness: a static recompilation of the second game](https://awesomerea.org/resources/monster-truck-madness-2-recomp-case/index.md): Case study · Monster Truck Madness statically lifts Monster Truck Madness 2's Monster.exe to C with pcrecomp and runs it on a 32-bit Windows host. The repository includes function cataloging, code generation and DirectDraw presentation code; the author reports that scripted input can start and drive a race, while a complete race remains unfinished.
- [Mortal Kombat: Shaolin Monks: an Android static-recompilation port](https://awesomerea.org/resources/shaolin-monks-android-case/index.md): Case study · Mortal Kombat: Shaolin Monks for Android translates the original Xbox game's x86 code to C++ ahead of time with XboxXBE-Recomp, then builds an arm64 app. Its Android host uses Vulkan for drawing and SDL3 for windowing, input and audio, with touch and controller support.
- [MOTHER 3 Recomp: a native GBA game port](https://awesomerea.org/resources/mother-3-recomp-case/index.md): Case study · MOTHER 3 Recomp brings the GBA game to Windows, Linux and Android using gbarecomp and recomp-ui. Its released packages import the player's ROM and provide a launcher, widescreen presentation and patch support; the Android documentation also describes a private build that generates native-recompiled code locally.
- [Mother3Recomp: statically recompiling MOTHER 3 for PC](https://awesomerea.org/resources/mother3recomp-case/index.md): Case study · Mother3Recomp translates MOTHER 3's Game Boy Advance ARM7TDMI code into C for a native PC build using gbarecomp. It configures separate Japanese and English fan-patched ROM targets, imports function symbol metadata and runs missed paths through interpreter and JIT fallback.