# Reverse-engineering case studies · Page 8

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

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

## Games (200)

- [Moto Racer Recomp: a native Moto Racer port built by static recompilation](https://awesomerea.org/resources/moto-racer-recomp-case/index.md): Case study · Moto Racer Recomp translates the original Moto Racer Windows executable from a user's GOG installer into C and compiles a native program on the user's computer. Its runtime implements the Windows, DirectDraw, Direct3D, DirectSound and CD audio interfaces used by the game, with builds for Apple Silicon macOS, Windows x64 and x86-64 Linux.
- [MUA PC Port: three Xbox 360 games statically recompiled](https://awesomerea.org/resources/mua-bundle-recompiled-case/index.md): Case study · MUA PC Port statically recompiles three related Xbox 360 games into separate native programs using ReXGlue. A shared launcher installs each game from the user's disc image and starts its runtime on Windows, with experimental Linux and Steam Deck support.
- [Namco 2x Systems: rebuilding System 21, 22 and 23 arcade games](https://awesomerea.org/resources/namco-2x-systems/index.md): Case study · Namco 2x Systems rebuilds Namco System 21, 22, and 23 arcade games for Linux and Windows from MAME ROM sets, version 0.271 or later. The playable list includes Prop Cycle, Rave Racer, Tokyo Wars, Dirt Dash, Armadillo Racing, Time Crisis, Ace Driver, Cyber Commando, Ridge Racer 2, Cyber Sled, Time Crisis II, Crisis Zone, and Angler King. Each game names its zip, such as propcycl.zip or timecrs2.zip. Checksums are in docs/ROM_CHECKSUMS.md. The DSP BIOS is built in, so namcoc71.zip is not required.
- [Naruto: Clash of Ninja: static recompilation of five GameCube releases](https://awesomerea.org/resources/clash-of-ninja-recomp-case/index.md): Case study · Naruto: Clash of Ninja static recompilation builds native versions of five GameCube releases from user-supplied discs. Its launcher generates each game's symbol map and project files locally, translates PowerPC code to C, and links against a runtime for GameCube hardware.
- [Naruto: Rise of a Ninja — an Xbox 360 recompilation port for Switch](https://awesomerea.org/resources/naruto-rise-of-a-ninja-nx-case/index.md): Case study · Naruto: Rise of a Ninja is ported from Xbox 360 to Nintendo Switch homebrew through static recompilation of its PowerPC code with ReXGlue. Renut maps the game's Direct3D calls to deko3d, with documented work on shaders, tiled rendering and device layout. The author reports playable story mode and fights on a console.
- [Need for Speed Most Wanted (2005, PC) — Recompiled: an x86 static recompilation](https://awesomerea.org/resources/nfsmwpc-recompiled-case/index.md): Case study · Need for Speed Most Wanted (2005, PC) — Recompiled analyzes the PC game's x86 speed.exe and translates its functions to C with a patched pcrecomp toolchain for native Windows and Android builds. The project includes binary reports, lift scripts, runtime adapters and an Android Vulkan host; the author reports playable ARM64 builds.
- [Need for Speed Underground: a PC executable static recompilation](https://awesomerea.org/resources/nfsu1-recompiled-case/index.md): Case study · nfsu1-recompiled translates the x86 Speed.exe from Need for Speed Underground PC patch 1.4 into C with a patched pcrecomp lifter. It builds native Windows and Android hosts, with Win32 and graphics compatibility code; its documented progress reaches menus while races remain untested.
- [Need for Speed: Carbon — native Apple Silicon recompilation](https://awesomerea.org/resources/nfs-carbon-mac-case/index.md): Case study · This repository is a native Apple Silicon build of Need for Speed: Carbon, the 2006 PC game. The x86 code is translated to C ahead of time and compiled with a Metal renderer, native audio, and controller support. The README says career, races, the garage, and the menus run at 60 frames per second with sound.
- [Need for Speed: Most Wanted for Android — Xbox static recompilation for Android](https://awesomerea.org/resources/mostwanted-android-case/index.md): Case study · Need for Speed: Most Wanted for Android ports the original Xbox Black Edition to Android arm64 by translating its x86 XBE code to C++ with XboxXBE-Recomp. A Vulkan host renders the game, while SDL3 handles windowing, input and audio; the port also provides touch controls and graphics settings.
- [Need for Speed: Most Wanted: an Apple Silicon static recompilation](https://awesomerea.org/resources/nfs-most-wanted-mac-recomp-case/index.md): Case study · Need for Speed: Most Wanted Native translates the user's PC version 1.3 speed.exe from x86 into C and compiles it for Apple Silicon Macs. Its host provides Metal rendering, CoreAudio, controller support and asset conversion. An optional user-supplied Xbox 360 copy enables additional game content and effects.
- [Need for Speed: SHIFT: an Xbox 360 ReXGlue recompilation](https://awesomerea.org/resources/nfs-shift-xbox360-recomp-case/index.md): Case study · Need for Speed: SHIFT is being reconstructed from its Xbox 360 PowerPC executable through ReXGlue ahead-of-time translation to C++ and a native Linux runtime. Game-specific work covers XEX analysis, kernel integration and Xenos command rendering through Vulkan. The author reports that the retail boot chain reaches Menu Setup state 2, where it currently stalls.
- [Need for Speed: Underground 2: an Xbox static recompilation for Switch and Linux](https://awesomerea.org/resources/nfsu2-switch-linux-recompilation-case/index.md): Case study · nfsu2-sw turns the NTSC-U original Xbox release of Need for Speed: Underground 2 into native Nintendo Switch and Linux builds. Its vendored xboxrecomp toolkit lifts default.xbe to C, while the project adds host integration, renderer options, audio and game-specific overrides; game data comes from the player's extracted disc.
- [New Super Mario Bros. U: a native Wii U recompilation](https://awesomerea.org/resources/nsmbu-recomp-case/index.md): Case study · nsmbu-recomp builds a native New Super Mario Bros. U program from a user's Wii U game copy through its installer and runtime. It supports Windows, macOS, Linux, Android and iOS, with course and world-map save states and up to four controllers. The project documents supported USA and European revisions and experimental wider display and higher frame rates.
- [NFS CARBON 360 DECOMP: an Xbox 360 static recompilation for Android](https://awesomerea.org/resources/nfs-carbon-360-android-recomp-case/index.md): Case study · NFS CARBON 360 DECOMP translates the Xbox 360 release of Need for Speed Carbon from PowerPC code to C++ for Android ARM64 and Windows x64 builds. Its game-specific analysis maps Direct3D functions and shader containers for a Vulkan renderer; the author reports complete scene rendering on one Android device, with full races still untested.
- [NFS Carbon NX: a Switch recompilation of Need for Speed: Carbon](https://awesomerea.org/resources/nfs-carbon-nx-case/index.md): Case study · NFS Carbon NX ports the Xbox 360 release of Need for Speed: Carbon to Nintendo Switch by translating its PowerPC executable to C++ and compiling it for ARM64. Its Vulkan renderer draws Xenos commands through Mesa NVK, while game-specific fast paths cover audio, cutscenes, texture handling and uploads. Standard and Collector's Edition builds share the runtime.
- [NFSMW Recompiled for iOS: native Need for Speed: Most Wanted port](https://awesomerea.org/resources/nfsmw-ios-case/index.md): Case study · NFSMW Recompiled for iOS runs Need for Speed: Most Wanted from 2005, the Xbox 360 version, natively on iPhone and iPad. ReXGlue recompiles the PowerPC code ahead of time for Apple arm64, and a Metal renderer draws the shaders.
- [NFSMW Recompiled: statically recompiling Need for Speed: Most Wanted](https://awesomerea.org/resources/nfsmw-recompiled/index.md): Case study · NFSMW Recompiled is a native PC and Android port of the Xbox 360 version of Need for Speed: Most Wanted from 2005. It translates the PowerPC code to C++ and draws with a Vulkan 1.1 renderer. The README supports the PAL Spanish edition and the USA edition, identified by the SHA-256 prefixes aad15fc2 and aebdf3c1 of default.xex. Other editions are not supported. nfsmw.exe takes an ISO or an extracted folder, detects the edition, and builds nfsmw_shaders.nfsp from that disc. The launcher has English, Spanish, and Portuguese, with quality profiles and frame-rate limits of 30, 60, and 120.
- [nfsmw-nx: statically recompiling Need for Speed: Most Wanted for Switch](https://awesomerea.org/resources/nfsmw-nx-case/index.md): Case study · nfsmw-nx ports the Xbox 360 release of Need for Speed: Most Wanted (2005) to Nintendo Switch through static recompilation. ReXGlue translates the game's PowerPC default.xex to C++, while a Switch runtime supplies console services and a Vulkan renderer on NVK draws its graphics. Installation derives shaders and game data from the player's own disc.
- [NFSU2Recomp: a native Mac recompilation of Need for Speed: Underground 2](https://awesomerea.org/resources/nfsu2recomp-case/index.md): Case study · NFSU2Recomp statically recompiles Need for Speed: Underground 2 PC executable SPEED2.EXE into a native Apple Silicon application. Its lifter converts x86 code to C, while a handwritten runtime maps Win32, Direct3D 9 and DirectSound behavior to macOS, Metal and CoreAudio. The author reports that menus and races are playable.
- [NHL 14 Recomp: a static Xbox 360 recompilation and franchise-mode investigation](https://awesomerea.org/resources/nhl-14-recomp-case/index.md): Case study · NHL 14 Recomp translates a user-supplied Xbox 360 NHL 14 executable into C++ for a native PC build using ReXGlue. The repository also provides host runtime code, save and roster tools, and documented findings about Be a GM rules derived from game code and saves.
- [NHL Legacy: Xbox 360 static recompilation and Vulkan port](https://awesomerea.org/resources/nhl-legacy-recomp-case/index.md): Case study · Uses ReXGlue to statically recompile the Xbox 360 NHL Legacy executable into a native Windows program. A game-specific Vulkan renderer and host code handle presentation, while a builder prepares an installation from the player's ISO or extracted game folder. The source also documents graphics investigations and diagnostic tools.
- [Nightmare Creatures II: a PlayStation local recompilation kit](https://awesomerea.org/resources/nightmare-creatures-ii-recomp-case/index.md): Case study · Nightmare Creatures II provides a title-specific psxrecomp setup kit for the USA PlayStation release. A setup wizard accepts the user's disc image and SCPH-1001 BIOS, then generates and compiles the game locally through psxrecomp and recomp-ui. The repository includes game configuration, symbols and setup code.
- [Ninja Gaiden II Recompiled: a native Xbox 360 game port](https://awesomerea.org/resources/ng2recomp-case/index.md): Case study · Ninja Gaiden II Recompiled is a native Linux and Windows build of Ninja Gaiden II for Xbox 360 (2008). ReXGlue statically recompiles the PowerPC code, and a Vulkan renderer takes the game's Direct3D calls. The target is the World release, title ID 544307D5, with Title Update 3.
- [Noble Archimedes: recompiling Castlevania: Curse of Darkness for PC](https://awesomerea.org/resources/noble-archimedes/index.md): Case study · Noble Archimedes recompiles Castlevania: Curse of Darkness. The primary path turns the original Xbox release into native x64 code with Direct3D 12 and XAudio2. An experimental PlayStation 2 path covers the USA release SLUS-21168. The Windows beta compiles the game locally from the player's USA Xbox files on first run.
- [NosCore.ClientLab: statically recompiling the NosTale client for browser tests](https://awesomerea.org/resources/noscore-clientlab-case/index.md): Case study · NosCore.ClientLab statically recompiles a user-supplied NosTale Windows client from x86 into C and WebAssembly for automated tests against a NosCore server. Ghidra and IDR provide function information, a custom lifter translates instructions, and a browser host replaces Windows graphics, audio and networking services.
- [NSMB Wii Multiplayer Recompilation: native port of New Super Mario Bros. Wii](https://awesomerea.org/resources/nsmb-wii-multiplayer-recomp-case/index.md): Case study · NSMB Wii Multiplayer Recompilation is a native port of New Super Mario Bros. Wii made with static recompilation on WiiCompiled. The README lists Android, Windows, and Linux builds and says the game code is translated to native code ahead of time.
- [NSMBWiicompiled: a Windows static recompilation of New Super Mario Bros. Wii](https://awesomerea.org/resources/nsmbwiicompiled-case/index.md): Case study · NSMBWiicompiled converts New Super Mario Bros. Wii PAL revision 1 into a native Windows game through static recompilation. Its translator parses PowerPC code from Wii DOL files and emits C++ for a native runtime, while the player's disc supplies game assets. The port adds resolution, widescreen, input and multiplayer options.
- [NX1recomp: recompiling Call of Duty: Future Warfare](https://awesomerea.org/resources/nx1-future-warfare-recomp-case/index.md): Case study · NX1recomp statically recompiles NX1/Call of Duty: Future Warfare's Xbox 360 PowerPC code into native Windows executables. It converts Xenos shaders to PC formats and adds a game-specific D3D9 renderer for the multiplayer target, alongside a separate single-player build.
- [NX2navi: static recompilation of Ocarina of Time for Windows](https://awesomerea.org/resources/nx2navi-ocarina-of-time-switch-2-case/index.md): Case study · NX2navi statically recompiles the Nintendo Switch 2 version of The Legend of Zelda: Ocarina of Time into a Windows x86-64 application. Its pipeline lifts ARM64 modules to C, implements console services on the host, and renders through Vulkan. A launcher builds the port locally from the user's game files.
- [Ogre Battle 64: a native port through N64 static recompilation](https://awesomerea.org/resources/ogre-battle-64-recomp-case/index.md): Case study · The Ogre Battle 64 port statically recompiles the USA Rev A N64 game into a native PC executable with N64Recomp. Its build pipeline splits and links ROM code, recompiles the main program and bank units, and processes RSP microcode; a separate browser build uses WebGL2.
- [Oogie's Revenge Recomp: an Xbox static recompilation for PC](https://awesomerea.org/resources/oogies-revenge-recomp-case/index.md): Case study · Oogie's Revenge Recomp builds a Windows port of the USA Xbox game Tim Burton's The Nightmare Before Christmas: Oogie's Revenge by translating x86 functions into C++ with xboxrecomp. Its runtime replaces Xbox kernel and SDK services, while a Direct3D 11 renderer translates the game's Direct3D 8 shaders to HLSL. Game data comes from the player's disc image.
- [OoT: Recompiled: a native Ocarina of Time static recompilation](https://awesomerea.org/resources/oot-recompiled-jonb-case/index.md): Case study · OoT: Recompiled builds a native Windows version of Ocarina of Time from a user-supplied Nintendo 64 NTSC-U 1.0 ROM. N64Recomp translates MIPS code to C, N64ModernRuntime supplies console services, and RT64 renders display lists through Direct3D 12. Game-specific C patches replace selected original functions.
- [Open4DBoxing: static recompilation of 4D Sports Boxing](https://awesomerea.org/resources/open4dboxing-case/index.md): Case study · Open4DBoxing rebuilds the DOS game 4D Sports Boxing by recompiling four game executables and five sound drivers from machine code into C. A project runtime models DOS, BIOS, video and sound hardware, while SDL2 provides the frontend; the author reports comparisons with the original in DOSBox-X.
- [openNG2: a static recompilation of Ninja Gaiden II for Windows](https://awesomerea.org/resources/openng2-case/index.md): Case study · openNG2 turns the Xbox 360 Ninja Gaiden II into a native Windows build through ReXGlue static recompilation and game-specific host code. Its launcher builds from a user-owned World release and Title Update #2; the research ledger records evidence from REA, Ghidra and code generation while the port adds PC display and input features.
- [OpenPete: a static recompilation of Spyro the Dragon for PC](https://awesomerea.org/resources/openpete-case/index.md): Case study · OpenPete ports the 1998 PlayStation game Spyro the Dragon to PC by translating its executable to C and compiling it ahead of time. A custom runtime handles PlayStation library calls, while a game-aware renderer supports high frame rates, widescreen display and texture replacement. The port reads game content from a user-supplied NTSC-U disc.
- [OpenPopTB-MacOS: static recompilation of Populous: The Beginning for Apple Silicon](https://awesomerea.org/resources/openpoptb-macos-case/index.md): Case study · OpenPopTB-MacOS statically recompiles Populous: The Beginning and Undiscovered Worlds from a user's Windows executables into native Apple Silicon applications. A Python recompiler translates discovered x86 functions to C, while a C runtime provides guest memory and Win32 and DirectX behavior through SDL3. The author reports single-player playability and instruction-level and function-level differential checks.
- [OpenSamurai: reconstructing Sword of the Samurai](https://awesomerea.org/resources/opensamurai-case/index.md): Case study · OpenSamurai reconstructs the DOS game Sword of the Samurai as one C program from its separate original executables. It combines the title, role-playing, duel, melee and battle programs, runs on the user's game data, and documents comparisons with the original in an emulator.
- [OpenShao: statically recompiling Mortal Kombat: Shaolin Monks](https://awesomerea.org/resources/openshao/index.md): Case study · OpenShao statically recompiles the original Xbox game Mortal Kombat: Shaolin Monks with XboxXBERecomp. The launcher accepts an ISO, XISO, ZIP, extracted folder, or default.xbe and reads it in place. Windows 10 version 1903 or Linux with glibc 2.38 is required, plus an x64 CPU with SSE4.2 and POPCNT, and Direct3D 12 or Vulkan 1.2. A source build checks out XboxXBERecomp at 40e9c35451305f09ca9d86f677e4b9c2c37ff26b and runs python tools/build_recomp.py --xbe with that XBE and --test.
- [P3P3DS: running Persona 3 Portable on New Nintendo 3DS](https://awesomerea.org/resources/p3p3ds-case/index.md): Case study · P3P3DS adapts Persona 3 Portable's North American PSP release for New Nintendo 3DS through static MIPS-to-C++ recompilation, an interpreter fallback and a PSP service runtime. Its research documents the game's ELF32 PRX executable, relocations and imports. The author reports early playable progress on hardware, with sound and opening video still absent.
- [Pac-Man Championship Edition: a native PC static recompilation](https://awesomerea.org/resources/pac-man-championship-edition-pc-recomp-case/index.md): Case study · Pac-Man Championship Edition recompiles the Xbox 360 Live Arcade game's PowerPC code to x86-64 for a native Windows build using ReXGlue. Game-specific hooks adjust frame pacing and playfield placement, and an optional mode rearranges Championship Mode mazes. The repository also records Xbox 360 imports found during an earlier XenonRecomp attempt.
- [PacManRecomp: a native recompilation of NES Pac-Man](https://awesomerea.org/resources/pacmanrecomp-case/index.md): Case study · PacManRecomp builds a native Windows version of the 1993 Namco NES Pac-Man by translating the player's ROM from 6502 code to C with NESRecomp. Its launcher, runtime, and game additions are in the repository; the released package generates the game-code DLL on the player's computer. It also adds settings, high scores, mod support, and optional gameplay changes.
- [Parasite Eve: PlayStation static recompilation](https://awesomerea.org/resources/parasite-eve-recomp/index.md): Case study · This statically recompiles the two-disc USA release of Parasite Eve with PSXRecomp and recomp-ui. Both discs contain the same executable, and each passed a startup test. Release 0.3.3 is Windows x64. The v0.3.5 packages add Linux x64 and macOS on Apple Silicon and Intel, and remain candidates until their startup gates pass. OpenBIOS covers setup.
- [PaxDino: a Turok: Rage Wars static recompilation](https://awesomerea.org/resources/paxdino-turok-rage-wars-case/index.md): Case study · PaxDino statically recompiles the Nintendo 64 game Turok: Rage Wars with N64Recomp for a native PC port on N64ModernRuntime and RT64. Its own analysis, hooks and library patches support widescreen rendering, modern controls, local multiplayer and netplay.
- [payne-recomp: a native recompilation of Max Payne for Xbox](https://awesomerea.org/resources/payne-recomp-case/index.md): Case study · payne-recomp translates the PAL Xbox release of Max Payne into C on the user's machine and builds native Windows or Apple Silicon programs against DirectXbox-Recomp. Game-specific seeds, symbols and overrides accompany the build; the author reports that all 67 levels load in short scripted checks.
- [PC-3Ddot: statically recompiling 3D Dot Game Heroes for PC](https://awesomerea.org/resources/pc-3ddot-case/index.md): Case study · PC-3Ddot develops a native PC port of the PS3 game 3D Dot Game Heroes by statically recompiling its EBOOT for the ps3kit runtime. It includes a disc reader, file-format documentation and tools for inspecting the executable and assets. The author reports that the recompiled game reaches playable field maps, including combat and movement between maps.
- [pc-4ddriving: a native port of 4D Driving](https://awesomerea.org/resources/pc-4ddriving-case/index.md): Case study · pc-4ddriving ports the FM Towns Marty game 4D Driving by recompiling its 386 program and TBIOS into C++ with fmtownskit. Its SDL3 runtime supports windowed and headless play, and the project compares frames, races and audio with MAME while documenting the disc layout and game resource formats.
- [pc-abelsmt: statically recompiling ABEL for PC](https://awesomerea.org/resources/pc-abelsmt-case/index.md): Case study · pc-abelsmt ports the FM Towns game ABEL - Shin Mokushiroku Taisen to PC by statically recompiling its 386 programs and TBIOS to C++ on fmtownskit. It includes a runtime, extraction and comparison tools, and notes on disc and executable formats. The author reports that early screens match MAME pixel for pixel.
- [pc-arcrisefantasia: statically recompiling Arc Rise Fantasia for PC](https://awesomerea.org/resources/pc-arcrisefantasia-case/index.md): Case study · pc-arcrisefantasia builds a native PC port of the North American Wii release of Arc Rise Fantasia by translating its PowerPC code to C++ and running it on wiikit's replacement Wii runtime. Its tools extract the user's disc, identify functions in the stripped DOL with signatures and manual evidence, and compile the translated code. The author reports gameplay through the first battle.
- [pc-castlevaniajudgment: statically recompiling Castlevania Judgment for PC](https://awesomerea.org/resources/pc-castlevaniajudgment-case/index.md): Case study · pc-castlevaniajudgment builds a native PC port of the Wii game Castlevania Judgment by translating its PowerPC executable to C++ with wiikit. Game-specific scripts identify functions using Dolphin symbols and a related executable, while a hook layer maps controller state. The author reports reaching menus, save creation and fights in an initial session.
- [pc-conduit2: statically recompiling Conduit 2 for PC](https://awesomerea.org/resources/pc-conduit2-case/index.md): Case study · pc-conduit2 statically recompiles the North American Wii release of Conduit 2 from PowerPC code to C++ for a native PC port. Its tools and notes map the disc and stripped main.dol, recover function names, and integrate with wiikit; the author reports gameplay through the first level with keyboard, mouse, or gamepad input.
- [pc-deepfear: statically recompiling Deep Fear for PC](https://awesomerea.org/resources/pc-deepfear-case/index.md): Case study · pc-deepfear investigates the European Sega Saturn release of Deep Fear and statically recompiles its program toward a native PC port using saturnkit. Its notes map both discs, data formats, SH-2 code and the SCU DSP, while local scripts build and compare the translated C++ against an interpreter. The author reports reaching the first playable room.
- [pc-demolitionman: statically recompiling the 3DO Demolition Man](https://awesomerea.org/resources/pc-demolitionman-case/index.md): Case study · pc-demolitionman documents a static-recompilation port of the 3DO game Demolition Man using 3dokit. It translates the game's ARM60 programs into C++, boots a user-supplied disc through a Portfolio runtime, and records Gamegun input and boot behavior. The author reports reaching the attract loop and playing light-gun levels in a window.
- [pc-dragonquestswords: a partial static recompilation of Dragon Quest Swords for PC](https://awesomerea.org/resources/pc-dragonquestswords-case/index.md): Case study · pc-dragonquestswords ports the European Wii release of Dragon Quest Swords toward native PC execution by statically recompiling its PowerPC code to C++ and providing a replacement runtime through wiikit. Its notes map the disc, FPK archives and stripped executable; the author reports that the current port reaches the opening and early tutorial battles.
- [pc-finalfantasy12revenantwings: a static recompilation port of Final Fantasy XII: Revenant Wings](https://awesomerea.org/resources/pc-finalfantasy12revenantwings-case/index.md): Case study · pc-finalfantasy12revenantwings ports the European Nintendo DS release of Final Fantasy XII: Revenant Wings to PC by statically recompiling its ARM9 and ARM7 programs and six overlays to C++. The ndskit runtime replaces DS hardware, while repository tools and notes examine the cartridge, packed data, movies and executable layout. The author reports playing from a new game into the second chapter.
- [pc-megamanxcm: a native Mega Man X: Command Mission port](https://awesomerea.org/resources/pc-megamanxcm-case/index.md): Case study · pc-megamanxcm develops a native PC port of Mega Man X: Command Mission from the European GameCube release. It maps names from a symbol table left on the disc to the stripped DOL, then uses wiikit to translate PowerPC code to C++ and replace console hardware services. The author reports play through the opening scenes with audio; saving remains unavailable.
- [pc-monsterhunter3: a static recompilation of Monster Hunter Tri](https://awesomerea.org/resources/pc-monsterhunter3-case/index.md): Case study · pc-monsterhunter3 ports the European Wii release of Monster Hunter Tri to PC by translating its PowerPC executable and 21 RSO modules into C++ with wiikit. The repository records disc and code findings and supplies game-specific hooks. The author reports reaching the village and a first quest with gamepad input.
- [PC-ROA: statically recompiling Ragnarok Odyssey ACE for PC](https://awesomerea.org/resources/pc-roa-ragnarok-odyssey-ace-case/index.md): Case study · PC-ROA investigates the PS3 disc and executable of Ragnarok Odyssey ACE and statically recompiles the game's code to C++ for a PC runtime. Its repository includes disc readers, format documentation, extraction tools, and a separate reimplementation used for comparison. The author reports that the current build reaches the first quests and fights.
- [pc-thelaststory: statically recompiling The Last Story for PC](https://awesomerea.org/resources/pc-thelaststory-case/index.md): Case study · pc-thelaststory statically recompiles the European Wii release of The Last Story for a native PC port. Its tools identify functions in the stripped PowerPC executable and use wiikit to translate them to C++ while a runtime replaces Wii services. The author reports play from the title screen into the first chapter at 30 frames per second.
- [pc-thequeenofduellist: a native port of The Queen of Duellist](https://awesomerea.org/resources/pc-thequeenofduellist-case/index.md): Case study · pc-thequeenofduellist ports the FM Towns game The Queen of Duellist by recompiling its 386 program and TBIOS code into C++ with fmtownskit. Its runtime displays the game in an SDL3 window, while tools compare frames and audio against MAME; the repository also documents the disc layout, executable and resource formats.
- [pc-virtualhydlide: statically recompiling Virtual Hydlide for PC](https://awesomerea.org/resources/pc-virtualhydlide-case/index.md): Case study · pc-virtualhydlide ports the European Sega Saturn release of Virtual Hydlide toward PC by statically recompiling fifteen SH-2 programs to C++ and running them with saturnkit. Its notes document disc structure, game files, executable behavior, video and sound; the author reports playable output and an optional interpolated display between the game's logic frames.
- [Peggle 2 for Mac: an Apple Silicon static recompilation](https://awesomerea.org/resources/peggle-2-mac-case/index.md): Case study · Peggle 2 for Mac statically translates the Xbox 360 game's PowerPC code to C++ with XenonRecomp for Apple Silicon. Its runtime replaces console kernel calls, renders translated shaders through Metal, decodes XMA audio with FFmpeg and accepts a player's own game file during local installation.
- [Perfect Dark XBLA PC Recomp: statically recompiling the Xbox 360 remaster](https://awesomerea.org/resources/perfect-dark-xbla-recomp/index.md): Case study · This recompiles the 2010 Xbox 360 remaster of Perfect Dark to Windows with ReXGlue. The launcher imports title ID 584109C2. Supported packages begin with 4287CC74 or 8292DB97. The README lists play up to 4K and 60 fps, with keyboard, mouse, and LAN or virtual-LAN multiplayer for up to 8 players.
- [Persona 3 FES Recompiled: a PS2 static recompilation](https://awesomerea.org/resources/persona-3-fes-recompiled-case/index.md): Case study · Persona 3 FES Recompiled translates the PS2 game's MIPS R5900 executable to C++ and runs it with replacement EE, IOP, graphics, audio, and storage services. Its game-specific function map and configuration drive the recompiler. The author reports play through the opening story and a Tartarus area loaded from a memory card save; sound effects are silent and battles remain untested.
- [PES 2017 Android: recompiling the Xbox 360 game for ARM64](https://awesomerea.org/resources/pes2017-android-recomp-case/index.md): Case study · PES 2017 Android recompiles the European Xbox 360 release of Pro Evolution Soccer 2017 into an ARM64 Android app. XenonRecomp translates PowerPC code to C++, while the project's runtime replaces console kernel, graphics and audio services; the author reports that a match plays on a Galaxy S20 FE.
- [PES6 native: a Windows recompilation of Pro Evolution Soccer 6](https://awesomerea.org/resources/pes6-native-case/index.md): Case study · PES6 native builds a Windows x64 version of the European Xbox 360 release of Pro Evolution Soccer 6 by translating its PowerPC code to C++ with ReXGlue. The repository supplies project manifests, a ReXGlue SDK patch, native host code, an ISO extractor, and a builder that uses the player's own game copy.
- [PGR4-Recomp: statically recompiling Project Gotham Racing 4](https://awesomerea.org/resources/pgr4-recomp/index.md): Case study · PGR4-Recomp ports Project Gotham Racing 4 to x86-64. It uses the ReXGlue SDK to generate C++ ahead of time, and a DirectX renderer based on Plume. The README credits xextool for extracting the XEX from a dumped ISO, and points the launch steps to Setup.md. It describes the current tree as unfinished, with a later v2 still in progress.
- [Pilotwings 64: Recompiled — a native N64 static recompilation port](https://awesomerea.org/resources/pilotwings-64-recompiled-case/index.md): Case study · Pilotwings 64: Recompiled ports the USA N64 game to Windows and Linux with N64Recomp. Game-specific C patches widen the 3D view and move the HUD, while matrix interpolation supports higher display frame rates.
- [Pinyon Shift: a ShiftGlue static recompilation of Forza Horizon for PC](https://awesomerea.org/resources/pinyon-shift-forza-horizon-recomp-case/index.md): Case study · Builds a native port of the Xbox 360 release of Forza Horizon by translating its PowerPC executable ahead of time into C++ with ShiftGlue, the author’s fork of ReXGlue, and compiling it on the player’s machine from their own disc. A renderer written for this game runs its GPU commands on Vulkan, and some translated library code, such as FMOD Ex DSP units, is replaced by independently written native code checked against the translated original. README presents it as a playable preview with rendering bugs and slowdowns.
- [Pinyon Shift: statically recompiling Forza Horizon for Windows](https://awesomerea.org/resources/pinyon-shift/index.md): Case study · Pinyon Shift statically recompiles Forza Horizon for the Xbox 360 to Windows. The USA retail disc is serial MS-2505, title ID 4D5309C9. ShiftGlue, a fork of ReXGlue, translates the PowerPC code to C++. Vulkan 1.3 is the default renderer and Direct3D 12 is the other option. Internal resolution can reach 4K. Release notes are at 0.3.0. NVIDIA GPUs are the ones qualified so far. The README's checklist still has the Android runtime port unchecked.
- [PiratesAtWorldsEndRecomp: recompiling Pirates of the Caribbean: At World's End](https://awesomerea.org/resources/pirates-awe-recomp/index.md): Case study · This recompiles Pirates of the Caribbean: At World's End for the Xbox 360, USA disc, to Windows. The launcher installs the game from the player's ISO. The default renderer is NativeXRenderer. Xenos is the fallback renderer. The README reports 60 fps at the original game speed, and widescreen through 21:9. The first levels have been played in hour-long sessions. Later levels are still untested. Releases are a setup executable and a windows-x64 zip.
- [Plants vs. Zombies: Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/pvz-console-edition-case/index.md): Case study · pvz-console-edition converts the Xbox 360 Plants vs. Zombies release into a native Windows program by translating its PowerPC code to x86-64 with ReXGlue. It imports the user's XBLA package or disc image and adds mouse controls across menus, gameplay, mini-games, and local multiplayer.
- [PokemonRedAndBlueRecomp: static recompilation of Pokémon Red and Blue](https://awesomerea.org/resources/pokemon-red-blue-recomp-case/index.md): Case study · PokemonRedAndBlueRecomp translates the Game Boy code of Pokémon Red and Blue into C with a fork of gb-recompiled and compiles it as a native x64 program. It loads game data from the user's ROM and falls back to an interpreter for code paths missed by static analysis.
- [Pokopia Native: native builds of Pokémon Pokopia from a user dump](https://awesomerea.org/resources/pokopia-native-case/index.md): Case study · Pokopia Native builds native Mac, iPhone and Windows versions of the Switch 2 game Pokémon Pokopia from the user's own dump. Its Windows path recompiles the game's arm64 code through LLVM for a native runtime and Vulkan renderer, while the Apple builds run the game's code on Apple silicon with Metal graphics.
- [Pokopia Recomp: recompiling Pokémon Pokopia for Windows](https://awesomerea.org/resources/pokopia-recomp/index.md): Case study · Pokopia Recomp rebuilds Pokémon Pokopia for Nintendo Switch 2, version 2.0.1a, as a native Windows program. PokopiaLauncher.exe takes an extracted dump, or NSP and XCI files with the owner's key files, compiles the game, and then builds a shader cache. Windows 10 or 11 x64, Vulkan 1.3, and 16 GB of RAM are required. A source build copies exefs into game/dump/exefs and runs recomp/scripts/build_game.cmd pkp, then game-build/scripts/build.ps1. The toolchain is Visual Studio 2022 Build Tools, LLVM, CMake, Ninja, Python 3.13, the .NET 8 SDK, vcpkg, Rust, and Node.js.
- [Pokémon Generation I: static recompilation with trace-driven testing](https://awesomerea.org/resources/pokemon-generation-one-recomp-case/index.md): Case study · Pokémon Red, Blue and Yellow are built as native executables by translating their Game Boy SM83 code into C with gb-recompiled. The repository adds game-specific build recipes, PyBoy trace capture and a headless Red and Blue bridge for differential memory and frame testing. The author reports Red gameplay, Blue reaching its title screen and Yellow's opening sequence rendering.
- [Portal 2: static recompilation for Apple silicon](https://awesomerea.org/resources/portal-2-apple-silicon-recomp-case/index.md): Case study · Portal 2 is statically recompiled from its Linux x86 modules into a native ARM64 application for macOS and iPhone. Preparation tools lay out ELF modules and apply relocations; a lifter emits C functions that are compiled with a runtime for libc, threading, SDL2, graphics and Steam interfaces. The author reports playable builds on Mac and iPhone.
- [Power Dozer: statically recompiling Blast Corps](https://awesomerea.org/resources/power-dozer-case/index.md): Case study · Power Dozer statically recompiles Blast Corps USA Rev 1 with N64Recomp and runs it through N64ModernRuntime and RT64 on Windows and Linux. The game code is generated locally from the player's ROM; the project documents beta checks and remaining graphics, audio and gameplay coverage work.
- [Prince of Persia 2: statically recompiling the DOS game for Windows](https://awesomerea.org/resources/pop2-windows/index.md): Case study · This statically recompiles the DOS executable PRINCE.EXE from Prince of Persia 2 into C and links it with a Windows runtime. Game logic, rendering, the intro, and the music driver stay the original code. VGA, the timer, the keyboard, and Sound Blaster or AdLib are replaced. The launcher is PoP2 Launcher.exe.
- [Project 8 Plus: a native recompilation of Tony Hawk's Project 8](https://awesomerea.org/resources/project-8-plus-case/index.md): Case study · Project 8 Plus builds a native PC port of the PS3 Tony Hawk's Project 8 from a user's game copy. Its launcher uses RPCS3 for setup decryption and ps3recomp for static recompilation, then adds display options, texture upscaling, and Lua mod support.
- [Project Arwing (2): Star Fox 2 recompiled from a matching disassembly](https://awesomerea.org/resources/project-arwing-2-star-fox-2-recomp-case/index.md): Case study · Rebuilds Star Fox 2 from a coverage-seeded 65816 and SuperFX disassembly that reassembles to the original ROM, then translates it statically to C for native Windows, macOS and Linux builds. Unreached code and RAM code that differs from the ROM run through an interpreter, and the README reports identical per-frame hashes against interpreted runs. It accepts the SNES Classic release image, not the 1995 prototypes; results remain project-reported.
- [Project Arwing: Star Fox recompiled from a matching disassembly](https://awesomerea.org/resources/project-arwing-star-fox-recomp-case/index.md): Case study · Disassembles Star Fox’s 65816 and SuperFX code from runtime coverage and recursive descent, reassembles it into the original ROM, then translates it statically to C on a from-scratch SNES runtime for Windows, macOS and Linux. Code never reached in recorded sessions, and RAM code that no longer matches the ROM, falls back to an interpreter; the README reports identical per-frame hashes for both paths. The generated C is a mechanical translation rather than hand-decompiled source, and results remain project-reported.
- [Project Gotham Racing 2: an Xbox XBE static recompilation](https://awesomerea.org/resources/pgr2-recomp-case/index.md): Case study · pgr2-recomp ports the original Xbox release of Project Gotham Racing 2 to Windows by statically recompiling its x86 XBE code. The port reimplements Xbox graphics, audio and system services and documents executable variants, XDK libraries and game-specific GPU command behavior.
- [Project Gotham Racing: an Xbox static recompilation for Windows](https://awesomerea.org/resources/project-gotham-racing-recomp-case/index.md): Case study · Project Gotham Racing is ported from the original Xbox to Windows by statically recompiling the game's x86 code with Xbox XBE Recomp. The port supplies Windows implementations of Xbox graphics, sound and system interfaces and builds the game from the user's disc. Its findings also document XBE sections and the GOTHPOK asset container.
- [Project Helghast: a static recompilation of Killzone 3 for PC](https://awesomerea.org/resources/project-helghast-killzone-3-case/index.md): Case study · Project Helghast builds a native PC port of the PS3 game Killzone 3 by statically recompiling code from a user's US disc dump, version 1.14 update, and decrypted EBOOT with ps3recomp. Its Windows build uses Direct3D 12 and can run under Proton on Linux. The author reports partial playability, with levels loading and playing while performance and rendering defects remain.
- [Project Pyrrhus: a static recompilation of Killzone 2 for PC](https://awesomerea.org/resources/project-pyrrhus-killzone-2-case/index.md): Case study · Project Pyrrhus builds a native Windows x64 port of the PS3 game Killzone 2 by statically recompiling code from a user's disc, matching version 1.29 update, and decrypted EBOOT. Its tooling lifts PPU code with a patched ps3recomp and builds a Direct3D 12 executable. The author reports that the prerelease reaches menus and plays the first level.
- [Project Tandem: statically recompiling Mario Kart: Double Dash!! for online PC play](https://awesomerea.org/resources/project-tandem-mkdd-case/index.md): Case study · Project Tandem statically recompiles the USA GameCube release of Mario Kart: Double Dash!! from the player's disc image into a native Windows program. It builds on gcn-recomp and adds online multiplayer, widescreen display, controller support, and mouse and keyboard controls.
- [Project Vekta: a static recompilation of Killzone HD](https://awesomerea.org/resources/project-vekta-case/index.md): Case study · Project Vekta builds a native Linux or Windows port of the PS3 game Killzone HD by translating its PPU and SPU code to C++ with a patched ps3recomp. Its runtime replaces PS3 services and replays graphics commands through Vulkan; players generate the game code locally from their own files.
- [Proving Ground Recompiled: a native Tony Hawk's Proving Ground port](https://awesomerea.org/resources/proving-ground-recompiled-case/index.md): Case study · Proving Ground Recompiled builds a native PC port of Tony Hawk's Proving Ground from its Xbox 360 PowerPC executable. ReXGlue translates game code to C++ ahead of time, while a project runtime renders through Vulkan and adds frame pacing, display, and launcher controls. The author reports playable Windows gameplay; Linux gameplay remains untested.
- [PSP2I_Recomp: a native Phantasy Star Portable 2 Infinity port](https://awesomerea.org/resources/psp2i-recomp-case/index.md): Case study · PSP2I_Recomp uses psprecomp to generate native code from Phantasy Star Portable 2 Infinity's PSP EBOOT.BIN and builds host programs for Windows, Android and experimental Apple Silicon macOS. Its source supplies game hooks, rendering, SDL3 input and audio integration.
- [PSPRecomp: statically recompiling GTA: Vice City Stories into a native Windows build](https://awesomerea.org/resources/psprecomp-vice-city-stories-case/index.md): Case study · Provides a PSP static-recompilation framework that analyzes Allegrex/MIPS executables and emits C++ for a native host runtime. Its Vice City Stories profile checks in code generated for the US ULUS-10160 executable, plus HLE, Direct3D 12 rendering, audio and input layers. The decrypted executable and game data come from the user’s own copy, and no gameplay status is published.
- [Quest 64 Tale: Recompiled — a native Quest 64 port with runtime adaptations](https://awesomerea.org/resources/quest-64-tale-recompiled-case/index.md): Case study · Quest 64 Tale: Recompiled builds a native Windows and Linux port of the USA release of Quest 64 using N64Recomp, N64ModernRuntime and RT64. Its own runtime adaptations and gameplay handlers support ROM selection, Controller Pak saves, graphics options and optional mods.
- [Quest 64: Recompiled — a static recompilation port](https://awesomerea.org/resources/quest-64-recompiled-case/index.md): Case study · Quest 64: Recompiled turns the North American N64 release of Quest 64 into a native port through N64Recomp static translation. RT64 renders the game, and the program loads assets from the player's ROM. The port adds configurable graphics, controls and mod support.
- [rac-rs: a static recompilation of Ratchet & Clank for PC](https://awesomerea.org/resources/rac-rs-case/index.md): Case study · rac-rs ports the 2002 PlayStation 2 Ratchet & Clank to PC by statically recompiling code from the user's disc into Rust. A Rust PS2 CPU core runs the translated game logic, while native code handles graphics, audio, input and saving; selected rewritten functions are compared with original game memory.
- [RaceWave46: an AI-assisted Wave Race 64 recompilation for Windows](https://awesomerea.org/resources/racewave46-wave-race-64-recomp-case/index.md): Case study · Recompiles the USA Rev 1 Nintendo 64 release of Wave Race 64 into a native Windows application with N64Recomp and RSPRecomp, on modified copies of the N64ModernRuntime, RecompFrontend and RT64 stacks. Game and microcode C is generated locally from the user’s ROM, after an included widescreen patch is applied to a temporary copy, and checked against recorded checksums. The port adds higher resolutions, frame interpolation, ultrawide views, rasterized and ray-traced reflections and shadows, split-screen or separate-window two-player play and RetroAchievements; the maintainer calls it an AI-assisted recompilation.
- [Racing 8 DX Recomp: statically recompiling Mario Kart 8 Deluxe](https://awesomerea.org/resources/racing-8-dx-recomp-case/index.md): Case study · Racing 8 DX Recomp builds Mario Kart 8 Deluxe for Linux by translating user-supplied AArch64 game code to C and compiling it ahead of time with a patched suyu-derived engine. Its launcher handles local inputs, while a native graphics path and plugins provide Vulkan rendering and upscaling. Android support is in development, and Windows support is planned.
- [Rampage Recompiled: static ports of two N64 games](https://awesomerea.org/resources/rampage-recompiled-case/index.md): Case study · Rampage Recompiled builds native ports of Rampage: World Tour and Rampage 2: Universal Tour by running N64Recomp on the user's N64 ROMs. Project symbol maps, stubs, and hooks feed generated code into N64ModernRuntime and RT64. The author reports both games boot and play, with controller-pak saves still absent.
- [RampageRE: a native reconstruction of Rampage: Total Destruction](https://awesomerea.org/resources/rampagere-case/index.md): Case study · RampageRE rebuilds Rampage: Total Destruction for native platforms using a PS2Recomp static recompilation as a reference and replacement code for game formats, rendering, and systems. Its documentation covers scripts, bundles, effects, monsters, and other game data; the port reads data from the player's PS2 disc.
- [Ratchet & Clank: Tools of Destruction: a PS3 static recompilation](https://awesomerea.org/resources/ratchet-tools-of-destruction-recomp-case/index.md): Case study · Ratchet & Clank: Tools of Destruction Recompiled translates the European PS3 game’s PPU and SPU code to C/C++ ahead of time with ps3recomp. The Windows port replaces PS3 system libraries and RSX graphics with native implementations and Direct3D 12, while building game data from the user’s disc.
- [Rayman 3 HD Recompiled: statically recompiling the Xbox 360 game](https://awesomerea.org/resources/rayman3-hd-recompiled-case/index.md): Case study · Rayman 3 HD Recompiled is a native Windows port of Rayman 3 HD for the Xbox 360. The game's code is statically recompiled to run on a PC, and the installer sets it up from the player's own Xbox 360 package.
- [Rayman Origins Recompiled: translating the Xbox 360 game for desktop and Android](https://awesomerea.org/resources/rayman-origins-recompiled-case/index.md): Case study · Rayman Origins Recompiled translates the Xbox 360 game's PowerPC executable to native C++ for desktop and Android. A game-specific detector recovers jump tables missed by XenonAnalyse, while host code supplies Xbox 360 services and a Vulkan renderer draws frames with translated shaders. The author reports gameplay with audio and controls on Apple Silicon macOS and Android.
- [rb2: Dragon Ball Z Budokai HD recompiled with ReXGlue](https://awesomerea.org/resources/dbz1-budokai-hd-case/index.md): Case study · DBZ1 is a ReXGlue-based recompilation project for Dragon Ball Z Budokai HD. It provides a function-map configuration and a native host that loads the game's XEX image, initializes the runtime and opens a game window.
- [RB2: recompiling Dragon Ball: Raging Blast 2](https://awesomerea.org/resources/rb2-recomp-case/index.md): Case study · RB2 is a recompilation of Dragon Ball: Raging Blast 2 made with the ReXGlue SDK.
- [Re-Cherry: recompiling Lollipop Chainsaw](https://awesomerea.org/resources/re-cherry-lollipop-chainsaw-case/index.md): Case study · Re-Cherry builds a ReXGlue-based version of the Xbox 360 game Lollipop Chainsaw from a user's extracted game image. Its C++ host sources include game hooks and a costume switcher, and the build invokes ReXGlue code generation before CMake compilation.
- [re-Sonic06Demo: a ReXGlue recompilation of the Sonic the Hedgehog (2006) demo](https://awesomerea.org/resources/re-sonic06demo-case/index.md): Case study · re-Sonic06Demo uses the ReXGlue SDK to recompile the Sonic the Hedgehog (2006) demo and build a native executable. The author reports that the demo can be played from start to finish, with slowdowns especially during videos; it currently supports gamepad input only.
- [re-wor: statically recompiling Guitar Hero: Warriors of Rock](https://awesomerea.org/resources/re-wor-case/index.md): Case study · re-wor is a static recompilation of Guitar Hero: Warriors of Rock for Xbox 360, built for Windows with the RexGlue SDK. It is based on re-gh2. The repository does not include game assets.
- [re:Blue — native static recompilation of Blue Dragon](https://awesomerea.org/resources/reblue/index.md): Case study · re:Blue statically recompiles Blue Dragon into a native program. The setup checks a disc image from each of the three retail discs. Windows is x86-64 with DirectX 12. Linux covers AMD64 and ARM64, including SteamOS 3.6. macOS is ARM64 and needs macOS 13.3 or later. cmake --preset win-amd64-release and cmake --build --preset win-amd64-release build it. The same presets exist for linux-amd64, linux-arm64, mac-amd64, and mac-arm64. The build uses the ReXGlue SDK.
- [Reach Cache Debug: recompiling a Halo debug executable](https://awesomerea.org/resources/reach-cache-debug-recomp-case/index.md): Case study · Reach Cache Debug Recomp uses ReXGlue to recompile halo3_cache_debug.xex from a Reach-era Xbox 360 debug build. It supplies debug-service stubs, memory and socket hooks, and virtual filesystem mappings for the executable.
- [reblue: recompiling Blue Dragon from DVD 1](https://awesomerea.org/resources/reblue-xbox360-blue-dragon-case/index.md): Case study · reblue uses ReXGlue to recompile Blue Dragon from game files extracted from DVD 1, then builds a native executable with game-specific file, memory and patch code. The author reports that this part is barely playable and that support for the full game remains in progress.
- [Recompia: a native Pokémon Pokopia build for Windows](https://awesomerea.org/resources/recompia-case/index.md): Case study · Recompia builds a native Windows version of the Switch 2 game Pokémon Pokopia from the user's extracted game files. The project extends pokopia-native with its own game-build code and launcher, and describes a setup process that compiles the game and prepares a shader cache. It also documents Linux use through Proton.
- [ReCompiled Steel: a Real Steel static recompilation with Vulkan rendering](https://awesomerea.org/resources/recompiled-steel-case/index.md): Case study · ReCompiled Steel builds native Windows, Linux and Android versions of Xbox 360 Real Steel through ReXGlue static recompilation. Its game-specific Vulkan renderer consumes the Xbox command stream and shaders translated ahead of time; game code and shader caches are generated from the user's copy.
- [Red Dead Revolver - XBE Recomp: an original Xbox static recompilation port](https://awesomerea.org/resources/red-dead-revolver-xbe-recomp-case/index.md): Case study · Red Dead Revolver - XBE Recomp ports the original Xbox game to Windows through static recompilation with Xbox XBE Recomp. It uses game files supplied by the user and adds display and graphics settings, texture dumping and replacement, and keyboard, mouse and controller input.
- [RedBaron_Recomp: a Snoopy Flying Ace Xbox 360 recompilation](https://awesomerea.org/resources/redbaron-snoopy-flying-ace-case/index.md): Case study · RedBaron_Recomp builds a native Windows x64 version of the Xbox 360 game Snoopy Flying Ace with ReXGlue and ReXAuto. Its launcher extracts the player's game files, generates code and compiles the port locally; repository patches adapt the runtime for graphics, controls and online services.
- [Redline Recompiled: Forza Motorsport ported by static recompilation](https://awesomerea.org/resources/redline-recompiled-forza-motorsport-case/index.md): Case study · Redline Recompiled ports the 2005 Xbox release of Forza Motorsport to Windows by statically translating the game’s x86 code and supplying new graphics, sound and input layers. Its launcher extracts and builds from the user’s USA Rev 1 disc image or game folder. The project includes an x86-to-C lifter, function-discovery tools and a host runtime.
- [reGH2: recompiling Guitar Hero II for Linux](https://awesomerea.org/resources/regh2/index.md): Case study · reGH2 recompiles Guitar Hero II for the Xbox 360, USA, to a Linux program with a native Vulkan renderer. The supported default.xex has SHA-1 b90b864487e6291761b207c8d0064e9a0779bdee and title ID 415607E7. Pre-release 0.2.1 has been played in Quick Play and in Career through the fourth venue. Resolutions include 1080p, 1440p, and 4K.
- [ReGTA Chinatown Wars PSP Recompilation: a native Windows port](https://awesomerea.org/resources/regta-chinatown-wars-case/index.md): Case study · ReGTA Chinatown Wars PSP Recompilation targets the Europe v1.01 PSP release of Grand Theft Auto: Chinatown Wars for a Windows x64 port. Its C++20 mainline compiles original MIPS control flow ahead of time and supplies PSP services, graphics and audio; the repository also documents analysis of the original executable.
- [Renegade Squadron: static recompilation of the PSP game for Windows](https://awesomerea.org/resources/renegade-squadron-pc/index.md): Case study · This statically recompiles Star Wars Battlefront: Renegade Squadron for the PSP, US ULUS10292, into a Windows executable. BOOT.BIN is checked against SHA-256 f4c7a9ef93475fc8017f649346ef79b599649dc47462ec419e9fd373146f8c68. Vulkan is the default renderer, and DirectX 12 remains selectable. The game frame rate is raised from the PSP's 20 fps to 60 fps. The program is RenegadeSquadron.exe.
- [reNut: recompiling Banjo-Kazooie: Nuts & Bolts](https://awesomerea.org/resources/renut/index.md): Case study · reNut recompiles the USA release of Banjo-Kazooie: Nuts & Bolts with the ReXGlue SDK. The current release hooks the game's D3D calls through Plume and compiles shaders from XenosRecomp into the executable. The launcher extracts a USA ISO and Title Update 3, and can add a DLC package. It runs on Windows and Linux. The README says physics misbehave above 60 FPS, and the frame limit is set to 60 under F4, Performance. Online play uses RexLiveless, opened with F10 or the guide button.
- [reo: recompiling Resident Evil Outbreak for Windows](https://awesomerea.org/resources/reo-outbreak/index.md): Case study · reo recompiles Resident Evil Outbreak for the PlayStation 2, NTSC-U SLUS-20765, to native Windows x86-64 with PS2Recomp. The README says a scripted boot reaches the first scenario in J's Bar, drawn by the game's own code, at about 35 times slower than real time. Sound output is not implemented, and play past that point has not been tried.
- [ReRevved: statically recompiling Civilization Revolution](https://awesomerea.org/resources/rerevved/index.md): Case study · ReRevved statically recompiles Civilization Revolution for the Xbox 360. The Windows program is rerevved.exe and uses Direct3D 12. Linux x64 uses Vulkan. macOS arm64 needs Apple silicon, Vulkan, and macOS 13.3 or newer. The first run asks for the player's ISO or extracted folder and for the version 1.3 update. The SDK is a BSD-3-Clause fork of ReXGlue.
- [ReShadowTower: recompiling Shadow Tower for PC](https://awesomerea.org/resources/reshadowtower/index.md): Case study · ReShadowTower recompiles Shadow Tower for the PlayStation, USA SLUS-00863, for Linux and Windows x64. The first launch compiles the game from the player's BIN/CUE. OpenBIOS is included. Unsupported paths fall back to an interpreter. The README says not every gameplay path is verified as native code.
- [Resident Evil 3: Nemesis Recompiled: a PlayStation setup candidate](https://awesomerea.org/resources/resident-evil-3-nemesis-recomp-case/index.md): Case study · Resident Evil 3: Nemesis Recompiled provides a title-specific PSXRecomp setup candidate for the European PlayStation release. Its wizard is configured to take the user's SLES-02529 disc, matching SBI companion and SCPH-5502/5552 BIOS for local code generation and compilation. The repository includes configuration, seed data and setup code.
- [Resident Evil Gaiden: Recompiled](https://awesomerea.org/resources/regaiden-recomp-case/index.md): Case study · Resident Evil Gaiden: Recompiled is a native static recompilation of Resident Evil Gaiden for the Game Boy Color. Release 0.4.1 targets Windows and Android ARM64, with Linux marked as work in progress. Rendering uses SDL2, OpenGL ES 3, and Dear ImGui.
- [ReStuff: recompiling Naughty Bear Gold Edition](https://awesomerea.org/resources/naughty-bear-restuff-case/index.md): Case study · ReStuff statically recompiles the Xbox 360 game Naughty Bear Gold Edition using the ReXGlue SDK. Its host code includes Vulkan rendering, guest D3D hooks, texture decoding and shader translation, while diagnostic scripts and reports track game-specific boot and graphics behavior.
- [reUndr 2: porting Need for Speed: Underground 2 to PS5](https://awesomerea.org/resources/reundr2-ps5-case/index.md): Case study · reUndr 2 ports the original Xbox Need for Speed: Underground 2 to homebrew-enabled PS5 consoles using ahead-of-time C translation and a replacement graphics, audio and input runtime. Its PS5 host builds on an existing recompilation and loads game files from the user's own Xbox disc image.
- [Ridge Racer 6 Recomp: an Xbox 360 static recompilation](https://awesomerea.org/resources/ridge-racer-6-recomp-case/index.md): Case study · Ridge Racer 6 Recomp translates the Xbox 360 game's PowerPC program to C++ for a native Windows build on ReXGlue. Its launcher extracts the user's disc image, while game-specific code addresses saves, input, display and rendering behavior; the repository also records SDK issues found during bring-up.
- [Ridge Racer Type 4: PlayStation static recompilation](https://awesomerea.org/resources/ridge-racer-type4-recomp/index.md): Case study · This recompiles Ridge Racer Type 4 for the PlayStation with PSXRecomp. The project configuration targets the USA release SLUS-00797. The Windows launcher expects Ridge_Racer_4_Recompiled.exe beside launcher/ and bios/. It can use the bundled OpenBIOS or a BIOS the player supplies.
- [Ring Out: native PC port of a GameCube fighting game](https://awesomerea.org/resources/ring-out-case/index.md): Case study · Ring Out is a native PC port of a GameCube fighting game with disc ID GRSEAF, produced by static recompilation. The README says the disc's PowerPC executable is translated ahead of time into C, compiled for x86-64, and run in a Dolphin-derived runtime.
- [Rise of Legends: static recompilation of the Win32 game](https://awesomerea.org/resources/rise-of-legends-static-recomp-case/index.md): Case study · Rise of Legends statically recompiles the game's final Win32 executable to native C with pcrecomp, then runs the lifted code in a 32-bit host that maps the original image and binds its imports. The author reports playable Quick Battle skirmishes and progress into the Vinci campaign's first mission from a build assembled using the user's retail discs.
- [Road Rash 64 Recompiled: a native PC port of the N64 game](https://awesomerea.org/resources/road-rash-64-recompiled-case/index.md): Case study · Road Rash 64 Recompiled builds a PC version of the N64 game from the user's USA v1.0 ROM. The project provides Windows and experimental Linux packages, game-specific rendering and input changes, and optional local import of Mario Kart 64 tracks from a second user-supplied ROM.
- [Road Trip Adventure: a PlayStation 2 recompilation](https://awesomerea.org/resources/road-trip-recomp/index.md): Case study · This statically recompiles Road Trip, Choro Q HG 2 for the PlayStation 2, USA SLUS-20398, to Windows, macOS, and Android with PS2Recomp. The first launch reads the player's disc image and compiles the game on the device. Render scale goes up to 4x. Extra frames at 120 and 240 Hz are redrawn from the game's geometry. The Windows archive is RoadTripRecomp-<version>-Windows-x64.zip. The disc check compares the image with the Redump dump.
- [Robotech: Battlecry: statically recompiling the Xbox game for PC](https://awesomerea.org/resources/robotech-battlecry-native-port-case/index.md): Case study · Robotech: Battlecry ports the 2002 Xbox game to PC by statically recompiling a user-supplied XBE into C and linking it to a replacement Xbox runtime. The project adds an x86 frontend, symbol maps, handwritten engine code and Direct3D 11, sound and input bridges. The author reports that the menu and selected missions run, with frame comparisons against xemu.
- [Rocket-R: a native Rocket: Robot on Wheels port](https://awesomerea.org/resources/rocket-r-case/index.md): Case study · Rocket-R brings Rocket: Robot on Wheels to Windows, Linux, and Android. Release 1.0.2 uses RocketRet's matching decompilation, N64Recomp, RSPRecomp, N64ModernRuntime, RT64, and SDL2. Packages cover Windows x64, Steam Deck, Linux x64, Linux ARM64, and Android ARM64.
- [Rockstar Games presents Table Tennis: Xbox 360 recompilation for PC](https://awesomerea.org/resources/rockstar-table-tennis-case/index.md): Case study · This is a Windows x64 recompilation of Rockstar Games presents Table Tennis for the Xbox 360. The game code is recompiled with ReXGlue SDK 0.10.0 and rendered with DirectX 12. Gameplay is paced at 60 FPS.
- [Rogue Galaxy Recompiled: native Windows build of Rogue Galaxy](https://awesomerea.org/resources/rogue-galaxy-recomp-case/index.md): Case study · Rogue Galaxy Recompiled is a native Windows build of the USA PlayStation 2 release SCUS-97490, statically recompiled with PS2Recomp. Version 0.2.0 is an early pre-release. The README says the whole game plays, with full-playthrough testing still pending.
- [Rogue Squadron 3D: a native PC port by static recompilation](https://awesomerea.org/resources/rogue-squadron-3d-recomp-case/index.md): Case study · Rogue Squadron 3D recompiles the Steam PC release of Star Wars: Rogue Squadron 3D from x86 machine code to C with pcrecomp and runs the result in a 32-bit Windows host. The host adapts DirectDraw display handling and input, while generated code and original game files are produced or copied from the user's installation.
- [Rondorecomp: a partial static recompilation of Castlevania: Rondo of Blood](https://awesomerea.org/resources/rondorecomp-case/index.md): Case study · Rondorecomp translates Castlevania: Rondo of Blood’s PC Engine CD HuC6280 code into C at build time and runs it against C models of the console’s CPU, video, CD, input, and System Card services. Its analysis directory contains boot-chain disassembly and tools for code discovery and data decoding. The author reports rendering the intro and file-select screens and reaching the prologue, with much of the game still unverified.
- [RROP: a static recompilation of Rings of Power](https://awesomerea.org/resources/rrop-rings-of-power-case/index.md): Case study · RROP statically translates the Sega Genesis Rings of Power 68000 and Z80 programs into C for native Linux and Windows builds. Its runtime models console memory, video, input and sound, while game-specific additions provide widescreen rendering, font replacement and saves.
- [RubySapphireRecomp: statically recompiling Pokémon Ruby and Sapphire](https://awesomerea.org/resources/ruby-sapphire-recomp/index.md): Case study · RubySapphireRecomp statically translates Pokémon Ruby and Sapphire USA revision 1 ROMs into native C. Ruby SHA-1 is 610b96a9c9a7d03d2bafb655e7560ccff1a6d894. Sapphire SHA-1 is 4722efb8cd45772ca32555b98fd3b9719f8e60a9. The runtime refuses an unrecognized ROM. The files are variants/ruby/roms/ruby_usa.gba and variants/sapphire/roms/sapphire_usa.gba. gba_recompile writes the generated C, and cmake --build build --target RubyRecomp builds one executable.
- [Rumble Roses XX: experimental Xbox 360 static recompilation](https://awesomerea.org/resources/rumble-roses-xx-recomp-case/index.md): Case study · Rumble Roses XX Recomp is an experimental Windows port that translates the Xbox 360 game's PowerPC program into C++ with XenonRecomp and supplies memory, kernel, filesystem, input and graphics interfaces. The author reports an internal frame loop, rendered scenes and one playable match. That match used a locally modified GPU plugin absent from the published source.
- [RumbleRecomp: a Windows static recompilation of Poke Rumble](https://awesomerea.org/resources/rumblerecomp-case/index.md): Case study · RumbleRecomp builds a Windows version of Poke Rumble from the user's USA WiiWare WAD. It statically recompiles the game's PowerPC code to C, compiles it with clang, and runs it on a patched Dolphin and ModernGekko runtime. The port adds widescreen display, save states, controller support and optional texture packs.
- [rushrecomp: static recompilation and analysis of Sonic Rush](https://awesomerea.org/resources/rushrecomp-case/index.md): Case study · rushrecomp translates Sonic Rush's Nintendo DS ARM9 and ARM7 code to C ahead of time with ndsrecomp and maintains a parallel manual x86-32 path based on decompiled subsystems. Its notes map ROM functions and hardware accesses, while the manual path records partial function coverage and unresolved stubs.
- [SacredStonesRecomp: statically recompiling Fire Emblem: The Sacred Stones](https://awesomerea.org/resources/sacred-stones-recomp/index.md): Case study · This statically recompiles Fire Emblem: The Sacred Stones for the Game Boy Advance to Windows x64 and Android ARM64. The USA ROM SHA-1 is c25b145e37456171ada4b0d440bf88a19f4d509f. The runtime refuses any other checksum. The save is 32 KiB SRAM. Debug port 19842. Release 0.1.20 is SacredStonesRecomp-0.1.20-win64.zip. Android packages target Android 9 or newer.
- [Saint Seiya: The Hades: a PS2 static recompilation for Linux](https://awesomerea.org/resources/saint-seiya-recomp-case/index.md): Case study · Saint Seiya: The Hades is ported to Linux by translating the European PS2 executable's MIPS R5900 functions to C and building them with a native runtime. The runtime models PS2 CPU, IOP, graphics and audio services, reads the user's disc image, and renders through Vulkan or a software GS; the author reports that the separate assembly rebuild matches the original byte for byte.
- [Saints Reborn: a ReXGlue static recompilation of Saints Row](https://awesomerea.org/resources/saints-reborn-recomp-case/index.md): Case study · An unofficial native Windows port of Saints Row (Xbox 360, 2006) that statically recompiles the game's PowerPC executable to C++ for x86-64 with the ReXGlue SDK, which also reimplements the console's kernel, GPU (on Direct3D 12), audio and input. A recompiler manifest, game-specific function overrides and an SDK patch make the result run, and each user builds it locally from their own disc. The README reports the game fully playable with built-in co-op and lists known issues.
- [Saints Row: static recompilation of the Xbox 360 game](https://awesomerea.org/resources/saints-row-360/index.md): Case study · Version 0.1.0 statically recompiles Saints Row for the Xbox 360, NTSC-U title ID 545107D1, to Windows with ReXGlue. It boots through the logos and menu, and New Game reaches Player Creation and then Stilwater on foot, with graphics, audio, and controller input. The first mission, combat, vehicles, and Load Game are untested. The installer is SaintsRow-Installer-windows-x64.exe. A checkout can use Setup.cmd and Play.cmd. The first build takes 30 to 60 minutes and needs about 20 GB free.
- [Samurai Shodown: Warriors Rage Recomp — a PlayStation native build](https://awesomerea.org/resources/samurai-shodown-warriors-rage-recomp-case/index.md): Case study · Samurai Shodown: Warriors Rage Recomp configures PSXRecomp to generate a native build of the USA PlayStation game. The repository includes title symbols, function seeds and code-generation setup; the author reports that the Windows build is playable.
- [San Francisco Rush 2049: Recompiled — an N64 static recompilation](https://awesomerea.org/resources/san-francisco-rush-2049-recompiled-case/index.md): Case study · San Francisco Rush 2049: Recompiled translates the Nintendo 64 game's MIPS code to C with N64Recomp and runs it through N64ModernRuntime and RT64. The port adds game-specific patches for rendering, controls, audio and saves, and provides Windows and browser builds that load a player's ROM. The author reports playable Windows races and browser play in Chrome.
- [San Francisco Rush — Recompiled: an N64 static recompilation](https://awesomerea.org/resources/san-francisco-rush-recompiled-case/index.md): Case study · San Francisco Rush — Recompiled analyzes the N64 game's boot segment and LZSS-compressed main code, then prepares a patched ROM for N64Recomp's MIPS-to-C translation. The repository includes symbol maps, decompression tools and runtime code; boot and rendering remain unfinished.
- [San Recompiled: statically recompiling Grand Theft Auto V for Xbox 360](https://awesomerea.org/resources/san-recomp/index.md): Case study · San Recompiled is a static recompilation of the Xbox 360 version of Grand Theft Auto V, using XenonRecomp to translate PowerPC code to C++. The build system covers Windows, Linux, and macOS, and the installer accepts an ISO, a folder, or XContent. Shader conversion, the GPU pipeline, audio, and save data are still open.
- [Savage Wind Recomp: statically recompiling The Legend of Zelda: Breath of the Wild](https://awesomerea.org/resources/savagewindrecomp/index.md): Case study · Savage Wind Recomp is an in-progress static recompilation of the Nintendo Switch version of The Legend of Zelda: Breath of the Wild for Windows and Linux. It builds native game code locally from the player's extracted files; the README reports playable early areas but says the full story remains unconfirmed.
- [Scooby-Doo Refrightened: recompiling Night of 100 Frights for Windows](https://awesomerea.org/resources/scooby-doo-refrightened/index.md): Case study · This recompiles Scooby-Doo! Night of 100 Frights for the GameCube, 2002, into a Windows program with WiiCompiled. The supported disc is USA version 1.01, product code GIHE78, revision 1, as ISO, GCM, or CISO. The README lists resolutions up to 4K, widescreen or 4:3, 30 or 60 fps, MSAA, and HDR.
- [Scooby-Doo: Re-Masked: a static recompilation of Scooby-Doo! Unmasked](https://awesomerea.org/resources/scooby-doo-re-masked-case/index.md): Case study · Scooby-Doo: Re-Masked statically translates the GameCube release of Scooby-Doo! Unmasked to C++ with WiiCompiled for a Windows port. Its runtime handles console graphics, audio and system calls, while the launcher extracts game data from the user's disc image.
- [SD Gundam: Dimension War Recompiled: a Virtual Boy static recompilation](https://awesomerea.org/resources/sd-gundam-dimension-war-recompiled-case/index.md): Case study · SD Gundam: Dimension War Recompiled builds a native Windows version of the Japanese Virtual Boy game with vbrecomp and recomp-ui. It generates cartridge code from the user's ROM and includes optional English, color and adaptive widescreen mods plus tools comparing opening-mission state and output against Beetle.
- [Sega Rally Championship: lifting Model 2A i960 code to a host runtime](https://awesomerea.org/resources/sega-rally-model2-recomp-case/index.md): Case study · The Sega Rally Championship project compiles lifted i960 code from the Model 2A arcade game into a host executable. It pairs game and library C with a portable Model 2 runtime, disassembly artifacts and ROM extraction scripts. On first run, the host extracts the required data from user-supplied board dumps and offers cold-boot and practice-start targets.
- [Sega Superstars Tennis ReMatch: an Xbox 360 static recompilation](https://awesomerea.org/resources/sega-superstars-tennis-rematch-case/index.md): Case study · Sega Superstars Tennis ReMatch builds a native Windows and Linux port of the Xbox 360 game with ReXGlue. Its renderer translates Xbox 360 shaders for Direct3D 12 and Vulkan, with build-time shader packing and runtime compilation for shaders generated during play.
- [Sexy Parodius Recompiled: a PlayStation recompilation build kit](https://awesomerea.org/resources/sexy-parodius-recompiled-case/index.md): Case study · Sexy Parodius Recompiled configures PSXRecomp to generate and compile the Japanese PlayStation release of Sexy Parodius from a user-supplied disc. The repository contains game-specific identity, symbols, seeds and build configuration; the author reports a Windows build reaching the title screen and attract-mode gameplay.
- [SF2Recomp: statically recompiling Shadow Fight 2 for native platforms](https://awesomerea.org/resources/sf2recomp-case/index.md): Case study · SF2Recomp converts a user's Shadow Fight 2 Nintendo Switch game files into native builds for Linux, Windows, macOS, and Android. Its converter combines translated game code with a runtime and user-supplied assets, adding controls, graphics options, sparring, and LAN play.
- [sh2-nx: Switch port of Silent Hill 2](https://awesomerea.org/resources/sh2-nx/index.md): Case study · sh2-nx is a native Nintendo Switch port of the PC version of Silent Hill 2, Director's Cut / Restless Dreams, with support for Silent Hill 2: Enhanced Edition packs. The game's x86 executable is statically recompiled to C and compiled for the Switch ARM64 CPU, and the Windows layer it expects is reimplemented with SDL2, OpenGL, and FFmpeg. The README also documents a Linux x86-64 build.
- [sh4-nx: a Nintendo Switch recompilation of Silent Hill 4](https://awesomerea.org/resources/sh4-nx-case/index.md): Case study · sh4-nx statically translates the GOG Windows executable of Silent Hill 4: The Room into C and builds it for Nintendo Switch ARM64. It adapts an existing Windows API runtime, bridges additional game imports and patches widescreen presentation; the author reports running it on Switch and in a Linux test build.
- [Shadow of the Colossus: a PS3 static recompilation reaching the flip loop](https://awesomerea.org/resources/shadow-of-the-colossus-ps3-recomp-case/index.md): Case study · Shadow of the Colossus uses ps3recomp to lift the PS3 HD remaster's EBOOT and eight SPU images into a native Windows build. The author reports that the build reaches cellGcmInit and the display flip loop, then stalls before opening nico.psarc because SPURS 2.0 support is missing.
- [Shadow the Hedgehog: a PS2 static recompilation checkpoint](https://awesomerea.org/resources/shadow-the-hedgehog-ps2-recomp-case/index.md): Case study · Shadow the Hedgehog Recomp translates the PS2 game's MIPS and VU code into native C++ with PS2Recomp and links it to ps2xRuntime. The author reports static compilation, linking and bootloader initialization; video bypass, menus, input and 3D gameplay remain unfinished.
- [Shantae Recomp: a Game Boy Color static recompilation](https://awesomerea.org/resources/shantae-recomp-case/index.md): Case study · Shantae Recomp uses gbrecompiled to translate the USA Game Boy Color Shantae ROM into native code for Windows and Linux. Its game-specific hooks, ROM investigations and checks support an expanded view, movement changes, a map, rewind and shader presets.
- [Shining Force III Recomp: a Sega Saturn static recompilation for PC](https://awesomerea.org/resources/shining-force-iii-recomp-case/index.md): Case study · Shining Force III Recomp generates C++ from the SH-2 code on supported Sega Saturn discs and compiles a native PC port with graphics, sound, and storage services. Exact-content profiles cover the original US Scenario 1 and selected translated revisions of Scenarios 1–3; the author reports playable selected Windows routes.
- [Silent Hill 3: a native Nintendo Switch port](https://awesomerea.org/resources/sh3-nx/index.md): Case study · sh3-nx is a native Nintendo Switch port of the PC version of Silent Hill 3, release v0.06. The x86 executable is statically recompiled to C and compiled for ARM64. Direct3D 8, DirectSound, DirectInput, and kernel32 are reimplemented on SDL2 and OpenGL.
- [SimCity 4 Deluxe: static recompilation from the Steam executable](https://awesomerea.org/resources/simcity-4-static-recompilation-case/index.md): Case study · SimCity 4 Deluxe statically recompiles the user's Steam game executable into locally generated C with pcrecomp and runs it in a native32 host. The repository supplies setup, lift and runtime code while excluding generated game source and assets. The author reports that scripted runs load a region and city, simulate a month and save data the original game can load.
- [Sin & Punishment: a work-in-progress N64 static recompilation](https://awesomerea.org/resources/sin-punishment-recompiled-case/index.md): Case study · Sin & Punishment: Recompiled uses N64Recomp and RSPRecomp to build an experimental native C++ port from a user-supplied Japanese N64 ROM and the repository's symbol maps, with RT64 rendering. The author reports that it reaches the title screen; menu navigation, gameplay, audio validation, and a public pipeline for its patched working image remain unfinished.
- [Sin and Punishment: a Windows and Android N64 static recompilation](https://awesomerea.org/resources/snprecomp-case/index.md): Case study · snprecomp ports the N64 game Sin and Punishment to Windows and Android by statically recompiling the Japanese ROM with N64Recomp. It uses N64ModernRuntime and RT64, and includes symbol work, ROM variant handling, mouse aiming and Android touch controls.
- [Skate 2 PC Recompilation: an Xbox 360 game port through ReXGlue](https://awesomerea.org/resources/skate-2-pc-recompilation-case/index.md): Case study · Skate 2 PC Recompilation translates the Xbox 360 release of Skate 2 into a native Windows build with the ReXGlue SDK and a user-supplied disc image. Its title-specific configuration adds missed function entry points and a jump-table override, while SDK patches address rendering and runtime faults.
- [Skate 2 PC: recompiling the Xbox 360 game for Windows](https://awesomerea.org/resources/skate-2-pc-case/index.md): Case study · Skate 2 PC recompiles the Xbox 360 version of Skate 2 into a native Windows port using ReXGlue. It translates graphics through Direct3D 12, checks the supplied game revision during import, and adds controller input, local saves, and selectable rendering and frame rate profiles.
- [Skate 3 Mobile: an Android ARM64 fork of Skate3Recomp](https://awesomerea.org/resources/skate3-mobile-android-recomp-case/index.md): Case study · Carries the Skate3Recomp static recompilation of the Xbox 360 Skate 3 to Android: rexglue translates the configured PowerPC guest functions, and Android Clang compiles them into ARM64 libraries linked against a compatibility runtime. Runtime hooks pass the game’s meshes, textures and shader state to a native Vulkan scene renderer, and this fork adds SDL3 input and audio, a multitouch overlay and handheld performance profiles. The author calls it an experimental developer build that is playable on the Anbernic RG406V.
- [Skate 3 Recomp: a native Xbox 360 recompilation through ReXGlue](https://awesomerea.org/resources/skate3-recomp-case/index.md): Case study · Recompiles the Xbox 360 version of Skate 3 into native Windows, Linux and macOS builds with a Skate-specific fork of the ReXGlue SDK. Since v2.0.0 a native Direct3D 12 and Vulkan renderer with ports of the game’s own material shading replaces emulation of the Xbox 360 GPU, which remains as a fallback. Game files come from the user’s disc image; the author calls the native renderer early and has not tested the game end to end.
- [Skate 3: an early XenonRecomp boot experiment](https://awesomerea.org/resources/skate-3-xenonrecomp-experiment-case/index.md): Case study · This Skate 3 experiment uses XenonRecomp to analyze an Xbox 360 default.xex and generate PowerPC-derived C++ for a Windows build. Its launcher imports and validates a user-supplied ISO or extracted dump, while the runtime stages XEX loading and a guarded generated-code entry bridge.
- [skate: statically recompiling the Xbox 360 game for Windows](https://awesomerea.org/resources/skate1-recompiled/index.md): Case study · This recompiles skate (2007) for the Xbox 360 into a Windows program with a ReXGlue fork. The README says the game boots and that the intro videos, menus, audio, career start, and Freeskate work. A portable.txt file beside the executable keeps saves in a userdata folder.
- [Skies of Arcadia Legends: Recompiled — a native GameCube game port](https://awesomerea.org/resources/skies-of-arcadia-legends-recomp/index.md): Case study · This is a native port of the GameCube game Skies of Arcadia Legends for Windows, Linux, macOS, and Android. It translates the PowerPC code ahead of time and uses Dolphin's graphics, sound, and input code. The documented beta is v0.83. Select Disc accepts the original USA, European, or Japanese release, game IDs GEAE8P, GEAP8P, and GEAJ8P, as RVZ, ISO, GCM, GCZ, WIA, or CISO. The Japanese disc is Eternal Arcadia Legends. Windows 10 version 1703 or 11 runs Skies of Arcadia Legends.exe. Linux uses an AppImage or the unpacked binary. macOS 13 or later is Apple silicon. Android is 7.0 or newer on arm64.
- [Skullburglar: statically recompiling 50 Cent: Blood on the Sand](https://awesomerea.org/resources/skullburglar-case/index.md): Case study · Skullburglar is a native port of 50 Cent: Blood on the Sand for the Xbox 360, statically recompiled with the ReXGlue SDK. Ready-to-play builds target Windows, macOS on Apple silicon, Linux, and the Steam Deck. Version 1.0 adds a renderer written for the port that reads the game's scene from memory.
- [SkyboundTOTK: a native static recompilation of Tears of the Kingdom](https://awesomerea.org/resources/skyboundtotk-case/index.md): Case study · SkyboundTOTK statically recompiles The Legend of Zelda: Tears of the Kingdom into a native Windows or Linux executable. Its build translates the game's AArch64 code to C, compiles it locally, supplies expected runtime services and translates graphics work and shaders for WebGPU. The author describes graphics and compatibility as incomplete.
- [Slip Stream: static recompilation of a Sega System 32 arcade game](https://awesomerea.org/resources/slipstream-recomp-case/index.md): Case study · Slip Stream translates the arcade game's V60 program from the player's ROM into C and runs it with a Sega System 32 board model on Windows or Linux. The translation driver follows reference execution to emit functions. The author reports matching state hashes against a MAME based reference runner over 1,800 frames and a separate video comparison during development; the port remains unfinished.
- [SM35 Recomp: static recompilation of Super Mario Bros. 35](https://awesomerea.org/resources/sm35-recomp-case/index.md): Case study · SM35 Recomp statically recompiles the player's Super Mario Bros. 35 v1.0.2 code into C and runs it with a native runtime and Metal or Vulkan graphics. Its game-specific layer handles setup, patches and Nextendo online services; the author reports Course Practice and two-player battle testing.
- [SMM2 Recomp: a Super Mario Maker 2 static recompilation](https://awesomerea.org/resources/smm2-recomp-case/index.md): Case study · SMM2 Recomp translates Super Mario Maker 2 v3.0.3 AArch64 code into C ahead of time and builds it for native platforms. Its runtime supplies Switch system services and renders NVN graphics through Metal or Vulkan. The launcher generates game-derived code and data locally from the player's dump.
- [smo-recomp: statically recompiling Super Mario Odyssey for Windows](https://awesomerea.org/resources/smo-recomp-case/index.md): Case study · smo-recomp is a native Windows x64 build of Super Mario Odyssey version 1.4.1. The game's AArch64 code is translated to C ahead of time and compiled for the PC, with a project runtime and a Vulkan renderer.
- [SMT NINE Recomp: native port of Shin Megami Tensei NINE](https://awesomerea.org/resources/smt-nine-recomp/index.md): Case study · SMT NINE Recomp is a native Windows port of Shin Megami Tensei NINE for the original Xbox, built with xboxrecomp. The default build is Japanese, translated from the player's Japanese retail disc. A Chinese translation is optional. Config can import an ISO patched with an English translation.
- [smt4-recomp: a 3DS Shin Megami Tensei IV static recompilation](https://awesomerea.org/resources/smt4-recomp-case/index.md): Case study · smt4-recomp builds a native PC version of the USA 3DS release of Shin Megami Tensei IV by translating its ARM code to C with 3dsrecomp. Zakuro supplies the kernel, services, graphics and sound runtime; project overrides add widescreen and gameplay options.
- [Snap64 Recomp: a static-recompilation port of Pokémon Snap](https://awesomerea.org/resources/snap64-recomp-case/index.md): Case study · Uses N64Recomp to statically recompile the US Nintendo 64 release of Pokémon Snap into a native Windows, Linux, Steam Deck and macOS port rendered with RT64. The recompiler reads a relocatable ELF linked from the matching ethteck/pokemonsnap decompilation together with the user’s ROM, and game-side patches are modified copies of decompiled functions. The author reports building the port with Claude Code; results remain project-reported.
- [SnapPad: a Pokémon Snap static recompilation for Apple devices](https://awesomerea.org/resources/snappad-pokemon-snap-case/index.md): Case study · SnapPad builds a native Apple version of Pokémon Snap from a user-supplied US ROM using the game's decompilation, N64Recomp, RSPRecomp, and RT64. Its integration supplies Metal rendering, touch and controller input, private ROM setup, and persistent saves for iPhone, iPad, and Apple silicon Mac.
- [Sneak King: an original Xbox static recompilation](https://awesomerea.org/resources/sneaky-whopper-recomp-case/index.md): Case study · Sneak King statically recompiles the original Xbox game into a native Windows port and an experimental WebAssembly build. A vendored xboxrecomp pipeline lifts functions from the user's default.xbe into C, while project code supplies Xbox runtime services and translates Direct3D 8 graphics through OpenGL ES 3 and ANGLE.
- [Snowboard Kids 2: Recompiled — a native N64 static recompilation](https://awesomerea.org/resources/snowboard-kids-2-recompiled-case/index.md): Case study · Snowboard Kids 2: Recompiled ports the Nintendo 64 game to native systems through N64: Recompiled, using RT64 for rendering. It loads assets from the user's North American ROM and includes game-specific patches, display options, and mod support. Build instructions describe ROM decompression, code generation, and compilation.
- [Snowboard Kids Recompiled: a native N64 recompilation for PC](https://awesomerea.org/resources/snowboard-kids-recompiled-case/index.md): Case study · Snowboard Kids Recompiled runs the USA Nintendo 64 game as a native Linux or Windows application using N64Recomp, RT64 and a separate game module. It validates a player-supplied ROM and adds desktop input, Controller Pak persistence, savestates and rendering settings around the recompiled game logic.
- [Snowboard Kids: Recompiled — an N64 static recompilation port](https://awesomerea.org/resources/snowboardkids-recompiled-case/index.md): Case study · Snowboard Kids: Recompiled uses N64Recomp to translate the N64 game into a native port and RT64 to render it. It accepts the North American and Japanese ROMs, loads game assets from the user's copy, and includes game-specific patches for widescreen, frame rate behavior and controls. Its source also supports mods and texture packs.
- [Soleanna: a static recompilation of Sonic the Hedgehog (2006) for PC](https://awesomerea.org/resources/soleanna-sonic-2006-case/index.md): Case study · Soleanna builds a native Windows port of the PlayStation 3 version of Sonic the Hedgehog (2006) from the user's BLES00028 disc. Its launcher decrypts EBOOT.BIN with RPCS3, uses ps3recomp to translate PowerPC code to C, and compiles an x86-64 executable with a high-level PS3 runtime and Direct3D 12 rendering.
- [Sonic 3 & Knuckles — Recompiled: native PC build](https://awesomerea.org/resources/sonic3k-recomp/index.md): Case study · This recompiles Sonic 3 & Knuckles, and also offers separate Sonic 3 and Sonic & Knuckles builds, with segagenesisrecomp. Release v0.7.3 provides Windows x64 ZIPs and Linux x86_64 AppImages. Sonic3KRecomp is the combined game. The launcher asks for the matching ROM. High refresh rate options in v0.7.0 are 120, 144, or the display rate, while gameplay and music keep their normal speed.
- [Sonic Adventure 2 — Nintendo Switch port: an Xbox 360 static recompilation](https://awesomerea.org/resources/sa2-nx-case/index.md): Case study · The Sonic Adventure 2 Nintendo Switch port translates the Xbox 360 game's default.xex and stage-data module to C++ with ReXGlue and draws through a deko3d renderer. Its repository includes game-specific code, renderer changes and notes on executable behavior. The author reports near-60 FPS single-player results in tested scenes, with heavier two-player scenes running slower.
- [Sonic Generations Recompiled: an Xbox 360 static recompilation](https://awesomerea.org/resources/sonic-generations-recompiled-case/index.md): Case study · Sonic Generations Recompiled translates the Xbox 360 game's PowerPC code into native C++ with XenonRecomp and builds host services for kernel calls, audio, input, files and graphics. A newer Windows path uses ReXGlue with Vulkan graphics experiments; the author describes both paths as incomplete for game-level play.
- [Sonic the Fighters (PC): a ReXGlue native port](https://awesomerea.org/resources/sonic-fighters-xbla-pc-case/index.md): Case study · Sonic the Fighters (PC) uses a game-specific ReXGlue manifest to translate the player's XBLA default.xex from PowerPC instructions into C++ and build a native PC or Linux program. The author describes the current port as single player and controller driven.
- [Sonic the Hedgehog Recompiled Runner: a Genesis static recompilation](https://awesomerea.org/resources/sonic-the-hedgehog-recompiled-runner-case/index.md): Case study · Sonic the Hedgehog Recompiled Runner uses a Genesis recompiler to analyze a Sonic 1 ROM and emit native C functions for its 68K routines. Its game-specific runner executes those functions with a backend for VDP graphics, bus behavior, Z80 scheduling, audio synthesis and controllers. Adaptive widescreen and higher refresh presentation are optional features.
- [Sonic the Hedgehog: a Master System Z80 static recompilation](https://awesomerea.org/resources/sonic-the-hedgehog-sms-recomp-case/index.md): Case study · SonicTheHedgehogSMSRecomp translates the Sega Master System Sonic the Hedgehog Z80 program ahead of time into native C with smsggrecomp. Its game configuration records ROM identity and control-flow data, while the runtime models video, sound, ports, and the mapper; unresolved computed jumps can use a Z80 interpreter.
- [SonicBlastGGRecomp: a Game Gear Sonic Blast static recompilation](https://awesomerea.org/resources/sonic-blast-gg-recomp-case/index.md): Case study · SonicBlastGGRecomp configures smsggrecomp to translate the Game Gear Sonic Blast Z80 program into native C from a user's ROM. Its game-specific configuration, build script and coverage suite accompany the runtime's modeled video, sound and mapper behavior; the author reports assisted scene coverage while unassisted play remains unverified.
- [SonicTheHedgehog2Recomp: a Sonic 2 native runner with ROM-derived code](https://awesomerea.org/resources/sonic-the-hedgehog-2-recomp-case/index.md): Case study · SonicTheHedgehog2Recomp runs Sonic the Hedgehog 2 through ROM-derived generated C and a native runner. Game-specific code handles saves, character options, wider stage rendering, and object visibility, while the Android instructions describe generating code from the user's ROM before cross-building.
- [Soulbrandt: a native Demon's Souls PC port](https://awesomerea.org/resources/soulbrandt-case/index.md): Case study · Soulbrandt converts the US PlayStation 3 release of Demon's Souls into a native Windows and Linux port using the player's game files. Setup uses RPCS3 to decrypt the required files or accepts files the player has decrypted, then builds the port locally. The project includes game-specific analysis, runtime integration, rendering, controls and online services.
- [Soulcalibur II HD: statically recompiling the PS3 game for Mac and PC](https://awesomerea.org/resources/soulcalibur2hd-recomp-case/index.md): Case study · This project runs the PlayStation 3 game Soulcalibur II HD Online natively on a Mac or PC. ps3recomp translates the PowerPC and Cell SPU code ahead of time. Graphics use Metal on macOS and Vulkan on Linux and Windows.
- [Soulcalibur II Recomp: a native Xbox game port by static recompilation](https://awesomerea.org/resources/soulcalibur-ii-recomp-case/index.md): Case study · Soulcalibur II Recomp translates the Xbox release's program ahead of time into C and runs it on a native runtime for macOS, Linux, Windows and Android. It builds from the user's Xbox disc and can convert optional Link and Heihachi content from the user's GameCube and PlayStation 2 discs. Documentation covers the executable lift, runtime and guest-content conversion.