---
title: "Curated reverse engineering resources · Page 19"
url: https://awesomerea.org/resources/page/19/
updated: 2026-11-10
type: page
---

# Curated reverse engineering resources · Page 19

> Page 19 of 52, entries 1,801–1,900. 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/19/>
- JSON: <https://awesomerea.org/api/v1/resources.json>
- 简体中文: <https://awesomerea.org/zh/resources/page/19/index.md>

## Games (100)

- [LEGO City Undercover: a matching Nintendo Switch decompilation](https://awesomerea.org/resources/lego-city-undercover-decomp-case/index.md): Case study · LEGO City Undercover Decompilation reconstructs functions from the Nintendo Switch game in C++. The project uses symbols from the game's dumped main executable and checks rebuilt functions against the original binary, with contributor instructions for analysis in IDA or Ghidra.
- [Gunboat: a function-level C++ port of the DOS game](https://awesomerea.org/resources/gunboat-port-case/index.md): Case study · Gunboat reconstructs the 1990 DOS game Gunboat: River Combat Simulation in C++ and SDL3, porting functions from GB.EXE and reading the player's original data at runtime. It includes an executable map, subsystem specifications and differential tests against original code; the author reports native gameplay across the original video modes.
- [Imperialism: reconstructing the 1997 game in C++ and Rust](https://awesomerea.org/resources/imperialism-decomp-case/index.md): Case study · Imperialism reconstructs the 1997 Windows game's executable as ABI and behavior faithful C++ using Ghidra evidence, the original MSVC 5.0 toolchain and reccmp comparisons. A separate Rust implementation imports retail files and uses process-isolated differential tests against named behavioral captures.
- [Bakugan: Battle Brawlers: a matching Nintendo DS decompilation](https://awesomerea.org/resources/bakugan-battle-brawlers-ds-decomp-case/index.md): Case study · bakubrawlers reconstructs C++ source for the US Nintendo DS release of Bakugan: Battle Brawlers using the original compiler. Its build extracts a user-supplied ROM, links the reconstructed code and checks the output SHA-1; the author reports 4,485 of 4,505 functions matched.
- [axis-web: a WebAssembly reconstruction of AXIS](https://awesomerea.org/resources/axis-web-case/index.md): Case study · axis-web ports the Korean action game AXIS to browsers by reconstructing client formats and simulation layers in C and compiling them to WebAssembly. WebGL renders original maps from user-supplied files, while documented packet codecs and a WebSocket relay support multiplayer state exchange.
- [Over the Hedge: an ongoing PlayStation 2 matching decompilation](https://awesomerea.org/resources/over-the-hedge-ps2-decomp-case/index.md): Case study · Over the Hedge reconstructs source for the retail NTSC-U PlayStation 2 game, targeting a build identical to its original executable. The repository contains C++, assembly, splat configuration and a PS2 build script for the ongoing decompilation.
- [Contra (J) disasm: rebuilding the Japanese NES game](https://awesomerea.org/resources/contra-j-disasm-case/index.md): Case study · Contra (J) disasm reconstructs the Japanese NES game's program banks in assembly. Its Makefile assembles the ROM and compares its SHA3-256 checksum with the original; users provide the CHR banks from their own ROM.
- [Parasite Eve II: matching PlayStation decompilation of the USA release](https://awesomerea.org/resources/parasite-eve-2-decomp-case/index.md): Case study · Parasite Eve II Decompilation reconstructs the USA PlayStation game's executable, resident and title overlays, and code packages as buildable C. The author reports byte-identical output using the original GCC toolchain and checksum checks against the user's two game discs; the repository also documents game formats and matching techniques.
- [Starquake: an annotated Z80 game disassembly](https://awesomerea.org/resources/starquake-disassembly-case/index.md): Case study · Starquake is a work-in-progress disassembly of the 1985 game, with SkoolKit files for the game and its loader. Many routines and data items remain undocumented.
- [CMaNGOS: a World of Warcraft Classic server reconstruction](https://awesomerea.org/resources/cmangos-classic-case/index.md): Case study · CMaNGOS develops server software to emulate a World of Warcraft service, using the service’s behavior to guide its implementation. The repository contains server code, SQL files, and client-data extraction tools.
- [RA2 Engine: reconstructing Red Alert 2 and Yuri's Revenge](https://awesomerea.org/resources/ra2-engine-case/index.md): Case study · RA2 Engine rebuilds Command & Conquer: Red Alert 2 with Yuri's Revenge as a C++17 and SDL2 engine for Windows and Android. It reads the player's original MIX and CSF files, including rulesmd.ini, and implements combat, movement, AI and timing from observed game behavior. The author describes version 0.9 as a playable beta.
- [Tomodachi Native: running Tomodachi Life on Apple Silicon](https://awesomerea.org/resources/tomodachi-native-case/index.md): Case study · Tomodachi Native adapts nxnative to run the Switch game Tomodachi Life: Living the Dream on Apple Silicon Macs and iPads. It rewrites selected ARM64 instructions, supplies Switch system services and translates NVN graphics to Metal 4 using a game-specific profile. The author reports that early island and Mii creation scenes work on Mac.
- [OpenLGR: rehosting Lego Racers with emulation and runtime patches](https://awesomerea.org/resources/openlgr-lego-racers-case/index.md): Case study · OpenLGR rehosts the Windows release of Lego Racers using x86 CPU emulation and implementations of the Windows functions the game uses. It patches replacement open-source code into the game at runtime, while still running original code and loading original game assets.
- [OpenMM1: incrementally rewriting Midtown Madness 1](https://awesomerea.org/resources/openmm1-case/index.md): Case study · OpenMM1 incrementally rewrites Midtown Madness 1 in C++, using the original game binary for functions still unimplemented. It targets the specified original release, runs alongside the installed game and uses dgVoodoo 2 for modern graphics compatibility.
- [Rockman Dash: a partial Japanese Nintendo 64 decompilation](https://awesomerea.org/resources/rockman-dash-n64-decomp-case/index.md): Case study · RockmanDash-Decomp partially reconstructs the Japanese Nintendo 64 release of Rockman Dash as C source. Its segment map assigns ROM offsets to C, assembly and data, and the source files combine recovered functions with assembly placeholders.
- [Fate/Unlimited Codes: a matching Japanese PS2 decompilation](https://awesomerea.org/resources/fate-unlimited-codes-jp-decomp-case/index.md): Case study · Reconstructs functions from the Japanese PS2 release of Fate/Unlimited Codes in C and compares their compiled code with the original executable. The author reports 1,525 of 5,827 game functions matched; unfinished functions are assembled from the user's own game copy during the build.
- [RS Mod: RuneScape server-mechanics reconstruction](https://awesomerea.org/resources/rsmod-runescape-case/index.md): Case study · RS Mod reconstructs RuneScape game-server behavior in Kotlin, with the goal of matching the original mechanics. Its documentation recommends RSProx to inspect client-server packets while developing and checking those mechanics, and the repository contains server, cache and gameplay modules.
- [Zombie Revenge: a Dreamcast executable decompilation](https://awesomerea.org/resources/zombie-revenge-decomp-case/index.md): Case study · Zombie Revenge decomp reconstructs the European Dreamcast game's executable with C and a disc-derived assembly baseline. Its tools split functions, map assets, run directed equivalence cases and build a replacement executable; the author reports 65.8% instruction test coverage over functions eligible for C translation.
- [SonsOfSparta-PS5 Native: God of War running on Windows](https://awesomerea.org/resources/sons-of-sparta-ps5-native-case/index.md): Case study · SonsOfSparta-PS5 Native runs the PS5 release of God of War: Sons of Sparta on Windows by executing its x86-64 game code through a compatibility layer. The layer reimplements PS5 system libraries and GPU commands, while a first-start process prepares the user’s decrypted game files. The author reports play from the logo into gameplay and identifies later areas as untested.
- [Columns: a Sega Master System game disassembly](https://awesomerea.org/resources/columns-sms-disassembly-case/index.md): Case study · Columns Disassembly organizes the Sega Master System game into assembly modules for audio, input, entities, menus, interrupts and data. The project aims to document the game's disassembly and build the USA and Europe ROM identified by its published SHA-1.
- [FIFA 09 PC: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/fifa-09-pc-case/index.md): Case study · FIFA 09 PC translates the Xbox 360 release of FIFA 09 to native Windows code with the ReXGlue SDK. The repository provides game hooks, SDK patches, a launcher and file-format tools; online matches use NOBK.Online servers. Users generate game-derived code from their own matching disc files.
- [Digimon World: a PS1 decompilation with binary comparison](https://awesomerea.org/resources/digimon-world-decomp-case/index.md): Case study · Digimon World decomp reconstructs the PlayStation game as C source and versioned build configuration. Its workflow extracts the user’s disc, regenerates disassembly, builds replacement binaries and runs a comparison against the original binaries.
- [OpenMCM2: a Motocross Madness 2 engine reimplementation](https://awesomerea.org/resources/openmcm2-case/index.md): Case study · OpenMCM2 reimplements Motocross Madness 2 in Rust for macOS, Windows, and Linux using files from the user's own game copy. It decodes archives, terrain, scenes, models, textures, and other game formats, and reconstructs riding physics and AI from study of the original. The author reports that some physics comparisons still differ.
- [Amplitude: a PS2 decompilation in progress](https://awesomerea.org/resources/amplitude-2003-case/index.md): Case study · Amplitude (2003) is a decompilation project for the NTSC-U/C retail release. The workflow extracts SCUS_972.58 from a retail ISO, runs configure.py and ninja, and sets up objdiff after a successful build.
- [Twilight Princess PC Port: an early port of the GameCube decompilation](https://awesomerea.org/resources/twilight-princess-pc-port-mbayonal-case/index.md): Case study · Twilight Princess PC Port adapts the zeldaret Twilight Princess decompilation to PC and is developing a bridge from GameCube GX graphics to Aurora. Its source initializes heap, video, controller and process systems, while asset loading, scene creation and gameplay rendering remain unfinished.
- [Pocky & Rocky: an annotated game disassembly](https://awesomerea.org/resources/pocky-rocky-disassembly-case/index.md): Case study · The Pocky & Rocky source file records a game disassembly with RAM and ROM maps, named routines and annotated instructions. It aligns machine-code bytes with assembly and C-like explanations for portions of the program.
- [BaK-Again: reconstructing Betrayal at Krondor](https://awesomerea.org/resources/bak-again-case/index.md): Case study · BaK-Again rebuilds Betrayal at Krondor in Unity, loading story, world, rules and art from the player's installed game. It includes .NET data libraries, Kaitai specifications for game formats and tests; the author reports that every chapter can be played to its end.
- [OpenDF: a Daggerfall engine reconstruction](https://awesomerea.org/resources/opendf-case/index.md): Case study · OpenDF reconstructs an open engine for Daggerfall. Its C++ source includes BSA archive loading with named and indexed entries, alongside game-world, rendering and input components.
- [Donkey Kong Country: a work-in-progress SNES disassembly](https://awesomerea.org/resources/donkey-kong-country-disassembly-case/index.md): Case study · Donkey Kong Country reconstructs assembly source for the SNES US v1.0 release. The work began with snes2asm output and includes game banks, SPC700 audio code, build scripts and notes on the ROM's HiROM layout. The project aims to recreate the game's source through static and dynamic analysis.
- [Pheenix: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/pheenix-disassembly-case/index.md): Case study · Pheenix documents a disassembly of the ZX Spectrum game using SkoolKit. The repository contains SkoolKit source, control and reference files, plus scripts that build browsable hexadecimal and decimal HTML listings. Building the development listings requires SkoolKit; users need the original game to disassemble its code.
- [SpyroEngine: a native PC port of the PlayStation Spyro trilogy](https://awesomerea.org/resources/spyroengine-trilogy-case/index.md): Case study · SpyroEngine ports the original PlayStation Spyro trilogy to PC with title-specific native subsystems and psxport's Lightrec executor for remaining MIPS code. It authenticates each player's game executable before running it, and records per-title progress on presentation, terrain and gameplay paths.
- [Indiana Jones and the Infernal Machine: a matching C decompilation](https://awesomerea.org/resources/infernal-machine-matching-decomp-case/index.md): Case study · This decompilation reconstructs C source for the 1.0 and 1.2 releases of Indiana Jones and the Infernal Machine. The game's original compilers rebuild source files, whose code, data and layout are checked against slices of a user-supplied Indy3D.exe; the resulting executable is checked by hash. The author reports a byte-identical rebuilt executable that includes small library sections and unused bytes copied from the original input.
- [Mega Man 64: an Android and iOS port of the recompilation](https://awesomerea.org/resources/mega-man-64-mobile-port-case/index.md): Case study · Mega Man 64 Recompiled Mobile adapts the MegaMan64Recompiled game port to Android and iOS with N64ModernRuntime and RT64. It adds ROM import, editable touch controls, controller input and persistent saves; a separate Quest preview displays the game on an OpenXR virtual screen.
- [Blood Wake Recomp: a native Windows static recompilation of the Xbox game](https://awesomerea.org/resources/blood-wake-recomp-case/index.md): Case study · Blood Wake Recomp translates the original Xbox game's code into C from a user-owned disc and compiles it into a native Windows build with xboxrecomp. Its runtime provides graphics, audio, controls, and Original and Remastered editions; the author reports that every game function translates and all story missions are playable.
- [Tenchu 1: a PlayStation decompilation of Shinobi Gaisen](https://awesomerea.org/resources/tenchu-shinobi-gaisen-decomp-case/index.md): Case study · The Tenchu 1 project reconstructs code for the PlayStation game Shinobi Gaisen through a split, C compilation and reassembly pipeline. Its documentation reports 175 exact C functions recovered for the ending executable and describes per-function matching work across the game's executables.
- [sh3redux: a Silent Hill 3 engine remake in C++](https://awesomerea.org/resources/sh3redux-case/index.md): Case study · sh3redux rebuilds the Silent Hill 3 engine in C++ with OpenGL rendering. Its source includes game engine, graphics and ARC archive structures, with a CMake build and a Code::Blocks project.
- [Hybrid Heaven: a native port through N64 static recompilation](https://awesomerea.org/resources/hybrid-heaven-recompiled-case/index.md): Case study · Hybrid Heaven: Recompiled ports the N64 game to Windows, Linux and Android by statically recompiling its code with N64: Recompiled. It uses N64ModernRuntime and RT64 for execution and rendering, and loads game data from the user's USA retail ROM.
- [Ape Escape: differential C reconstruction and native port](https://awesomerea.org/resources/ape-escape-decomp-port-case/index.md): Case study · Ape Escape translates functions from the US PlayStation game's MIPS code into structured C and compares them against the original instructions on shared RAM images. A native SDL3 and OpenGL viewer runs selected game logic; the author reports about 1,500 functions differentially checked.
- [Arcanum: a Unity engine reimplementation on the original game data](https://awesomerea.org/resources/arcanum-unity-reimplementation-case/index.md): Case study · Arcanum — Unity Reimplementation rebuilds the engine of Arcanum: Of Steamworks and Magick Obscura in Unity 6 while reading data from the user's game installation. Its C# readers cover archives, art, dialog and other formats, and its notes describe the original engine's systems and behavior. The playable systems remain partial.
- [Marvel Nemesis: an original Xbox static recompilation port](https://awesomerea.org/resources/marvel-nemesis-recomp-case/index.md): Case study · Marvel Nemesis: Rise of the Imperfects is ported from original Xbox to Windows by recompiling the user's XBE locally with XboxXBERecomp. The repository includes a game-specific host and compatibility changes to the bundled SDK, with Direct3D 12 rendering, local Versus and added PC settings.
- [Frogger's Adventures: Temple of the Frog: a matching GBA decompilation](https://awesomerea.org/resources/frogger-adventures-temple-decomp-case/index.md): Case study · The project reconstructs Frogger's Adventures: Temple of the Frog for Game Boy Advance as C and assembly compiled with agbcc. Its build extracts data from a user-provided USA baserom and checks the output ROM by SHA1. The author reports a byte-identical build while substantial code, naming and data reconstruction work remains.
- [Olduvai: reconstructing the Prehistorik engine](https://awesomerea.org/resources/olduvai-prehistorik-case/index.md): Case study · Olduvai reimplements the 1991 Prehistorik engine in C++ and SDL2 for desktop and Linux handhelds, reading data from a user's game copy. Its documented method studies the DOS executable with disassemblers and checks behavior against a separate reference implementation frame by frame; the author reports a playable release candidate.
- [Max Payne Mobile: Android binary rehosting on Switch](https://awesomerea.org/resources/max-payne-mobile-switch-port-case/index.md): Case study · Rehosts the Android release of Max Payne Mobile on Nintendo Switch by loading and patching its original AArch64 shared library. The wrapper supplies a minimal Android-like environment and Switch-specific hooks for game, audio and graphics behavior. It adapts an earlier Vita port and uses files supplied by the player.
- [Graffiti Soul: mapping and testing Jet Set Radio Future functions](https://awesomerea.org/resources/graffiti-soul-jsrf-case/index.md): Case study · Maps functions in Jet Set Radio Future's Xbox executable and provides a workflow for patching reconstructed C++ functions into the user's XBE for emulator checks. The repository records selected addresses and subsystem findings while its source tree remains at an early stage.
- [VCMI: recreating the Heroes of Might & Magic III engine](https://awesomerea.org/resources/vcmi-case/index.md): Case study · VCMI recreates the Heroes of Might & Magic III engine in C++ for playing the original game with an open-source runtime. The repository includes game logic, battle AI, a client and documentation for mods and supported game file formats.
- [Zaxxon: a Commodore 64 cartridge disassembly](https://awesomerea.org/resources/zaxxon-c64-disassembly-case/index.md): Case study · Disassembles the Commodore 64 Zaxxon cartridge in Kick Assembler syntax and rebuilds its two banks and four CHIP sections into a CRT image. The author explains the mirrored $9000 memory window and includes it in the assembly for debugger breakpoints.
- [Ace Combat 5: a PS2 static recompilation with native rendering](https://awesomerea.org/resources/ace-combat-5-static-recompilation-case/index.md): Case study · Ace Combat 5 statically translates the US PlayStation 2 game's main executable into C and compiles it with a Windows runtime. The project renders aircraft, terrain and other 3D scenes through native Vulkan meshes while remaining menus and effects use a GS path; runtime components cover audio, movies, controllers and storage. Generated game code and assets come from the user's disc.
- [NexusForever: WildStar build 16042 server reconstruction](https://awesomerea.org/resources/nexusforever-wildstar-case/index.md): Case study · NexusForever reconstructs a server for WildStar client build 16042 in C#. Its source tree includes authentication, character and game-service components, with database schemas and message handling for the matching game client.
- [BananaPad: bringing Donkey Kong 64 Recompiled to Apple devices](https://awesomerea.org/resources/bananapad-case/index.md): Case study · BananaPad adapts the Donkey Kong 64 static-recompilation port for Apple Silicon macOS, iPhone and iPad. Its scripts generate game and RSP code from a user-supplied ROM, then combine that code with a native Apple shell, Metal rendering, touch controls and game-specific patches. The author reports playable macOS and Simulator builds and a physical iPad build that renders the game.
- [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.
- [GTA IV for PS5: porting an Xbox 360 recompilation to PlayStation 5](https://awesomerea.org/resources/gta-iv-ps5-port-case/index.md): Case study · GTA IV for PS5 ports the existing Xbox 360 static recompilation of Grand Theft Auto IV and its two episodes to a jailbroken PlayStation 5. Its added code supplies PS5 startup, a game-selection hub, trophy integration, controls, build steps, and packaging around the inherited recompilation and renderer.
- [Hollywood Poker: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/hollywood-poker-disassembly-case/index.md): Case study · Hollywood Poker documents a disassembly of the ZX Spectrum game made with SkoolKit. The repository holds SkoolKit source, control and reference files and utilities for producing browsable hexadecimal and decimal listings. Building the development listings requires SkoolKit; users need the original game to disassemble its code.
- [doubutsu-no-mori: an early N64 Animal Crossing decompilation](https://awesomerea.org/resources/doubutsu-no-mori-decomp-case/index.md): Case study · doubutsu-no-mori is an early matching decompilation effort for the Japanese Nintendo 64 Animal Crossing game. It uses splat to split a user-supplied ROM and builds a decompressed ROM for comparison; the author also planned a byte-matching compressed ROM build.
- [Jurassic Park: an SNES disassembly of the USA release](https://awesomerea.org/resources/jurassic-park-snes-disassembly-case/index.md): Case study · The Jurassic Park SNES disassembly provides assembly source and scripts for the USA V1.0 release. Its asset extraction step takes a clean, headerless copy of the supported ROM, identified by an MD5 hash, and uses the author's SNES ROM framework.
- [180: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/180-disassembly-case/index.md): Case study · 180 documents a SkoolKit disassembly of the ZX Spectrum game. The repository includes SkoolKit source, control and reference files, plus utilities for generating hexadecimal and decimal HTML listings. Building the development listings requires SkoolKit; users need the original game to disassemble its code.
- [OpenJazz: a Jazz Jackrabbit 1 engine reimplementation](https://awesomerea.org/resources/openjazz-case/index.md): Case study · OpenJazz reimplements the Jazz Jackrabbit 1 engine in portable C++ and runs with data from the original game. It builds with CMake and SDL for desktop platforms, with further ports for consoles, handhelds and browsers.
- [kys-cpp: a C++ remake of 金庸群侠传](https://awesomerea.org/resources/kys-cpp-jin-yong-heroes-case/index.md): Case study · kys-cpp recreates the DOS game 金庸群侠传 in C++ with SDL3 and several selectable combat modes. Companion tools convert original IDX/GRP graphics, dialogue, event instructions and saves for the new engine; the application uses a separately supplied game resource directory.
- [Street Rod Enhanced: an SDL3 port with a new road view](https://awesomerea.org/resources/street-rod-enhanced-case/index.md): Case study · Street Rod Enhanced ports the reconstructed Street Rod engine to SDL3 and adds a road view drawn at the display refresh rate with higher resolution and antialiasing. The engine retains the original garage, opponents, physics and screens, while the new renderer covers races and drives through town.
- [HamHamGamesDecomp: an early Hamtaro GBA disassembly](https://awesomerea.org/resources/hamhamgames-decomp-case/index.md): Case study · HamHamGamesDecomp is an early assembly-stage reconstruction of Hamtaro: Ham-Ham Games for Game Boy Advance. Its build script uses DevKitARM tools to generate the PAL(E) ROM from an original ROM and checks the output against a stored SHA-1.
- [Onegai Monsters: a small N64 decompilation experiment](https://awesomerea.org/resources/onegai-monsters-case/index.md): Case study · Onegai Monsters explores decompilation of the N64 game through source files and a build that extracts data from a user-supplied .z64 ROM. The author describes the effort as minimal and unlikely to become a full decompilation.
- [XI on Anything: statically recompiling FINAL FANTASY XI clients](https://awesomerea.org/resources/xi-on-anything-case/index.md): Case study · XI on Anything recompiles FINAL FANTASY XI's 32-bit x86 FFXiMain.dll and FFXi.dll to C from the user's installation and runs them through a native game host. Its platform layer supplies graphics, audio, input and sockets across desktop and selected mobile or console targets. A LandSandBoat server provides sign-in and gameplay services.
- [Open Greedy: a from-scratch Greedy XP rewrite](https://awesomerea.org/resources/open-greedy-case/index.md): Case study · Open Greedy reimplements Greedy XP as a C game written from scratch. Its source tree contains game logic, an engine and rendering code, and the documented build relies on SDL, SDL_mixer, OpenGL, libxmp-lite and zlib.
- [WWE '12 PC: an Xbox 360 static recompilation for Windows](https://awesomerea.org/resources/wwe-12-pc-case/index.md): Case study · WWE '12 PC ports the Xbox 360 version of WWE '12 to Windows through ReXGlue static recompilation and a native Vulkan renderer. Its build uses the player's game files and includes code-generation patches, native hooks, and a script for finding function pointers omitted by the recompiler.
- [Shining in the Darkness: a rebuildable 68k disassembly](https://awesomerea.org/resources/shining-in-the-darkness-disassembly-case/index.md): Case study · Shining in the Darkness is reconstructed as a 68k assembly listing intended for documentation and fan projects. Scripts split data chunks from the user's original US ROM and assemble them with the code. The author reports that the resulting ROM is bit identical to the original.
- [Goemon 64 Recompiled — Android: a mobile port with game-code analysis](https://awesomerea.org/resources/goemon64-recompiled-android-case/index.md): Case study · Goemon 64 Recompiled — Android ports the Mystical Ninja Starring Goemon recompilation to Android with RT64 Vulkan rendering, touch controls and ROM selection. Its game-specific analysis notes trace indirect calls through N64 overlays and correct earlier camera-function conclusions.
- [JGR Portable: a native PSP reconstruction of Jet Grind Radio](https://awesomerea.org/resources/jgr-portable-case/index.md): Case study · JGR Portable rebuilds Jet Grind Radio as a native PSP game using reconstructed game and DSP behavior. Its conversion tools process a user-supplied Dreamcast GDI image locally into the data needed by the PSP program. The repository includes PSP source, format converters and build documentation; the author describes performance as scene-dependent.
- [HarkinianPad: an iOS port of Ocarina of Time via Ship of Harkinian](https://awesomerea.org/resources/harkinianpad-case/index.md): Case study · HarkinianPad adapts the Ship of Harkinian Ocarina of Time source port for iPhone and iPad. It adds Metal rendering, touch controls, controller support and local ROM import; the app creates its game archive from the user's ROM.
- [dynamitedan: an annotated Dynamite Dan disassembly](https://awesomerea.org/resources/dynamitedan-case/index.md): Case study · dynamitedan presents an annotated disassembly of the 1985 computer game Dynamite Dan. Its SkoolKit files include game and loader listings, with reference files for the game.
- [medarot: a partial matching disassembly of Medarot Kabuto](https://awesomerea.org/resources/medarot-kabuto-disassembly-case/index.md): Case study · medarot reconstructs portions of the Game Boy game Medarot Kabuto in assembly while importing unreconstructed ranges from baserom.gbc. Its RGBDS build compares the resulting ROM against that base ROM.
- [Super Columns: a Game Gear disassembly](https://awesomerea.org/resources/super-columns-game-gear-disassembly-case/index.md): Case study · Super Columns provides a disassembly of the Sega Game Gear game. The author says it came from Emulicious and can be reassembled with WLA-Z80 and WLALINK. The repository includes the main assembly file, data includes and a shell build script.
- [Pool of Radiance: DOS engine and file-format reconstruction](https://awesomerea.org/resources/pool-of-radiance-dos-reconstruction-case/index.md): Case study · Reconstructs the DOS v1.3 Pool of Radiance engine in portable C, supported by overlay analysis, format readers and isolated runs of the original for behavior comparisons. Documented readers cover DAX, GEO, ECL, EGA and save-related structures; the gameplay reconstruction remains in progress.
- [tnt-splat: reconstructing The New Tetris for N64](https://awesomerea.org/resources/tnt-splat-new-tetris-case/index.md): Case study · tnt-splat reconstructs The New Tetris for Nintendo 64 from C, assembly and a user-provided ROM. Its documented build uses splat to split the ROM, compiles with a MIPS cross toolchain and compares the resulting ROM against the base image.
- [GX Spirit Caller Decomp: a three-region matching DS reconstruction](https://awesomerea.org/resources/gx-spirit-caller-decomp-case/index.md): Case study · GX Spirit Caller Decomp reconstructs Yu-Gi-Oh! GX Spirit Caller for the European, US and Japanese Nintendo DS releases using C and assembly. The author reports byte-identical ROM builds across all three regions; much matching assembly still awaits conversion into readable C.
- [openc2e: reimplementing the Creatures game engine](https://awesomerea.org/resources/openc2e-creatures-case/index.md): Case study · openc2e reimplements an engine for the Creatures artificial life games and reads their original data directories. It targets Creatures 1–3, Docking Station, Playground and Adventures; agents, biochemistry and sound effects work, while creature support and world saving remain incomplete.
- [Geometry Dash: reconstructing Android game classes from ARM64 disassembly](https://awesomerea.org/resources/geometry-dash-android-class-reconstruction-case/index.md): Case study · Reconstructs portions of Geometry Dash's Android C++ game classes from ARM64 disassembly, focusing on GameObject, GJBaseGameLayer, memory layouts, area movement, effects, and object state. The repository includes class source and headers and tracks unfinished vtable, trigger, and runtime 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.
- [MHServerEmu: reconstructing the Marvel Heroes server](https://awesomerea.org/resources/mhserveremu-marvel-heroes-case/index.md): Case study · MHServerEmu recreates the backend for Marvel Heroes clients using C# server code and versioned protocol definitions. Its documentation covers client-server packet structure, authentication, and game-data formats; the author reports full support for client 1.52.0.1700 and preliminary support for several others.
- [HotelMarioRecomp: an early Philips CD-i static recompilation](https://awesomerea.org/resources/hotel-mario-cdi-recomp-case/index.md): Case study · HotelMarioRecomp builds a native Hotel Mario program on the cdirecomp static-recompilation engine using a locally supplied CD-i BIOS and game disc image. Its game-specific build configuration generates modules and sets runtime checks; the author reports clearing the first three Hotel 1 stages, while full campaigns remain unverified.
- [Lego Star Wars III: an in-progress Wii decompilation](https://awesomerea.org/resources/lego-clone-wars-wii-case/index.md): Case study · LegoCloneWarsWii reconstructs code for the Wii release of Lego Star Wars III: The Clone Wars, targeting USA and EU Rev 0 debug builds. It configures a build from the user's disc image with Python and Ninja and supplies objdiff configuration for comparing compiled objects during decompilation.
- [e17p: reconstructing Ever17 and Remember11 storage formats](https://awesomerea.org/resources/e17p-ever17-remember11-case/index.md): Case study · e17p reconstructs storage formats used by the visual novels Ever17 and Remember11 while developing a Python engine for their data. Its tools extract LNK and AFS archives, convert CPS and T2P images and WAF audio, and inspect script data; several script semantics remain unknown.
- [WiiCompiled: a static recompilation of Mario Kart Wii for PC](https://awesomerea.org/resources/wiicompiled-case/index.md): Case study · WiiCompiled turns a user-supplied Mario Kart Wii disc image into a native PC application through PowerPC static recompilation. Its translator parses Wii DOL files, lifts instructions through IR and SSA, emits C++, and compiles the output with a runtime; project manifests select game revisions and input layouts.
- [ApeEscapeRecomp: an Ape Escape PlayStation static recompilation](https://awesomerea.org/resources/ape-escape-recomp-case/index.md): Case study · ApeEscapeRecomp translates Ape Escape's PlayStation MIPS code into native C ahead of time with PSXRecomp. The repository provides game-specific configuration, Ghidra-derived function seeds, overlay preparation and optional enhancements for a native PC build.
- [spore-decomp: reconstructing SporeApp.exe resource handling](https://awesomerea.org/resources/spore-decomp-case/index.md): Case study · spore-decomp reconstructs behaviour from Spore's SporeApp.exe in portable C++17, currently covering DBPF, RefPack and name hashing. It annotates reimplemented functions with original addresses and provides Ghidra scripts plus a Unicorn harness for differential tests against a user's game copy. The source tree also includes matching experiments and progress records.
- [Final Fantasy IX Recompiled: a PSXRecomp setup candidate](https://awesomerea.org/resources/final-fantasy-ix-recompiled-case/index.md): Case study · Final Fantasy IX Recompiled provides a title-specific setup candidate for rebuilding the PlayStation game with PSXRecomp and the recomp-ui launcher. Its wizard takes a user-supplied SLUS-01251 disc and specified European BIOS, then runs generation and rebuilding. The author reports that package setup and gameplay acceptance are still pending.
- [Gran Turismo 5 Prologue Recompiled: a PS3 boot investigation](https://awesomerea.org/resources/gran-turismo-5-prologue-recompiled-case/index.md): Case study · Gran Turismo 5 Prologue Recompiled lifts the PS3 game's PowerPC code with ps3recomp and builds a native Windows x86-64 executable. Game-specific scripts cover SELF decryption, function discovery, SPU workloads and a longjmp patch. The author reports repeatable loading of 116 assets during boot, before any frame is drawn.
- [Dino Crisis 2 Decompilation: a matching PlayStation reconstruction](https://awesomerea.org/resources/dino-crisis-2-decomp-case/index.md): Case study · Dino Crisis 2 Decompilation reconstructs the US PlayStation game's executable and 82 code overlays in C and assembly. The build uses a period toolchain, preserves unmatched functions as assembly and checks every rebuilt code binary against its original SHA-1.
- [Final Fantasy VI: a three-version ROM disassembly](https://awesomerea.org/resources/final-fantasy-vi-disassembly-case/index.md): Case study · Final Fantasy VI Disassembly reconstructs assembly and game data for the Japanese Super Famicom and two US SNES releases, using ca65 and ld65 to build ROMs. Its scripts extract required data from a user-provided ROM; the Japanese build fills unused regions with 0xFF and has a different CRC32 from the original.
- [Hungry Horace: a SkoolKit ZX Spectrum disassembly](https://awesomerea.org/resources/hungry-horace-disassembly-case/index.md): Case study · The Hungry Horace project publishes a SkoolKit disassembly of the ZX Spectrum game. Its source can generate browsable hexadecimal or decimal HTML and an assembly file for an assembler.
- [Sonic CD: reconstructing the Sonic Gems Collection version](https://awesomerea.org/resources/sonic-gems-sonic-cd-decomp-case/index.md): Case study · Sonic CD Decompilation reconstructs C source for the version of Sonic CD included in Sonic Gems Collection. The repository also contains an SDL launcher with game file loading, graphics and audio support.
- [DARIUSBURST SP Vita: an Android executable port to PS Vita](https://awesomerea.org/resources/dariusburst-sp-vita-case/index.md): Case study · DARIUSBURST SP Vita runs the Android ARMv7 game executable on PS Vita by loading it into memory, resolving its imports with native functions and applying runtime patches. The author reports testing with version 1.2.0; users provide the Android APK and OBB files.
- [FC3 Bevy: a Far Cry 3 runtime built from original game data](https://awesomerea.org/resources/fc3-bevy-case/index.md): Case study · FC3 Bevy rebuilds a Far Cry 3 runtime in Rust and Bevy using archives from the user's installed game. It converts game data to a local cache and implements world rendering and simulation; accompanying research documents Dunia 2 animation, DARE audio containers and RNV navigation meshes.
- [Digimon Rumble Arena: matching PlayStation decompilation](https://awesomerea.org/resources/digimon-rumble-arena-decomp-case/index.md): Case study · Digimon Rumble Arena decomp reconstructs the Japanese and USA PlayStation releases as C and assembly that the author reports rebuilds the executable and 13 code overlays byte for byte. GCC 2.95.2, splat and objdiff support the matching workflow; remaining overlay functions are still assembly.
- [Super Street Fighter II Turbo HD Remix: an Xbox 360 static recompilation port](https://awesomerea.org/resources/ssf2t-hd-remix-recompiled-case/index.md): Case study · This port translates the Xbox 360 code of Super Street Fighter II Turbo HD Remix into native PC code with the ReXGlue SDK. It supports the base release and Title Update #1, with a launcher for local package import, graphics settings and online play.
- [OpenMoM: reconstructing Master of Magic](https://awesomerea.org/resources/openmom-case/index.md): Case study · OpenMoM rebuilds Master of Magic as a C++14 and SDL2 game engine that reads the original game's LBX data. Its palette-based renderer aims to reproduce the game's graphics and animations, while documented LBX structures cover sprites, fonts and help text. Units, cities, combat and spells are described as prototypes.
- [Blaster: reconstruction of an arcade sound ROM](https://awesomerea.org/resources/blaster-sound-rom-reconstruction-case/index.md): Case study · Reconstructs the sound ROM of the Williams arcade game Blaster in assembly and supplies a separate address-by-address disassembly. Source comments compare reused sound routines with related Williams games and identify newer routines whose names remain unknown.
- [Jackal UEFI: a disassembly-based UEFI port of the NES game](https://awesomerea.org/resources/jackal-uefi-port-case/index.md): Case study · Jackal UEFI ports the NES game Jackal to a native UEFI Shell application by translating its 6502 disassembly line by line into a C core. UEFI GOP handles graphics while UEFI services handle input and timing; a ROM extractor generates tiles, palettes, and layouts from the user's copy. Audio calls retain state and timing behavior without sound output.
- [OpenWINGS: reconstructing Wings flight and terrain behavior](https://awesomerea.org/resources/openwings-wings-reconstruction-case/index.md): Case study · OpenWINGS studies the DOS game Wings v1.40 and reconstructs flight, terrain collision, landing and damage behavior in portable C. Ghidra analysis, symbol maps and DOSBox-X traces support tick-by-tick differential checks; the author reports eight functions verified so far.
- [LARecomp: statically recompiling Midnight Club: Los Angeles](https://awesomerea.org/resources/larecomp-case/index.md): Case study · LARecomp statically recompiles the Xbox 360 release of Midnight Club: Los Angeles Complete Edition into native C++ for Windows with ReXGlue. Game-specific hooks adjust frame timing, camera behavior and presentation, while technical notes document disassembly and runtime measurements behind the changes.
- [Die Hard Trilogy Recompiled: a PlayStation setup and static recompilation](https://awesomerea.org/resources/die-hard-trilogy-recompiled-case/index.md): Case study · Die Hard Trilogy Recompiled supplies a PSXRecomp setup host for generating a native build from a user-owned PlayStation disc. The repository includes title-specific symbols and a documented correction for verifying the USA Rev 1 multi-BIN disc.
- [Rayverse: porting Rayman 1 from its disassembly](https://awesomerea.org/resources/rayverse-rayman-1-case/index.md): Case study · Rayverse ports Rayman 1 PC version 1.21 into a modern executable based on a disassembly of the original. Its C source and platform code target Windows, Linux and macOS as a replacement for RAYMAN.EXE.