# Curated reverse engineering resources · Page 24

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

## Games (100)

- [EoWRecomp: static recompilation of Echoes of Wisdom](https://awesomerea.org/resources/eowrecomp-case/index.md): Case study · EoWRecomp translates The Legend of Zelda: Echoes of Wisdom's Switch ARM64 modules into C ahead of time and runs them with native Horizon-service and NVN replacements. Its renderer uses Vulkan, including MoltenVK on macOS; the author reports that the Linux build reaches the opening and first controllable scene.
- [ssrecomp: a single-screen Pokémon SoulSilver static recompilation](https://awesomerea.org/resources/ssrecomp-pokemon-soulsilver-case/index.md): Case study · ssrecomp statically translates Pokémon SoulSilver's ARM9 code to C++ and runs it with a patched melonDS core supplying Nintendo DS hardware. Its frontend combines play on one screen and adds widescreen presentation and controller support. Builds generate game-specific code locally from the user's US ROM or decompilation output; the author states development has moved to another project.
- [Lufia II: portable semantic reconstruction of SNES game logic](https://awesomerea.org/resources/lufia2-semantic-decomp-case/index.md): Case study · Lufia2Decomp reconstructs Lufia II: Rise of the Sinistrals game logic as a portable C library for SNES recompilation consumers. Its CPU-state and memory adapters preserve observable routine behavior, and a resource tool decodes compressed data from an owner's ROM. The author reports 2,305 functions marked verified by original-ROM differential checks.
- [OpenJones3D: reconstructing the Indiana Jones and the Infernal Machine engine](https://awesomerea.org/resources/openjones3d-case/index.md): Case study · OpenJones3D reconstructs the Jones3D engine of Indiana Jones and the Infernal Machine in C. Its method analyses the original engine executable, debug symbols and strings, then replaces calls into the original binary with implemented functions while retaining the user's game assets.
- [Bomberman 64: a decompressed USA ROM decompilation](https://awesomerea.org/resources/bomberman-64-bm64-case/index.md): Case study · bm64 reconstructs a decompressed ROM of the USA Nintendo 64 game Bomberman 64 from C, assembly and a user-supplied baserom. Its build specifies an MD5 for the resulting ROM and provides setup steps for extraction and reassembly.
- [Pokopia Native: native builds of Pokémon Pokopia from a user dump](https://awesomerea.org/resources/pokopia-native-case/index.md): Case study · Pokopia Native builds native Mac, iPhone and Windows versions of the Switch 2 game Pokémon Pokopia from the user's own dump. Its Windows path recompiles the game's arm64 code through LLVM for a native runtime and Vulkan renderer, while the Apple builds run the game's code on Apple silicon with Metal graphics.
- [LOZ: rebuilding The Legend of Zelda from ROM disassembly](https://awesomerea.org/resources/loz-remake-case/index.md): Case study · LOZ remakes the original The Legend of Zelda in C++ and Allegro, using graphics and data tables extracted from the player's ROM. The author built disassembly tools and examined much of the original game code to guide the remake; the extractor and game are separate Visual Studio projects.
- [Shantae Recomp: a Game Boy Color static recompilation](https://awesomerea.org/resources/shantae-recomp-case/index.md): Case study · Shantae Recomp uses gbrecompiled to translate the USA Game Boy Color Shantae ROM into native code for Windows and Linux. Its game-specific hooks, ROM investigations and checks support an expanded view, movement changes, a map, rewind and shader presets.
- [Bubsy 3D: a work-in-progress matching decompilation of the USA executable](https://awesomerea.org/resources/bubsy-3d-decomp-case/index.md): Case study · Bubsy 3D reconstructs C for the USA game's SLUS_001.10 executable and compares compiled functions with the original bytes. Its code map separates exact matches from fuzzy candidates and documents unresolved executable regions.
- [OpenSWOS: rebuilding Sensible World of Soccer in C](https://awesomerea.org/resources/openswos-case/index.md): Case study · OpenSWOS rebuilds Sensible World of Soccer in C from reverse engineering of the Amiga game and runs it across desktop, mobile and Amiga platforms. Its setup creates the required graphics, music and team data from the user's own game copy, and the port adds online multiplayer and widescreen display.
- [GTA4Unity: reconstructing the GTA IV world in Unity](https://awesomerea.org/resources/gta4unity-case/index.md): Case study · GTA4Unity reconstructs GTA IV world loading and rendering in Unity 6 using the player's original game files. It parses IMG archives, WDR/WFT models, WTD textures, IDE definitions and IPL/WPL placements, converts RAGE coordinates to Unity space and streams world geometry through Unity's Entity Component System.
- [openh4: reimplementing the Heroes of Might and Magic IV engine](https://awesomerea.org/resources/openh4-case/index.md): Case study · openh4 reimplements the Heroes of Might and Magic IV engine in C++23 using data from a player's own GOG copy. The repository contains the engine, a game application and h4-tool for inspecting and rendering game data. The author describes the project as unfinished.
- [OpenZ: reconstructing Z as a 3D strategy game](https://awesomerea.org/resources/openz-z-remake-case/index.md): Case study · OpenZ recreates the 1996 strategy game Z as a Unity 6 game with 3D battlefields, units, and newly produced media. It reproduces territory capture and factory-based combat, adds new content, and ports its computer opponent from the open-source Zod Engine.
- [Resident Evil 1: PC decompilation and modern platform port](https://awesomerea.org/resources/resident-evil-1-pc-decomp-case/index.md): Case study · Resident Evil 1 for PC Decompilation reconstructs the 1997 game’s logic from Ghidra analysis of its executable and runs it on Windows and Linux. The port replaces the original Marni System’s DirectX 5 implementation with Direct3D 11 or OpenGL rendering and corresponding audio and video layers. The author reports that the full game is playable and that 1,716 of 1,717 game logic functions are implemented.
- [BallPad: an iOS and iPadOS port of Super Mario Strikers](https://awesomerea.org/resources/ballpad-strikers-port-case/index.md): Case study · BallPad ports Super Mario Strikers to iOS and iPadOS by compiling a community decompilation-based source port as native ARM64 code. It adds Metal presentation, touch and physical-controller input, and an importer for the user's USA revision 0 disc image.
- [Need for Speed Underground: a PC executable static recompilation](https://awesomerea.org/resources/nfsu1-recompiled-case/index.md): Case study · nfsu1-recompiled translates the x86 Speed.exe from Need for Speed Underground PC patch 1.4 into C with a patched pcrecomp lifter. It builds native Windows and Android hosts, with Win32 and graphics compatibility code; its documented progress reaches menus while races remain untested.
- [Whippy: matching decompilation of Kirby's Return to Dream Land](https://awesomerea.org/resources/whippy-kirby-return-to-dream-land-case/index.md): Case study · Whippy reconstructs Kirby's Return to Dream Land source for the USA and Korean Wii releases, comparing rebuilt main.dol files byte for byte with the originals. Its documentation covers the game's MetaFortress checks, linker code merging, object splits and matching workflow.
- [Ottsel: an ARM64 port of Jak and Daxter](https://awesomerea.org/resources/ottsel-jak-port-case/index.md): Case study · Ottsel ports OpenGOAL's decompiled Jak and Daxter: The Precursor Legacy source to iPad, iPhone and Apple Silicon Macs. It adds an ARM64 compiler backend, ahead-of-time signed modules and an Apple-platform app with touch and controller input, while extracting art and data from the user's PS2 disc. The author reports physical-iPad and Mac runs; physical-iPhone testing remains pending.
- [Baroque: a PlayStation 2 code translation for native Windows](https://awesomerea.org/resources/baroque-native-port-case/index.md): Case study · Baroque translates the USA PlayStation 2 game's routines into a native Windows C++ port. It reads models, game data, audio and movies from the user's disc image through its own loaders, and adds widescreen presentation, higher display frame rates and keyboard and mouse controls.
- [Xenosaga Episode I: an in-progress PlayStation 2 decompilation](https://awesomerea.org/resources/xenosaga-episode-i-decomp-case/index.md): Case study · Xenosaga Episode I decomp reconstructs source for the NTSC-U PlayStation 2 release and builds its SLUS_204.69 ELF. The repository contains game C files, symbols and build configuration; its build starts from an executable extracted from the user's game disc.
- [UltraCombo: native ports of the Killer Instinct arcade games](https://awesomerea.org/resources/ultracombo-case/index.md): Case study · UltraCombo ports the arcade games Killer Instinct and Killer Instinct 2 to Windows and Linux using users' ROM and disk files. It boots each game on an interpreter, snapshots loaded code, translates the game and sound DSP programs to C, and compiles native modules while emulating the surrounding arcade hardware.
- [Apocalypse-xport: an Apocalypse PlayStation decompilation port](https://awesomerea.org/resources/apocalypse-xport-case/index.md): Case study · Apocalypse-xport ports reconstructed code from the PlayStation game Apocalypse. Its C++ source initializes game systems and handles CD data by resolving DATA paths, reading CD.WAD resources and mounting APOC.XA streams.
- [007: Agent Under Fire — an Xbox static recompilation port](https://awesomerea.org/resources/007-agent-under-fire-recomp-case/index.md): Case study · 007: Agent Under Fire becomes a native Windows port by statically recompiling the original Xbox game's x86 XBE programs. The project includes game-specific hooks and findings for the launcher, on-foot and driving executables, and builds game code from a user-provided USA or European disc.
- [OutRun 2006 Coast 2 Coast: a native port from reconstructed PC code](https://awesomerea.org/resources/outrun-2006-native-port-case/index.md): Case study · OutRun 2006 Coast 2 Coast is ported from a C++ reconstruction of its PC executable to Switch, Apple silicon macOS, PS5 homebrew and Xbox Developer Mode. Some functions remain translated from x86 while others are handwritten; each platform has native graphics, audio, input and file layers. The port reads tables and game data from the user's Steam installation.
- [San Francisco Rush 2049: Recompiled — an N64 static recompilation](https://awesomerea.org/resources/san-francisco-rush-2049-recompiled-case/index.md): Case study · San Francisco Rush 2049: Recompiled translates the Nintendo 64 game's MIPS code to C with N64Recomp and runs it through N64ModernRuntime and RT64. The port adds game-specific patches for rendering, controls, audio and saves, and provides Windows and browser builds that load a player's ROM. The author reports playable Windows races and browser play in Chrome.
- [Alien Resurrection Recompilation: a disc-local PlayStation static recompilation](https://awesomerea.org/resources/alien-resurrection-recompilation-case/index.md): Case study · Alien Resurrection Recompilation turns the user's USA PlayStation disc image into a native build by generating C# with a RecompOne fork and compiling it locally. Its launcher manages first-run compilation, cached builds, saves, and game-specific fixes to disc, memory-card, and audio behavior.
- [Super Mario Advance 2: exact-match GBA disassembly](https://awesomerea.org/resources/sma2-disasm-case/index.md): Case study · SMA2 disasm reconstructs the US Game Boy Advance ROM of Super Mario World: Super Mario Advance 2 as Armips assembly. The author reports an exact full-ROM rebuild, with ROM pointers replaced by labels and graphics and sound extracted locally from an original ROM.
- [Harvest Moon 64 PC Port / Recomp: a work-in-progress native build](https://awesomerea.org/resources/aitdd-harvest-moon-64-recomp-case/index.md): Case study · Harvest Moon 64 PC Port / Recomp uses N64Recomp and RT64 to build a native port of Harvest Moon 64 from locally provided ROM and ELF files. The author reports playable boot, audio, input and SRAM saves, and documents fixes for controller input, save type and display flicker.
- [inFamous PC: a PlayStation 3 static recompilation for Windows](https://awesomerea.org/resources/infamous-pc-case/index.md): Case study · inFamous PC builds a native Windows port of the European PlayStation 3 release of inFamous by statically recompiling its PPU and SPU code with ps3recomp. Its installer reads the player's disc, generates the code, applies game-specific patches and compiles the result.
- [Game Boy Camera: mapping the save format and image slots](https://awesomerea.org/resources/game-boy-camera-save-format-case/index.md): Case study · The project maps the Game Boy Camera SRAM save format through comparisons of dumps from real hardware. Its notes identify image-slot state vectors, mirrored fields and checksums, while GNU Octave and MATLAB scripts inspect slots, extract pictures and inject custom images. The repository also includes sample saves for several camera variants.
- [Un-Banished: reconstructing the Banished engine in Rust](https://awesomerea.org/resources/un-banished-case/index.md): Case study · Un-Banished rebuilds the Banished 1.0.7 engine in Rust for desktop and browser play using data from the user's own game copy. Its documented process uses Ghidra pseudocode, emulated original functions and comparisons of the new code with original behavior. The engine also reads existing saves and BanishedKit .pkm mods; the author reports a beta with known differences.
- [Project Tandem: statically recompiling Mario Kart: Double Dash!! for online PC play](https://awesomerea.org/resources/project-tandem-mkdd-case/index.md): Case study · Project Tandem statically recompiles the USA GameCube release of Mario Kart: Double Dash!! from the player's disc image into a native Windows program. It builds on gcn-recomp and adds online multiplayer, widescreen display, controller support, and mouse and keyboard controls.
- [TA3D: rebuilding Total Annihilation in a 3D engine](https://awesomerea.org/resources/ta3d-total-annihilation-case/index.md): Case study · TA3D rebuilds Total Annihilation gameplay in an OpenGL 3D engine that loads original game maps, units and animation scripts from separate resource files. It implements movement, construction, weapons and campaign play, with additional visual effects and a game console.
- [Dunk Shot: commented MSX disassembly](https://awesomerea.org/resources/dunk-shot-msx-case/index.md): Case study · Dunk Shot documents the 1986 MSX game's code and data through a commented disassembly generated from a user-provided cartridge image. Its tools trace Z80 control flow, draw graphics from cartridge data, inspect sound pieces and compare the reassembled ROM with the original; the author reports a byte-for-byte match.
- [Strider 2 Recompiled: a PlayStation static recompilation](https://awesomerea.org/resources/strider-2-recompiled-case/index.md): Case study · Strider 2 Recompiled uses psxrecomp to generate C from the US PlayStation release of Strider 2 and compiles a playable build locally from the user's disc. Its title-specific work includes symbol mapping and framework fixes for simulation pacing, line drawing on the stage briefing screen and interlaced menu text. The development notes describe comparisons with PlayStation reference implementations.
- [ToeJam & Earl: matching Sega Genesis decompilation](https://awesomerea.org/resources/toejam-and-earl-case/index.md): Case study · ToeJam & Earl reconstructs two Sega Genesis retail revisions as matched C and readable 68000 and Z80 assembly. Build tools extract typed assets from the user's ROM and compare each rebuilt image with the original; the author reports byte-identical builds for both revisions.
- [Kirpich: reimplementing Game Boy Tetris behavior](https://awesomerea.org/resources/kirpich-case/index.md): Case study · Kirpich recreates the Game Boy Tetris game in native C++ on Polyrhythm using behavior specifications derived from the original. It reads graphics and sound from the player's ROM and runs the original randomization and sound routines in a narrow SM83 virtual-machine host; desktop builds add optional modes and controls.
- [Shadow of the Colossus: running the PS4 game natively on Windows](https://awesomerea.org/resources/shadow-of-the-colossus-pc-case/index.md): Case study · Shadow of the Colossus-PC runs the PS4 version of Shadow of the Colossus on Windows 10 and 11 using the user's game dump. Its loader runs the game's x86-64 code on the host CPU, supplies needed PS4 system functions and translates graphics to Vulkan. The author reports playing from the last colossus through the ending and credits.
- [Gears of War: Judgment for PC: an Xbox 360 static recompilation](https://awesomerea.org/resources/gears-of-war-judgment-pc-case/index.md): Case study · Gears of War: Judgment for PC translates the Xbox 360 game's PowerPC program to C++ ahead of time and compiles it as a native Windows application on ReXGlue. The port adds keyboard and mouse input, graphics options and save support; the author reports that early single-player campaign play works.
- [SkyRoads: a DOS game engine reconstructed in portable C11](https://awesomerea.org/resources/skyroads-port-case/index.md): Case study · skyroads-port reconstructs the DOS game SkyRoads as a portable C11 engine after disassembling SKYROADS.EXE and documenting its file formats and algorithms. It reads original data files supplied by the user, and the author reports that replaying DEMO.REC follows the original demo road tick for tick.
- [Need for Speed: Most Wanted: an Apple Silicon static recompilation](https://awesomerea.org/resources/nfs-most-wanted-mac-recomp-case/index.md): Case study · Need for Speed: Most Wanted Native translates the user's PC version 1.3 speed.exe from x86 into C and compiles it for Apple Silicon Macs. Its host provides Metal rendering, CoreAudio, controller support and asset conversion. An optional user-supplied Xbox 360 copy enables additional game content and effects.
- [SuperMarioRPGSNESRecomp: an early 65816 static recompilation](https://awesomerea.org/resources/super-mario-rpg-snes-recomp-case/index.md): Case study · SuperMarioRPGSNESRecomp applies snesrecomp to Super Mario RPG: Legend of the Seven Stars, compiling qualified 65816 code paths to C while other paths run through an interpreter. The shared snesrecomp runner emulates the game's SA-1 coprocessor, and coverage tools collect dispatch misses to guide later regeneration. The author reports a working attract loop and early-game replay, with two qualified ahead-of-time variants.
- [God of War: Chains of Olympus: an experimental PSP hybrid recompilation](https://awesomerea.org/resources/god-of-war-chains-of-olympus-hybrid-recomp-case/index.md): Case study · The God of War: Chains of Olympus project combines game-specific ahead-of-time translated Allegrex blocks with an interpreter fallback for PSP code. Its runtime implements partial PSP system services, graphics display lists and SDL2 audio, while diagnostic logs and traces track the game's startup and rendering behavior.
- [Rockstar Table Tennis Decompilation: an Xbox 360 PowerPC to C++ reconstruction](https://awesomerea.org/resources/rockstar-table-tennis-decomp-case/index.md): Case study · Rockstar Table Tennis Decompilation reconstructs the Xbox 360 game's PowerPC functions as C++. Its source tree includes function maps, vtable data, initialization-flow findings and an MCP server that exposes decompilation context to contributors. The author reports 3,413 functions decompiled out of 13,545.
- [OpenTIE: reimplementing Star Wars: TIE Fighter](https://awesomerea.org/resources/opentie-case/index.md): Case study · OpenTIE reimplements Star Wars: TIE Fighter for Windows, macOS and Linux using data from the original 1995 Collector's CD-ROM or 1998 Windows release. Its engine supports each edition and can combine the 1995 menus, cutscenes and iMUSE music with the 1998 flight simulation and assets.
- [xenogears-decomp-port: matching Xenogears decompilation and native PC port](https://awesomerea.org/resources/xenogears-decomp-port-case/index.md): Case study · xenogears-decomp-port combines a partial matching C decompilation of PlayStation Xenogears with a native Linux x86-64 port. The port runs decompiled game code with PsyCross and SDL2 providing PlayStation hardware and host services, and reads files extracted from the user's own USA Disc 1. The author reports that the r5 release reaches the prologue, Lahan and the first Gear battle.
- [The Way of the Exploding Fist: a SkoolKit disassembly](https://awesomerea.org/resources/way-of-the-exploding-fist-disassembly-case/index.md): Case study · The Way of the Exploding Fist presents a SkoolKit disassembly of the ZX Spectrum game. Its source files and scripts generate browsable hexadecimal and decimal HTML views.
- [Dodge It: annotated Fairchild Channel F disassembly](https://awesomerea.org/resources/dodge-it-videocart-16-case/index.md): Case study · Dodge It is an annotated disassembly of the Fairchild Video Entertainment System game. It documents F8 scratchpad use, the game's two-level calling convention, a call graph and unused routines, and gives a dasm build command.
- [OpenGG: rebuilding Gearhead Garage from observed rules and data formats](https://awesomerea.org/resources/opengg-gearhead-garage-case/index.md): Case study · OpenGG reimplements Gearhead Garage: The Virtual Mechanic as a Godot and C# engine that loads cars, jobs, decals, sounds and scenes from a user's game folder. Its rules and interface follow observations of the running original, while its loaders parse data-file formats worked out from the original files.
- [Super Mario Advance 4 Recomp: a GBA static recompilation for Windows](https://awesomerea.org/resources/super-mario-advance-4-recomp-case/index.md): Case study · Super Mario Advance 4 Recomp builds a native Windows version of the GBA game through gbarecomp using a locally supplied ROM and BIOS. The project provides game configuration, a launcher, controls and save-state support. The author reports that the experimental build boots to the title screen and runs Super Mario Bros. 3 gameplay.
- [FFT-1997-Decomp: early Final Fantasy Tactics decompilation](https://awesomerea.org/resources/fft-1997-decomp-case/index.md): Case study · FFT-1997-Decomp is an early decompilation of Final Fantasy Tactics starting with the PlayStation executable SCUS_942.21. The author uses Ghidra 12.1.3 and separates recovered routines into C and assembly files while working through names for functions and data.
- [WolfensteinRPG-RE: a C++ reconstruction of Wolfenstein RPG](https://awesomerea.org/resources/wolfensteinrpg-re-case/index.md): Case study · WolfensteinRPG-RE reconstructs Wolfenstein RPG in C++ for desktop builds. Its source implements gameplay, combat, rendering, and resource loading from a game package, with CMake instructions for Linux and Windows.
- [Crash Bandicoot PC: a native port from matching decompiled source](https://awesomerea.org/resources/crash-bandicoot-pc-port-case/index.md): Case study · Crash Bandicoot PC ports the North American PlayStation game to native C11 on macOS and Linux from a matching decompilation. It keeps the game's PS1 memory layout, routes GPU packets through PsyZ and reads the player's CUE/BIN disc image; the author reports playable levels and focused disc-based tests.
- [Gears of War 3: a XenonRecomp PC port from the Xbox 360 disc](https://awesomerea.org/resources/gears-of-war-3-pc-port-case/index.md): Case study · Gears of War 3 — PC port builds a native Windows version from a user-owned Xbox 360 disc image. Its pipeline unpacks the XEX and translates PowerPC code to C++ with XenonRecomp, then runs it on a replacement kernel and Xenia graphics components. Research notes map functions, data layouts and game file formats.
- [AVP2 Reconstructed: matching the LithTech engine and renderer](https://awesomerea.org/resources/avp2-reconstructed-case/index.md): Case study · AVP2 Reconstructed recovers C++ for the LithTech 2.2 engine executable and DirectDraw/Direct3D renderer used by Aliens versus Predator 2 v1.0.9.6. It compares compiled functions with the originals and byte-gates mixed relinks against whole-file SHA-1 hashes. The author reports partial matching; unfinished regions still come from the original files.
- [Digimon World 2: a matching PlayStation decompilation](https://awesomerea.org/resources/digimon-world-2-decomp-case/index.md): Case study · Digimon World 2 Decompilation reconstructs the USA PlayStation game's main executable and seven stage overlays as C source. The build compiles with a period PSX GCC toolchain, links each component, and compares its SHA-1 against files from the user's disc. The author reports byte-identical rebuilds and 1,088 matched game functions.
- [Mario Tennis (GBC): a matching USA and Europe disassembly](https://awesomerea.org/resources/mario-tennis-gbc-disasm-case/index.md): Case study · Mario Tennis (GBC) reconstructs the USA and Europe Game Boy Color releases as named RGBDS assembly. The build extracts graphics, audio and other data from a user-provided ROM, then reassembles and compares the result with the retail image; subsystem notes cover game logic and data formats.
- [Hot Shots Tennis: Get a Grip: matching PSP decompilation](https://awesomerea.org/resources/hot-shots-tennis-psp-case/index.md): Case study · Hot Shots Tennis: Get a Grip reconstructs the PSP game's main executable and Game Sharing program in C and C++. It compiles candidate functions with the original compiler and accepts exact-byte matches; the author reports 12,780 matched functions across the two game modules as of 2026-11-02.
- [Rogue Galaxy: a matching PlayStation 2 decompilation](https://awesomerea.org/resources/rogue-galaxy-decomp-case/index.md): Case study · Rogue Galaxy reconstructs the NTSC-U PlayStation 2 game's main executable and five overlays as C or C++. Its build extracts remaining library code and data values from the user's disc, then compares all six linked images with the retail files; the author reports byte-identical outputs.
- [Ocarina of Time: version 1.0 disassembly](https://awesomerea.org/resources/glitterberri-oot-disassembly-case/index.md): Case study · The Ocarina of Time 1.0 disassembly provides a labelled MIPS assembly listing and a function-address index. The listing records instructions under function labels and memory addresses for inspection of the game's code.
- [openQ4: replacing the Quake 4 engine and game binaries](https://awesomerea.org/resources/openq4-quake-4-case/index.md): Case study · openQ4 replaces the Quake 4 engine and game binaries with a GPL engine and SDK-licensed game modules that use the player's retail game assets. The source adds modern display, audio and controller support, with experimental multiplayer and Vulkan rendering.
- [A Link to the Past 3DS: a dual-screen Zelda3 port](https://awesomerea.org/resources/a-link-to-the-past-3ds-case/index.md): Case study · A Link to the Past 3DS adapts the reverse-engineered Zelda3 engine for Nintendo 3DS with gameplay on the upper screen and maps, inventory and settings on the lower screen. It extracts assets locally from the user's USA ROM and adds 3DS rendering, controls and per-ROM settings.
- [Advance Wars 2: Black Hole Rising: partial GBA decompilation](https://awesomerea.org/resources/aw2bhr-case/index.md): Case study · aw2bhr reconstructs Advance Wars 2: Black Hole Rising for Game Boy Advance with C source and assembly. Its build uses the user's base ROM for unfinished regions and provides a SHA-1 target for comparing the generated ROM.
- [openblack: rebuilding Black & White from original game data](https://awesomerea.org/resources/openblack-engine-case/index.md): Case study · openblack reimplements Black & White (2001) in C++ with OpenGL and Vulkan rendering, loading assets extracted from the user's original game. Its repository includes utilities for game formats such as GLW visual effects and a library for LHVM script bytecode. Several non-desktop builds are described as experimental.
- [Star Fox Adventures: kiosk default.dol decompilation](https://awesomerea.org/resources/star-fox-adventures-kiosk-dol-case/index.md): Case study · Star Fox Adventures kiosk default.dol is a work-in-progress reconstruction of the executable found in the game's kiosk ROM. The repository includes C sources, GameCube SDK headers, split and symbol configurations, and Python/ninja build instructions using a user-provided executable.
- [Quest 64 Tale: Recompiled — a native Quest 64 port with runtime adaptations](https://awesomerea.org/resources/quest-64-tale-recompiled-case/index.md): Case study · Quest 64 Tale: Recompiled builds a native Windows and Linux port of the USA release of Quest 64 using N64Recomp, N64ModernRuntime and RT64. Its own runtime adaptations and gameplay handlers support ROM selection, Controller Pak saves, graphics options and optional mods.
- [NHLPA93Genesis: matching disassembly of three NHLPA Hockey 93 revisions](https://awesomerea.org/resources/nhlpa93genesis-case/index.md): Case study · NHLPA93Genesis reconstructs NHLPA Hockey 93 for Sega Genesis as 68000 and Z80 assembly. Its build extracts graphics, sound and names from a user-provided ROM, assembles the code and compares Rev 0, Rev A or Rev B output byte for byte with the corresponding original.
- [F-15 Strike Eagle 2 source port: a modern port of the reconstructed DOS game](https://awesomerea.org/resources/f15-strike-eagle-2-source-port-case/index.md): Case study · F-15 Strike Eagle 2 source port brings reconstructed source for the 1991 DOS game to modern architectures with SDL3 input and presentation, OpenGL rendering and AdLib emulation. Its asset tools decode original PIC, SPR, 3D3 and WLD files into inspectable formats. The author reports that the game is playable while further fixes and features remain in progress.
- [OpenLW: recreating Sonic Lost World from Ghidra decompilations](https://awesomerea.org/resources/openlw-sonic-lost-world-case/index.md): Case study · OpenLW recreates Sonic Lost World from Ghidra decompilations of its Wii U and PC versions. Its source aims to reproduce the PC game’s structure and records function addresses; the repository also hosts LWAPI bindings for PC DLL mods. The author describes the recreation as a major work in progress.
- [Mother3Recomp: statically recompiling MOTHER 3 for PC](https://awesomerea.org/resources/mother3recomp-case/index.md): Case study · Mother3Recomp translates MOTHER 3's Game Boy Advance ARM7TDMI code into C for a native PC build using gbarecomp. It configures separate Japanese and English fan-patched ROM targets, imports function symbol metadata and runs missed paths through interpreter and JIT fallback.
- [Final Fantasy IX: matching US PlayStation decompilation](https://awesomerea.org/resources/ff9-decomp-case/index.md): Case study · ff9-decomp reconstructs the US PlayStation Final Fantasy IX boot executable and code overlays as C that the author reports compiles to byte-identical binaries. The workflow extracts data from four user-owned discs, while PsyQ SDK code stays in assembly and separate equivalent C supports port work.
- [Galaxian³: Project Dragoon — PlayStation matching decompilation](https://awesomerea.org/resources/galaxian3-project-dragoon-decomp-case/index.md): Case study · cannon-seed reconstructs C source for Galaxian³: Project Dragoon on PlayStation across Japanese and European boot executables and game payloads. Its build pipeline splits target executables, compiles candidates with a pinned toolchain, and compares rebuilt images with retail SHA-1 hashes. The repository also retains assembly for nonmatching functions.
- [th10: reconstructing Mountain of Faith 1.00a for the browser](https://awesomerea.org/resources/th10-mountain-of-faith-case/index.md): Case study · th10 reimplements Mountain of Faith 1.00a in C++ for a portable browser runtime. Its TH10-specific systems handle game rules, ANM and ECL data, numeric behavior and replay logic, while SDL and WebGL provide the platform layer.
- [ALTTP-DX: rebuilding A Link to the Past for native PC play](https://awesomerea.org/resources/alttp-dx-case/index.md): Case study · ALTTP-DX rebuilds The Legend of Zelda: A Link to the Past as a native PC game that extracts its assets from a user-supplied US ROM. Its Zig source adds widescreen display, menus and graphics options. A development mode runs the original machine code alongside the game and compares RAM each frame.
- [Ape Escape: matching PlayStation executable decompilation](https://awesomerea.org/resources/ape-escape-matching-decomp-case/index.md): Case study · apes-escaped reconstructs the USA PlayStation Ape Escape executable as C compiled with a PsyQ-era GCC 2.8.1 toolchain. Unfinished functions and 48 overlays remain in assembly so the build can reproduce the original executable. The author reports 1,257 matching C functions, covering 58.3% of game-code bytes.
- [OpenIGI: a C# engine reimplementation for Project I.G.I. and I.G.I. 2](https://awesomerea.org/resources/openigi-engine-case/index.md): Case study · OpenIGI reimplements the engine for Project I.G.I. and I.G.I. 2 in C# on .NET 10, reading missions, scripts and assets from the user's retail installations. It runs the games' QVM scripts in a reconstructed interpreter and provides a native renderer, launcher and modding layer. The author reports all 14 first-game missions playable, while I.G.I. 2 remains in development.
- [Pocket Puyo Puyo Tsuu: matching Game Boy disassembly](https://awesomerea.org/resources/pocket-puyo-puyo-tsuu-disasm-case/index.md): Case study · Pocket Puyo Puyo Tsuu is a matching disassembly of the Japanese Game Boy game. Its banked assembly sources build a ROM with RGBDS v0.5.1, and a Makefile comparison target checks the output against a stored SHA-1. The project requires a base ROM while its source reconstruction remains in progress.
- [Twisted Metal Re-Arc: matching reconstruction of the Japanese PlayStation game](https://awesomerea.org/resources/twisted-metal-re-arc-case/index.md): Case study · Twisted Metal Re-Arc reconstructs code and data from the Japanese 1995 PlayStation release of Twisted Metal using matching decompilation. Its build splits the user's extracted SIPS_600.07 executable, compiles replacement C units and checks a headerless code-and-data image against the original.
- [OpenRedRacing: a Big Red Racing engine reimplementation](https://awesomerea.org/resources/openredracing-big-red-racing-case/index.md): Case study · OpenRedRacing reimplements Big Red Racing in a portable C++ engine using SDL2 and OpenGL 3.3. It reads the user's original game files, recreates circuits, vehicle handling and races, and includes level and vehicle viewers. The author reports Windows builds and tests; all seven championship rounds are implemented but have not been fully tried in game, and some handling and rendering details remain unfinished.
- [Pokémon Sword and Shield: matching Pawn script decompilation](https://awesomerea.org/resources/swsh-pawn-scripts-case/index.md): Case study · Pokémon Sword and Shield's Pawn AMX scripts are reconstructed from game files. The disassembler emits code representations and data sections; a compile tool builds the repository's scripts with gf-pawncc, compares the generated representations and checks binary hashes against the game files.
- [Sid Meier's SimGolf: source reconstruction of the English 1.03 release](https://awesomerea.org/resources/simgolf-decomp-case/index.md): Case study · Sid Meier's SimGolf reconstructs C and C++ source for the English 1.03 game's executable and three DLLs, comparing recompiled functions with the originals. The author reports instruction matches for every function, while the final linked files retain differences. Kaitai Struct definitions document several save, course, golfer and sprite-bank formats.
- [Age of Empires: The Rise of Rome — a function-matched beta decompilation](https://awesomerea.org/resources/age-of-empires-rise-of-rome-beta-decomp-case/index.md): Case study · Reconstructs the 17 July 1998 beta of Age of Empires: The Rise of Rome as C++ source compiled with Visual C++ 5.0. The project checks individual functions against the original empiresx.exe and uses recorded gameplay inputs to compare behavior; the author reports 5,013 byte-identical functions, with other functions still differing.
- [Mortal Kombat: Deception: matching GameCube decompilation of the USA release](https://awesomerea.org/resources/mortal-kombat-deception-decomp-case/index.md): Case study · Mortal Kombat: Deception decomp reconstructs the USA GameCube release as C and C++ source. Its setup checks a user-supplied retail disc, downloads the configured compilers and matching tools, then builds a main.dol whose expected result is checked against the original.
- [Spyro 2: Ripto's Rage!: an in-progress PlayStation decompilation](https://awesomerea.org/resources/spyro-2-riptos-rage-decomp-case/index.md): Case study · Spyro 2: Ripto's Rage! reconstructs the NTSC-U revision 0 PlayStation executable and overlays from C source and assembly. The project targets byte-identical output, uses an older MIPS compiler for game source and keeps unmatched routines in assembly.
- [Daggerfall: matching DOS executable reconstruction and XnGine translation](https://awesomerea.org/resources/daggerfall-matching-decomp-case/index.md): Case study · daggerfall-decomp reconstructs The Elder Scrolls II: Daggerfall 1.07.213 FALL.EXE with Watcom C 10.0a and separately translates its XnGine assembly engine into C. Its tools compare compiled functions, rebuild the executable, run scripted game scenarios and trace asset use. The author reports all 2,297 game C functions matched and a byte-identical FALL.EXE.
- [Age of Empires II: matching PC and PlayStation 2 decompilation](https://awesomerea.org/resources/age-of-empires-ii-decomp-case/index.md): Case study · Age of Empires II Decompilation reconstructs C++ for The Conquerors 1.0c and Age of Kings 2.0a on PC, plus PAL and Japanese PlayStation 2 editions of Age of Kings. Its generated Ninja build and objdiff comparisons track functions matched against user-supplied original binaries.
- [Riiablo: rebuilding Diablo II in Java](https://awesomerea.org/resources/riiablo-case/index.md): Case study · Riiablo rebuilds Diablo II in Java with LibGDX, OpenGL, FlatBuffers, and Netty, loading game assets from the user's own installation. The current build can load supported saves and let characters move through the game, while an MPQ viewer and map viewer aid development. The author states that it is not yet playable.
- [DKR-GC: a native GameCube port of Diddy Kong Racing](https://awesomerea.org/resources/dkr-gc-diddy-kong-racing-case/index.md): Case study · DKR-GC ports the Diddy Kong Racing N64 decompilation to native GameCube PowerPC code. It maps N64 scheduling, storage, graphics and audio services onto libogc2 and GX, and reads game data from a user-supplied ROM.
- [Crusader: No Remorse — a C++ engine reimplementation](https://awesomerea.org/resources/crusader-no-remorse-decomp-case/index.md): Case study · Crusader: No Remorse — DECOMP reimplements the 1995 game's engine in C++20 and SDL2 for Windows and Linux. It reads data from supported French, US, and English editions and includes shape and map viewers, script probes, and a tool for comparison with the original.
- [OpenHoW: rebuilding Hogs of War from its game data](https://awesomerea.org/resources/openhow-hogs-of-war-case/index.md): Case study · OpenHoW is an early-stage reimplementation of Hogs of War designed to use content extracted from the PC release. Its extractor copies and updates original assets, and its research documents describe game model, map and texture formats, including MAD, MTD, PMG and POG.
- [Soulcalibur II Recomp: a native Xbox game port by static recompilation](https://awesomerea.org/resources/soulcalibur-ii-recomp-case/index.md): Case study · Soulcalibur II Recomp translates the Xbox release's program ahead of time into C and runs it on a native runtime for macOS, Linux, Windows and Android. It builds from the user's Xbox disc and can convert optional Link and Heihachi content from the user's GameCube and PlayStation 2 discs. Documentation covers the executable lift, runtime and guest-content conversion.
- [fci-recomp: static recompilation of Far Cry Instincts and Evolution](https://awesomerea.org/resources/fci-recomp-case/index.md): Case study · fci-recomp builds Windows ports of the original Xbox games Far Cry Instincts and Far Cry Instincts: Evolution by translating their disc code to C ahead of time. A project runtime supplies Xbox kernel, graphics and audio behavior, while a reverse-engineering layer records symbols and game-system findings.
- [NFSU2Recomp: a native Mac recompilation of Need for Speed: Underground 2](https://awesomerea.org/resources/nfsu2recomp-case/index.md): Case study · NFSU2Recomp statically recompiles Need for Speed: Underground 2 PC executable SPEED2.EXE into a native Apple Silicon application. Its lifter converts x86 code to C, while a handwritten runtime maps Win32, Direct3D 9 and DirectSound behavior to macOS, Metal and CoreAudio. The author reports that menus and races are playable.
- [George of the Jungle: partial matching PS2 decompilation](https://awesomerea.org/resources/george-of-the-jungle-decomp-case/index.md): Case study · The George of the Jungle and the Search for the Secret decompilation reconstructs the USA PS2 game's main CPU code with a byte-matched assembly baseline and selected C/C++ functions compared against the retail executable. Its tooling extracts boot files from the user's disc, builds a hybrid ELF and reports function-level byte matches; the author reports 24,396 matched C/C++ code bytes.
- [DuperHex: reimplementing the Super Hexagon engine from extracted game logic](https://awesomerea.org/resources/duperhex-case/index.md): Case study · DuperHex reimplements the Super Hexagon engine in Rust with SDL3 and wgpu. Its extractor uses angr and Unicorn to recover game logic encoded in executable conditional branches and convert it to JSON, alongside assets from the Steam-on-Linux release.
- [GHVanHRecomp: a native Guitar Hero: Van Halen port](https://awesomerea.org/resources/ghvanhrecomp-case/index.md): Case study · GHVanHRecomp statically recompiles the Xbox 360 release of Guitar Hero: Van Halen into a native Windows port. Its launcher installs game data from the user's ISO, while the project supplies the runtime, renderer integration, controls and display adaptations. The author describes the current release as beta.
- [BackstabRecomp: rehosting the Android BackStab HD game on Windows](https://awesomerea.org/resources/backstabrecomp-case/index.md): Case study · BackstabRecomp runs the user-supplied Android ARMv7 library from BackStab HD 1.2.8d in a Windows x64 host through AndroidRecomp. It implements the game's needed Android, JNI, graphics, audio, filesystem, input, and lifecycle behavior, with widescreen rendering changes.
- [WWE 2K16 PC Recomp: an Xbox 360 static recompilation for PC](https://awesomerea.org/resources/wwe-2k16-pc-recomp-case/index.md): Case study · WWE 2K16 PC Recomp statically recompiles the Xbox 360 game for a PC build using the ReXGlue SDK. Its launcher accepts a user-supplied ISO or extracted folder and adds graphics settings, input mapping, DLC support and mods.
- [Game Creator: reconstructing the classic Game Maker engine](https://awesomerea.org/resources/game-creator-game-maker-case/index.md): Case study · Game Creator implements a cross-platform .NET engine for games created with classic Game Maker versions through 8.1. It derives compatibility from observed API and gameplay behavior and includes game logic, function and action libraries, with interpreter, editor and file compatibility work distributed across branches.
- [shock2quest: recreating the Dark engine for System Shock 2 VR](https://awesomerea.org/resources/shock2quest-case/index.md): Case study · shock2quest recreates the Dark engine for a virtual-reality version of System Shock 2 on Meta Quest. Its runtime reads KPF archives and cutscenes copied from the user's 25th Anniversary Remaster installation; the Rust workspace includes engine, game and VR runtime components.