# Curated reverse engineering resources · Page 14

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

## Games (100)

- [cor64: C# Nintendo 64 emulator](https://awesomerea.org/resources/cor64/index.md): Case study · cor64 is a work-in-progress Nintendo 64 emulator written in C#. The README builds and runs it with nuke, and lists .NET Framework or Mono, .NET Core 3.x or newer, and GLFW development libraries on Linux. Global dotnet tools named in the README are Paket and nuke.globaltool.
- [OpenSHC: reimplementation of Stronghold Crusader](https://awesomerea.org/resources/openshc/index.md): Case study · OpenSHC is an open-source reimplementation of Stronghold Crusader. It builds as a DLL loaded at game start and hooks functions that have a functionally identical reimplementation. The README requires Stronghold Crusader 1.41 in a Latin-language version such as English or German.
- [Fahrenheit: an analytical PS2 prototype decompilation](https://awesomerea.org/resources/santamonica-fahrenheit-case/index.md): Case study · santamonica is an early C++ decompilation of a PS2 prototype of Fahrenheit, also known as Indigo Prophecy. The prototype's RUNTIME.ELF and RUNTIME.MAP supply debugging symbols for analysis, and the build scripts compare the produced ELF with a recorded checksum. The author intends the unfinished work for learning and analysis.
- [SDLPoP2: rebuilding the Prince of Persia 2 DOS engine](https://awesomerea.org/resources/sdlpop2-prince-of-persia-2-case/index.md): Case study · SDLPoP2 rebuilds the engine of Prince of Persia 2: The Shadow and the Flame from its DOS program as C for Linux and Windows. It reads the user's original game data, and its findings document DOSBox-X traces, reconstructed routines and equivalence tests; a headless core supports tool-assisted runs.
- [Smash 64 DS Port: bringing Super Smash Bros. 64 logic to Nintendo DS](https://awesomerea.org/resources/smash-64-ds-port-case/index.md): Case study · Smash 64 DS Port brings reconstructed Super Smash Bros. 64 game logic from BattleShip to a Nintendo DS backend. Its build checks a user-provided North American ROM, regenerates assets locally, and produces a DS game image; the author reports playable campaign and local four-fighter matches, with performance and feature gaps.
- [Radio Helicopter: a Wii decompilation in progress](https://awesomerea.org/resources/radio-helicopter-wii-decomp-case/index.md): Case study · The Radio Helicopter project reconstructs source for the European RGCPGT Wii release, also known in the Americas as MiniCopter: Adventure Flight. It includes game-specific build configuration, source files and symbol maps for Ghidra and Dolphin, and builds from the user's disc image.
- [Kaze no Notam: matching PlayStation decompilation](https://awesomerea.org/resources/kaze-no-notam-ps1-decomp-case/index.md): Case study · Reconstructs the PlayStation game Kaze no Notam as C compiled with PSX-patched GNU C and maspsx. The author reports that all 648 game functions pass isolated byte comparisons and that the executable rebuild is byte-identical; PsyQ SDK code remains in assembly.
- [Lolo: reconstructing the OverField game server and protocol](https://awesomerea.org/resources/lolo-overfield-case/index.md): Case study · Lolo implements portions of an OverField server for a client connected through a configured proxy. The bundled Iridium tool captures and decodes the game's TCP traffic, exposes live packets through a web view and JSON API, and saves per-session NDJSON for protocol analysis.
- [Psychonauts: matching Lua scripts and PC engine functions](https://awesomerea.org/resources/psychonauts-decomp-case/index.md): Case study · Psychonauts decompiles the PC game's modified Lua 4.0 scripts and portions of its 32-bit x86 engine into source checked by per-function byte comparisons. Its tools extract scripts from a user-owned game copy, rebuild them with a patched Lua compiler, and compare engine objects with Psychonauts.exe. The author reports all script functions matching and the engine still early in progress.
- [Super Mario Land 2: a Game Boy static recompilation with adaptive widescreen](https://awesomerea.org/resources/super-mario-land-2-recompiled-case/index.md): Case study · Super Mario Land 2: 6 Golden Coins — Recompiled builds native versions of the Game Boy V1.0 game and a DX color variant from one user ROM. It uses gbrecompiled for static recompilation and adds an optional widescreen view whose margins are constructed from live level data.
- [Rampage 2: Universal Tour: matching PlayStation decompilation](https://awesomerea.org/resources/rampage-2-universal-tour-case/index.md): Case study · Rampage 2: Universal Tour is being reconstructed as matching C for the USA PlayStation release SLUS-00742. Its build reads the executable and two overlays from an owned disc image, first rebuilding them from split assembly and then replacing functions with C. The author reports a byte-identical split-assembly build and 97.1% of game code matched from C.
- [Valiant Hearts Vita: rehosting the Android game on PS Vita](https://awesomerea.org/resources/valiant-hearts-vita-case/index.md): Case study · Valiant Hearts Vita runs the Android release of Valiant Hearts: The Great War on PS Vita by loading its ARMv7 executable into memory. The loader resolves imports with native functions and patches the program for the Vita environment. Users provide the executable extracted from their own APK and the game's OBB file.
- [Fable2Recomp: static recompilation of Fable 2](https://awesomerea.org/resources/fable2recomp-case/index.md): Case study · Fable2Recomp is an in-progress static recompilation of Fable 2 GOTY TU1 using ReXGlue, with a host runtime intended for Windows and Linux. Its configuration identifies game functions, while the host loads the game's XEX image and supplies content paths and selected function replacements.
- [Splatoon 1 PC Port: statically recompiling the Wii U game](https://awesomerea.org/resources/splatpc-splatoon-port-case/index.md): Case study · Splatoon 1 PC Port builds a Windows and Linux port of the Wii U game Splatoon by statically recompiling its RPX code to C++. Continuing RebrewU, it adds game-version manifests, a Cafe OS runtime, GX2-to-Vulkan rendering and a builder that uses the player's Wii U dump. The author describes the port as work in progress.
- [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.
- [Mario Kart DS: an incremental matching decompilation of the European release](https://awesomerea.org/resources/mkds-decomp-case/index.md): Case study · mkds-decomp incrementally reconstructs the European Mario Kart DS ARM9 code in C. Candidate functions are compiled with mwccarm, compared against cartridge bytes with relocation checks, and incorporated into a ROM rebuild checked by SHA-1. The author reports that unmatched spans remain original-byte gap objects during the partial reconstruction.
- [Conker's Bad Fur Day: an in-progress N64 decompilation](https://awesomerea.org/resources/conkers-bad-fur-day-decomp-case/index.md): Case study · Conker's Bad Fur Day Decompilation reconstructs the US Nintendo 64 game from C, assembly and ROM-extracted sections. Its build splits compressed code, recompiles recovered functions and checks the rebuilt ROM; documentation also records the ROM layout and its rzip compression.
- [Street Rod: a DOS game reconstructed in C for SDL3](https://awesomerea.org/resources/street-rod-sdl3-case/index.md): Case study · Street Rod SDL3 reconstructs the 1989 DOS game's behavior in C and runs it through SDL3 using the player's original files. The repository records function specifications and file formats for the game's picture libraries and data, and its port covers the VGA game, racing systems, saves, and PC speaker sound.
- [F.E.A.R. NX: statically recompiling the Xbox 360 game for Switch](https://awesomerea.org/resources/fear-nx-case/index.md): Case study · F.E.A.R. NX statically recompiles the Xbox 360 release of F.E.A.R. from PowerPC to AArch64 for Nintendo Switch. A native Vulkan renderer runs through Mesa/NVK on Horizon, and the browser installer packages the user's supported Xbox 360 files locally.
- [Hybrid: matching reconstruction of the Japanese PlayStation executable](https://awesomerea.org/resources/hybrid-ps1-decomp-case/index.md): Case study · Hybrid reconstructs the Japanese 5.877 PlayStation game's P69.EXE as linked assembly, C and classified data. The author reports an exact hash match for the rebuilt executable, while only a small portion is matching C; the repository also documents recovered MUF material and LEV level structures.
- [MacioGalaxy: porting Super Mario Galaxy to Apple Silicon](https://awesomerea.org/resources/maciogalaxy-case/index.md): Case study · MacioGalaxy ports the Petari Super Mario Galaxy decompilation to Apple Silicon Macs. It compiles reconstructed game code for arm64, renders GX graphics through Aurora and Metal, and adds native input, audio, and menus. Game resources come from the user's extracted USA revision 0 disc data.
- [The Hobbit: reconstructing its graphics engine](https://awesomerea.org/resources/hobbitgfx-case/index.md): Case study · hobbitgfx implements the graphics engine of Melbourne House's 1982 text adventure The Hobbit in JavaScript. The repository contains the engine script and HTML demo pages.
- [MechAssault 2: Lone Wolf: an Xbox static recompilation for Windows](https://awesomerea.org/resources/mechassault-2-recomp-case/index.md): Case study · MechAssault2-recomp builds a native Windows port of the original Xbox game MechAssault 2: Lone Wolf. It uses xboxrecomp to translate the user's ma2.xbe into C, then links that code with an Xbox runtime and game-specific input, display and behavior hooks.
- [Power Strike: ROM, sound and compression teardown](https://awesomerea.org/resources/power-strike-teardown-case/index.md): Case study · Power Strike teardown analyzes the Sega Master System game's ROM, mapping its banks, boot and vblank paths, sound engine and tile compression. It includes a sound-bank disassembly excerpt and scripts that decode, re-encode and patch tile sheets within their original compressed size.
- [ZZT Disassembly Project: documenting ZZT creature behavior](https://awesomerea.org/resources/zztasm-case/index.md): Case study · The ZZT Disassembly Project documents how creatures and other tile types behave in ZZT by disassembling ZZT.EXE. It publishes annotated assembly, pseudocode for functions and game objects, memory-layout notes, and an IDA database.
- [Party Board: a multiplatform Mario Party 4 port](https://awesomerea.org/resources/party-board-case/index.md): Case study · Party Board is a work-in-progress port of Mario Party 4 for Windows, Linux, macOS, Android and iOS that requires the user's own game copy. The repository includes C/C++ source, configuration for the two USA revisions GMPE01_00 and GMPE01_01, and platform build instructions.
- [Thirdeye: reimplementing the AESOP engine for Eye of the Beholder 3 and Dungeon Hack](https://awesomerea.org/resources/thirdeye-aesop-engine-case/index.md): Case study · Thirdeye reimplements the AESOP/16 and AESOP/32 engine in C++ to run Eye of the Beholder 3 and Dungeon Hack from their original RES files and unchanged bytecode. It includes a SOP virtual machine, resource readers and a RES disassembler, alongside a modern runtime with SDL3 audio, input and display support.
- [GoldenEye Metal: an Xbox 360 recompilation with native Metal rendering](https://awesomerea.org/resources/goldeneye-metal-case/index.md): Case study · GoldenEye Metal ports GoldenEye 007's Xbox 360 game code to Apple Silicon Macs through ahead-of-time ARM64 recompilation. Its compatibility runtime supplies Xbox 360 APIs, and its Metal backend translates Xenos shaders and renders the game's GPU commands.
- [Guitar Hero II Recompiled: an Xbox 360 static recompilation](https://awesomerea.org/resources/guitar-hero-ii-xbox-recomp-case/index.md): Case study · Guitar Hero II Recompiled translates the Xbox 360 game's executable to native C++ with XenonRecomp and ReXGlue, then builds a Windows program with D3D12 graphics. The repository contains game-specific extraction tools, analysis notes and runtime hooks; the author reports playable menus and gameplay.
- [OpenE2140: an OpenRA remake of Earth 2140](https://awesomerea.org/resources/opene2140-earth-2140-remake-case/index.md): Case study · OpenE2140 recreates Earth 2140 as an OpenRA-based game with C# logic, rules and loaders for the original game's files. It imports assets from a user's installed Earth 2140 copy on first startup and offers builds for multiple desktop platforms.
- [Lego Battles: a hand-decompiled Nintendo DS reconstruction](https://awesomerea.org/resources/lego-battles-decomp-case/index.md): Case study · Lego Battles reconstructs Nintendo DS game source through manual decompilation, chiefly targeting the European version. Its build combines recovered C/C++ code with assets extracted from the user's ROM; an optional ARM7 BIOS enables a matching ROM build.
- [OpenStrike: reconstructing Desert Strike and Jungle Strike data and engine behavior](https://awesomerea.org/resources/openstrike-case/index.md): Case study · OpenStrike is an early C++ reimplementation of Desert Strike and Jungle Strike. Its tools unpack original DAT archives and display graphics and complete levels; the game skeleton loads and renders some sprites and animations. The author describes the game as not yet playable.
- [Arizona Vamp Recomp: a static recompilation of Darkwatch](https://awesomerea.org/resources/arizona-vamp-darkwatch-recomp-case/index.md): Case study · Arizona Vamp Recomp builds a native Windows port of the original Xbox Darkwatch by statically translating its executable to x86-64 code. A host runtime maps Direct3D 8 calls to Direct3D 12 and DirectSound to XAudio2, while game files come from the user's copy. The author reports a playable beta with campaign progress into the first chapter.
- [Inferno: an arcade sound ROM disassembly](https://awesomerea.org/resources/inferno-sound-rom-case/index.md): Case study · Disassembles the sound ROM of Williams Electronics' 1984 arcade game Inferno. The repository contains an assembly listing and sound-studio preset notes.
- [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.
- [Hey You, Pikachu!: N64 disassembly](https://awesomerea.org/resources/hey-you-pikachu-disassembly-case/index.md): Case study · Disassembles the Nintendo 64 game Hey You, Pikachu! into assembly files organized under versioned directories. The project includes MIPS disassembly and extraction tools and a Makefile with a ROM build and optional MD5 comparison.
- [hode: a Heart of Darkness engine reimplementation](https://awesomerea.org/resources/hode-case/index.md): Case study · hode reimplements the engine of Heart of Darkness and reads data files from the original Windows demo or CD release. Its C++ source includes game, level, resource, video and audio handling, with command-line options for data paths, levels and checkpoints.
- [DOLSharp: a Dark Age of Camelot server reimplementation](https://awesomerea.org/resources/dolsharp-daoc-server-case/index.md): Case study · DOLSharp rebuilds a server for Dark Age of Camelot. It provides network communication for the game client, stores characters and world data in MySQL or SQLite, and supplies a persistent framework for game rules and behavior.
- [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.
- [Splitting Images: a ZX Spectrum disassembly](https://awesomerea.org/resources/splitting-images-spectrum-case/index.md): Case study · Splitting Images provides SkoolKit disassembly sources for the ZX Spectrum game also known as Split Personalities. Its source and control files support generated HTML listings in hexadecimal and decimal forms.
- [Doom SNES: a SNESRecomp native PC port](https://awesomerea.org/resources/doom-snes-recomp-case/index.md): Case study · DoomSNESRecomp ports the SNES release of Doom to native Windows, Linux and macOS builds using SNESRecomp. Bank configuration and symbol maps guide code generation from the user’s ROM; the host renderer captures Super FX scene state for higher resolution and widescreen presentation. Optional controls and gameplay changes sit alongside the recompilation.
- [Castle Excellent: shared-source NES reconstruction with Castlequest](https://awesomerea.org/resources/castle-excellent-castlequest-reconstruction-case/index.md): Case study · Reconstructs Castle Excellent for Famicom and Castlequest for NES from shared ca65 assembly source. The build extracts private assets from users' ROMs and compares each revision byte for byte; MAME attract-mode checks cover selected behavior after code relocation.
- [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.
- [Wipeout Pure: a native PSP static recompilation](https://awesomerea.org/resources/wipeout-pure-recomp-case/index.md): Case study · pure-recomp turns Wipeout Pure’s US Greatest Hits v2.00 PSP executable into a native Apple Silicon macOS or Windows program through ahead-of-time translation. It supplies host implementations of PSP services and Metal or Vulkan graphics, generating translated game code from the user’s disc image. Its checks compare frames with PPSSPP captures.
- [2EZDecomp: matching decompilation of EZ2AC](https://awesomerea.org/resources/2ezdecomp-ez2ac-case/index.md): Case study · 2EZDecomp reconstructs C and C++ for an EZ2AC arcade rhythm game executable and compares compiled functions with reccmp. The project targets version 2.05 with Microsoft Visual C++ 7.1 and reports all 1,474 functions decompiled, with 1,300 byte-identical at the recorded checkpoint.
- [Beetle Adventure Racing Recomp: an N64 static recompilation port](https://awesomerea.org/resources/beetle-adventure-racing-recomp-case/index.md): Case study · Beetle Adventure Racing Recomp builds a native PC port of the USA Nintendo 64 game using N64Recomp and a modern runtime. Continuing an earlier port, it adds widescreen and HUD work, extended draw distance, diagnostics and a technical reference on the ROM, relocatable modules and rendering. The author reports playable races on Windows; the Linux build is still in progress.
- [Costume Quest: Windows x86 functional decompilation](https://awesomerea.org/resources/costume-quest-decomp-case/index.md): Case study · Costume Quest reconstructs functions from the Windows x86 Steam build 81338 as C++ source intended to match game behavior. The project records original function addresses, marks uncertain or unfinished sections, and builds with xmake and an x86-capable MSVC toolchain using a separately obtained game copy and Steamworks SDK.
- [Titanic: an osu! Bancho server reconstruction across client generations](https://awesomerea.org/resources/titanic-osu-bancho-case/index.md): Case study · Titanic reconstructs osu! server services to examine how Bancho works across stable client releases from 2007 through 2026. The repository combines a Python Bancho game server with Go score and web services, database migrations and shared client-version checks.
- [OpenApoc: rebuilding the X-COM: Apocalypse engine](https://awesomerea.org/resources/openapoc-case/index.md): Case study · OpenApoc reimplements the X-COM: Apocalypse engine in C++ and SDL2 using files from the user's original game. It adds modern display support, XML-based save editing, modding facilities, and experimental skirmish play while tracking unfinished original-game features.
- [Mega Man Legends Recompiled: a European PlayStation setup host](https://awesomerea.org/resources/mega-man-legends-psxrecomp-case/index.md): Case study · Mega Man Legends Recompiled provides a Windows setup host that uses psxrecomp to generate and build the European PlayStation game on the user's computer. Its game profile and disc verifier recognize the supported release, including the canonical split-track layout. The author reports gameplay in a private package, while exact public-package startup checks remain open.
- [SMW NES Disassembly: disassembling the Famicom Super Mario World port](https://awesomerea.org/resources/smw-nes-disassembly-case/index.md): Case study · SMW NES Disassembly is a work-in-progress assembly disassembly of the unlicensed Famicom port of Super Mario World. Its build extracts assets from the user's ROM and assembles the source; the contribution guide calls for checking the assembled ROM against the final version's code.
- [F-Zero GX: a matching GameCube decompilation](https://awesomerea.org/resources/fzero-gx-decomp-case/index.md): Case study · F-Zero GX is a work-in-progress matching C decompilation of the GameCube game's executable code. Its workflow compares functions with objdiff and linked outputs against retail hashes. The targets include the main DOL, main.rel extracted from the encrypted, compressed line__.bin archive, and screen-specific REL modules.
- [Mega Man X: an address-annotated disassembly](https://awesomerea.org/resources/mmx1-disassembly-case/index.md): Case study · MMX1-Disassembly presents Mega Man X as a large assembly listing with ROM addresses, instruction bytes and labels. The listing exposes control flow and instruction-level behavior for analysis.
- [Max Payne 3 RePrescribed: an Xbox 360 to PS5 recompilation](https://awesomerea.org/resources/max-payne-3-represcribed-case/index.md): Case study · Max Payne 3 RePrescribed recompiles the Xbox 360 Max Payne 3 Title Update 9 executable for a native PS5 port. Its build applies game-specific patches to a PS5 framework, runs ReXGlue code generation and packages the runtime and installer, with original discs and update files supplied by the owner.
- [Marvel vs. Capcom 2: matching PS2 decompilation and browser port](https://awesomerea.org/resources/mvc2-ps2-decomp-case/index.md): Case study · Marvel vs. Capcom 2 reconstructs the NTSC-U PS2 game's code as C checked byte for byte against the retail executable, then compiles that code for a WebAssembly and WebGL2 port. The author reports 99.93% code coverage, a byte-exact ELF rebuild and end-to-end browser play; desktop ports are planned.
- [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.
- [Project ANISE: an AI5V and SILV scripting engine interpreter](https://awesomerea.org/resources/project-anise-ai5v-case/index.md): Case study · Project ANISE is a C++ interpreter for Japanese adventure games built on the AI5V or SILV scripting engines. Its source includes script operations, graphics, sound and input components. The project was developed on Windows with SDL, and the author reports compiling and running it on Linux.
- [Travel With Trashman: a ZX Spectrum disassembly](https://awesomerea.org/resources/travel-with-trashman-spectrum-case/index.md): Case study · Travel With Trashman provides SkoolKit disassembly sources for the ZX Spectrum game. Its source and control files support generated HTML listings in hexadecimal and decimal forms.
- [Medarot Parts Collection: a Game Boy disassembly and translation workspace](https://awesomerea.org/resources/medarot-parts-collection-disassembly-case/index.md): Case study · medarot1-pc disassembles parts of Medarot Parts Collection for Game Boy and maintains text, tilemap, and tileset extraction tools for a translation workspace. Its build overlays the reconstructed parts on a user-supplied ROM and compares the output with the original.
- [NHL 94 Genesis: a matching Sega Genesis disassembly](https://awesomerea.org/resources/nhl-94-genesis-case/index.md): Case study · NHL 94 Genesis reconstructs the Sega Genesis game's assembly and compares the assembled retail build byte for byte with a user-supplied ROM. Its build extracts graphics, sound and names from that ROM, while segment checks compare individual address ranges.
- [Digimon World 2003 Recompiled: a local PSXRecomp setup host](https://awesomerea.org/resources/digimon-world-2003-recompiled-case/index.md): Case study · Digimon World 2003 Recompiled provides a psxrecomp setup host for the European PlayStation game. Its title recipe, symbols and seed data support local code generation from the user's disc and BIOS; the author reports gameplay in a private package while exact-package gates remain open.
- [Summoner: A Goddess Reborn: an in-progress GameCube decompilation](https://awesomerea.org/resources/summoner-goddess-reborn-decomp-case/index.md): Case study · sgr reconstructs source for the USA GameCube release of Summoner: A Goddess Reborn. Its build uses the user's disc image and generated configuration, while objdiff compares rebuilt objects as the C and C++ decompilation progresses.
- [Vagrant Story Recompiled: a disc-local PSXRecomp port](https://awesomerea.org/resources/vagrant-story-recompiled-case/index.md): Case study · Vagrant Story Recompiled builds a native PC version of the USA PlayStation game through psxrecomp. It reads the user's disc for game code and supplies title-specific widescreen, input, menu and frame-rate plugins, plus patches to the recompiler runtime.
- [milondasm: disassembling Milon's Secret Castle](https://awesomerea.org/resources/milondasm-nes-case/index.md): Case study · milondasm provides an annotated assembly reconstruction of the North American NES release of Milon's Secret Castle. The author reports that it can assemble to the original when the user supplies graphics binaries; the repository also includes music transcriptions generated from ROM data.
- [Sonic the Hedgehog (2006): Xbox 360 source reconstruction](https://awesomerea.org/resources/sonic-2006-decomp-case/index.md): Case study · The Sonic the Hedgehog (2006) project reconstructs source for the Xbox 360 game. It builds against a user-provided XEX and uses objdiff to compare compiled objects with the original while contributors replace functions with C++ source.
- [Deus Ex: reconstructed DeusEx.dll native code](https://awesomerea.org/resources/deus-ex-dll-reconstruction-case/index.md): Case study · Reconstructs the native DeusEx.dll game module for Deus Ex from analysis of its retail binary and Unreal Engine 1 interfaces. The project combines decompiler output, disassembly, SDK headers, UnrealScript declarations, and observed behavior; its recovered C++ remains a work in progress.
- [vc64-decomp: disassembling the SM64 Wii Virtual Console build](https://awesomerea.org/resources/vc64-decomp-case/index.md): Case study · vc64-decomp disassembles and partly decompiles the Wii N64 Virtual Console build targeting the North American Super Mario 64 release. Its build combines PowerPC assembly and C sources into a Wii .app file.
- [OpenUT2k4: recreating Unreal Tournament 2004 in Unreal Engine 5.8](https://awesomerea.org/resources/openut2k4-case/index.md): Case study · OpenUT2k4 recreates Unreal Tournament 2004 in C++ on Unreal Engine 5.8 using maps, characters, audio and music converted locally from the player's installation. It builds maps at runtime and implements UT2004 network compatibility so its client and server can play alongside the original game.
- [ra2-decomp: a matching decompilation of Yuri's Revenge](https://awesomerea.org/resources/ra2-decomp-yuris-revenge-case/index.md): Case study · ra2-decomp reconstructs Command & Conquer: Red Alert 2 – Yuri's Revenge 1.001 as C++ and checks compiled functions against gamemd.exe byte for byte. It maps function addresses, source files and hashes, while recording unmatched attempts separately. The author reports 79% of the game's code bytes matched as of 6 November 2026.
- [Harvest Moon: Back to Nature: a byte-matching PlayStation decompilation](https://awesomerea.org/resources/harvest-moon-back-to-nature-decomp-case/index.md): Case study · Harvest Moon: Back to Nature reconstructs the USA PlayStation release SLUS_011.15 as matching C source. It rebuilds the executable and 13 overlays byte for byte, and can check a full disc image against SHA-1 hashes when supplied with the user's disc. The build records one SDK-word patch and original padding bytes as exceptions.
- [drmario64_recomp: an experimental Dr. Mario 64 recompilation](https://awesomerea.org/resources/dr-mario-64-recomp-case/index.md): Case study · drmario64_recomp is an experimental native port of Dr. Mario 64 built with N64Recomp and RSPRecomp from a user-supplied US ROM. The project includes recompilation configuration, game patches and an RT64-based renderer.
- [Tony Hawk's Underground 2: a behavioral C++ reconstruction](https://awesomerea.org/resources/thug2-decomp-case/index.md): Case study · thug2-decomp reconstructs Tony Hawk's Underground 2 for PC as readable C++ across engine, game, rendering, scripting, and networking subsystems. The author says rewritten functions were checked against the original's behavior; the resulting executable runs using data from the user's game installation and includes source-level fixes and additions.
- [reWoodpecker: a PSP reconstruction of Woody Woodpecker](https://awesomerea.org/resources/rewoodpecker-case/index.md): Case study · reWoodpecker rebuilds Woody Woodpecker: Escape from Buzz Buzzard Park for PSP with a C++ engine and a Qt converter for the user's PS2 disc. The runtime loads levels, handles collision and gameplay, executes EKO scripts and renders through the PSP GU.
- [Buffy the Vampire Slayer: Chaos Bleeds — an Xbox static recompilation for PC](https://awesomerea.org/resources/buffy-chaos-bleeds-pc-case/index.md): Case study · Buffy the Vampire Slayer: Chaos Bleeds — PC Port turns the 2003 Xbox game's code into a native Windows program with xboxrecomp. It replaces console graphics and input with Vulkan or Direct3D 11 rendering and XInput support, and provides an Android build. The launcher installs game data from the user's own PAL or NTSC Xbox disc image.
- [Underworld Adventures: recreating Ultima Underworld I](https://awesomerea.org/resources/underworld-adventures-case/index.md): Case study · Underworld Adventures recreates Ultima Underworld I as a C++ engine for modern systems, loading the user's original game files. It uses OpenGL for 3D graphics, SDL2 for platform services and Lua for scripting, and includes documentation of Ultima Underworld I and II file formats.
- [Ninja Master: a native Shinobi III reconstruction](https://awesomerea.org/resources/ninja-master-shinobi-iii-case/index.md): Case study · Ninja Master reconstructs Shinobi III: Return of the Ninja Master's gameplay as a native desktop program. It loads graphics, sound and stage data from a compatible user-supplied Mega Drive ROM, with widescreen presentation, configurable controls and save slots.
- [Breakdown Recompilation: an Xbox game rebuilt for Windows](https://awesomerea.org/resources/breakdown-recompilation-case/index.md): Case study · Breakdown Recompilation builds a native Windows version of the original Xbox game from the user's disc image. Its launcher extracts the ISO, uses an XboxRecomp fork to lift XBE code into C, and applies game-specific overrides before building.
- [Super Mario 64: a PlayStation port of reconstructed game source](https://awesomerea.org/resources/sm64-psx-port-case/index.md): Case study · sm64-psx ports reconstructed Super Mario 64 source to the original PlayStation. It replaces floating-point-heavy paths with fixed-point math, translates RSP display lists into a PSX-oriented format and converts textures, while extracting required assets from a user-provided US ROM.
- [StarTropics: a byte-matched NES disassembly](https://awesomerea.org/resources/startropics-disassembly-case/index.md): Case study · Reconstructs StarTropics (USA) as labelled ca65 assembly across its 32 PRG banks and compares the resulting ROM byte for byte with the user's copy. Python tools generate the assembly from annotations, decode game data and export debugger labels.
- [lbtvg: matching decompilation of LEGO Batman: The Videogame](https://awesomerea.org/resources/lbtvg-lego-batman-case/index.md): Case study · lbtvg reconstructs C++ source for the 2008 PC game LEGO Batman: The Videogame and compares builds against a reference executable. The project includes game-specific source, build configuration, and scripts for binary analysis and matching. The author reports 18.53% match progress; reference binaries are supplied locally by the user.
- [GTA IV Recompiled: an Xbox 360 static recompilation](https://awesomerea.org/resources/gta-iv-recompiled-case/index.md): Case study · GTA IV Recompiled translates the Xbox 360 version of Grand Theft Auto IV from PowerPC code to C++ ahead of time with rexglue and builds a native Windows program. Its configurations add constructor, callback and thunk entry points, while its notes trace a failure in streamed static world collision. The author reports that the game reaches interactive play, although the player falls through the ground.
- [OpenXeen: rebuilding the World of Xeen engine in Java](https://awesomerea.org/resources/openxeen-case/index.md): Case study · OpenXeen is a Java engine rewrite for Might and Magic IV and V: World of Xeen. Its current code parses CC archives and some graphics, audio and map information, creates file proxies and renders selected game components. The author states that the software is not ready for release.
- [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.
- [Gangstar: West Coast Hustle: Android native-library decompilation](https://awesomerea.org/resources/gangstar-west-coast-hustle-case/index.md): Case study · Gangstar: West Coast Hustle is being decompiled from its Android ARM library libsanangeles.so into C++ intended to reproduce retail bytes. The project maps symbols and original source-file names, stores unmatched functions as named assembly, and records matching work by gameplay area. The author reports 4,661 game functions in scope and 24.40% matched bytes.
- [GMDprivateServer: a Geometry Dash server emulator](https://awesomerea.org/resources/gmdprivateserver-geometry-dash-case/index.md): Case study · GMDprivateServer implements a PHP server emulator for Geometry Dash versions 1.0 through 2.2. It uses a MySQL or MariaDB database and requires redirecting the game's executable to the replacement endpoints; its code includes account, messaging and game-specific hash handling.
- [Forza Horizon 2: an experimental Xbox 360 recompilation for Android](https://awesomerea.org/resources/forza-horizon-2-android-recomp-case/index.md): Case study · Forza Horizon 2 Recomp Android targets an ARM64 Android port of the Xbox 360 game using XenonRecomp for PowerPC code and XenosRecomp for shaders. It contains a mobile runtime, JNI bridge, setup screen and touch HUD; the author reports offline translation of the executable and partial shader conversion, while gameplay integration remains unfinished.
- [X-Wing Alliance: statically recompiling the 1999 PC game for Windows](https://awesomerea.org/resources/xwa-wing-alliance-case/index.md): Case study · xwa statically recompiles Star Wars: X-Wing Alliance by lifting its x86 code to C and linking it with a Win32/DirectX compatibility layer and Direct3D 11 renderer. The workflow uses the user's Steam installation and a locally obtained decrypted executable. The author reports an alpha build that reaches campaign flight and completes the first mission under autoplay; audio and much game logic remain untested.
- [Moonlight Madness: a SkoolKit ZX Spectrum disassembly](https://awesomerea.org/resources/moonlight-madness-case/index.md): Case study · Moonlight Madness is a SkoolKit disassembly of the ZX Spectrum game. Its source tree includes a .skool listing, reference files, and scripts that generate browsable hexadecimal and decimal views. SkoolKit is needed to build the development version.
- [BOOGA-BOO: a rebuildable MSX-1 Z80 disassembly](https://awesomerea.org/resources/boogaboo-disasm-msx-case/index.md): Case study · BOOGA-BOO reconstructs the MSX-1 game's Z80 code as assembly. The documented z80asm build produces a binary with a stated SHA hash, and the repository includes scripts and data for game graphics and maps.
- [Dragon Warrior: a commented NES disassembly](https://awesomerea.org/resources/dragon-warrior-disassembly-case/index.md): Case study · Dragon Warrior Disassembly reconstructs the NES game as commented assembly source and includes Ophis to assemble it. A build script can compare checksums between assembled output and original binary files; the author reports that the game’s reverse engineering is complete.
- [Yu-Gi-Oh! The Duelists of the Roses: a byte-matched PS2 decompilation](https://awesomerea.org/resources/duelists-of-the-roses-decomp-case/index.md): Case study · This decompilation reconstructs the NTSC-U PS2 release of Yu-Gi-Oh! The Duelists of the Roses in C, covering SLUS_205.15 and 762 code modules. Its make check target compares rebuilt files byte for byte with the user's originals. The author reports that the main executable is in C while module functions remain partly in assembly.
- [BOTW Compiled: an experimental Wii U recompilation port](https://awesomerea.org/resources/botw-compiled-case/index.md): Case study · BOTW Compiled is an experimental Windows x64 port of the Wii U release of The Legend of Zelda: Breath of the Wild. It uses generated PowerPC code, a native runtime and an experimental GX2/Latte graphics path; the source reports an opening screen and introductory text while character and environment rendering remain incomplete.
- [BullyRecomp: a static recompilation of Bully: Scholarship Edition](https://awesomerea.org/resources/bully-recomp-case/index.md): Case study · BullyRecomp translates the Xbox 360 Bully: Scholarship Edition executable to C++ with ReXGlue and runs it on Windows with a Direct3D 12 backend. Game-specific configuration repairs function boundaries, initializers and jump tables, while local patches adjust graphics and timing. The author reports gameplay in the opening tutorial; missions and wider areas remain untested.
- [Mercenaries 2: a Rust reconstruction of World in Flames](https://awesomerea.org/resources/mercenaries-2-rust-reconstruction-case/index.md): Case study · Mercenaries 2: World in Flames is reconstructed as a Rust game engine that loads models, terrain, scripts, menus, audio and other data from the user's PC installation. The project traces the Xbox 360 program in Ghidra to recover engine behavior and uses game data and original footage for other behavior. The author reports a playable single-player story on Windows, while shared-world co-op remains unfinished.
- [F-15 Strike Eagle 2: reconstructing the DOS game source](https://awesomerea.org/resources/f15-strike-eagle-2-reconstruction-case/index.md): Case study · F-15 Strike Eagle 2 reconstructs C and assembly source for selected executables of the MS-DOS game v451.03 from analysis of the original binaries. Its build uses Microsoft C 5.1 and can compare reconstructed executables with originals through mzdiff. The author reports instruction-level matches for C routines compiled with the original toolchain, while some sound-related executables remain outside the reconstruction.
- [The Jungle Book: a Game Boy disassembly with level-analysis tools](https://awesomerea.org/resources/jungle-book-gb-disassembly-case/index.md): Case study · The Jungle Book project disassembles the Game Boy game into banked assembly and supplies tools to extract assets from a user's ROM. Its analysis utilities render level maps, decompress LZ77 data, inspect level objects, and export animation frames; the author reports a byte-exact rebuild when the extracted assets are supplied.
- [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.
- [Ocarina of Time: an early ROM disassembly and NTSC 1.0 memory map](https://awesomerea.org/resources/camthesaxman-zelda-oot-disassembly-case/index.md): Case study · zelda_oot assembles an Ocarina of Time ROM from game assembly and files extracted from a base ROM. Its Makefile checks the resulting image against an MD5 checksum, while included NTSC 1.0 notes map save data, inventory fields, and instruction addresses.
- [Ganbare Goemon Kirakira Douchuu: a Super Famicom disassembly](https://awesomerea.org/resources/ganbare-goemon-kirakira-douchuu-case/index.md): Case study · Ganbare Goemon Kirakira Douchuu is being disassembled bank by bank for the Super Famicom v1.0 ROM. The build extracts assets from the user's original ROM, assembles source with Asar, and can compare the rebuilt SHA-1. Code and data identification remain incomplete, and later ROM revisions are not supported.
- [Tomodachi Life: an early 3DS decompilation](https://awesomerea.org/resources/tomodachi-life-3ds-decomp-case/index.md): Case study · Tomodachi Life is the target of an early 3DS decompilation with C++ source, symbol splits, and a build pipeline. The setup uses the USA Rev 1 code.bin and exheader together with armcc; the source tree currently contains only a small amount of reconstructed code.