# Curated reverse engineering resources · Page 10

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

## Games (100)

- [Bushido Blade 2: matching decompilation of the North American PS1 executable](https://awesomerea.org/resources/bushido-blade-2-decomp-case/index.md): Case study · Bushido Blade 2 reconstructs the North American PlayStation game's SLUS_006.63 executable from C and retained canonical assembly. Its build extracts a user-supplied disc, compiles the reconstructed sources and checks the resulting executable against the original SHA-1; the author reports a byte-identical build.
- [War1: a C reimplementation of Warcraft: Orcs & Humans](https://awesomerea.org/resources/war1-warcraft-remake-case/index.md): Case study · War1 reimplements Warcraft: Orcs & Humans in C as an RTS engine that reads the original game's DATA.WAR assets. It implements unit movement and training, building construction, resource gathering, fog of war, spells and basic enemy behavior; AI, cinematics and save/load are still listed as unfinished.
- [SSX 3: a work-in-progress GameCube decompilation](https://awesomerea.org/resources/ssx-3-gamecube-decomp-case/index.md): Case study · SSX 3 reconstructs source for the USA Rev 0 GameCube release as an unfinished decompilation. Its configuration uses a user-supplied disc image to prepare a Ninja build, while objdiff compares rebuilt objects with the original game.
- [Glover: an in-progress Nintendo 64 decompilation](https://awesomerea.org/resources/glover-n64-decomp-case/index.md): Case study · Glover is an in-progress decompilation of the Nintendo 64 game, with C source and assembly for functions that remain nonmatching. Its Makefile defines a MIPS cross-build for the game and separates matching from nonmatching build settings. The author describes Claude as a major contributor to the work.
- [RustyWorld: a Rust reimplementation of the Another World engine](https://awesomerea.org/resources/rustyworld-case/index.md): Case study · RustyWorld reimplements the Another World game engine in Rust and runs on the user's original data. Its VM separates instruction decoding from execution and groups related opcodes, while minifb handles video and input and rodio handles audio.
- [OpenSolomonsKey: a Linux and Windows port of Solomon's Key](https://awesomerea.org/resources/open-solomons-key-case/index.md): Case study · OpenSolomonsKey ports the 1986 arcade game Solomon's Key to Linux and Windows in C++. Its source includes gameplay, graphics, audio, level handling and platform entry points, with build scripts for the supported systems.
- [Sonic Adventure DX: an early matching decompilation of the 2014 Steam release](https://awesomerea.org/resources/sonic-adventure-dx-steam-decomp-case/index.md): Case study · Sonic Adventure DX is being reconstructed from its 2014 Steam executable as C and C++ source that matches retail machine code function by function. The project uses the identified Visual C++ 2010 SP1 compiler, game-specific function and code-generation maps, and reccmp scores to compare rebuilt functions. The author reports an early stage with six exact function matches.
- [GoldenPad: GoldenEye 007 rebuilt for Apple devices](https://awesomerea.org/resources/goldenpad-case/index.md): Case study · GoldenPad runs GoldenEye 007 on iPhone, iPad and Apple Silicon Mac using statically recompiled game code from GoldenEye64Recomp. Its Apple host adds touch and controller input, saves and audio, while RT64 presents graphics through Metal. Users generate the game-bearing build from their own US retail ROM.
- [Dino Crisis 2 Recompiled: a PSXRecomp setup candidate](https://awesomerea.org/resources/dino-crisis-2-recompiled-case/index.md): Case study · Dino Crisis 2 Recompiled provides a PSXRecomp configuration and portable setup candidate for the SLUS-01279 PlayStation game. The setup wizard takes a user-supplied disc image and BIOS, then generates and rebuilds the program; gameplay acceptance remains pending.
- [Digimon World DS: matching Nintendo DS decompilation](https://awesomerea.org/resources/digimon-world-ds-decomp-case/index.md): Case study · Digimon World DS reconstructs the North American Nintendo DS game's ARM9 program and overlays as matching C source. Its dsd-based build takes code still awaiting decompilation from the user's ROM, links recovered functions into the modules and checks the output byte for byte; the author reports 2,386 of 3,665 game functions in C as of October 2026.
- [OpenTS: reconstructing the Tiberian Sun engine](https://awesomerea.org/resources/opents-case/index.md): Case study · OpenTS reconstructs the Command & Conquer: Tiberian Sun 2.03 Firestorm engine as a standalone program. It combines GPL-released source from related Command & Conquer games with reverse engineering of the original executable, and uses assets from the user's installed game.
- [Zelda3: a C reimplementation of A Link to the Past](https://awesomerea.org/resources/zelda3-case/index.md): Case study · Zelda3 reimplements The Legend of Zelda: A Link to the Past in C, extracting levels and images from the user's US SNES ROM. It can run the original machine code beside the replacement and compare RAM state after each frame; the author reports that the game is playable from start to end.
- [Verdite1: porting the Japanese King's Field to PC and Android](https://awesomerea.org/resources/verdite1-case/index.md): Case study · Verdite1 ports the Japanese PlayStation release of King's Field to Windows, Linux, and Android as native C/C++ built from an existing decompilation and King's Field Enhanced. It reads a user-provided SLPS-00017 disc image and adds widescreen display, keyboard and mouse controls, rendering changes, and mod support.
- [Ratchet & Clank 2: a functional reconstruction of PAL game systems](https://awesomerea.org/resources/rac2decomp-case/index.md): Case study · RAC2Decomp studies the PAL PlayStation 2 release of Ratchet & Clank 2: Going Commando and translates observed engine behavior into C. Its workflow uses Ghidra for static analysis and the PCSX2 debugger for runtime traces; the repository includes code and notes on boot state, graphics initialization, and text rendering.
- [Sonic Adventure DX: a multi-version GameCube decompilation](https://awesomerea.org/resources/sadx-gamecube-decomp-case/index.md): Case study · doldecomp/sadx reconstructs Sonic Adventure DX for GameCube across eight prototype, demo and retail versions. Its build uses extracted game DOL and REL files, builds DOLs and disassembles REL modules as the decompilation progresses.
- [Army of Two: The 40th Day — an Xbox 360 recompilation](https://awesomerea.org/resources/army-of-two-40th-day-rexglue-case/index.md): Case study · Army of Two: The 40th Day Recomp translates the Xbox 360 game's PowerPC default.xex into C++ with ReXGlue for a Windows x64 port. Game-specific patches and configuration support the proof of concept. The author reports early menus and Shanghai gameplay, while later engine functions, boss scripts and saves remain unfinished.
- [I COULD HAVE GIVEN YOU THE WORLD: a native 007 N64 port](https://awesomerea.org/resources/i-could-have-given-you-the-world-case/index.md): Case study · I COULD HAVE GIVEN YOU THE WORLD ports the N64 game 007: The World Is Not Enough to PC and Steam Deck. Its first launch compiles native game code locally from the user's ROM; the project adds widescreen rendering, modern controls and save features.
- [ReFlood: reconstructing the Amiga game Flood in C and SDL2](https://awesomerea.org/resources/reflood-case/index.md): Case study · ReFlood reconstructs the Amiga game Flood as a C99 program with an SDL2 host, using assets extracted from the player's own disk image. Its reports map the game's custom disk layout and document behavior recovered from the original, while the build also offers a headless core and a level editor.
- [ReHLDS: reconstructing the Half-Life dedicated server](https://awesomerea.org/resources/rehlds-hlds-case/index.md): Case study · ReHLDS reconstructs the Half-Life dedicated server from DWARF debug information embedded in the Linux HLDS engine_i486.so for builds 6152/6153. Its replacement engine fixes reported defects and provides an extended API for mods and plugins.
- [rust-theft-auto: reimplementing the original Grand Theft Auto engine](https://awesomerea.org/resources/rust-theft-auto-case/index.md): Case study · rust-theft-auto reimplements the original Grand Theft Auto engine in Rust using map and style files from a player's installation. The source includes map structures, tile and style handling, and a renderer. Reimplementing gameplay and extending maps and missions are stated goals.
- [SuperMetroidSNESRecomp: a selective 65816 static recompilation](https://awesomerea.org/resources/super-metroid-recomp-case/index.md): Case study · SuperMetroidSNESRecomp translates selected Super Metroid 65816 functions into native C with snesrecomp and executes other paths from the user's ROM through an interpreter. Its game-specific runtime adds optional rendering and gameplay features plus replay capture for diagnosing divergences. The author reports boot, demo, door traversal, pause and ship-save checks while broader progression testing continues.
- [mlbis: matching Mario & Luigi: Bowser's Inside Story decompilation](https://awesomerea.org/resources/mlbis-decomp-case/index.md): Case study · mlbis reconstructs the Nintendo DS game Mario & Luigi: Bowser's Inside Story as C/C++ source intended to match the retail ROM byte for byte. Its tooling compiles units with CodeWarrior, compares functions and data objects against delinked ROM targets, and relinks modules for byte comparison.
- [Sexy Parodius Recompiled: a PlayStation recompilation build kit](https://awesomerea.org/resources/sexy-parodius-recompiled-case/index.md): Case study · Sexy Parodius Recompiled configures PSXRecomp to generate and compile the Japanese PlayStation release of Sexy Parodius from a user-supplied disc. The repository contains game-specific identity, symbols, seeds and build configuration; the author reports a Windows build reaching the title screen and attract-mode gameplay.
- [Luigi's Mansion: a four-version GameCube decompilation](https://awesomerea.org/resources/luigis-mansion-decomp-case/index.md): Case study · Luigi's Mansion decomp reconstructs source for four GameCube releases: USA Rev 0, Japan Rev 0 and PAL Revs 0 and 1. The repository supplies game C and C++ files, symbols and per-version build configurations, with Ninja builds and objdiff support starting from a user-supplied disc image.
- [Encounter HD: rebuilding the 1983 Oric adventure](https://awesomerea.org/resources/encounter-hd-case/index.md): Case study · Encounter HD rebuilds the 1983 Oric text adventure in C and assembly for floppy-based Oric hardware. The new version revises item interactions and hazards, replaces action-count timing with a clock, and adds graphics, audio and alternative routes through some obstacles.
- [Defender: annotated arcade disassembly](https://awesomerea.org/resources/defender-arcade-disassembly-case/index.md): Case study · Defender-Source-Code documents the Williams Defender arcade game in an annotated disassembly. It labels PCB registers, RAM variables and game routines, with separate notes for palette values and ROM check bytes.
- [ZONE OF THE ENDERS: an early game decompilation](https://awesomerea.org/resources/zone-of-the-enders-2001-case/index.md): Case study · zoe1 is an early decompilation of the 2001 game ZONE OF THE ENDERS. Its source implements the game's string-hash routine and sketches cache-system functions, many of which are still marked for decompilation.
- [Banjo-Tooie: Scurvy Dog Port — a static PC recompilation](https://awesomerea.org/resources/banjo-tooie-scurvy-dog-port-case/index.md): Case study · Banjo-Tooie: Scurvy Dog Port translates the game's Nintendo 64 code with N64Recomp and renders a native Windows port with RT64. Game-specific patches and runtime adapters handle behavior and presentation, including widescreen rendering and interpolation. The author describes the current release as alpha.
- [VETTE! 2026: a disassembly-based game reconstruction](https://awesomerea.org/resources/vette-2026-case/index.md): Case study · VETTE! 2026 rebuilds the DOS racing game in C++20 and SDL3 from disassembly and documented format research. The original runs in a built-in emulator while native routines are added and compared incrementally; the port also reads optional PC-98 and Macintosh art and sound from the user's copies.
- [Kirby Air Ride: a three-region GameCube decompilation](https://awesomerea.org/resources/kar-kirby-air-ride-case/index.md): Case study · KAR reconstructs Kirby Air Ride code for the USA, Japan and Europe GameCube releases using decomp-toolkit and CodeWarrior build settings. It keeps source, symbols and split metadata for comparison with the user's extracted discs; data-split notes describe source ownership inferred from strings, cross-references and layout.
- [Captain America Super Soldier Recompiled: a title-screen build](https://awesomerea.org/resources/captain-america-super-soldier-recompiled-case/index.md): Case study · Captain America Super Soldier Recompiled configures ReXGlue v0.4 to build the Xbox 360 game as a native program. The repository includes a title manifest and host application source. The author reports a title-screen boot followed by a crash when story mode loads because addresses remain missing from the configuration.
- [Lazarus: a Mass Effect 2 static recompilation for Nintendo Switch](https://awesomerea.org/resources/lazarus-mass-effect-2-case/index.md): Case study · Lazarus translates the Xbox 360 version of Mass Effect 2 with Title Update 2 from PowerPC code into C++ for Nintendo Switch. It converts Xenos shaders ahead of time and uses a deko3d renderer that handles the game's Direct3D calls. The repository includes game-specific hooks, native function replacements and build documentation for user-supplied discs.
- [Prehistorik_js: a first-level demo rewrite](https://awesomerea.org/resources/prehistorik-demo-rewrite-case/index.md): Case study · Prehistorik_js rewrites the first level of a specified Prehistorik playable demo in C. Its source includes game, cave, object, and level code alongside scripts for unpacking and converting DOS resources.
- [Star Wars Episode I: Racer: an N64 static recompilation](https://awesomerea.org/resources/star-wars-episode-i-racer-recomp-case/index.md): Case study · Racer statically recompiles the N64 release of Star Wars Episode I: Racer with N64Recomp, N64ModernRuntime and RT64. Its ROM-analysis and symbol tools support game-specific fixes for libultra calls, split functions, asset loading and controller input; the author reports driving into a tournament race.
- [Xenosaga Episode I: an early PS2 matching decompilation](https://awesomerea.org/resources/xenosaga-i-decomp-case/index.md): Case study · Xenosaga-I-Decomp recovers C functions from the NTSC-U PS2 executable of Xenosaga Episode I and compares compiled bytes with the original ELF. Its tools split the executable, extract symbols and track decompilation progress. The author reports a byte-matching full executable build with a small fraction of functions rewritten in C; Japanese releases are planned.
- [Chrono Trigger: a frame-checked native C reimplementation](https://awesomerea.org/resources/chrono-trigger-reimplemented-case/index.md): Case study · Chrono Trigger Reimplemented ports the USA SNES game to handwritten C and compares ported routines frame by frame against the original ROM. Its development runtime combines native routines with generated C and a 65816 interpreter while the attract sequence, field, menu, event and battle systems are being ported.
- [Technician Ted: an annotated ZX Spectrum disassembly](https://awesomerea.org/resources/chipfact-case/index.md): Case study · chipfact is an annotated disassembly of the 1984 computer game Technician Ted. Its SkoolKit sources cover the game and its loader, with separate room-format and loader notes in the repository.
- [Harvest: decompiling and porting Massive Encounter](https://awesomerea.org/resources/harvest-massive-encounter-case/index.md): Case study · Harvest reconstructs C++ for the Linux amd64 1.18 release of Harvest: Massive Encounter and ports the recovered game and engine code to desktop and web platforms. Matching tools compare compiled objects with the original executable; the port replaces the platform layer with Zig, SDL3 and related components and reads separately supplied game data.
- [The Last Guardian: a Windows port through PS4 compatibility layers](https://awesomerea.org/resources/tlg-port-case/index.md): Case study · TLG-Port runs The Last Guardian's PS4 executable on Windows through game-specific replacements for PS4 system libraries. It executes the game's x86-64 instructions on the host CPU and maps graphics commands to Vulkan while converting shaders to SPIR-V during play.
- [adam: an N64 recompilation of Neon Genesis Evangelion](https://awesomerea.org/resources/adam-evangelion-recomp-case/index.md): Case study · adam recompiles the Japanese N64 release of Neon Genesis Evangelion into a native Windows program using N64Recomp and RT64. It provides an ahead of time build pipeline and a live build that translates code from the player's ROM at startup, with game-specific overlay, audio and input support.
- [PanzerChasm: recreating Chasm: The Rift with original game data](https://awesomerea.org/resources/panzerchasm-chasm-the-rift-case/index.md): Case study · PanzerChasm recreates Chasm: The Rift in C++ as an SDL2 game that loads the player's original CSM.BIN data file. The repository includes game and rendering source, shaders, and notes on the game's binary formats.
- [Dogcomp: a PAL PlayStation 2 decompilation of Dog's Life](https://awesomerea.org/resources/dogs-life-decomp-case/index.md): Case study · Dogcomp decompiles the PAL PlayStation 2 release of Dog's Life into C++ source. Its Splat-based build splits the user-provided SCES_512.48 executable, inserts assembly for functions without a C++ match, links the result and compares its checksum with the original.
- [MechWarrior SDL port: reconstructing the 1989 game in C17](https://awesomerea.org/resources/mechwarrior-sdl-port-case/index.md): Case study · MechWarrior SDL port reconstructs the 1989 game's campaign and combat systems in C17 and SDL3 for Windows x64. It reads resources and executable-authored tables from the player's installation; the author reports an experimental build reaching briefing, movement, firing and combat return.
- [Pocket Wormhole: an Android port of the FTL engine reimplementation](https://awesomerea.org/resources/pocket-wormhole-ftl-android-case/index.md): Case study · Pocket Wormhole brings the Project Wormhole reimplementation of FTL: Faster Than Light to Android using the player's ftl.dat. Its port replaces desktop OpenGL, OpenAL, GLFW and Slick2D interfaces with Android graphics, audio and touch input layers, and adds save export and import for compatible game runs.
- [BaK GL: rebuilding Betrayal at Krondor mechanics](https://awesomerea.org/resources/bakgl-case/index.md): Case study · BaKGL reimplements Betrayal at Krondor in a C++ and OpenGL engine built around original game data. It reconstructs exploration, quests, shops, inventory and other mechanics, includes resource explorers and an image extractor, and allows replacement textures. Combat remains in progress.
- [ZumaTAS: a JavaScript port of Zuma Deluxe and search-generated TAS](https://awesomerea.org/resources/zuma-deluxe-tas-case/index.md): Case study · ZumaTAS ports Zuma Deluxe game logic from the CircleShootApp decompilation into a deterministic JavaScript simulation for browser and Node.js use. It includes asset extraction from a user's game installation, a replay viewer, search programs, and recorded tool-assisted play through all 76 Adventure levels. The author reports an 8:12 total for the published run.
- [Alien Trilogy: a byte-matched PS1 source reconstruction](https://awesomerea.org/resources/alien-trilogy-ps1-decomp-case/index.md): Case study · Alien Trilogy reconstructs C source for the USA PlayStation game executable SLUS_000.07 using its original GCC 2.5.7 toolchain. Per-function comparisons check rebuilt code and relocations against retail bytes; a gate overlays rebuilt units on the user's executable and checks the complete hash. The author reports 645 byte-matched game C functions, with remaining gaps and pending source-quality work documented.
- [Mario Party 3: a partial Nintendo 64 decompilation](https://awesomerea.org/resources/mario-party-3-partial-decomp-case/index.md): Case study · mp3 partially decompiles the US Nintendo 64 release of Mario Party 3 into C source. Its build extracts a user-provided big-endian ROM and reassembles the game; the author describes fully decompiled overlays that can be edited and rebuilt. The repository is archived.
- [Dreerally: a Death Rally engine reimplementation](https://awesomerea.org/resources/dreerally-case/index.md): Case study · Dreerally recreates the Windows version of Death Rally as a replacement executable that reads files from an original game copy. Its C source covers game systems and rendering, and accompanying scripts extract or decrypt BPA, BPK, music, and save data.
- [LSD: Dream Emulator: an early PlayStation decompilation](https://awesomerea.org/resources/lsd-dream-emulator-cawfee-decomp-case/index.md): Case study · LSD Decompiled is an early-stage C decompilation of the PlayStation game LSD: Dream Emulator. Its documented workflow uses a user-supplied game executable and a MIPS cross-toolchain, then checks the rebuilt executable's hash. Many functions and filenames are still being identified.
- [ROLLER: reconstructing Whiplash/Fatal Racing for modern PCs](https://awesomerea.org/resources/roller-whiplash-case/index.md): Case study · ROLLER aims to reimplement the functionality of the 1995 game Whiplash/Fatal Racing for modern PCs. Its C implementation substitutes DOS-specific functions with SDL and Windows or Unix equivalents, and its documentation records symbol and executable analysis used during reconstruction.
- [OpenKeeper: a Dungeon Keeper II game and engine remake](https://awesomerea.org/resources/openkeeper-dungeon-keeper-ii-case/index.md): Case study · OpenKeeper reimplements the Dungeon Keeper II game and engine as a cross-platform Java application using JMonkeyEngine. It targets version 1.7 and three bonus packs, loading assets from the user's original game copy.
- [n64dd: decompiling Ocarina of Time's Disk Drive code](https://awesomerea.org/resources/n64dd-decomp-case/index.md): Case study · n64dd reconstructs the Nintendo 64 Disk Drive component found in an Ocarina of Time ROM as C and assembly. Its scripts extract a user-supplied NTSC US ROM, produce disassembly and build the component; the Makefile provides an MD5 comparison mode for output.
- [OpenMTV: Mad TV decompiled and ported to modern systems](https://awesomerea.org/resources/openmtv-mad-tv-case/index.md): Case study · OpenMTV ports the 1991 DOS game Mad TV to Windows, macOS, and Linux using readable C reconstructed from its executable. A static recompiler supplies machine-level C for remaining code, while a DOS and hardware runtime supports the game and comparisons with original behavior.
- [Another Mind: matching PlayStation source reconstruction](https://awesomerea.org/resources/another-mind-decomp-case/index.md): Case study · Another Mind reconstructs C source for Squaresoft's Japanese PlayStation 1 game. Its workflow extracts the user's retail disc, converts assembly placeholders with m2c, and checks compiled output against the retail executable's SHA-1. The author reports 226 decompiled functions out of 900.
- [South Park: Tenorman's Revenge: an Xbox 360 static recompilation](https://awesomerea.org/resources/south-park-tenormans-revenge-recompiled-case/index.md): Case study · South Park: Tenorman's Revenge is ported to Windows and Linux by translating its Xbox 360 executable to native PC code with ReXGlue. The project includes a package importer, launcher, and game-specific function analysis; the author reports that levels play on Windows while a full playthrough remains unconfirmed.
- [Super Mario Sunshine: an Android port of the decompiled game](https://awesomerea.org/resources/sms-android-port-case/index.md): Case study · sms-android ports Super Mario Sunshine to native ARM64 Android using decompiled game source, OpenGL ES 3.0, and SDL2 input. It reads a user-provided USA GameCube GMSE01 ISO and adds on-screen touch controls alongside USB and Bluetooth gamepad support.
- [Black & White: reconstructing the game from its x86 binary](https://awesomerea.org/resources/black-and-white-reconstruction-case/index.md): Case study · Black & White reconstructs the 2001 game's systems in portable C++ using analysis of its original x86 executable. An IDA and Ghidra pipeline walks RTTI vtables to recover class methods; the native viewer runs reconstructed world loading, physics, animation, scripting and audio paths.
- [Open KF: a Killing Floor reimplementation in Rust and Bevy](https://awesomerea.org/resources/open-kf-killing-floor-case/index.md): Case study · Open KF reimplements the 2009 Killing Floor engine and gameplay in Rust and Bevy, reading maps, textures, audio and other resources from the user’s installed copy. Its ue-assets crate parses Unreal packages and provides commands to inspect objects, scripts, meshes and BSP data. The project offers single-player play and experimental cooperative multiplayer.
- [Jet Force Gemini: Recompiled — an N64 static recompilation port](https://awesomerea.org/resources/jet-force-gemini-recompiled-case/index.md): Case study · Jet Force Gemini: Recompiled translates the US N64 game's code from a user-supplied ROM into C with N64Recomp and runs it with N64ModernRuntime and RT64. The native port supports Windows, Linux and Steam Deck, with revised controls, display options and mod loading. The repository also contains game-specific source and build scripts.
- [OpenDaed: reimplementing The Daedalus Encounter](https://awesomerea.org/resources/opendaed-case/index.md): Case study · OpenDaed reimplements the interactive-movie puzzle game The Daedalus Encounter in C++ using the original CD data. Its source includes game-file readers, an interpreter, video playback and puzzle implementations. The author describes an early build that runs the opening scenes but is not yet playable end to end.
- [Aidyn Chronicles: Ghidra-derived N64 source reconstruction](https://awesomerea.org/resources/aidyn-chronicles-decomp-case/index.md): Case study · Aidyn Chronicles: The First Mage is examined through Splat configurations and symbol tables for debug and NTSC 1.0 builds. The repository contains headers and manually cleaned, Ghidra-derived pseudocode for game source files, which the author describes as untested.
- [Galaxy on Fire 2: matching reconstruction of the Android Abyss Engine library](https://awesomerea.org/resources/galaxy-on-fire-2-android-decomp-case/index.md): Case study · Galaxy on Fire 2 reconstructs C++ for the Android game's Abyss Engine library, libgof2hdaa.so. Its NDK r18b build compiles ARM objects, links a shared library and compares functions and symbols with the original; notes record unresolved type and control-flow matches.
- [Super Mario Advance 4: an exact-match Armips disassembly](https://awesomerea.org/resources/sma4-disasm-case/index.md): Case study · Super Mario Advance 4: Super Mario Bros. 3 U rev 1 is reconstructed as Armips assembly that the author reports reassembles to an exact ROM match. The project replaces ROM pointers with labels and supplies scripts to extract required graphics and sound data from the player's original ROM. A Wii U Virtual Console variant is supported when its data is supplied.
- [pc-megamanxcm: a native Mega Man X: Command Mission port](https://awesomerea.org/resources/pc-megamanxcm-case/index.md): Case study · pc-megamanxcm develops a native PC port of Mega Man X: Command Mission from the European GameCube release. It maps names from a symbol table left on the disc to the stripped DOL, then uses wiikit to translate PowerPC code to C++ and replace console hardware services. The author reports play through the opening scenes with audio; saving remains unavailable.
- [Suikoden II: a disc-local PlayStation static recompilation](https://awesomerea.org/resources/suikoden-ii-recomp-case/index.md): Case study · Suikoden II Recomp configures psxrecomp to generate and compile the US PlayStation game from the player's SLUS-00958 disc image and SCPH-1001 BIOS. A recomp-ui setup host collects those inputs and builds normal and diagnostic executables locally.
- [Exolon: an HTML5 remake of the ZX Spectrum game](https://awesomerea.org/resources/exolon-case/index.md): Case study · Exolon recreates the 1987 ZX Spectrum game as an HTML5 game built with melonJS. Its repository includes JavaScript game code and TMX level maps, and the author recommends Firefox or Chrome for play.
- [Guilty Gear X Plus: decompiling the Korean release](https://awesomerea.org/resources/guilty-gear-x-plus-decomp-case/index.md): Case study · Guilty Gear X Plus is decompiled into game-specific C source, headers and symbol maps for the Korean release. The build starts from an extracted SLPM_645.25 executable, then uses configure.py and Ninja; the repository also contains a decompilation permuter for matching C functions to target assembly.
- [Soulbrandt: a native Demon's Souls PC port](https://awesomerea.org/resources/soulbrandt-case/index.md): Case study · Soulbrandt converts the US PlayStation 3 release of Demon's Souls into a native Windows and Linux port using the player's game files. Setup uses RPCS3 to decrypt the required files or accepts files the player has decrypted, then builds the port locally. The project includes game-specific analysis, runtime integration, rendering, controls and online services.
- [OpenDUNE: a native recreation of Dune II](https://awesomerea.org/resources/opendune-case/index.md): Case study · OpenDUNE recreates Dune II in ANSI C for desktop systems and Atari TOS. Desktop builds use SDL or SDL2; the game reads original Dune II 1.07 data files, including dune2.exe, from a user-provided data directory.
- [VERA20K: rebuilding Red Alert 2: Yuri's Revenge in Rust](https://awesomerea.org/resources/vera20k-case/index.md): Case study · VERA20K rebuilds the Red Alert 2: Yuri's Revenge engine in Rust while reading the user's original game files. The project says coding agents study the original engine with Ghidra, implement its behavior in a new simulation and rendering architecture, and compare results with the original through tools and playtests.
- [Habbo: a Flash-client server emulator](https://awesomerea.org/resources/habbo-flash-server-case/index.md): Case study · Habbo recreates server-side services for the Habbo Flash client in Node.js. Its source accepts TCP connections, dispatches client packets and defines handshake, user, navigator and room messages; the README presents development screenshots of a running Flash client.
- [Bushido Blade 2: a disc-local PlayStation static recompilation](https://awesomerea.org/resources/bushido-blade-2-recomp-case/index.md): Case study · Bushido Blade 2 Recomp configures psxrecomp to generate and compile the US PlayStation release from the player's SLUS-00663 disc image and SCPH-1001 BIOS. Its recomp-ui setup host creates normal and diagnostic builds on the player's machine.
- [OpenD2: rebuilding the Diablo II engine](https://awesomerea.org/resources/opend2-diablo-ii-case/index.md): Case study · OpenD2 rewrites the Diablo II game engine in C++ to use the original game’s data and save files. Its source includes MPQ archive, rendering, audio, networking, and game components. The README reports that most of the main menu works, while TCP/IP games stall during loading.
- [rd-131655: reconstructing an unreleased Minecraft cave test](https://awesomerea.org/resources/rd-131655-minecraft-cave-test-case/index.md): Case study · rd-131655 recreates an unreleased pre-classic Minecraft cave test from its first public video and contemporary IRC logs. The Java implementation includes cave generation and 8×8×8 chunks, and the project provides a Gradle run task.
- [Go Vacation: a halted Wii decompilation](https://awesomerea.org/resources/go-vacation-wii-case/index.md): Case study · Go Vacation is a Wii game decompilation with source and build configurations for several game versions. The author halted work because the game's main code sits in relocatable RSO modules that the decompilation toolkit did not support.
- [Zombies Ate My Neighbors: a ROM-checked C port](https://awesomerea.org/resources/zombies-ate-my-neighbors-pc-port-case/index.md): Case study · The Zombies Ate My Neighbors PC Port rewrites the SNES game's logic in C and checks it against execution of the user's original ROM. An in-tree tracer produces code/data logs and memory maps, while a co-simulation harness compares port behavior with the reference core; the port also adds widescreen display and controller options.
- [Heretic2: adapting reconstructed game code to Yamagi Quake II](https://awesomerea.org/resources/heretic2-yamagi-reconstruction-case/index.md): Case study · Heretic2 adapts Heretic 2 game code from an earlier reconstruction project to a customized Yamagi Quake II Remaster engine. Its source and progress notes cover differences in effects, movement, rendering and save handling while targeting single-player play from Heretic 2 game data.
- [Escape Velocity Nova: an engine reimplementation guided by decompilation](https://awesomerea.org/resources/escape-velocity-nova-reimplementation-case/index.md): Case study · evnova-decomp reimplements the Escape Velocity Nova engine in C++23 and SDL3 using data from a local Windows Community Edition installation. Its research notes cover resource formats, missions and gameplay behavior, while Ghidra-based tools support comparison with original functions. The author reports a playable storyline but notes missing features and timing differences.
- [HWDE-decomp: matching Hyrule Warriors: Definitive Edition functions](https://awesomerea.org/resources/hwde-decomp-case/index.md): Case study · HWDE-decomp reconstructs functions from Hyrule Warriors: Definitive Edition update 1.0.1 as C++ intended to match the AArch64 main module. Its checker compiles source with specified Clang flags, resolves relocations, and compares function words with an original module extracted by the user.
- [uo-client: reconstructing the Ultima Online 2.0.7 client](https://awesomerea.org/resources/uo-client-case/index.md): Case study · uo-client reconstructs the Ultima Online T2A 2.0.7 client in C++, including its packet protocol, MUL asset loading and isometric display. The author describes consulting the decompiled original in IDA, recording findings in its database and comparing renderer output and protocol behavior with the original. The client targets the UO Demo shard and includes a JavaScript-driven navigation bot.
- [Robot War Engine: a Total Annihilation-compatible engine reconstruction](https://awesomerea.org/resources/robot-war-engine-case/index.md): Case study · Robot War Engine rebuilds a Total Annihilation-compatible strategy-game engine that runs on the player's original data files. Its C++ core parses HPI archives, GAF sprites, 3DO models and COB unit scripts, while a separate Electron launcher provides a multiplayer lobby.
- [Mega Man 9: a matching WiiWare decompilation](https://awesomerea.org/resources/mega-man-9-wiiware-decomp-case/index.md): Case study · Mega Man 9 is being reconstructed as C source for the US WiiWare release WR9E, with the original CodeWarrior toolchain used to match game functions. The build combines reconstructed units with split original objects and compares the resulting DOL against the target SHA-1. The author reports 1,760 exact game-function matches out of 2,941; source remains split by function.
- [Hookshot: static recompilation of the Switch 2 Ocarina of Time remake](https://awesomerea.org/resources/hookshot-oot-switch2-case/index.md): Case study · Hookshot statically recompiles the Switch 2 remake of The Legend of Zelda: Ocarina of Time into a native Windows or Linux program using the user's game files. Its pipeline lifts AArch64 game code to C, implements Horizon OS and NVN2 natively, and renders GPU work with Vulkan.
- [Test Drive SDL3: reconstructing the DOS and Amiga game ports](https://awesomerea.org/resources/test-drive-sdl3-case/index.md): Case study · Test Drive SDL3 ports the DOS EGA, CGA and Hercules versions and the Amiga version of the 1987 game to native SDL3 programs. Reverse-engineering specifications cover game flow, simulation, rendering and platform behavior, while a separate document covers file formats. The ports read user-supplied original game files.
- [Greenwood: a matching Robin Hood decompilation](https://awesomerea.org/resources/greenwood-robin-hood-decomp-case/index.md): Case study · Greenwood reconstructs Robin Hood: The Legend of Sherwood v1.1 as C++ intended to compile into byte-identical machine code with Microsoft Visual C++ 6.0 SP6. The repository contains game-specific source for actors, artificial intelligence and other systems, and uses compiled-function comparison tools to track matching progress. The author reports 4,723 of 6,113 game functions decompiled.
- [Black & White: decompiling the Windows and Classic Mac OS game builds](https://awesomerea.org/resources/black-and-white-1-decomp-case/index.md): Case study · Black & White is being reconstructed as C and C++ source for multiple Windows PE/COFF and Classic Mac OS PEF releases. The workflow splits user-supplied game binaries into objects, builds reconstructed source with period toolchains, and compares objects with objdiff.
- [Igor: interpreting the original Objetivo Uikokahonia executable](https://awesomerea.org/resources/igor-uikokahonia-case/index.md): Case study · Igor runs the Spanish CD release of Igor: Objetivo Uikokahonia through an x86 decoder and interpreter built from analysis of the original executable. It extracts game data and replaces higher-level palette, display and input routines, with separate notes on the executable's structure.
- [FS15 Reconstruction: Farming Simulator 15 and GIANTS Engine 6 component recovery](https://awesomerea.org/resources/fs15-reconstruction-case/index.md): Case study · FS15 Reconstruction recovers components of Farming Simulator 15 and GIANTS Engine 6 from the Windows 1.4.2.0 release. It combines decompilation, recovered scripts and native component comparisons with experimental gameplay and Linux hosts. The author reports that original GE6 code reaches a Linux-rendered farm view, while full engine and farming behavior remain incomplete.
- [Portémon Nitro: a HeartGold and SoulSilver engine port](https://awesomerea.org/resources/portemon-nitro-hgss-case/index.md): Case study · Portémon Nitro reimplements the Pokémon HeartGold and SoulSilver engine in LÖVE for PCs and mobile devices. It reads a user-owned Nintendo DS ROM, derives game data locally, and separates ROM interpretation from runtime behavior and the app interface. The repository contains Lua game code, Nintendo DS and game-specific libraries, and ROM import tooling.
- [F-Zero X: an early US N64 decompilation](https://awesomerea.org/resources/bttrdrgn-f-zero-x-decomp-case/index.md): Case study · F-Zero X reconstructs parts of the US Nintendo 64 game in C, alongside assembly extracted from the user's ROM. Its build extracts a user-supplied Z64 ROM and produces a ROM with a published SHA-1 target. The author describes the codebase as early research and says its output is not yet suitable as a general modification base.
- [NHL24 PC: running NHL 24 on Windows through a game-specific PS4 runtime](https://awesomerea.org/resources/nhl24-pc-case/index.md): Case study · NHL24 PC runs the PS4 version of NHL 24 on Windows through a game-specific shadPS4 fork. It executes the game's x86-64 code directly, replaces PS4 system-library calls with native implementations, translates GCN shaders to SPIR-V for Vulkan, and extracts the user's own base and update PKGs through its launcher.
- [Halo 3 Delta: reconstructing halo3_cache_release.xex](https://awesomerea.org/resources/halo3-cache-release-recomp-case/index.md): Case study · The Halo 3 Delta project targets halo3_cache_release.xex from build 08172.07.03.08.2240.delta for ReXGlue-based recompilation. The repository contains C++ game source modules and a CMake configuration that includes them in the executable target.
- [Xena: Warrior Princess Recompiled: a PlayStation setup host](https://awesomerea.org/resources/xena-warrior-princess-recompiled-case/index.md): Case study · Xena: Warrior Princess Recompiled configures PSXRecomp and recomp-ui to generate a native build of the USA PlayStation game from a user's disc and BIOS. Its repository contains game configuration, symbol seeds and setup-host build files; the project report identifies gameplay, input, audio and save checks as outstanding.
- [OpenBreed: reconstructing the classic Alien Breed games](https://awesomerea.org/resources/openbreed-case/index.md): Case study · OpenBreed investigates and reimplements Alien Breed Special Edition 92, Alien Breed II and Alien Breed: Tower Assault. Its C# editor reads maps, sprites, tiles and image formats from original resources, while the author works to recover behavior and tables stored in the games' executables. The game engine lacks game-specific logic and is not yet playable.
- [ProTanki Server: reconstructing a game server for an older client](https://awesomerea.org/resources/protanki-server-case/index.md): Case study · ProTanki Server reimplements a ProTanki game server in Kotlin for client library-20221001-223140. Its source includes packet processing and handlers for authentication, battles, chat, garage and other game operations; a later protocol update prevents support for newer clients.
- [Sonic the Hedgehog: a Master System Z80 static recompilation](https://awesomerea.org/resources/sonic-the-hedgehog-sms-recomp-case/index.md): Case study · SonicTheHedgehogSMSRecomp translates the Sega Master System Sonic the Hedgehog Z80 program ahead of time into native C with smsggrecomp. Its game configuration records ROM identity and control-flow data, while the runtime models video, sound, ports, and the mapper; unresolved computed jumps can use a Z80 interpreter.
- [Top Spin 4 Recomp: a native Xbox 360 game port](https://awesomerea.org/resources/top-spin-4-recomp-case/index.md): Case study · Top Spin 4 Recomp ports the Xbox 360 game Top Spin 4 to Windows through ahead-of-time translation of its PowerPC code with ReXGlue. A game-specific renderer maps its Direct3D 9 calls to Vulkan, and a launcher prepares files from the user’s disc image and Title Update 1. The author reports working exhibition, career, academy, and local multiplayer modes.
- [Duke2Reconstructed: matching Duke Nukem II source reconstruction](https://awesomerea.org/resources/duke2reconstructed-case/index.md): Case study · Duke2Reconstructed rebuilds Duke Nukem II's DOS source in C and assembly from disassembly of the original executable. The author reports that an era-appropriate build produces a byte-identical binary after LZEXE compression, while original names and file organization remain approximations.
- [Open Ocarina: a PC source port of Ocarina of Time](https://awesomerea.org/resources/open-ocarina-master-port-case/index.md): Case study · Open Ocarina ports the Ocarina of Time decompilation to a Windows build using assets extracted from the player's ROM. It adds adjustable frame rates, free camera control, keyboard and gamepad mappings, and support for GLideN64 texture packs.