# Curated reverse engineering resources · Page 21

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

## Games (100)

- [Open Horizon: rebuilding Ace Combat: Assault Horizon rendering and physics](https://awesomerea.org/resources/open-horizon-ace-combat-case/index.md): Case study · Open Horizon reimplements the rendering and physics of Ace Combat: Assault Horizon in C++ using resource files from the original game. Its source includes game, renderer, physics and container modules. Its contribution guide suggests clean-room design or documenting findings when direct disassembly is unavoidable.
- [Julius: recreating Caesar III's gameplay logic](https://awesomerea.org/resources/julius-caesar-iii-case/index.md): Case study · Julius reimplements Caesar III's gameplay logic and reads the original game's files to run across desktop, mobile and browser platforms. It preserves compatibility with Caesar III saves while adding widescreen and other interface improvements.
- [The Bigs 2 Recompiled: an Xbox 360 PC port](https://awesomerea.org/resources/the-bigs-2-recompiled-case/index.md): Case study · The Bigs 2 Recompiled converts the Xbox 360 game's executable to C++ with ReXGlue for native Linux and Windows builds. Its game-specific hooks and renderer changes add resolution scaling, an experimental 60 fps mode and a first-run disc import screen.
- [Mario 64 for PlayStation 5: a Ghostship port](https://awesomerea.org/resources/ps5-ghostship-case/index.md): Case study · Mario 64 for PlayStation 5 ports Ghostship's decompilation-based Super Mario 64 application to PS5. It adds console-specific SDL drivers, Vulkan and RADV integration, and patches to the Ghostship stack; the user's ROM is converted into game data on first launch.
- [Lemmings.ts: rebuilding Lemmings for the browser](https://awesomerea.org/resources/lemmings-ts-case/index.md): Case study · Lemmings.ts recreates Lemmings as a TypeScript browser game that reads original Lemmings, Oh No! More Lemmings and Holiday Lemmings data files. Its game code includes level and graphics readers and interprets adlib.dat music through an Adlib emulator. The source lists gameplay fixes and touch support as unfinished.
- [BT3-Recomp: a PlayStation 2 static recompilation of Budokai Tenkaichi 3](https://awesomerea.org/resources/bt3-recomp-case/index.md): Case study · BT3-Recomp translates the USA PlayStation 2 release of Dragon Ball Z: Budokai Tenkaichi 3 from MIPS code to C++ at build time. It combines game-specific function maps and patches with a recompiler, PS2 runtime, OpenGL renderer and launcher for native desktop builds.
- [Fossil Fighters Champions: matching the Nintendo DS battle overlay](https://awesomerea.org/resources/fossil-fighters-champions-decomp-case/index.md): Case study · Reconstructs Fossil Fighters Champions' Nintendo DS battle overlay as C compiled with the original mwccarm toolchain, retaining assembly for unmatched functions. The author reports 1,141 of 1,382 overlay functions build-verified, and the repository documents accuracy and damage behavior.
- [ds3os: reconstructed Dark Souls 2 and 3 online servers](https://awesomerea.org/resources/ds3os-dark-souls-server-case/index.md): Case study · ds3os reconstructs online servers for Dark Souls 2: Scholar of the First Sin and Dark Souls 3, with matchmaking, profiles and multiplayer features. It includes a loader that redirects the games to a custom server and protobuf definitions for network traffic; some server calls and message fields remain unresolved.
- [Decompiling Sonic 1: translating 68K disassembly into C++](https://awesomerea.org/resources/decompiling-sonic-1-case/index.md): Case study · Decompiling Sonic 1 translates the game's 68K assembly disassembly into organized C++11 source to study its behavior. The source covers levels, objects, movement, graphics and sound, while accompanying notes explain assembly patterns and inferred semantics.
- [Tomb Raider: Legend: a cdcEngine decompilation](https://awesomerea.org/resources/tomb-raider-legend-cdc-engine-case/index.md): Case study · cdcEngine reconstructs C++ source for the engine used by Tomb Raider: Legend. The code includes game loop, archive filesystem, rendering, sound, and scene components, with a Premake configuration for an x86 windowed application.
- [Dr. Mario 64 Recomp: a native N64 recompilation with rendering changes](https://awesomerea.org/resources/dr-mario-64-recomp-plus-case/index.md): Case study · Dr. Mario 64 Recomp builds a modernized native version of the US Nintendo 64 game using N64Recomp and RSPRecomp on a user-supplied ROM. Its changes include GPU pill rendering, interpolated motion, four-player controllers and CRT effects. The author describes the release as lightly tested.
- [Alice in Wonderland: a matching Wii decompilation](https://awesomerea.org/resources/alice-in-wonderland-2010-wii-decomp-case/index.md): Case study · The Alice in Wonderland decompilation reconstructs source for the Wii game's US and European releases. Contributors extract main.dol from their own game copy, build with the documented tools, and use objdiff to compare generated objects with original game code.
- [Mind over Recomp: rebuilding Crash: Mind over Mutant for PC](https://awesomerea.org/resources/mind-over-recomp-case/index.md): Case study · Mind over Recomp translates Crash: Mind over Mutant's Xbox 360 program to C++ with ReXGlue for native Windows and Linux builds. It adds a Vulkan renderer and game-specific service replacements, with investigation notes documenting the disc, recompilation, boot and rendering work.
- [Guild Rebrew: C89 reconstruction of Europa 1400 binaries](https://awesomerea.org/resources/guild-rebrew-europa-1400-case/index.md): Case study · Guild Rebrew reconstructs Europa 1400: The Guild as C89 source built with the original MSVC6 toolchains. Rebrew workflows compare functions, data and layout against a server DLL and two client executables. The author reports a byte-identical server build; the two client reconstructions remain incomplete.
- [Stretch Panic: matching decompilation of three PlayStation 2 releases](https://awesomerea.org/resources/stretch-panic-decomp-case/index.md): Case study · Stretch Panic reconstructs three PlayStation 2 releases from shared C/C++ source and compares each rebuilt executable’s loaded image byte for byte with the original. Its build splits a user-provided executable with splat, compiles matched functions with a pinned CodeWarrior toolchain, and assembles remaining functions; the author reports 589 of 1,351 game functions matched.
- [Jet Set Willy: a SkoolKit disassembly of the ZX Spectrum game](https://awesomerea.org/resources/jet-set-willy-disassembly-case/index.md): Case study · Jet Set Willy documents a disassembly of the ZX Spectrum game in SkoolKit source format. The repository provides the annotated source and commands to generate a browsable HTML release or assembly language output.
- [FIFA Street 2: an early Xbox static recompilation for Windows](https://awesomerea.org/resources/fifastreet2-recomp-case/index.md): Case study · fifastreet2-recomp attempts a native Windows port of the Xbox version of FIFA Street 2 through static recompilation with xboxrecomp. Its documented pipeline parses and disassembles the user's XBE, classifies functions, generates C, and starts a host runtime that reaches the recompiled entry point.
- [fc3-nx: an experimental Far Cry 3 static recompilation](https://awesomerea.org/resources/fc3-nx-far-cry-3-case/index.md): Case study · fc3-nx uses ReXGlue to translate the Xbox 360 Far Cry 3 PowerPC executable into C++ for a planned Nintendo Switch port. It contains game-specific manifests, analysis and renderer adaptations; the documented PC build links but stops during boot at a guest-memory access.
- [Sly 2: Bevy of Thieves — a partial Rust and Bevy port](https://awesomerea.org/resources/sly-2-bevy-of-thieves-case/index.md): Case study · Sly 2: Bevy of Thieves ports Sly 2: Band of Thieves logic function by function into Rust and Bevy, replacing PS2 hardware services with native systems. It reads levels and media from the user's disc image; the archived build loads early episode hubs but cannot be played start to finish.
- [Goemon's Great Adventure: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/goemons-great-adventure-decomp-case/index.md): Case study · Goemon's Great Adventure reconstructs the Nintendo 64 US game's code as C and supplies tools to rebuild its ROM from a user-provided copy. The author reports that the reconstructed ROM matches the original byte for byte and that all 5,838 game functions match at the instruction level. The build extracts assets from the user's ROM and rebuilds them alongside the code.
- [Shadowgate 64: an N64 disassembly and source reconstruction](https://awesomerea.org/resources/shadowgate-64-case/index.md): Case study · Shadowgate 64 is an N64 disassembly and source reconstruction for the North American release. Its configuration splits a hash-checked user ROM into code segments, while the displayed C file still incorporates assembly functions.
- [New Play Control! Pikmin 2: a Wii decompilation](https://awesomerea.org/resources/pik2wii-case/index.md): Case study · pik2wii reconstructs source for the USA Wii release of New Play Control! Pikmin 2. Its workflow extracts the user's game files, builds with Ninja, and uses objdiff to compare source objects; a separate nonmatching mode produces a modifiable DOL.
- [Spider-Man 2: Enter Electro: a PlayStation static recompilation kit](https://awesomerea.org/resources/spider-man-2-enter-electro-recomp-case/index.md): Case study · The Spider-Man 2: Enter Electro kit configures psxrecomp to generate and compile the USA PlayStation game from the user's disc and BIOS during first-run setup. It includes title-specific symbols and function seeds, a recomp-ui launcher and a diagnostic build path.
- [max_vita: porting Max Payne Mobile's Android binary to PS Vita](https://awesomerea.org/resources/max-vita-case/index.md): Case study · max_vita ports the Android release of Max Payne Mobile to PS Vita by loading and patching the user's original game binary. Its wrapper supplies a small Android-like environment and compatibility hooks for graphics, audio and game behavior.
- [Excitebike 64: matching three Nintendo 64 releases](https://awesomerea.org/resources/excitebike-64-decomp-case/index.md): Case study · Excitebike 64 reconstructs the LodgeNet, US Rev 1, and European Nintendo 64 releases in a shared C and assembly tree. The build compiles functions at their original addresses, compresses the game image, and checks the rebuilt ROM against each release's SHA-1. The author reports byte-identical results for all three versions; original assets and RSP microcode are taken from user-supplied ROMs.
- [EA SPORTS UFC 3: a native PS4 game port for Linux and Windows](https://awesomerea.org/resources/ufc-3-ps4-port-case/index.md): Case study · The EA SPORTS UFC 3 port runs the PS4 game's original x86-64 code on Linux and Windows. A game-specific runtime supplies PS4 system services, while a renderer derived from shadPS4 translates GPU work to Vulkan; the user supplies the game's CUSA06534 dump and update 1.14.
- [Chameleon Twist: an in-progress Japanese N64 decompilation](https://awesomerea.org/resources/chameleon-twist-jp-decomp-case/index.md): Case study · Chameleon Twist reconstructs code for the Japanese 1.0 Nintendo 64 game in a matching decompilation workflow. Contributors supply the ROM, build with configure and Ninja, and use the build's match result while expanding the recovered C source.
- [Kye for C64: reconstructing the puzzle game's rules in 6502 assembly](https://awesomerea.org/resources/kye-c64-case/index.md): Case study · Kye for C64 ports the 1992 puzzle game to Commodore 64 in 6502 assembly. Its author inferred object-processing and magnet rules by testing the original, then implemented them alongside a parser for original Kye level files; the port documents its behavioral differences.
- [OpenGMK: reconstructing the GameMaker Classic runner and projects](https://awesomerea.org/resources/opengmk-case/index.md): Case study · OpenGMK reconstructs the GameMaker Classic runner and supplies tools for examining its games. GM8Decompiler extracts game data embedded in GameMaker 8 executables and rebuilds GMK or GM81 project files. Its companion emulator runs Classic games and records or replays TAS input; development remains in progress.
- [Crash Tag Team Racing: GameCube decompilation](https://awesomerea.org/resources/crash-tag-team-racing-decomp-case/index.md): Case study · Crash Tag Team Racing is a work-in-progress GameCube decompilation with C and C++ source, symbol maps and build configurations for the USA and Japanese releases. Users provide their own disc image, configure the target and build with Ninja; the Japanese release has not yet been split.
- [BAR Decomp: a matching Beetle Adventure Racing! decompilation fork](https://awesomerea.org/resources/bar-decomp-case/index.md): Case study · BAR Decomp reconstructs the USA Nintendo 64 release of Beetle Adventure Racing! as C intended to compile to the original ROM bytes. It extends an earlier decompilation with AI-assisted source recovery and a ROM hash gate for changes.
- [The Journeyman Project Turbo!: a Windows 3.1 decompilation](https://awesomerea.org/resources/journeyman-project-turbo-decomp-case/index.md): Case study · jman-decomp reconstructs C++ source for the Windows 3.1 version of The Journeyman Project Turbo!. It includes game-specific classes, build material and version metadata for English releases 1.0 and 1.1, with later porting as its stated purpose.
- [hl2-recomp: statically recompiling Xbox Half-Life 2](https://awesomerea.org/resources/half-life-2-xbox-recomp-case/index.md): Case study · hl2-recomp translates the Xbox Half-Life 2 XBE to C with xboxrecomp and links it to a native Windows runtime. Its game-specific tools recover RTTI classes, function boundaries and datamaps, while technical notes trace boot, controller and NV2A rendering paths; the author reports a title screen and partial level loading.
- [bully-re: reconstructing the Bully: Scholarship Edition engine](https://awesomerea.org/resources/bully-re-case/index.md): Case study · bully-re reimplements the PC engine of Bully: Scholarship Edition from analysis of its executable. The C++ code and technical notes cover RTTI-derived classes, Lua API bindings, action-tree AI and loaders for original game files, with host tests comparing parsed values against the user's copy.
- [Halo: Combat Evolved: a decompilation-based PS Vita port](https://awesomerea.org/resources/halo-ce-vita-case/index.md): Case study · Halo CE Vita compiles reconstructed Halo: Combat Evolved Xbox game code for the PS Vita's ARM processor. It adapts Direct3D rendering to the Vita GPU and includes extensive object-matching notes, platform code, campaign support and multiplayer features.
- [Bokura no Kazoku: matching PS2 source reconstruction](https://awesomerea.org/resources/bokura-no-kazoku-decomp-case/index.md): Case study · Bokura no Kazoku reconstructs the Japanese PlayStation 2 game's SCPS_150.88 executable as C++ compiled with Sony EE-GCC toolchains. The build compares its rebuilt ELF with the user's disc; remaining functions use assembly. The author reports 6,404 of 7,223 functions represented in C in the October 2026 progress snapshot.
- [picowalker: recreating the Pokéwalker accessory](https://awesomerea.org/resources/picowalker-case/index.md): Case study · picowalker develops an RP2350-based recreation of the Pokéwalker accessory for Pokémon HeartGold and SoulSilver. This repository provides board drivers for the OLED display, IrDA, EEPROM, accelerometer, power management and USB save-data transfer; the application core is separate. Full compatibility with the games remains a goal.
- [EQOA Decomp: matching PS2 modules of EverQuest Online Adventures: Frontiers](https://awesomerea.org/resources/eqoa-frontiers-decomp-case/index.md): Case study · EQOA Decomp reconstructs C++ source for PS2 modules of EverQuest Online Adventures: Frontiers. Its tools extract and disassemble functions from user-supplied module images, then compare compiled candidates against instructions, callees and data references. The author reports byte-exact matches across SUPPORT, CLIENT, SETUP, STATION, MCERR and SNDDRV, with remaining functions still open.
- [Pipe Dreams 3D: an early PlayStation decompilation](https://awesomerea.org/resources/pipe-dreams-3d-decomp-case/index.md): Case study · Begins a C decompilation of the PlayStation game Pipe Dreams 3D, with source files, a splat configuration, symbols, and a MIPS cross-build Makefile. Users place their own BIN/CUE game image in the GAME directory; a full build guide remains pending.
- [Battlefield Heroes: master-server protocol reconstruction](https://awesomerea.org/resources/bfh-master-protocol-case/index.md): Case study · BFH-Master-Protocol documents the proprietary master-server communication of Battlefield Heroes. It describes exchanges involving game clients, game servers, FESL authentication, Magma HTTPS account services and Theater session services. Some protocol details remain unresolved.
- [TsumuLightRecomp: static recompilation of Tsumu Light](https://awesomerea.org/resources/tsumu-light-recomp-case/index.md): Case study · TsumuLightRecomp configures PSXRecomp to translate the Japanese PlayStation game's MIPS code into native C and compile a PC executable. It supplies title-specific function seeds, build settings and a runtime English text layer; the author reports puzzle-stage play and memory-card save/load.
- [Gregory Horror Show: a work-in-progress PS2 decompilation](https://awesomerea.org/resources/gregory-horror-show-ps2-decomp-case/index.md): Case study · Decompiles the PlayStation 2 game Gregory Horror Show through a workflow that unpacks a user-provided ISO, splits its executable, and rebuilds a destination ISO from assembly and C. The repository includes version configuration, build scripts, headers, and source files.
- [Croc 2: a partial Game Boy Color disassembly](https://awesomerea.org/resources/croc-2-disassembly-case/index.md): Case study · Croc 2 reconstructs part of the Game Boy Color game as RGBDS assembly for modding and randomization. Its Makefile assembles the source with a supplied baserom.gbc and checks the resulting croc2.gbc against a recorded SHA-1.
- [Game and Watch for FPGAs: reconstructing Sharp handheld hardware](https://awesomerea.org/resources/game-and-watch-fpga-case/index.md): Case study · Game and Watch for FPGAs reconstructs Sharp handheld CPU and LCD behavior as a SystemVerilog core for Analogue Pocket and MiSTer. It covers SM510, its Tiger variant and SM5a, documents instructions and ROM formats, and supplies a converter for MAME ROMs.
- [LSD: Dream Emulator — a matching PlayStation decompilation](https://awesomerea.org/resources/lsd-dream-emulator-decomp-case/index.md): Case study · LSD: Dream Emulator reconstructs the Japanese PlayStation release SLPS-01556 in documented C source. Its build uses the user's retail disc and Psy-Q SDK inputs, then checks the output SHA-1; the author reports that every game function is completed and the executable matches byte for byte.
- [Space Rangers HD — Free Pascal Port: adapting recovered Delphi source](https://awesomerea.org/resources/space-rangers-hd-free-pascal-port-case/index.md): Case study · Space Rangers HD — Free Pascal Port adapts recovered Delphi source for Space Rangers HD: A War Apart to Free Pascal. It documents compatibility changes for Delphi arithmetic, floating-point and control-flow behavior and targets desktop, mobile, browser and Switch platforms using player-supplied game data.
- [WWE SmackDown vs. Raw 2007: an Xbox 360 static recompilation](https://awesomerea.org/resources/wwe-svr2007-recomp-case/index.md): Case study · WWE SmackDown vs. Raw 2007 recompiles the Xbox 360 game's code with ReXGlue and renders it through game-specific native graphics code on PC. The release targets Windows directly and runs on Linux or Steam Deck through Proton. The author reports 60 FPS in entrances and matches, with resolution and controller settings exposed in game.
- [Super Mario All-Stars: a ROM-based Windows and Android port](https://awesomerea.org/resources/super-mario-all-stars-pc-port-case/index.md): Case study · Super Mario All-Stars runs from the user's SNES ROM in a Windows and Android port with its own SNES runtime and game-specific extensions. The repository documents reverse-engineering findings for the included Mario games, including RAM fields, code banks and checks made with traces, memory watches and save states.
- [Re47: a partial Hitman: Codename 47 decompilation](https://awesomerea.org/resources/re47-hitman-codename-47-case/index.md): Case study · Re47 reconstructs source from the executable and DLLs of Hitman: Codename 47, using IDA Pro and the GOG game release as a reference. The author reports partial progress across modules, aims for a compilable game build, and states that byte-accurate matching is not currently pursued.
- [Kirby's Return to Dream Land: an early C/C++ decompilation](https://awesomerea.org/resources/krtdl-decomp-case/index.md): Case study · KRTDL-Decomp is an early reconstruction of Kirby's Return to Dream Land assembly into C and C++. The author plans to use Ghidra to inspect routines, build a symbol map and recompile a DOL for Dolphin; the repository contains game source, assembly and build scripts.
- [Twin Snakes Native Port: GameCube code analysis toward static recompilation](https://awesomerea.org/resources/twin-snakes-native-port-case/index.md): Case study · Twin Snakes Native Port analyzes the GameCube executables of Metal Gear Solid: The Twin Snakes for a planned native recompilation. Its workflow uses Ghidra, decomp-toolkit, signature matching, and DolRecomp to recover function boundaries and symbols and translate PowerPC code to C. The repository also contains runtime code for GameCube SDK services; current work centers on symbol recovery.
- [Ridge Racer 64: a ROM-splitting decompilation attempt](https://awesomerea.org/resources/ridge-racer-64-decomp-case/index.md): Case study · The Ridge Racer 64 decompilation project records ROM splits, symbols and linker settings for the USA Nintendo 64 release. Its Makefile runs splat and builds a new ROM from a user-supplied original; the author describes the effort as an attempt.
- [fheroes2: a Heroes of Might and Magic II engine recreation](https://awesomerea.org/resources/fheroes2-case/index.md): Case study · fheroes2 reimplements the Heroes of Might and Magic II engine from scratch and runs on resources from a full or demo copy of the game. It adds higher-resolution graphics, AI changes, fixes and interface improvements across several platforms.
- [1080 Snowboarding: matching Nintendo 64 decompilation with USO overlay analysis](https://awesomerea.org/resources/1080-snowboarding-decomp-case/index.md): Case study · 1080 Snowboarding decomp reconstructs Nintendo 64 game code in C and C++, including its custom USO overlays and Yay0-compressed segments. The author reports a byte-identical ROM build, while its progress table distinguishes matched C from partial work and assembly-backed portions. The project also documents recovering overlay relocation targets through emulator-assisted symbol dumping.
- [band3 recompiled: an early Rock Band 3 recompilation](https://awesomerea.org/resources/band3-recompiled-case/index.md): Case study · band3 recompiled is an early ReXGlue recompilation of Rock Band 3 title update 5. Its C++ hooks and build configuration cover parts of the game's runtime, and the author describes the current build as barely playable.
- [OpenMM2: a bottom-up Midtown Madness 2 rewrite](https://awesomerea.org/resources/openmm2-case/index.md): Case study · OpenMM2 rewrites Midtown Madness 2 from the bottom up in C++, using the installed game's original binary to supply functions that have not yet been reimplemented. The project aims to make game fixes, new features and ports possible, but its author describes it as mostly abandoned because of technical limits.
- [Benno4j: reconstructing a game world from GAM saves and BSH graphics](https://awesomerea.org/resources/benno4j-game-world-case/index.md): Case study · Benno4j reconstructs a game world in Java from original save and graphics files for the NINA and History Edition versions. Its readers parse GAM save chunks for islands and ships and BSH image files for rendering; the interface includes ship movement and pathfinding.
- [Animaniacs: The Great Edgar Hunt: a GameCube static recompilation](https://awesomerea.org/resources/animaniacs-great-edgar-hunt-recomp-case/index.md): Case study · The Animaniacs: The Great Edgar Hunt port translates the USA GameCube game's PowerPC code into a native module with DolRecomp, while ModernGekko supplies graphics, audio, input and timing. Its scripts validate the user's disc and build the module; the author reports gameplay with a narrow interpreter fallback.
- [Far Cry Instincts Recomp: a static recompilation of the Xbox game for Windows](https://awesomerea.org/resources/far-cry-instincts-recomp-case/index.md): Case study · Far Cry Instincts Recomp translates the original Xbox game's x86 code from a user's default.xbe into C++ and compiles it into a Windows x64 DLL. Its runtime replaces Xbox kernel, Direct3D 8 and DirectSound services, with graphics rendered through Direct3D 11.
- [Grand Theft Auto: a Windows static recompilation of the 1997 game](https://awesomerea.org/resources/grand-theft-auto-1997-recomp-case/index.md): Case study · Grand Theft Auto translates the 1997 Windows game's x86 executable into C and links it with modern replacements for Win32, DirectDraw and sound services. The repository supplies a runtime, import bridges and analysis tools; the author reports that the translated game reaches its title screen and city-selection menu. Related executables for GTA London and GTA2 are also investigated.
- [NASCAR Heat 2002: a matching GBA decompilation and SDL2 port](https://awesomerea.org/resources/nascar-heat-2002-gba-decomp-case/index.md): Case study · Reconstructs the US Game Boy Advance release of NASCAR Heat 2002 as a byte-matching source build and compiles the same game code into an SDL2 desktop port. The build extracts graphics, tracks, music, and samples from a user-supplied ROM; the author reports that make check reproduces the retail ROM.
- [Elite: a symbolic MSX game disassembly](https://awesomerea.org/resources/elite-msx-disassembly-case/index.md): Case study · Elite is a disassembly of the 1987 MSX game organized by its boot sector, loader, main program and data files. The assembly assigns symbolic names to routines and data and uses macros to explain constants; the README documents the disk's sector layout.
- [Burnout 3: Takedown — matching PlayStation 2 game-code decompilation](https://awesomerea.org/resources/burnout-3-ps2-decomp-case/index.md): Case study · Burnout 3: Takedown's PlayStation 2 game code is being reconstructed as byte-matching C and C++. Individual functions are compiled with CodeWarrior and compared with the original, while vendor libraries remain as assembly generated from the user's disc. The author reports a matching full-build SHA-1 and partial game-code progress.
- [OpenCMR2 VR: a Quest and PCVR port of Colin McRae Rally 2.0](https://awesomerea.org/resources/opencmr2-vr-case/index.md): Case study · OpenCMR2 VR ports Colin McRae Rally 2.0 to Meta Quest 3 and Windows PCVR using the OpenCMR2 codebase built from CMR2Decomp. It adds OpenXR rendering and controller support and imports data from a player's installed PC copy. The Quest build runs on the headset; the Windows build uses a connected OpenXR headset.
- [wkbre2: recreating the Warrior Kings engine](https://awesomerea.org/resources/wkbre2-case/index.md): Case study · wkbre2 is an engine reimplementation for Warrior Kings and Warrior Kings Battles. It uses a client-server architecture and original game assets, and aims to load unit definitions and interpret gameplay scripts from the games' data.bcp archive. It supports Direct3D and OpenGL rendering and is in early development; it is not completely playable.
- [Sega Superstars Tennis ReMatch: an Xbox 360 static recompilation](https://awesomerea.org/resources/sega-superstars-tennis-rematch-case/index.md): Case study · Sega Superstars Tennis ReMatch builds a native Windows and Linux port of the Xbox 360 game with ReXGlue. Its renderer translates Xbox 360 shaders for Direct3D 12 and Vulkan, with build-time shader packing and runtime compilation for shaders generated during play.
- [Open RCT3: an early RollerCoaster Tycoon 3 reimplementation](https://awesomerea.org/resources/open-rct3-case/index.md): Case study · Open RCT3 is an early-stage reimplementation of RollerCoaster Tycoon 3. Its C# code includes an OVL file reader and writer, while the published roadmap places terrain, scenery, rides and gameplay in unfinished phases. The project may require assets from the player's original game copy.
- [Black Ops II Recompiled: separate Xbox 360 game codegen targets](https://awesomerea.org/resources/black-ops-ii-recompiled-case/index.md): Case study · Black Ops II Recompiled configures ReXGlue to generate native builds from the Xbox 360 game's single-player default.xex and multiplayer default_mp.xex. Separate configurations and scripts handle code generation, CMake setup and builds using the user's extracted game files.
- [MedalOfHonor-xport: a Medal Of Honor PlayStation decompilation port](https://awesomerea.org/resources/medalofhonor-xport-case/index.md): Case study · MedalOfHonor-xport ports reconstructed routines from the PlayStation game Medal Of Honor. Its Windows C runtime loads the original SLUS_009.74 executable, rebuilds startup state and handles selected PSX interrupt, DMA and memory operations.
- [GoldenEye 007 PC Recompilation: an Xbox 360 game port](https://awesomerea.org/resources/goldeneye-360-recomp-case/index.md): Case study · GoldenEye 007 PC Recompilation ports the Xbox 360 version of GoldenEye 007 to a native PC executable using ReXGlue. The repository contains game-specific hooks and patches, plus keyboard and mouse, graphics and online-play support. The player supplies the game files in an assets folder.
- [Digimon World 4: a work-in-progress GameCube decompilation](https://awesomerea.org/resources/dw4-gc-case/index.md): Case study · dw4-gc is a work-in-progress decompilation of Digimon World 4 for GameCube, targeting GDJEB2 Rev 1 USA. It configures and builds from a user-provided disc image, then generates objdiff configuration for comparing reconstructed source objects. The repository contains C source, headers, symbols, and split configuration.
- [MissionFleet: reconstructing the NavyFIELD 2.062 client and server stack](https://awesomerea.org/resources/missionfleet-case/index.md): Case study · MissionFleet reconstructs the historical NavyFIELD 2.062 client and server stack using byte-level decompilation evidence and a Rust server implementation. The author reports a byte-matched inventory spanning client and server modules, most of it represented by instruction streams rather than readable C++. Its Rust login transport implements framing, checksums and liveness probes; authentication and the game and save services remain incomplete.
- [Gran Turismo 3: A-Spec: matching PS2 executable decompilation](https://awesomerea.org/resources/gt3-decomp-case/index.md): Case study · gt3-decomp reconstructs C and C++ for Gran Turismo 3: A-Spec's PS2 CORE.GT3 executable, NTSC-U v1.00. It compiles functions with the original ee-gcc toolchain, checks instructions per function, and SHA-1-compares a full build that combines matched source with disassembly from the user's executable; the author reports partial matching progress.
- [Wipeout XL Recompiled: a local PlayStation recompilation setup](https://awesomerea.org/resources/wipeout-xl-recomp-case/index.md): Case study · Wipeout XL Recompiled supplies a PSXRecomp recipe and recomp-ui setup host that generates and builds the PlayStation game from the user's own disc and BIOS. The repository includes title-specific identity and seed files; package setup and gameplay acceptance remain pending.
- [DoomIIRPG-RE: a Doom II RPG reconstruction](https://awesomerea.org/resources/doomiirpg-re-case/index.md): Case study · DoomIIRPG-RE reconstructs Doom II RPG game systems in C++. Its source implements gameplay, rendering, script execution, and resource loading from the game's package layout, with CMake configuration for a desktop build.
- [Lantern Engine: a Bloodborne runtime for Windows and Linux](https://awesomerea.org/resources/lantern-engine-case/index.md): Case study · Lantern Engine runs Bloodborne CUSA03173 update 1.09 from the player's own PS4 dump on Windows and Linux. Built on bbport and shadPS4, its game-specific runtime supplies PS4 system services while the game's code executes on the CPU and graphics are translated to Vulkan. The source documents additional launcher, rendering, control, and performance work.
- [Ratchet & Clank Collection: PS3 executable analysis and matching reconstruction](https://awesomerea.org/resources/ratchet-clank-collection-ps3-case/index.md): Case study · Ratchet & Clank Collection analyzes four PS3 retail executables for the BCUS98282 release and develops C and C++ bodies to match their bytes. Its Python tools inspect SELF and PPU ELF structures, bound functions, compare related builds, and grade reconstructed bodies. The author reports six matching bodies at the documented checkpoint.
- [Yoshi's Woolly World: an early game decompilation](https://awesomerea.org/resources/yoshis-woolly-world-decomp-case/index.md): Case study · Yoshi's Woolly World is an early decompilation of the game with C++ source and headers in the repository. Its build instructions use Green Hills Software MULTI PowerPC v5.3.27 and a Python compile script; assembly diffing and match calculations remain on the task list.
- [Little King's Story: a Wii decompilation project](https://awesomerea.org/resources/little-kings-story-decomp-case/index.md): Case study · lks_decomp develops source for the USA RO3EXJ Wii release of Little King's Story. Its configuration builds from a user-supplied disc image, generates objdiff project data, and supports source-to-original object comparison on Windows, macOS and Linux.
- [Phoenix: a Java remake of Emperor of the Fading Suns](https://awesomerea.org/resources/phoenix-efs-case/index.md): Case study · Phoenix rebuilds Emperor of the Fading Suns as a Java game using data from the user's EFS 1.4 installation. Its source includes game systems, a GUI, FLC animation handling and galaxy-file readers. The project aims to reproduce EFS.EXE behavior while keeping the original data outside its distribution.
- [The Sims 2 Castaway: a Wii disassembly in progress](https://awesomerea.org/resources/sims-2-castaway-wii-decomp-case/index.md): Case study · ts2c reconstructs the US Wii build of The Sims 2 Castaway through disassembly and decompilation. The repository contains hundreds of assembly files organized by original code unit and a Makefile targeting a rebuilt main.dol.
- [Midnight Club: Los Angeles - Recompiled: an Xbox 360 PC port](https://awesomerea.org/resources/midnight-club-los-angeles-recompiled-case/index.md): Case study · Midnight Club: Los Angeles - Recompiled translates the Xbox 360 game's PowerPC default.xex to native Windows code with ReXGlue. The port adds a DirectX 12 graphics path and launcher; its Ghidra research identifies the projection matrix function and instruction relevant to ultrawide rendering.
- [Mask 3: Venom: a partial ZX Spectrum disassembly](https://awesomerea.org/resources/mask-3-venom-case/index.md): Case study · Mask 3: Venom is a partial assembly reconstruction of the ZX Spectrum game MASK III: VENOM Strikes Back. Its address-labelled assembly files cover game routines, and the source is described as compilable with SjASM+.
- [Oracles NX: a Nintendo Switch port of the Oracle games](https://awesomerea.org/resources/oracles-nx-case/index.md): Case study · Oracles NX ports the C reimplementation of Oracle of Ages and Oracle of Seasons to Nintendo Switch homebrew. It builds the native game code into an .nro and adds Switch-specific ROM installation, SDL3 and OpenGL ES rendering, controls and fiber stacks.
- [engge: a Thimbleweed Park engine remake](https://awesomerea.org/resources/engge-case/index.md): Case study · engge reimplements the Thimbleweed Park adventure engine in C++ and runs with ThimbleweedPark.ggpack1 and ggpack2 copied from the user's installation. It uses an SDL2-based framework and a modified Squirrel library; the author reports the game can be finished despite bugs.
- [open-spyro: matching decompilation of Spyro the Dragon](https://awesomerea.org/resources/open-spyro-case/index.md): Case study · open-spyro rebuilds Spyro the Dragon's PlayStation executable and 37 overlays byte for byte from matched C and retained original assembly. Its build uses a locked GCC 2.7.2 toolchain and per-function instruction diffs. The author reports that all counted game-code bytes match; readability cleanup continues.
- [Trouble Makers: a Mischief Makers static-recompilation port](https://awesomerea.org/resources/trouble-makers-mischief-makers-case/index.md): Case study · Trouble Makers turns Mischief Makers' N64 MIPS code into a native PC port with N64Recomp, N64ModernRuntime and RT64. The repository includes a US 1.1 symbol map, compatibility patches and a technical reference covering the ROM and engine; optional widescreen and frame interpolation are experimental.
- [Splatoon: a Wii U C++ reconstruction workspace](https://awesomerea.org/resources/splatoon-wii-u-decomp-case/index.md): Case study · Reconstructs C++ components of the Wii U game Splatoon from its Gambit.rpx executable. The workflow verifies a user dump, extracts strings and RTTI, uses Ghidra for static analysis, and configures objdiff for function comparison; the tree includes game and library source files.
- [Final Fantasy Legend II: an English ROM disassembly](https://awesomerea.org/resources/final-fantasy-legend-ii-disassembly-case/index.md): Case study · Final Fantasy Legend II is an assembly-language disassembly of the English Game Boy release of SaGa 2. The repository separates ROM banks and RAM areas, records the target ROM's SHA-1, and documents its MBC1 mapper and memory layout.
- [MapleStory2: reconstructing server packet structures](https://awesomerea.org/resources/maple2-server-packet-case/index.md): Case study · Maple2 reconstructs a MapleStory2 server in C# and investigates the client's expected server-to-client packet layouts. Its PacketStructureResolver sends partial packets, uses client error reports to refine their structure, and saves the results for the server implementation.
- [ReKHCoM: native ports of Kingdom Hearts: Chain of Memories](https://awesomerea.org/resources/rekhcom-case/index.md): Case study · ReKHCoM ports the decompiled Game Boy Advance code of Kingdom Hearts: Chain of Memories to native and browser runtimes. It supplies rendering, audio, a launcher, widescreen options, and support for European, US, and Japanese cartridge dumps.
- [NES Tetris: a Rust reconstruction checked against the original](https://awesomerea.org/resources/nes-tetris-rust-case/index.md): Case study · NES Tetris rebuilds the 1989 NES game in Rust for desktop and browser play, reading graphics, music and data from a user-provided ROM. Its documented workflow translates disassembled routines into Rust and compares their calls with the original through a shadow oracle.
- [Yoshi's Story: an in-progress US decompilation](https://awesomerea.org/resources/yoshis-story-decomp-case/index.md): Case study · Yoshi's Story Decompilation reconstructs the US Nintendo 64 game's code in C and assembly. The repository provides source files, extraction and build commands, and a workflow that starts from a user-provided .z64 base ROM.
- [OutRunners: native ports built on an arcade game decompilation](https://awesomerea.org/resources/outrunners-port-case/index.md): Case study · OutRunners ports Sega's arcade game to native computer and handheld builds using the game's C decompilation. Its own runtime provides arcade and home versions, while extraction tools obtain graphics, sound and other data from a user-provided World ROM set.
- [Clone Dash: rebuilding Muse Dash gameplay](https://awesomerea.org/resources/clone-dash-case/index.md): Case study · Clone Dash rebuilds Muse Dash's rhythm gameplay in a cross-platform C# game engine and loads levels from the player's Steam installation. It provides the core play loop and supports custom albums in the .mdm format, while the author describes the project as a beta vertical slice.
- [Caesar II: a portable build of recovered game source](https://awesomerea.org/resources/caesar-ii-port-case/index.md): Case study · Caesar II ports recovered source from the 1995 game to Linux, Windows, macOS and browsers through SDL3. It replaces DOS and Windows platform calls while retaining the game's logic, and adds an XMIDI and OPL3 music stack, Smacker playback and an importer for data from the user's copy. The repository also carries tooling for comparing the original executable with a reconstruction.
- [dantes-inferno-nx: porting Dante's Inferno to Nintendo Switch](https://awesomerea.org/resources/dantes-inferno-nx-case/index.md): Case study · dantes-inferno-nx statically recompiles Dante's Inferno Xbox 360 PowerPC code to C++ for a Nintendo Switch homebrew build. Its Switch runtime renders through deko3d, and its shader tools translate Xenos shader containers through HLSL and SPIR-V. The build uses the user's supported disc and Title Update 2 or a supported Games on Demand install.
- [Pokémon Colosseum: continued GameCube matching decompilation](https://awesomerea.org/resources/pokemon-colosseum-continued-decomp-case/index.md): Case study · Pokémon Colosseum continues a GameCube matching decompilation with additional C and data reconstruction, a measured progress ledger, and native Windows build support. It covers the GC6E01 DOL and 25 REL modules. The author reports byte-identical rebuilt outputs using original fallback objects where source reconstruction remains incomplete.
- [Mario Golf 64: an early N64 decompilation](https://awesomerea.org/resources/rainchus-mario-golf-64-decomp-case/index.md): Case study · Mario Golf 64 is an early N64 decompilation project with a ROM split configuration, symbol and relocation data, assembly for unmatched functions and a small amount of reconstructed C. Its build generates nonmatched assembly and links a ROM from the user's local base image.
- [In Cold Blood Recompiled: a PlayStation setup host](https://awesomerea.org/resources/in-cold-blood-recompiled-case/index.md): Case study · In Cold Blood Recompiled configures PSXRecomp and recomp-ui to generate a native build from the user's PlayStation disc. It includes title configuration, symbol seeds and a setup host. The author reports gameplay in a private package, while exact-package setup and release gates remain open.