# Curated reverse engineering resources · Page 22

> Page 22 of 52, entries 2,101–2,200. 5,191 tools, projects, integrations, case studies, and references for websites, games, apps, native binaries, firmware, and communication protocols.

Source-reviewed means descriptions were checked against primary documentation. Each entry page lists the full requirements and sources; this page shows their counts and the review date.

- HTML: <https://awesomerea.org/resources/page/22/>
- JSON: <https://awesomerea.org/api/v1/resources.json>
- 简体中文: <https://awesomerea.org/zh/resources/page/22/index.md>

## Games (100)

- [Shadow the Hedgehog: a three-region GameCube decompilation](https://awesomerea.org/resources/shadow-the-hedgehog-decomp-case/index.md): Case study · Shadow the Hedgehog decomp reconstructs source for the USA, Japanese and European/Australian GameCube releases. Its build extracts inputs from a user-owned disc image, compiles reconstructed files with pinned tools and uses objdiff for object-level comparison.
- [DKC3Recomp: a SNES static recompilation of Donkey Kong Country 3](https://awesomerea.org/resources/dkc3recomp-case/index.md): Case study · DKC3Recomp translates Donkey Kong Country 3's SNES code into C with snesrecomp, using game-specific bank configuration derived from a public disassembly. Native macOS and Windows hosts run the result, while the shared runtime interprets code the static analysis cannot resolve. The project also documents widened presentation and limited bring-up checks.
- [Crash Twinsanity: a C++ reconstruction of the PAL PS2 executable](https://awesomerea.org/resources/crash-twinsanity-decomp-case/index.md): Case study · Crash Twinsanity reconstructs the PAL PlayStation 2 game’s executable in C++, using a platform layer and data split from the user’s original executable. The author reports that the build boots and plays in PCSX2 with matching boot state, frame output and saves. The build tools also generate assembly from the user’s executable for a byte-matching comparison.
- [DRIG: a Race Driver: GRID engine reconstruction](https://awesomerea.org/resources/drig-race-driver-grid-case/index.md): Case study · DRIG reimplements Race Driver: GRID in Rust and Bevy, loading tracks, cars, textures, sounds, and other data from the user's PC installation. Its research uses Ghidra on grid.exe and compares reconstructed driving, AI, audio, and selected routines against original behavior. The author describes the playable engine as early and experimental.
- [Guxt Decompilation Project: reconstructing the Guxt game source](https://awesomerea.org/resources/guxt-decompilation-case/index.md): Case study · Guxt Decompilation Project reconstructs the 2007 Guxt shooter as C++ source. The author extends earlier work with reverse engineering and fixes; a compiled pxGame.exe uses data files obtained from the original game.
- [Aegis Wing: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/aegis-wing-xbla-pc-case/index.md): Case study · Aegis Wing XBLA PC Recomp builds a native Windows version of the Xbox 360 game through ReXGlue static recompilation. Its launcher imports game data from the user's package, while project code adds PC input, display settings, local scores, and LAN multiplayer.
- [Need for Speed: Underground: a GameCube prototype decompilation](https://awesomerea.org/resources/nfs-underground-gamecube-decomp-case/index.md): Case study · Need for Speed: Underground reconstructs source for the GameCube game's GNDP8P prototype dated September 10, 2003. Its build configuration, symbols, and split definitions support object-by-object comparison with objdiff after extracting the user's game executable.
- [LEGO Racers, portable: porting the decompiled game across platforms](https://awesomerea.org/resources/lego-racers-portable-case/index.md): Case study · LEGO Racers, portable adapts the 1999 game's decompiled source for Windows, macOS and Linux. It replaces Windows windowing, input, audio and rendering paths with SDL3 and miniaudio, and handles original AVI movies with an in-tree demuxer and Indeo 5 decoder.
- [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.
- [SM64 Scratch: rebuilding selected Super Mario 64 gameplay in Scratch](https://awesomerea.org/resources/sm64-scratch-case/index.md): Case study · SM64 Scratch builds a playable Scratch version of selected Super Mario 64 scenes from a user's USA ROM. Python decoders reconstruct textures, models, animations, collisions, and audio using recorded ROM offsets and conversion recipes; Scratch block patches implement gameplay based on the public decompilation. The initial beta includes the castle grounds, part of the castle interior, and Bob-omb Battlefield.
- [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.
- [CrossCraft: a Zig reconstruction of Minecraft Classic 0.30](https://awesomerea.org/resources/crosscraft-case/index.md): Case study · CrossCraft reconstructs Minecraft Classic 0.30 as a Zig client and server on the Aether engine. Shared code covers world generation, physics, saves and networking, and the project documents independent reverse engineering behind its compatible network protocol. It uses original or third-party licensed assets.
- [Command Series engine: playing Atari strategy games from disk images](https://awesomerea.org/resources/command-series-engine-case/index.md): Case study · Command Series engine recreates play for MicroProse's Crusade in Europe, Decision in the Desert and Conflict in Vietnam using the user's Atari ATR disk image. Its Go code includes game rules and interface modules, plus tools for disk reading, map and image extraction and disassembly. Music, sound, intros, endings and some visual effects are listed as missing.
- [SF1RE: reconstructing the Shining Force analysis database](https://awesomerea.org/resources/sf1re-case/index.md): Case study · SF1RE uses game-specific IDC scripts to rebuild an IDA Pro analysis database for the USA release of Shining Force. Its workflow imports labels and parsing rules, formats the ROM's code and data, and exports a split disassembly for the separate SF1DISASM project to rebuild and compare.
- [Teenage Mutant Ninja Turtles: Turtles in Time Re-Shelled — a static recompilation for PC](https://awesomerea.org/resources/tmnt-turtles-in-time-reshelled-recompiled-case/index.md): Case study · Teenage Mutant Ninja Turtles: Turtles in Time Re-Shelled Recompiled translates the Xbox 360 game's PowerPC code into C++ and builds a native PC port with the ReXGlue SDK. Its launcher extracts an exact Xbox Live Arcade package supplied by the user; the port adds PC display options and an online multiplayer service.
- [Children and Dog go Pew Pew (CadgPP): an N64 static recompilation port](https://awesomerea.org/resources/cadgpp-n64-port-case/index.md): Case study · Children and Dog go Pew Pew builds a native Windows and Linux port of an N64 game with N64Recomp and RT64. It uses the player's revision 0 ROM to generate translated code locally and adds modern controls, widescreen rendering, save states and locally generated textures.
- [Pokémon Rumble: an early Wii decompilation](https://awesomerea.org/resources/pokemon-rumble-decomp-case/index.md): Case study · The Pokémon Rumble project reconstructs C and C++ source for the Wii game, targeting USA revision WPSE01_01. Its workflow extracts main.dol from the owner's WAD, builds with Ninja and uses objdiff to compare changed objects; the author describes the work as very early.
- [METAL GEAR SOLID: THE TWIN SNAKES: a partial decompilation](https://awesomerea.org/resources/metal-gear-solid-twin-snakes-decomp-case/index.md): Case study · mgstts contains partial reconstructed C source for METAL GEAR SOLID: THE TWIN SNAKES. Its game-specific code includes region-selected stage character entries and a documented 24-bit string-hash routine, alongside headers named for game data formats.
- [Silent Engine: porting the original Silent Hill from decompiled code](https://awesomerea.org/resources/silent-engine-case/index.md): Case study · Silent Engine ports the original Silent Hill to a cross-platform C++ engine using logic migrated from a decompilation of the PlayStation game. It includes format loaders, asset streaming and a launcher that extracts original assets from the user's compatible ROM. Boot, video playback and some menus are partially functional.
- [Battlestations Pacific: an incremental Win32 C++ reconstruction](https://awesomerea.org/resources/battlestations-pacific-reconstruction-case/index.md): Case study · Reconstructs Battlestations Pacific's Win32 executable routine by routine as compilable MSVC C++ from Ghidra analysis. Addressed ledgers record ABI details, evidence, and uncertainty, while a milestone-based executable and focused probes exercise recovered subsystems.
- [How to Be a Complete Bastard: a SkoolKit disassembly](https://awesomerea.org/resources/how-to-be-a-complete-bastard-case/index.md): Case study · How to Be a Complete Bastard is a SkoolKit disassembly of the ZX Spectrum game. The repository keeps .skool source and helper scripts for producing browsable hexadecimal and decimal listings.
- [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.
- [Paper Mario: The Thousand-Year Door: seven-version matching decompilation](https://awesomerea.org/resources/ttyd-seven-version-decomp-case/index.md): Case study · This Paper Mario: The Thousand-Year Door fork reconstructs one C source tree for three GameCube retail releases and four demos. The author reports that each build reproduces its main executable and area REL files byte for byte; version-specific configurations and architecture notes accompany the code.
- [Arkanum: reconstructing Arcanum archives and map sectors](https://awesomerea.org/resources/arkanum-arcanum-formats-case/index.md): Case study · Arkanum reconstructs Arcanum game data formats as part of a Python engine recreation. Its code reads and extracts DAT archives and parses map-sector structures including tiles, roofs, scripts and blocked-tile arrays, with field layouts recorded beside the parsers.
- [ReGameDLL_CS: reconstructing the Counter-Strike server GameDLL](https://awesomerea.org/resources/regamedll-cs-case/index.md): Case study · ReGameDLL_CS reconstructs the Counter-Strike server GameDLL from the original HLDS Linux library using its embedded DWARF debug information. The replacement mp.dll or cs.so supports Counter-Strike 1.6 and Condition Zero and adds an extended API and gameplay settings.
- [Breath of Fire III Recompiled: a PlayStation overlay recompilation](https://awesomerea.org/resources/breath-of-fire-iii-recompiled-case/index.md): Case study · Breath of Fire III Recompiled translates the Japanese PlayStation game's MIPS code and disc-extracted overlays into C for a native build. Its documentation maps overlay loading, text and game systems; the author reports play through the opening areas while dynamic overlay entry-point coverage remains in progress.
- [widebrim: reimplementing the Professor Layton and Pandora's Box engine](https://awesomerea.org/resources/widebrim-case/index.md): Case study · widebrim recreates the Nintendo DS Layton 2 engine in Python and pygame, informed by decompilation research on the European Professor Layton and Pandora's Box release. It reads a user-provided ROM and implements game modes, puzzles and saves while documenting behavior it approximates or omits.
- [Marble Love: a differential TypeScript port of Marble Madness](https://awesomerea.org/resources/marble-love-case/index.md): Case study · Marble Love ports Marble Madness arcade routines from 68010 disassembly into a TypeScript engine and browser frontend. MAME traces and focused Musashi execution provide comparison data for gameplay, rendering and audio behavior; the project also documents a Slapstic prefetch finding.
- [Boss Rally / Top Gear Rally: matching decompilations and native ports](https://awesomerea.org/resources/boss-rally-top-gear-rally-case/index.md): Case study · Boss Rally / Top Gear Rally reconstructs the PC and N64 games as C source checked against their original machine code. The author reports that all 572 functions of the N64 release match byte for byte, while the Boss Rally PC work remains partly matched. Rally Builder creates native builds from users’ BIN/CUE or ROM copies.
- [Warsmash: reimplementing Warcraft III on LibGDX](https://awesomerea.org/resources/warsmash-warcraft-iii-case/index.md): Case study · Warsmash reimplements Warcraft III gameplay on LibGDX using assets from the user's own game installation. A configurable virtual file system reads MPQ archives, extracted folders, or CASC sources according to the installed patch, while Java source implements simulation, rendering, interface, and scripting components.
- [Devilution: reconstructing Diablo's original source](https://awesomerea.org/resources/devilution-case/index.md): Case study · Devilution reconstructs source for the original Diablo game from surviving symbols and debug information in PlayStation and PC releases. Its C++ code builds a replacement for Diablo.exe that uses the user's original game files. The project preserves original behavior, including bugs, and treats Hellfire support as future work.
- [Animal Crossing: Wild World: a native PC port of the decompilation](https://awesomerea.org/resources/animal-crossing-wild-world-native-case/index.md): Case study · Animal Crossing: Wild World, native compiles decompiled code from the USA Rev 1 Nintendo DS game into a PC program. A host layer supplies DS hardware services, SDL input, and CPU or WebGPU renderers; this branch changes the source for portability. The byte-matching ROM build is retained at the matching tag.
- [ZOE-Recompiled: statically recompiling Zone of the Enders for Windows](https://awesomerea.org/resources/zoe-recompiled-case/index.md): Case study · ZOE-Recompiled is a native Windows port of Zone of the Enders for the PlayStation 2, USA SLUS-201.48. PS2Recomp statically recompiles the MIPS code to C++. The runtime uses an OpenGL renderer, compiled vector-unit programs, and IOP and sound emulation.
- [Cryogenic: reimplementing the 1992 Dune game](https://awesomerea.org/resources/cryogenic-dune/index.md): Case study · Cryogenic is a C# reimplementation of Cryo's Dune, the 1992 CD version, running on Spice86. Builds target Linux, macOS, and Windows on .NET 10.
- [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.
- [Dragon Quest IX: matching Nintendo DS decompilation](https://awesomerea.org/resources/dqix-decomp-case/index.md): Case study · This project is a 1:1 disassembly and decompilation of Dragon Quest IX: Sentinels of the Starry Skies for the Nintendo DS. The primary focus is the USA and Japanese versions. European builds are produced from the USA sources.
- [iPod Click Wheel Recomps: statically recompiling six iPod games](https://awesomerea.org/resources/ipod-clickwheel-recomps/index.md): Case study · iPod Click Wheel Recomps translates six iPod click-wheel games from their ARM code into C++ that builds on current hardware. Mini Golf, Cubis 2, Hold 'Em, and the other listed games share a runtime. Mini Golf also targets Nintendo Switch and Android.
- [Kingdom Hearts: Chain of Memories — matching GBA decompilation](https://awesomerea.org/resources/khcom-decomp-case/index.md): Case study · This is a matching decompilation of Kingdom Hearts: Chain of Memories for the Game Boy Advance. It targets the US, Japanese, and European versions.
- [Las Marionetas: reimplementing The Sims 2](https://awesomerea.org/resources/las-marionetas/index.md): Case study · Las Marionetas is an open-source reimplementation of The Sims 2. Unimplemented functions still come from the original binary. The README says it currently runs on Windows and needs The Sims 2: Ultimate Edition installed.
- [Alien Resurrection: Recompiled — native PlayStation game port](https://awesomerea.org/resources/alien-resurrection-recomp-case/index.md): Case study · Alien Resurrection: Recompiled is a native macOS, Windows, and Linux port of Alien Resurrection for the PlayStation, USA SLUS-00633. The MIPS code is statically recompiled, and a runtime stands in for the PlayStation BIOS and hardware.
- [Mario Kart Wii: matching decompilation of the PAL game](https://awesomerea.org/resources/mkw-decomp-case/index.md): Case study · This is a work-in-progress decompilation of Mario Kart Wii. The supported version named in the README is the PAL release RMCP01.
- [u6-decompiled: decompiling Ultima VI: The False Prophet](https://awesomerea.org/resources/u6-decompiled-case/index.md): Case study · This repository decompiles the PC and MS-DOS version of Ultima VI: The False Prophet, version 4.5. It builds GAME.EXE and compares the result with the original. The C portions were built with Borland Turbo C 2.0.
- [MegaManX5Recomp: statically recompiling Mega Man X5 for Windows](https://awesomerea.org/resources/megaman-x5-recomp-case/index.md): Case study · MegaManX5Recomp is a native Windows build of Mega Man X5, USA SLUS-01334, statically recompiled with PSXRecomp. It includes an experimental simultaneous X and Zero co-op mode that uses OpenGL.
- [NitroSharp: reimplementing the N2System visual novel engine](https://awesomerea.org/resources/nitrosharp/index.md): Case study · NitroSharp is an open-source reimplementation of N2System, the visual-novel engine used by Nitroplus. The current target is Chaos;Head Noah on Windows x64, with Direct3D 11 and Vulkan, and on Linux x64 with Vulkan. The Linux build has no sound.
- [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.
- [DS Kart Recompiled: statically recompiling Mario Kart DS for PC](https://awesomerea.org/resources/ds-kart-recompiled-case/index.md): Case study · DS Kart Recompiled is a native PC port of the European Mario Kart DS, game code AMCP, made by static recompilation of the ARM9 and ARM7 code. A runtime supplies memory, interrupts, timers, the 2D and 3D engines, sound, saving, and controls.
- [Kirby's Epic Yarn: decompiling the USA Wii release](https://awesomerea.org/resources/kirby-epic-yarn-decomp/index.md): Case study · This repository is a work-in-progress decompilation of Kirby's Epic Yarn. The supported version is RK5E01, the USA revision 0. The tree contains no game assets or assembly.
- [Rhythm Heaven: in-progress Nintendo DS decompilation](https://awesomerea.org/resources/rhgold/index.md): Case study · This repository is a work-in-progress decompilation of Rhythm Heaven for the Nintendo DS. The supported version is YLZE01, USA revision 0. The tree contains no game assets or assembly.
- [G-Diffuser 3DS: F-Zero X port for Nintendo 3DS](https://awesomerea.org/resources/gdx-3ds-case/index.md): Case study · G-Diffuser 3DS is a native port of the F-Zero X decompilation to Old and New Nintendo 3DS, built on the G-Diffuser PC port. It has stereoscopic 3D and full audio. Optional Expansion Kit builds stream 64DD content from the SD card.
- [TA: Byte Tactics — byte-matching Total Annihilation source reconstruction](https://awesomerea.org/resources/byte-tactics/index.md): Case study · TA: Byte Tactics is a matching decompilation of Total Annihilation (Cavedog, 1997). The C++ in src/ is written to compile with Visual C++ 5.0 into the same bytes as TotalA.exe. The README says all 3,267 game functions match.
- [ReksioEngine: reimplementing the Przygody Reksia game engines](https://awesomerea.org/resources/reksio-engine/index.md): Case study · ReksioEngine reimplements the BlooMoo and Piklib engines used by the Przygody Reksia games. It runs the original assets and scripts in a web browser.
- [Wacki: porting Wacki: Kosmiczna rozgrywka from decompiled code](https://awesomerea.org/resources/wacki-case/index.md): Case study · Wacki is a cross-platform port of Wacki: Kosmiczna rozgrywka (1998), reconstructed from the decompiled WACKI.EXE. The English portion of the README says it runs on macOS, Linux, Windows, Android, Miyoo and other PortMaster handhelds, and PlayStation 2.
- [.hack//Recompilation: native recompilation of the .hack//IMOQ games](https://awesomerea.org/resources/dothack-recompilation-case/index.md): Case study · .hack//Recompilation is a native recompilation of the PlayStation 2 .hack//IMOQ games, using PS2Recomp. Current work is .hack//INFECTION, US product SLUS-20267. The README says that game boots through the logo and OPENING movie. MUTATION, OUTBREAK, and QUARANTINE are listed as not started.
- [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.
- [Tetris: byte-matching Game Boy disassembly](https://awesomerea.org/resources/tetris-gb-disassembly/index.md): Case study · This is a disassembly of Tetris for the Game Boy. It compiles 1:1 to the official Tetris (World) ROM. Code annotation and data annotation are still listed as unfinished.
- [OpenNitemare3D: reimplementing Nitemare 3D in C#](https://awesomerea.org/resources/opennitemare3d/index.md): Case study · OpenNitemare3D is a C# reimplementation of the 1994 first-person game Nitemare 3D. It loads original bitmaps and maps, plays MIDI, and plays sound effects from the Windows version. The README says the active development branch is C-Rewrite.
- [WWE SmackDown! Here Comes the Pain: static recompilation for Windows](https://awesomerea.org/resources/hctp-recomp-case/index.md): Case study · HCTP Recompiled is a static recompilation of WWE SmackDown! Here Comes the Pain for PlayStation 2, NTSC-U SLUS-20787, into a native Windows program. PS2Recomp translates the MIPS code to C++. A Direct3D 11 renderer draws the graphics, and the IOP runs the game's IRX modules.
- [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.
- [Bounce Tales: decompiling the J2ME game](https://awesomerea.org/resources/bounce-tales-decomp/index.md): Case study · This repository is a decompilation of Rovio's Bounce Tales (2008), a J2ME game that shipped on Nokia Series 40 phones. It aims to reproduce the original behavior. A Jademula layer can run it as a Windows application.
- [MegaManX2SNESRecomp: statically recompiling Mega Man X2](https://awesomerea.org/resources/megaman-x2-recomp-case/index.md): Case study · MegaManX2SNESRecomp is a static recompilation of Mega Man X2 (USA) built on snesrecomp. Version 0.1.5 is a playable Windows release. The ROM file is mmx2.sfc, headerless, CRC32 0x947B0355.
- [Celosia: statically recompiling Shadow of the Colossus for Mac and Vita](https://awesomerea.org/resources/celosia/index.md): Case study · Celosia is a native port of Shadow of the Colossus for PlayStation 2, USA SCUS-97472, to macOS on Apple Silicon and to the PlayStation Vita. PS2Recomp translates the MIPS code to C++. The Mac renderer is Metal and the Vita renderer is OpenGL ES.
- [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.
- [Infinite Undiscovery Recomp: native Xbox 360 game recompilation](https://awesomerea.org/resources/infinite-undiscovery-recomp-case/index.md): Case study · Infinite Undiscovery Recomp is a native Windows x64 recompilation of Infinite Undiscovery for Xbox 360 (2008), built with ReXGlue and XenonRecomp. The public release candidate is v1.0.0-rc1. The README says development is frozen.
- [Star Fox 64: Dreamcast port](https://awesomerea.org/resources/sf64-dc-case/index.md): Case study · This is a Sega Dreamcast port of Star Fox 64, based on sonicdcer/sf64. The player builds a CDI from their own Nintendo 64 ROM. The README says it is intended for real Dreamcast hardware, with VMU saving when a VMU is present.
- [Pentagram: reimplementing the Ultima 8 engine](https://awesomerea.org/resources/pentagram-u8/index.md): Case study · Pentagram reimplements the Ultima 8 engine. The documentation dated 9 November 2011 says the supported games are the English versions of Ultima 8, both before and after the patch. German, French, and Spanish versions are listed as less tested.
- [MGS2 for Android: statically recompiling Sons of Liberty HD](https://awesomerea.org/resources/mgs2-android-case/index.md): Case study · This project statically recompiles Metal Gear Solid 2: Sons of Liberty HD from the NVIDIA SHIELD TV, a 32-bit ARM game, into ARM64 for Android phones. It translates the ARM32 functions to C and supplies a runtime for memory, libc, OpenGL, audio, and JNI. The README says about 22,000 game functions and about 3,000 C++ library functions are recompiled.
- [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.
- [BreadFlowerDos: reimplementing the Refractor 2 game engine](https://awesomerea.org/resources/breadflowerdos/index.md): Case study · BreadFlowerDos is a modern C++ recreation of the Refractor 2 engine, focused on Battlefield 2 and Battlefield 2142. The README says it reimplements functionality rather than matching the original binaries.
- [Ballanced: reimplementing the Ballance runtime](https://awesomerea.org/resources/ballanced/index.md): Case study · Ballanced is a source-level reimplementation of the Ballance runtime. It rebuilds the player, engine libraries, building blocks, and plugins into a Ballance-compatible directory layout. The documented runtime is the cross-platform SDL3 build on the sdl branch.
- [ZGloom: reimplementing the Amiga game Gloom](https://awesomerea.org/resources/zgloom/index.md): Case study · ZGloom reimplements the Amiga first-person game Gloom, including Zombie Massacre. Windows builds need the Visual Studio 2013 runtime. Linux builds use SDL2, SDL2_mixer, and libXMP.
- [Automobili Lamborghini: Recompiled](https://awesomerea.org/resources/automobili-lamborghini-recomp/index.md): Case study · Automobili Lamborghini: Recompiled is a native port of the North American Nintendo 64 game Automobili Lamborghini. Release packages are provided for Windows x64 and Linux x64. An Android ARM64 path exists and is described as experimental.
- [th06-sdl2: porting Touhou Koumakyou to SDL2](https://awesomerea.org/resources/th06-sdl2/index.md): Case study · th06-sdl2 is a cross-platform port of Touhou Koumakyou, the Embodiment of Scarlet Devil, version 1.02h, built on the happyhavoc/th06 reconstruction. Direct3D 8 and the Win32 window and audio stack are replaced with SDL2. Renderers are desktop OpenGL, OpenGL ES 2.0, and an optional Vulkan backend. The README says the project is archived.
- [agl: decompilation of a Nintendo graphics library](https://awesomerea.org/resources/agl-decomp/index.md): Case study · agl is a decompilation of agl, a C++ library used by first-party Nintendo games for graphics, lighting, and parameter utilities called AAMP. The README points to open-ead/sead for the project goal, contribution guidelines, and build information.
- [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.
- [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.
- [Monster Hunter: matching decompilation of the Japanese PS2 release](https://awesomerea.org/resources/mh1j-decomp/index.md): Case study · This repository decompiles the first Japanese PlayStation 2 release of Monster Hunter. The disc files are SLPM_654.95 and AFS_DATA. A successful build compares the ELF and overlays byte for byte. The README says the main ELF still has a few mismatches and overlay matching is currently turned off.
- [GLKeeper: reimplementing Dungeon Keeper 2](https://awesomerea.org/resources/glkeeper/index.md): Case study · GLKeeper, also titled Grim Lands Keeper, is an open-source reimplementation of Dungeon Keeper 2. The README says it is not playable yet.
- [F-Zero Recomp: statically recompiling F-Zero](https://awesomerea.org/resources/fzero-recomp-case/index.md): Case study · F-Zero Recomp is a native widescreen static recompilation of F-Zero (USA). It runs on Linux x86_64, macOS on Apple Silicon, and Windows x64. Display modes include the original 8:7, 16:9, and 32:9.
- [EmeraldRecomp: statically recompiling Pokémon Emerald](https://awesomerea.org/resources/emerald-recomp-case/index.md): Case study · EmeraldRecomp is a static recompilation of Pokémon Emerald for the Game Boy Advance, built on gbarecomp. Version 0.0.1 boots through the BIOS intro to the title screen and into gameplay. Paths the static recompiler has not covered run in an interpreter the first time, then are JIT-compiled and remembered.
- [Syphon Filter 2 Recompiled: a native Windows build of the PS1 game](https://awesomerea.org/resources/syphon-filter-2-recomp-case/index.md): Case study · Syphon Filter 2 Recompiled is an experimental Windows static recompilation of the two-disc USA release, bootstrapped from SCUS-94451 and built with PSXRecomp. Release v0.1.3-alpha runs the retail game logic as a native x64 program. The launcher can add 16:9, PGXP-assisted geometry, and mouse camera control.
- [Pokémon XD: matching GameCube decompilation](https://awesomerea.org/resources/xd-decomp/index.md): Case study · This repository is a decompilation of Pokémon XD: Gale of Darkness for GameCube. The goal is a matching retail binary. Supported versions are GXXE01, USA revision 0, and NXXJ01, the Japanese demo disc revision 0.
- [pokerecomp: reimplementing the Game Boy Pokémon games](https://awesomerea.org/resources/pokerecomp/index.md): Case study · pokerecomp is a Godot 4 reimplementation, written in GDScript, of the Game Boy Pokémon games. Gold, Silver, Crystal, Red, Blue, and Yellow are playable from the bedroom through the Hall of Fame and their credits. A cartridge dump is checked by SHA-1, decoded once into a cache, and then released.
- [Final Fantasy Crystal Chronicles: GameCube decompilation](https://awesomerea.org/resources/ffcc-decomp/index.md): Case study · This repository decompiles Final Fantasy Crystal Chronicles for GameCube. The English build supplied a debug symbol file and the PAL build a release symbol file, which recovered function names, parameters, and class hierarchies. Tracked versions are PAL GCCP01, USA GCCE01, and Japan GCCJGC.
- [Rocket: Robot on Wheels — Nintendo 64 decompilation](https://awesomerea.org/resources/rocket-robot-on-wheels-decomp/index.md): Case study · This repository is a decompilation of the Nintendo 64 game Rocket: Robot on Wheels. The US ROM is named baserom.us.z64.
- [sacengine: reimplementing the Sacrifice game engine](https://awesomerea.org/resources/sacengine/index.md): Case study · sacengine reimplements the engine of Sacrifice, the game by Shiny Entertainment. It is written in D. LDC 1.41.0 is a known working compiler.
- [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.
- [Yakuza: Dead Souls Recompiled — statically recompiling the PS3 game for Windows](https://awesomerea.org/resources/yakuza-dead-souls-recomp/index.md): Case study · Yakuza: Dead Souls Recompiled translates the PlayStation 3 game's PowerPC PPU code and Cell SPU programs into a native Windows executable. It boots without PS3 firmware, plays the intro movies, reaches the title screen, and enters gameplay. Indoor scenes such as the gun tutorial were reported at the game's 30 frame cap. The crowded outdoor opening was reported at about 20 frames per second.
- [Dance Central 3: decompiling the Xbox 360 game](https://awesomerea.org/resources/dc3-decomp/index.md): Case study · This repository decompiles Dance Central 3 for Xbox 360, the build dated 16 September 2012. The tree contains no game assets or assembly.
- [Klonoa 2: Lunatea's Veil — matching PlayStation 2 decompilation](https://awesomerea.org/resources/kl2-lv-decomp/index.md): Case study · This is a matching decompilation of Klonoa 2: Lunatea's Veil for PlayStation 2, NTSC SLUS_201.51. Debug symbols came from the executable on Demo Disc 2.3. The README says ee-gcc 2.9-991111-01 produces matching code most of the time, and that the project is early and may fail to build.
- [OpenReliant: reimplementing the StarLancer engine](https://awesomerea.org/resources/openreliant/index.md): Case study · OpenReliant reimplements the engine of StarLancer, the 2000 space-combat game by Warthog and Digital Anvil. It is written in Zig on SDL3 and draws with Vulkan, or Metal on macOS. The README says the beta can play the whole campaign, and that saves from the original game carry over.
- [Blast Corps: Nintendo 64 decompilation](https://awesomerea.org/resources/blastcorps-decomp/index.md): Case study · This repository is a decompilation of Blast Corps for the Nintendo 64. Named ROMs are the USA version, USA revision 1, the Japanese Blastdozer, and the European English and German version. Naming of the source and data is still in progress.
- [I26: reimplementing Interstate ’76 in Godot](https://awesomerea.org/resources/i26-interstate/index.md): Case study · I26 reimplements Interstate '76 in Godot. It includes the single-player campaign, scenarios, auto melee, multiplayer, online co-op, a 3D map editor, and a garage. F12 switches to the original 1997 graphics.
- [Ocarina of Time Master Quest: matching debug disassembly](https://awesomerea.org/resources/ocarina-mq-debug-disasm/index.md): Case study · This is a disassembly of The Legend of Zelda: Ocarina of Time Master Quest, debug version. It builds zelda_ocarina_mq_dbg.z64, MD5 717179476af84133b14ff73af87db57a.
- [AeroGauge: Recompiled — a native Nintendo 64 game build](https://awesomerea.org/resources/aerogauge-recomp/index.md): Case study · AeroGauge: Recompiled is a native build of the Nintendo 64 game AeroGauge. Supported targets are Windows 10 or later with Direct3D 12, Linux x64 or ARM64 with Vulkan, and Android 9 or later on ARM64 with Vulkan. macOS is unsupported. Accepted ROMs are USA and Japanese revision A.
- [Balloon Fight: disassembly of the NES game](https://awesomerea.org/resources/balloonfight-disasm/index.md): Case study · This is a disassembly of Balloon Fight for the NES, USA. Assembly uses ARM9's bass fork. An iNES build needs the CHR file named BalloonFight.chr.
- [CMR2Decomp: decompiling Colin McRae Rally 2.0](https://awesomerea.org/resources/cmr2-decomp/index.md): Case study · CMR2Decomp is a decompilation of the PC game Colin McRae Rally 2.0. It uses reccmp to check functions and globals. The solution is for Visual Studio 2022, and the code is written so it can still be compiled with MSVC 6.0. CI uses a portable MSVC 6.0.
- [Pokémon Puzzle League: matching Nintendo 64 decompilation](https://awesomerea.org/resources/puzzleleague64/index.md): Case study · This is a matching decompilation of Pokémon Puzzle League for the Nintendo 64. The default build is the USA version. A big-endian ROM is named baserom.usa.z64 under config/usa. The build uses splat and reports a matching ROM.
- [OpenJPOG: decompiling Jurassic Park: Operation Genesis and its Toshi engine](https://awesomerea.org/resources/openjpog/index.md): Case study · OpenJPOG decompiles Toshi engine 1.0 and Jurassic Park: Operation Genesis. The Windows build uses Visual Studio 2019 or 2022. The README says the progress images do not yet mark every finished function.
- [Digital Devil Saga: matching decompilation of two PS2 games](https://awesomerea.org/resources/dds-decomp/index.md): Case study · This is a matching decompilation of Shin Megami Tensei: Digital Devil Saga and Digital Devil Saga 2 for PlayStation 2. The USA targets are SLUS_209.74, SHA-1 6d18898e2724bf1d145392766e8ba1e678487419, and SLUS_211.52, SHA-1 9be91ee1b4a535a4cb6ec89237b5a6ba41be2add. ninja checks each built executable against its retail SHA-1.
- [EarthBound Companion: native EarthBound build](https://awesomerea.org/resources/earthbound-companion/index.md): Case study · EarthBound Companion is a native EarthBound build. Windows x64 release 1.0.18 is the supported package. Linux, macOS, and Android builds are community previews. It includes a pinned MaternalBound Redux adaptation, widescreen scenery, 1080p to 4K output, MSU music, and Story Shuffle. The game code is compiled C with SDL2.