# Curated reverse engineering resources · Page 5

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

## Games (100)

- [The Darkness Recomp: an Xbox 360 static recompilation with a native D3D11 renderer](https://awesomerea.org/resources/the-darkness-recomp-case/index.md): Case study · Builds a native Windows x64 port of The Darkness by translating its Xbox 360 executable to C++ ahead of time with a patched XenonRecomp. A D3D11 renderer draws from the engine’s original geometry, shader sources and device state instead of interpreting console GPU packets. Gameplay coverage and Linux results are project-reported, and the author discloses OpenAI Codex assistance.
- [MarioKart 64: Recompiled — a native port through N64Recomp static recompilation](https://awesomerea.org/resources/mariokart64-recompiled-case/index.md): Case study · Statically recompiles the US Nintendo 64 release of Mario Kart 64 into a native Windows, Linux and macOS application with N64Recomp, rendering through RT64. The README distinguishes this from a source port: game code is translated from the user’s ROM, while headers and some functions from a decompilation fork support patches and enhancements. Enhancement, fidelity and input-lag claims are project-reported.
- [Animal Crossing: matching GameCube decompilation](https://awesomerea.org/resources/animal-crossing-gamecube-decomp-case/index.md): Case study · Reconstructs Animal Crossing’s GameCube code as C and C++ source that rebuilds the USA release’s main executable and its foresta.rel module. The dtk-template build reads the original binaries and assets from a user-supplied disc image, then checks both outputs against SHA-1 hashes. A separate native PC port builds on it; completeness figures remain project-reported here.
- [Kingdom Hearts 358/2 Days: a matching Nintendo DS decompilation](https://awesomerea.org/resources/kingdom-hearts-days-matching-decomp-case/index.md): Case study · Reconstructs the ARM9 program and overlays of the EU Nintendo DS release of Kingdom Hearts 358/2 Days as C that recompiles byte for byte with CodeWarrior. README reports all 306 modules byte-identical, with about 99.5% of functions in real C and library assembly counted separately; the ARM7 binary is outside its scope. The repository holds no ROM, game assets or extracted disassembly and produces no playable build.
- [TonyWasAProSkater: a THPS1 native port forked from a matching decompilation](https://awesomerea.org/resources/thps1-decomp-native-port-case/index.md): Case study · Ports Tony Hawk’s Pro Skater (PlayStation, USA) to native Windows and Linux builds from a fork of an in-progress matching decompilation of the retail executable. The decompilation recompiles reconstructed functions with a Psy-Q toolchain and compares them byte for byte with the user’s retail executable, while the port replaces PlayStation hardware and libraries with SDL2 and OpenGL services. Play needs the user’s own disc image; matching and gameplay results remain project-reported.
- [P.T. for PC: a behavior-based engine reimplementation that reads the PS4 data](https://awesomerea.org/resources/pt-pc-port-case/index.md): Case study · Reimplements P.T.’s game logic in C++ on a new Vulkan engine that reads levels, models, textures, sounds, scripts and cutscenes from the user’s own PS4 copy at run time. The author documents reverse-engineered file formats and used the shadPS4 emulator as a behavior and frame reference. Fidelity to the original is author-reported, and the use of AI coding tools is disclosed.
- [SpaghettiKart: a native Mario Kart 64 port built on decompiled source](https://awesomerea.org/resources/spaghettikart-mk64-port-case/index.md): Case study · Builds a native Mario Kart 64 port for Windows, Linux, macOS and Switch from source that keeps the Mario Kart 64 decompilation’s file layout, running on libultraship’s reimplemented N64 SDK. Its bundled Torch extractor converts the user’s US ROM into an asset archive, and the port adds mods, custom tracks and an editor. The README does not name its upstream decompilation, and no matching or fidelity checks are published.
- [Animal Crossing: Wild World: matching Korean DS decompilation with differential runtime checks](https://awesomerea.org/resources/animal-crossing-wild-world-decomp-case/index.md): Case study · Reconstructs the ARM9 game code of Animal Crossing: Wild World’s Korean DS release as one C or C++ source per function, checked against the user’s ROM with the original Metrowerks compiler and linker. Each function also has a readable Clean rewrite, and an included DS interpreter compares the ROM code, natively compiled sources and rewrites on recorded play. Data sections, the ARM7 binary, the linked SDK libraries and regrouping into original source files remain outside the reconstruction.
- [King Kong Recompiled: an AI-developed Xbox 360 static recompilation](https://awesomerea.org/resources/king-kong-recompiled-case/index.md): Case study · Translates the Xbox 360 release of Peter Jackson's King Kong into native Windows code with the ReXGlue static-recompilation SDK, adding a launcher and display, control and graphics options. Project code completes streamed disc reads the way the console does, which README credits with getting past an opening freeze seen under Xenia. The author discloses that the port was made almost entirely with Claude Code, directed and tested by the repository owner.
- [Mario Party 4: matching GameCube decompilation of the USA releases](https://awesomerea.org/resources/mario-party-4-decomp-case/index.md): Case study · Reconstructs Mario Party 4’s GameCube main executable and REL modules as C source that rebuilds both USA releases. The build analyzes the user’s own disc image and checks every linked output against version-specific SHA-1 lists. PAL and Japanese work is stale and no PC port exists yet; matching results remain project-reported here.
- [SpeedBreaker: statically recompiling Need for Speed: Most Wanted for Xbox 360](https://awesomerea.org/resources/speedbreaker-nfs-most-wanted-case/index.md): Case study · Translates the Xbox 360 executable of Need for Speed: Most Wanted (2005) into native C++ with a patched XenonRecomp and runs it on a project runtime that stands in for the console’s kernel, Xenos GPU, XMA audio and controllers. Releases target SteamOS, Linux and Apple silicon Macs, with an experimental iPhone and iPad build, while all game data comes from the player’s own US disc. Rendering and frame-pacing improvements are project-reported.
- [The Sims: Bustin' Out: an AI-driven partial GBA matching decompilation](https://awesomerea.org/resources/sims-bustin-out-gba-decomp-case/index.md): Case study · Rebuilds the USA/Europe Game Boy Advance release of The Sims: Bustin' Out byte for byte while gradually replacing ROM regions with matching C compiled by agbcc. The README calls it an AI-driven experiment in which almost all code, analysis and tooling are AI-generated. Most of the ROM is still copied from the user’s dump.
- [Destiny 2 build 86657: Sunrise/Dawn reconstruction research report](https://awesomerea.org/resources/destiny2-build-86657-reconstruction-report-case/index.md): Case study · A dated research report on the Sunrise/Dawn reconstruction of the archived Destiny 2 build 86657 client, which emulates platform sign-on and the examined Bungie service contracts locally and adds reconstructed mission host policy. It records transport, decoding, object creation, presentation and gameplay results separately, and keeps superseded conclusions with their cited sources. It documents the case; playthroughs and native results remain project-reported.
- [SVR2011-Recomp: a ReXGlue recompilation of WWE SmackDown vs. Raw 2011](https://awesomerea.org/resources/svr2011-recomp-case/index.md): Case study · Translates the Xbox 360 executable of WWE SmackDown vs. Raw 2011 to C++ ahead of time with ReXGlue and builds it as a Windows program on a Vulkan runtime derived from Xenia. A hand-maintained manifest adds function entry points the automatic pass misses, and project patches address frame pacing, a music-player delay and pipeline stalls. Exhibition play is author-tested on one AMD GPU; career mode and online remain untested.
- [Snap64 Recomp: a static-recompilation port of Pokémon Snap](https://awesomerea.org/resources/snap64-recomp-case/index.md): Case study · Uses N64Recomp to statically recompile the US Nintendo 64 release of Pokémon Snap into a native Windows, Linux, Steam Deck and macOS port rendered with RT64. The recompiler reads a relocatable ELF linked from the matching ethteck/pokemonsnap decompilation together with the user’s ROM, and game-side patches are modified copies of decompiled functions. The author reports building the port with Claude Code; results remain project-reported.
- [Dead Rising 2: Case Zero — an Xbox 360 XBLA static recompilation port](https://awesomerea.org/resources/dead-rising-2-case-zero-recomp-case/index.md): Case study · Builds a native Windows, Linux, Steam Deck and Apple Silicon port of the XBLA game Dead Rising 2: Case Zero by statically recompiling its Xbox 360 code with patched XenonRecomp and translating its shaders with patched XenosRecomp. A purpose-built runtime supplies a Vulkan renderer, XMA audio, keyboard/mouse input and online co-op through the author’s XenonLive service. Completion and platform results are project-reported.
- [OpenRA: an engine reimplementation reimagining early Westwood RTS games](https://awesomerea.org/resources/openra-engine-case/index.md): Case study · Provides a C# engine for early Westwood real-time strategy games, with mods that reimagine Command & Conquer: Red Alert, Tiberian Dawn and Dune 2000. It loads the original games’ content through its own file-system, MiniYAML rules and Lua mission layers. Gameplay and interface follow OpenRA’s own design.
- [Dead Rising 2: Case West — a sibling Xbox 360 XBLA static recompilation port](https://awesomerea.org/resources/dead-rising-2-case-west-recomp-case/index.md): Case study · Builds a native Windows, Linux, Steam Deck and Apple Silicon port of the XBLA epilogue Dead Rising 2: Case West by statically recompiling its Xbox 360 code with patched XenonRecomp and translating its shaders with patched XenosRecomp. It shares most of its runtime with the author’s separate Case Zero port, executing the console GPU command stream on Vulkan with XMA audio and keyboard/mouse input. Completion and platform results are project-reported.
- [The Simpsons Wrestling Recompiled: a psxrecomp PlayStation static recompilation](https://awesomerea.org/resources/simpsons-wrestling-recompiled-case/index.md): Case study · Translates the PlayStation game’s MIPS code to C with a pinned psxrecomp fork and builds Windows and Linux programs on its hardware-modelling runtime, with a launcher and a game-specific plugin. Without patching game code, the plugin adds 16:9 matches, 60 FPS by raising the emulated CPU clock and rescaling movement, intro skipping and unlocks. The user’s own NTSC-U disc image is required, and the measurements are author-reported.
- [OpenRCT2: an open re-implementation of RollerCoaster Tycoon 2](https://awesomerea.org/resources/openrct2-engine-case/index.md): Case study · Re-implements RollerCoaster Tycoon 2, originally written in x86 assembly, as a C++ engine that runs on the original game’s data. It loads RCT2 saves and scenarios, and RCT1 scenarios when those files are present, while saving to its own documented park format. Modern-platform support, interface and AI changes, higher limits and multiplayer are deliberate extensions.
- [Touhou 6: reconstructing Embodiment of Scarlet Devil 1.02h source](https://awesomerea.org/resources/th06-decomp-case/index.md): Case study · Reconstructs C++ source for the Windows executable of Touhou 6: Embodiment of Scarlet Devil version 1.02h, aiming at an exact rebuild with the original Visual Studio .NET 2002 and DirectX 8 toolchain. reccmp and objdiff compare the rebuilt binary with the user’s original executable function by function. The committed progress badge reports every function implemented and 98.03% byte accuracy.
- [Driver Recompiled: a psxrecomp setup host that builds the game locally](https://awesomerea.org/resources/driver-recomp-setup-host-case/index.md): Case study · Packages a psxrecomp static-recompilation project for Driver (PlayStation, USA) as a setup host: releases carry the recompiler, runtime and a recomp-ui launcher, and the player’s machine generates and compiles the game from the user’s own disc image. The repository holds configuration, Ghidra-derived function seeds and release automation rather than game code. Its documented status is thin: an operator-confirmed private build reaches gameplay, while package release gates remain open.
- [Himuro: a matching Fatal Frame PS2 decompilation](https://awesomerea.org/resources/himuro-fatal-frame-decomp-case/index.md): Case study · Reconstructs Fatal Frame’s PS2 executable as C for the US, EU and Japanese releases, built with the original EE-GCC 2.9 toolchain and checked by SHA-1 against the user’s own executables. Committed objdiff reports list the US and EU code as fully matched and the Japanese code as partial, and a few routines still rely on assembly or byte patches. Porting to modern hardware is a stated later goal, not part of this repository.
- [DOAXVB Native PC Port: statically recompiling Dead or Alive Xtreme Beach Volleyball](https://awesomerea.org/resources/doaxvb-native-port-case/index.md): Case study · Lifts the original Xbox executable of Dead or Alive Xtreme Beach Volleyball to C with a fork of xboxrecomp and links it with a hand-written runtime that replaces kernel imports, audio and key Direct3D 8 and DirectSound APIs. Setup builds the runner locally from the user’s USA disc image and checks generated files against hashes in an authenticated recipe; releases carry only tools and source. Rewriting game logic as readable source has so far reached only the startup thread entry.
- [TH08 Web: a WebAssembly port built from reconstructed source](https://awesomerea.org/resources/th08-web-wasm-port-case/index.md): Case study · Compiles the reconstructed C++ source of the Japanese Touhou 8 1.00d release to WebAssembly with Emscripten, adding WebGL 2 rendering, Web Audio, browser input and IndexedDB saves behind the game’s D3D8-, DirectSound- and DirectInput-shaped interfaces. Players select their own retail DAT files locally. The web build is a separate port from the curated TH08 reconstruction.
- [OpenXcom: an open-source clone of X-COM: UFO Defense and Terror from the Deep](https://awesomerea.org/resources/openxcom-engine-case/index.md): Case study · Reimplements MicroProse’s UFO: Enemy Unknown (X-COM: UFO Defense) and X-COM: Terror from the Deep as a C++/SDL engine that runs on the user’s original game resources. Game data such as items, craft, research and missions is expressed in YAML rulesets, which also carry its standard mods and a wider modding ecosystem. It is a clone that reuses original content, not recovered MicroProse code.
- [Skate 3 Recomp: a native Xbox 360 recompilation through ReXGlue](https://awesomerea.org/resources/skate3-recomp-case/index.md): Case study · Recompiles the Xbox 360 version of Skate 3 into native Windows, Linux and macOS builds with a Skate-specific fork of the ReXGlue SDK. Since v2.0.0 a native Direct3D 12 and Vulkan renderer with ports of the game’s own material shading replaces emulation of the Xbox 360 GPU, which remains as a fallback. Game files come from the user’s disc image; the author calls the native renderer early and has not tested the game end to end.
- [Uncharted: The Nathan Drake Collection native Windows port](https://awesomerea.org/resources/uncharted-collection-pc-port-case/index.md): Case study · Runs the PS4 Uncharted: The Nathan Drake Collection’s own x86-64 executables natively on Windows: a runtime supplies the PS4 system libraries and a shadPS4-derived Vulkan renderer executes the GPU work. The port adds a per-game launcher, resolution patches and modern upscaling, and its status table reports all three games playable with listed open issues. It is a compatibility-runtime port rather than a decompilation, and its results remain project-reported.
- [TH095: function-level reconstruction of Shoot the Bullet 1.02a](https://awesomerea.org/resources/th095-reconstruction-case/index.md): Case study · Reconstructs source for the original Japanese Touhou 9.5: Shoot the Bullet 1.02a executable, accepting function exactness only through reproducible byte comparison of pinned Visual C++ .NET 2003 builds against one hash-attested target. The whole program also compiles and links into a playable Windows i386 executable, while README keeps playability, function matching and whole-executable identity as separate statuses.
- [CorsixTH: an open reimplementation of Theme Hospital](https://awesomerea.org/resources/corsixth-engine-case/index.md): Case study · Reimplements the engine of Bullfrog’s 1997 Theme Hospital, with game logic in Lua and C++ for graphics, sound, movies and pathfinding, on top of the original game’s data files. The README reports that the full campaign can be completed, lists features that are still missing, and adds extensions such as high resolutions and a map editor. It recreates the game’s behaviour on original content.
- [OpenRiseOfNations: a native macOS engine reimplementation](https://awesomerea.org/resources/openriseofnations-engine-case/index.md): Case study · Reimplements the Rise of Nations: Extended Edition engine as a native macOS app with a Metal renderer, a deterministic simulation, a computer opponent and a compatible BigHugeScript compiler and virtual machine, loading art, maps, rules and scripts from the user’s own Windows installation. Subsystem specifications written from Ghidra study of the symbol-bearing executable, together with JavaScript reference tools, guided a C++17 implementation built with heavy Claude Code assistance. The alpha plays tutorials and scenarios, and its bit-exactness checks remain project-reported.
- [TH04: rebuilding Lotus Land Story’s four PC-98 programs from source](https://awesomerea.org/resources/th04-reconstruction-case/index.md): Case study · Reconstructs source for the Japanese PC-98 Touhou 4: Lotus Land Story and rebuilds all four DOS programs, MAIN.EXE, OP.EXE, MAINE.EXE and ZUN.COM, with a pinned Borland toolchain under Wine. Function acceptance against the original binaries is tracked separately from emulator replays that compare inputs, RNG, object pools and video with the original game. Complete-campaign, original-timing and byte-identity goals remain open.
- [inFAMOUS Second Son native PC port](https://awesomerea.org/resources/infamous-second-son-pc-port-case/index.md): Case study · Runs the PS4 inFAMOUS Second Son’s own x86-64 code natively on Windows and Linux: a runtime reimplements the PS4 system libraries the game uses, and a shadPS4-derived core translates its GPU commands and shaders to Vulkan. The project reports a playable, in-development port that reaches gameplay and the first chapters, with unstable performance and remaining graphics glitches. It is a compatibility-runtime port rather than a decompilation, and its results remain project-reported.
- [xoreos: an open reimplementation of BioWare’s Aurora engine family](https://awesomerea.org/resources/xoreos-aurora-engine-case/index.md): Case study · Reimplements BioWare’s Aurora engine and its later derivatives as a portable C++ engine that runs on the user’s installed game data, targeting nine games from Neverwinter Nights to Dragon Age II. Resource management, many Aurora file formats, graphics and sound are in place, and every target shows partial in-game areas in a free-flying spectator mode. README states that normal gameplay is not implemented yet.
- [librw: a re-implementation of the RenderWare Graphics engine](https://awesomerea.org/resources/librw-renderware-reimplementation-case/index.md): Case study · Re-implements a large part of the RenderWare Graphics middleware API as a portable C++ library that reads and writes its DFF model and TXD texture files for PS2, D3D8, D3D9 and Xbox and is meant to convert them between platforms. Direct3D 9 and OpenGL backends render the scenes, while PS2 rendering works only as a test. README names rendering GTA as its use; BSP world files are not supported.
- [Super Mario Odyssey: per-function matching decompilation of the Switch executable](https://awesomerea.org/resources/odyssey-decomp-case/index.md): Case study · Reconstructs C++ source for Super Mario Odyssey’s Switch 1.0 main executable and checks each function against the original AArch64 machine code with the shared nx-decomp-tools checker. At the pinned commit its function list marks 18,996 of 74,171 functions matching. The README warns that the build remains an unplayable source reconstruction, the repository ships no game assets, and Nintendo libraries such as sead and agl come from open-ead’s separate reconstructions.
- [Star Fox 64: a complete matching Nintendo 64 decompilation](https://awesomerea.org/resources/sf64-matching-decomp-case/index.md): Case study · Reconstructs C source for the US 1.1 (Rev A) Nintendo 64 release of Star Fox 64 that, compiled with the IDO compiler through a static recompilation, rebuilds a ROM with the published MD5; the README badge counts all 2,951 functions as matching. Code and assets are split from the user’s own ROM at build time, and the repository contains no assets or assembly. The separately curated Starship PC port compiles this C code, while Starfox 64: Recompiled takes headers and some functions from it for its patches.
- [Metroid Prime: the PrimeDecomp matching GameCube decompilation](https://awesomerea.org/resources/primedecomp-metroid-prime-decomp-case/index.md): Case study · Reconstructs C++ source for Metroid Prime’s GameCube executable and its NES-emulator module so that CodeWarrior builds match the originals, across the USA, Korean, PAL and Japanese releases, with early configurations for demo discs and three Wii releases. Matched units are compiled from source and linked with objects split from the user’s disc, then checked against per-version SHA-1 hashes; the repository contains no game assets or assembly. The separately curated Metaforce and Metroid Prime Port build their native ports on this code.
- [Batla 3D server emulator (2015 client)](https://awesomerea.org/resources/batla-3d-server-emulator-case/index.md): Case study · C# server emulator for the 2015 Steam client of Batla 3D, covering HTTP account, shop and room services and Lidgren UDP gameplay. It includes a client-assembly patcher and protocol notes that distinguish recovered client evidence from emulator rules.
- [RSDKv4 Decompilation: Retro Engine v4 and the Sonic 1 & 2 (2013) menus](https://awesomerea.org/resources/rsdkv4-sonic-1-2-decomp-case/index.md): Case study · Decompiles Retro Engine (RSDK) v4, the engine behind Sonic the Hedgehog and Sonic the Hedgehog 2 (2013), together with the games’ natively coded menus, and builds it for Windows, Linux and Android. The engine runs the game scripts contained in the official releases’ data files, which users must supply. The project adds a script compiler, a mod loader and an experimental online mode for Sonic 2’s 2P VS; it is the predecessor of the same group’s RSDKv5 decompilation.
- [OpenRW: an open re-implementation of the Grand Theft Auto III engine](https://awesomerea.org/resources/openrw-gta3-engine-case/index.md): Case study · Re-implements Rockstar Games’ Grand Theft Auto III (2001) as a cross-platform C++ engine that runs on the data of a legitimate PC copy. It has its own loaders for the game’s RenderWare models, textures and archives, a script machine for the original mission scripts, and an optional Qt data viewer. Playability is partial: the project’s mission tracker marks six early Portland story missions as completable.
- [CoD4 Rewrite: Rust/Bevy reconstruction](https://awesomerea.org/resources/cod4-rewrite-reconstruction-case/index.md): Case study · A Rust/Bevy reconstruction of Call of Duty 4 multiplayer systems, using assets from a local game installation. Source covers menus, local bots, movement and combat, and connects custom relay-based netplay to the game.
- [libd2: Diablo II 1.14d engine-core libraries](https://awesomerea.org/resources/libd2-engine-core-reconstruction-case/index.md): Case study · Zig libraries reconstructing Diablo II 1.14d seeded maps, item generation, saves, simulation rules and network formats. Selected components expose native and WebAssembly interfaces; verification notes distinguish retail map comparisons from weaker subsystem evidence.
- [Underworld Exhumed: reconstructing Ultima Underworld I and II](https://awesomerea.org/resources/underworld-exhumed-case/index.md): Case study · Pairs reconstructed DOS sources with native ports of Ultima Underworld I and II. The upstream documents Exhume-based byte-matching builds, routine-level comparisons and recorded-session replay against DOS.
- [LineWars II: a portable SDL3 reconstruction](https://awesomerea.org/resources/linewars-ii-sdl-case/index.md): Case study · Provides an SDL3 backend for a portable-C reconstruction of the 1994 DOS game. Its build configuration links the reconstructed engine to video, input and audio adapters; the upstream documents differential gates against original machine code.
- [BFM-decomp: Brave Fencer Musashi matching decompilation](https://awesomerea.org/resources/bfm-decomp-case/index.md): Case study · Documents an agent-assisted reconstruction of the USA PlayStation game with a pinned compiler and whole-binary SHA-1 gates. The verification recipe covers the main executable, resident engine and disc-loaded code modules, with explicit library and assembly exceptions.
- [Snowboard Kids: an agent-assisted N64 matching decompilation](https://awesomerea.org/resources/snowboardkids-matching-decomp-case/index.md): Case study · A matching decompilation of the original Nintendo 64 Snowboard Kids that rebuilds SHA1-identical North American and Japanese ROMs from a user-supplied ROM. The author’s 84-day post-mortem describes coding agents run through his Nigel harness alongside m2c, the permuter and a shared file of compiler learnings, and declines to credit LLMs alone for the speed-up. It is a separate project from the Snowboard Kids 2 decompilation.
- [Sonic Advance 3: an AI-assisted match of one enemy module](https://awesomerea.org/resources/sa3-marun-ai-decomp-case/index.md): Case study · Macabeus’s dated study describes prompting Claude Sonnet 3.5 and DeepSeek R1 with assembly, similar decompiled functions and structs to write matching C for Marun, one enemy module of the community Sonic Advance 3 GBA decompilation. The resulting pull request replaced that module’s assembly and was merged; the author calls the setting unusually AI-friendly, and the project now bars LLM-origin contributions.
- [pw: a matching decompilation of the Pokéwalker firmware](https://awesomerea.org/resources/pokewalker-matching-decomp-case/index.md): Case study · Reconstructs as C the firmware of the Pokéwalker, the pedometer accessory for Pokémon HeartGold and SoulSilver, for its Renesas H8/38606 microcontroller. With artwork from the user’s retail firmware image and a supported Renesas compiler suite, the README reports a byte-identical rebuild of the 48 KiB image; without that image, original placeholder art gives a non-matching reference build. The author describes disassembling and decompiling the retail binary, the HeartGold/SoulSilver ROMs and the candidate compilers, alongside published hardware research.
- [wii-ipl: a decompilation of the Wii Menu (System Menu 4.3)](https://awesomerea.org/resources/wii-menu-ipl-decomp-case/index.md): Case study · A work-in-progress decompilation of the Wii Menu, the console’s System Menu (IPL), targeting version 4.3 in its USA, European, Japanese and Korean builds. It recovers the menu’s own code together with the Revolution SDK, NintendoWare (NW4R), EGG and middleware libraries linked into it, matched unit by unit against the original executable with decomp-toolkit and objdiff. The repository holds no assets or assembly; a build needs the user’s own Wii Menu WAD and yields only main.dol.
- [sead: a decompilation of Nintendo’s first-party C++ standard library](https://awesomerea.org/resources/sead-nintendo-library-decomp-case/index.md): Case study · Decompiles sead, the C++ standard library that Nintendo statically links into its first-party games, covering containers, heaps, strings, math, file devices, threads, the game framework and graphics. Compile-time presets target the recent versions used by Breath of the Wild, Super Mario Odyssey, Splatoon 3, Tears of the Kingdom and Super Mario Bros. Wonder, and game decompilations such as Breath of the Wild pull it in as a submodule. Names come from debugging symbols and assertions in retail titles, and the README warns that many inlined and templated names are guesses.
- [Animal Forest: an in-progress matching N64 decompilation](https://awesomerea.org/resources/animal-forest-n64-decomp-case/index.md): Case study · Rebuilds the Japanese Nintendo 64 release of Animal Forest (Dōbutsu no Mori) from C code reverse-engineered from the ROM, combined with assets and assembly extracted from a user-supplied ROM. Default builds compare the uncompressed and recompressed ROMs with stored MD5 checksums. The README rules out use as a port base or for commercial purposes, and decomp.dev reported 18.52% of code matched at the reviewed commit.
- [Phantom Hourglass: an early-stage matching Nintendo DS decompilation](https://awesomerea.org/resources/phantom-hourglass-ds-decomp-case/index.md): Case study · Recreates C++ source for The Legend of Zelda: Phantom Hourglass by hand-decompiling its European and US Nintendo DS releases, using the dsd toolkit to delink code from a user-supplied ROM and rebuild the ROM. objdiff tracks matches function by function, and the default build compares the output ROM with a stored SHA-1. The work is at an early stage: decomp.dev reported 2.82% of code matched at the reviewed commit.
- [Kinoko: reimplementing Mario Kart Wii’s physics engine for exact ghost replay](https://awesomerea.org/resources/kinoko-mkwii-physics-reimplementation-case/index.md): Case study · Re-implements Mario Kart Wii’s physics engine in C++ as a command-line simulator, continuing stblr/Hanachan’s goal of perfectly accurate time-trial ghost replay. Each test case replays a recorded ghost through the engine and compares kart position, rotation, velocities, speed and checkpoint state frame by frame with a trace captured from the original game. It reimplements only the physics behavior and runs through a command-line interface without a graphical frontend.
- [Mario Kart: Double Dash!!: a matching GameCube decompilation of the debug build](https://awesomerea.org/resources/mario-kart-double-dash-decomp-case/index.md): Case study · A work-in-progress 1:1 decompilation of Mario Kart: Double Dash!! that rebuilds the GameCube main.dol of the US debug build (MarioClub_us) from C and C++ with the original Metrowerks compilers, checking it against a stored SHA-1. The build splits the binary from a user-supplied disc image, and objdiff compares objects during development. decomp.dev reported 47.09% of code matched at the reviewed commit; a European retail target is configured but marked as not working yet.
- [3S Decomp: a byte-compared PS2 decompilation of Street Fighter III: 3rd Strike](https://awesomerea.org/resources/sfiii-3rd-strike-ps2-decomp-case/index.md): Case study · Decompiles the PlayStation 2 executable of Street Fighter III: 3rd Strike from Street Fighter Anniversary Collection into C that period Metrowerks and EE GCC compilers rebuild, then compares the rebuilt executable word by word with the user’s original. README reports the game code fully decompiled and the CRI middleware partly so. The separate 3SX native port describes itself as this project’s continuation.
- [Halo: Combat Evolved: an incremental re-implementation patched into the original Xbox executable](https://awesomerea.org/resources/halo-ce-xbox-reimplementation-case/index.md): Case study · A research project re-implementing the original Xbox Halo: Combat Evolved in C, one function at a time. Rewritten functions are compiled into a separate image and patched into the user’s original executable with redirects from the original implementations, so the hybrid game can be run and debugged in xemu or on an Xbox as work progresses. The project reports an early stage, and its sources document no byte-for-byte comparison with the original code.
- [Paper Mario: The Thousand-Year Door: an early matching GameCube decompilation](https://awesomerea.org/resources/paper-mario-ttyd-decomp-case/index.md): Case study · A work-in-progress matching decompilation of Paper Mario: The Thousand-Year Door that targets the Japanese Rev 0 GameCube release (G8MJ01), rebuilding MarioSt.dol and 31 REL modules with the original Metrowerks compilers and checking each against a stored SHA-1. The build splits these binaries from a user-supplied disc image, and objdiff compares objects during development. decomp.dev reported 12.10% of code matched at the reviewed commit.
- [3SX: a native Street Fighter III: 3rd Strike port continuing the PS2 decompilation](https://awesomerea.org/resources/3sx-third-strike-native-port-case/index.md): Case study · Builds Street Fighter III: 3rd Strike as native C for Windows, macOS and Linux, continuing the 3s-decomp PS2 decompilation, with SDL3 for video, input and audio and GekkoNet for rollback netplay. README stresses that it is neither a recompilation nor emulation. The port needs the player’s own PS2 game files and works toward arcade-accurate balance, which an optional Statcheck build tests against CPS3 RAM states recorded from Fightcade replays.
- [re4: a byte-identical decompilation of the Resident Evil 4 GameCube debug build](https://awesomerea.org/resources/re4-gamecube-debug-decomp-case/index.md): Case study · Reconstructs C and C++ source for the two-disc Resident Evil 4 GameCube debug prototype (G4BE08) and rebuilds main.dol and all 114 REL overlays with the compilers the README names, checking every output against a SHA-1 list. Function names are Capcom’s own from the debug build’s Bio4.sym files, and most struct and field names are aligned from the PS2 debug build’s debug information. The project’s research log says AI agents did the matching work; byte identity is project-reported.
- [Super Smash Bros. Brawl: an early matching Wii decompilation](https://awesomerea.org/resources/smash-bros-brawl-decomp-case/index.md): Case study · A work-in-progress matching decompilation of Super Smash Bros. Brawl that targets the USA Rev 2 Wii release (RSBE01_02), splitting main.dol and 126 REL modules from a user-supplied disc image and checking the rebuilt binaries against stored SHA-1 values. objdiff compares objects during development, and six other regional revisions are listed but commented out of the supported set. decomp.dev reported 1.27% of code matched at the reviewed commit.
- [re-plants-vs-zombies: decompiling and modernizing Plants vs. Zombies GOTY](https://awesomerea.org/resources/re-plants-vs-zombies-decomp-case/index.md): Case study · Reconstructs C++ source for Plants vs. Zombies on PopCap’s open-source SexyAppFramework, starting from an earlier community decompilation of version 0.9.9 and adding functionality reversed from the Game of the Year edition, with functions annotated by GOTY addresses. The project also modernizes the engine with current C++ and is replacing the DirectDraw and Direct3D 7 renderers with GLFW. It builds a fan executable that runs from an original game folder, aiming at a modernized, extensible game rather than an identical binary.
- [Sonic Advance 1 & 2: a matching GBA decompilation with widescreen ports](https://awesomerea.org/resources/sonic-advance-1-2-decomp-port-case/index.md): Case study · Reconstructs Sonic Advance and Sonic Advance 2 for the Game Boy Advance as C that rebuilds six hash-listed ROMs with SAT-R’s agbcc fork, and compiles the same code into widescreen SDL ports for Linux, macOS and Windows plus PSP and PS2 builds. README reports Sonic Advance 2 built entirely from C with about 60 functions still non-matching. Extracted graphics, music and data are committed, so the builds read no original ROM.
- [Paleblood: a functional decompilation of Bloodborne with its own runtime](https://awesomerea.org/resources/paleblood-bloodborne-functional-decomp-case/index.md): Case study · Rewrites code from Bloodborne’s PS4 executable (CUSA03173 with update 1.09) as readable C++, one function at a time, aiming at a native PC source port on a clean-room runtime of its own. It is a functional rather than matching decompilation: each replacement is hooked in, compared with the original machine code on recorded and generated inputs, and independently reviewed. Work is at an early stage: README reports 21 of 157,757 functions verified, and the game does not yet run on Paleblood’s own runtime.
- [Pikmin 2: a fully matched GameCube decompilation across five releases](https://awesomerea.org/resources/pikmin-2-matching-decomp-case/index.md): Case study · A fan decompilation of Pikmin 2 that rebuilds main.dol for five GameCube releases (USA retail, two USA demos, PAL and Japan) with the original Metrowerks compilers, checking each against a stored SHA-1. The build reads main.dol from the user’s own copy of each release. decomp.dev reported all code matched and fully linked for every version at the reviewed commit, and a non-matching mode builds the US DOL entirely from C++ for modding.
- [Gran Turismo 4: an agent-assisted PS2 engine matching decompilation](https://awesomerea.org/resources/gran-turismo-4-matching-decomp-case/index.md): Case study · Decompiles Gran Turismo 4’s PS2 engine executable (CORE.GT4, NTSC-U v1.01) into one C or C++ source per function for Sony’s ee-gcc 2.96, matching public libraries such as newlib and Expat from their own source. The README credits AI agents (Anthropic’s Claude) driving the project’s tools with most of the matching, each function accepted only on a compiler-and-judge comparison, and reports 95.4% of functions and 83.6% of code bytes matched for an October 2026 commit. A local full build links sources at their original addresses, fills the rest from disassembly and compares SHA-1 with the user’s executable.
- [Mario Kart Wii: an in-progress matching decompilation of the PAL release](https://awesomerea.org/resources/mario-kart-wii-decomp-case/index.md): Case study · A work-in-progress matching decompilation of Mario Kart Wii that targets the PAL release (RMCP01), rebuilding main.dol and the StaticR.rel module from C and C++ with Metrowerks compilers and checking both against stored SHA-1 values. The build splits these binaries from a user-supplied disc image, and objdiff compares objects during development. The README’s progress badges point to a decomp.dev page that did not resolve at review, and the default branch was last updated in September 2025.
- [Pinyon Shift: a ShiftGlue static recompilation of Forza Horizon for PC](https://awesomerea.org/resources/pinyon-shift-forza-horizon-recomp-case/index.md): Case study · Builds a native port of the Xbox 360 release of Forza Horizon by translating its PowerPC executable ahead of time into C++ with ShiftGlue, the author’s fork of ReXGlue, and compiling it on the player’s machine from their own disc. A renderer written for this game runs its GPU commands on Vulkan, and some translated library code, such as FMOD Ex DSP units, is replaced by independently written native code checked against the translated original. README presents it as a playable preview with rendering bugs and slowdowns.
- [Touhou 7: reconstructing Perfect Cherry Blossom 1.00b source](https://awesomerea.org/resources/th07-decomp-case/index.md): Case study · Reconstructs C++ source for the Windows executable of Touhou 7: Perfect Cherry Blossom 1.00b and its custom.exe configuration tool, built with the original Visual Studio .NET 2002 and DirectX 8 toolchain and compared function by function with the user’s originals through reccmp. The committed progress badges report th07.exe fully implemented at 99.78% accuracy and custom.exe fully matched. The README says the game should be fully playable, but a matching build trips the game’s integrity check, and the cross-platform ports live on separate branches.
- [DKC1Recomp: static recompilation of Donkey Kong Country](https://awesomerea.org/resources/dkc1-recomp-case/index.md): Case study · Statically recompiles the North American v1.0 SNES release of Donkey Kong Country into native Windows, macOS and iOS applications with a pinned fork of snesrecomp, which translates 65816 code to C and links it against a modelled SNES hardware runtime. Function boundaries, entry flag states and jump-table targets are ingested from a byte-identical community disassembly instead of discovered heuristically, and the game code is generated locally from the user’s verified ROM. Optional widescreen, CRT filters, MSU-1 music and a Dixie Kong Country variant are host-side additions to what the README calls a playable bring-up.
- [San Andreas Unity: a GTA San Andreas engine reimplementation in Unity](https://awesomerea.org/resources/san-andreas-unity-engine-case/index.md): Case study · Reimplements the Grand Theft Auto: San Andreas engine in Unity (C#), loading the archives, RenderWare models and textures, collision, animations, audio, text and item definitions from the user’s own PC installation. README says it will not be a complete reimplementation; it focuses on gameplay features, multiplayer and a framework for extending and modding the game through C# plugins. Development has stalled: the newest commit on any branch dates from 2022-09-30.
- [MinecraftLCE: an early-stage Minecraft: Nintendo Switch Edition decompilation](https://awesomerea.org/resources/minecraft-lce-switch-decomp-case/index.md): Case study · Decompiles Minecraft: Nintendo Switch Edition v1.0.17, a Legacy Console Edition release, into C++ that is compared function by function with the original executable using a patched Clang 4.0.1 and the open-ead Switch decompilation tools. The README explains the choice of the Switch build for its matchable Clang toolchain and type information, with names ported from the symbol-bearing Wii U Edition. At the reviewed commit the function list marks about 11% of functions decompiled, most of them matching; the result cannot run the game.
- [Final Fantasy VII: a matching PlayStation decompilation](https://awesomerea.org/resources/ff7-ps1-matching-decomp-case/index.md): Case study · Reconstructs C source for the US PlayStation release of Final Fantasy VII, aiming for code that compiles back to the original main executable and its game overlays. The build splits the user’s disc files with splat, compiles with period cc1-psx compilers and checks every rebuilt file against its SHA-1. A native build against the PsyZ PlayStation-library replacement is compiled in CI but is not documented as a playable port.
- [Mega Man X Recompiled: a snesrecomp static recompilation](https://awesomerea.org/resources/megaman-x-snes-recomp-case/index.md): Case study · Statically translates the 65816 CPU code of the SNES Mega Man X (USA Rev 1) to C with the snesrecomp framework; the PPU, audio, DMA and other hardware run in the framework’s runtime, and a LakeSnes-derived interpreter executes whatever the static pass cannot prove. The C is generated locally from the user’s ROM, with function names imported from community DiztinGUIsh annotations. Playable Zero, co-op and rollback netplay, X2/X3 boss weapons and adaptive widescreen are layered on top, using assets extracted locally from the user’s own sequel ROMs.
- [OpenSC4: an early open-source reimplementation of SimCity 4](https://awesomerea.org/resources/opensc4-simcity-4-reimplementation-case/index.md): Case study · Reimplements SimCity 4 as a Godot project in GDScript that reads DBPF archives, region folders and city saves from the user’s own SimCity 4 installation. The code draws a region view with city thumbnails and interface elements built from the game’s UI definitions, opens a saved city’s terrain and water in 3D, and includes a DAT explorer for previewing archive subfiles. It is an early, inactive engine case without simulation gameplay.
- [R.E.L.I.V.E.: an Oddworld Abe’s Oddysee and Abe’s Exoddus engine reimplementation](https://awesomerea.org/resources/relive-oddworld-abe-engine-case/index.md): Case study · Reimplements the engine of Oddworld: Abe’s Oddysee and Abe’s Exoddus as an open-source replacement executable that runs from the user’s own game folder. The team decompiled the original executables and replaced their functions incrementally, using injected DLLs that hook reimplemented code into the patched retail executable, then rewrote the result into a standalone cross-platform engine. The project site says both games are playable in their entirety, with bug fixes and windowed, high-resolution and controller play.
- [Age of Empires Free Software Remake: a re-implementation on the original data](https://awesomerea.org/resources/aoe-free-software-remake-case/index.md): Case study · Re-implements Microsoft’s Age of Empires and its Rise of Rome expansion as a cross-platform C++17 engine on SDL2 and OpenGL that loads the original game’s DRS archives and language.dll resources. README says it mimics the Windows API and the Genie engine for compatibility and reconstructs some code from the disassembly; the repository adds format notes and Python tools for inspecting the original data files. Only very basic gameplay through a multiplayer session exists so far, so it is an early engine case rather than a playable replacement.
- [God of War PS2 static recompilation: a native Windows port via PS2Recomp](https://awesomerea.org/resources/god-of-war-ps2-recomp-case/index.md): Case study · Statically recompiles the MIPS R5900 code of the NTSC-U PlayStation 2 God of War executable (SCUS-97399) to C++ with PS2Recomp and builds it as a native Windows program. Since October 2026 the port builds on Waffle565’s runtime, which replaces the PS2 hardware with native code: VU1 microprograms and, optionally, the game’s IRX modules are compiled ahead of time, and an OpenGL renderer stands in for the GS. The repository holds only the game-specific function map, recompiler configuration, overrides and runtime patches; the README reports gameplay on the opening ship level, with sustained 60 fps and a full playthrough still pending.
- [RaceWave46: an AI-assisted Wave Race 64 recompilation for Windows](https://awesomerea.org/resources/racewave46-wave-race-64-recomp-case/index.md): Case study · Recompiles the USA Rev 1 Nintendo 64 release of Wave Race 64 into a native Windows application with N64Recomp and RSPRecomp, on modified copies of the N64ModernRuntime, RecompFrontend and RT64 stacks. Game and microcode C is generated locally from the user’s ROM, after an included widescreen patch is applied to a temporary copy, and checked against recorded checksums. The port adds higher resolutions, frame interpolation, ultrawide views, rasterized and ray-traced reflections and shadows, split-screen or separate-window two-player play and RetroAchievements; the maintainer calls it an AI-assisted recompilation.
- [Jazz² Resurrection: a native C++ reimplementation of Jazz Jackrabbit 2](https://awesomerea.org/resources/jazz2-resurrection-engine-case/index.md): Case study · Reimplements Jazz Jackrabbit 2 (1998) as a native C++ game on an extensively modified nCine engine, converting the user’s original game files into its own cache on first start. It runs on desktop, mobile, web and many homebrew console targets, with multiplayer, an enhanced Reforged mode and partial JJ2+ and MLLE support. A two-sided trajectory probe checks its non-Reforged movement against the original game, and the project reports 376 of 406 scenarios within 25 px/s.
- [LBA2 Remake: a Little Big Adventure 1 and 2 reimplementation in TypeScript and Three.js](https://awesomerea.org/resources/lba2remake-little-big-adventure-case/index.md): Case study · Reimplements the engine of Little Big Adventure 2, and now also Little Big Adventure 1, in TypeScript, Three.js and React so that it runs in a browser on resources imported from the user’s copy of the game. README calls it a full re-engineering rather than a disassembly-based approach: every island and building can be explored and most graphics and part of the gameplay work, but the game cannot yet be completed. It adds an editor with an actor-script debugger, VR support and fan-made 3D replacement models for the isometric scenes.
- [OpenAWE: an open reimplementation of Remedy’s Alan Wake engine](https://awesomerea.org/resources/openawe-alan-wake-engine-case/index.md): Case study · Reimplements Remedy Entertainment’s Alan Wake engine, later known as Northlight, in C++ and OpenGL, aiming to run Alan Wake and Alan Wake’s American Nightmare portably from the user’s game data, with Quantum Break and possibly Control as later goals. README documents only a free camera for moving through loaded game data, and the American Nightmare script table implements 16 of its 278 native functions. The repository also includes command-line tools for the games’ archive, texture, Havok and sound formats.
- [CPS-2 Recomp: static recompilation of Capcom CPS-2 and CPS-1 arcade games](https://awesomerea.org/resources/cps2recomp-arcade-static-recomp-case/index.md): Case study · Translates the 68000 game programs and Z80 sound programs of Capcom arcade boards ahead of time into C++ and runs them on a machine model written for the project, with an interpreter for code that has not been translated. One launcher covers Street Fighter Alpha and Alpha 2, Super Puzzle Fighter II Turbo, Vampire Savior and its variants, Vampire Hunter 2, Alien vs. Predator and the CPS-1 Cadillacs and Dinosaurs, adding training modes, widescreen and three-player options. Translated code is generated from the user’s own ROM sets, and a check build compares it block by block with the interpreter.
- [impacto: a reimplementation of the MAGES. visual-novel engine](https://awesomerea.org/resources/impacto-mages-engine-case/index.md): Case study · Reimplements the MAGES. visual-novel engine, used by the Science Adventure and Memories Off series, in C++ with OpenGL, running supported titles from the user’s original data files through per-game Lua profiles in one binary. README says all endings can be reached in at least one game, Memories Off 6 T-Wave, but no game is fully complete. The project’s tracking issue lists partial support for titles including Chaos;Head Love Chu Chu, Chaos;Child Love Chu Chu, Steins;Gate and Robotics;Notes Elite.
- [Wind Waker HD decompilation: functions verified against the recompiled Wii U game](https://awesomerea.org/resources/wind-waker-hd-decomp-case/index.md): Case study · Decompiles the USA Wii U release of The Wind Waker HD function by function into readable C++ in zeldaret/tww’s style, and verifies each function by running it beside the original, statically recompiled from the user’s own copy, comparing return values, memory writes and calls on generated and recorded inputs, with coverage and mutation checks. README reports 28,244 of the game’s 39,713 functions verified, including 22,068 of 22,215 GameCube-derived functions. The code calls undecompiled functions by address, so it runs only inside the ZeldaWWHDRecomp port, not as a standalone game build.
- [SiegeFX: a Dungeon Siege engine reimplementation in alpha](https://awesomerea.org/resources/siegefx-dungeon-siege-engine-case/index.md): Case study · A C#/.NET 10 engine loads Dungeon Siege's original archives, scripts and models, with published alpha builds and an audit/parity ledger. The project also provides SiegeSmith modding tools, while describing remaining fidelity and playthrough risks.
- [Legend of Legaia: a Rust port with disc-local browser tooling](https://awesomerea.org/resources/legend-of-legaia-rust-port-case/index.md): Case study · A from-scratch Rust port of the North American PlayStation Legend of Legaia includes native/browser play, asset extraction and disc patching. The author documents Ghidra/emulator research and a full-game ladder for this fresh implementation.
- [RSDKv3 Decompilation: Sonic CD (2011) on a reconstructed Retro Engine v3](https://awesomerea.org/resources/rsdkv3-sonic-cd-decomp-case/index.md): Case study · Reconstructs Retro Engine v3, the engine behind the 2011 Sonic CD remaster, as a native C++ source port for Windows, Linux, macOS and Android. The engine runs the game's own scripts and assets from an official release, which the repository does not ship, and adds a mod loader, a settings file with remappable controls, support for the mobile versions' updated scripts and extra developer-menu debug keys. Its license describes the code as mostly functionally the same as the original rather than byte-matching; the same team's RSDKv5 decompilation is listed as a separate case.
- [ICO decompilation: byte-identical PAL and Japanese PlayStation 2 boot ELFs](https://awesomerea.org/resources/ico-matching-decomp-case/index.md): Case study · Rebuilds the boot ELFs of ICO’s PAL (SCES-50760) and Japanese (SCPS-11003) PlayStation 2 discs from one source tree with the game’s original compiler versions, and checks that every loaded byte and the whole ELF file match the disc’s SHA-1. The 73 data-only archive members are generated at build time from the user’s own ELF, so most read-only data still comes from the disc rather than from source. Separate branches target the USA, Korean and August 2001 prototype builds, and the catalog’s ICO PC port is a fork of this tree.
- [game-and-watch-patch: Nintendo Game & Watch custom firmware](https://awesomerea.org/resources/game-and-watch-patch-cfw-case/index.md): Case study · Custom firmware for the Mario and Zelda Game & Watch consoles that patches new C code into the user's own stock firmware backups, so the original firmware runs alongside the retro-go emulator. A Python patcher hooks stock function calls, relocates and LZMA-compresses stock code and data to free flash, and can merge both models' firmware into one image. Committed symbol maps, a cross-reference mapper and an analysis-ELF builder support the reverse engineering, and a journal records the author's first firmware-patching work.
- [IW4L: a Rust runtime that plays Modern Warfare 2 from the user’s installed game](https://awesomerea.org/resources/iw4l-mw2-rust-runtime-case/index.md): Case study · Implements a standalone runtime for Call of Duty: Modern Warfare 2 (2009) in Rust on Bevy and wgpu, loading maps, models, textures and weapons from the user’s installed game through native FastFile readers and translating its Direct3D 9 shaders to WGSL. Bots, demo recording and replay, and multiplayer over custom UDP with a QUIC master are implemented, while README warns that gameplay remains incomplete, with missing behavior, bugs and desyncs. README states that the whole project is written by an LLM; NOTICE names the community projects consulted and says the original binaries were read with Ghidra.
- [Skate 3 Rust Engine: a Bevy rewrite built on Skate 3 reverse-engineering research](https://awesomerea.org/resources/skate-3-rust-engine-case/index.md): Case study · Reimplements Skate 3’s skating, tricks, grinds and offboard movement in a new Rust and Bevy engine that runs on assets converted from the user’s own Xbox 360 copy, adding difficulty settings and a .skate custom-map format. Physics notes cite functions and constants read from the original executable in IDA, and audio research reads traces from a research-hooks branch of a separate Skate 3 static recompilation. README says gameplay parity is still a work in progress, credits dumbad’s years of format research and states that AI coding tools were used to write the rewrite.
- [Bravo: a reverse-engineered Minecraft server](https://awesomerea.org/resources/bravo-minecraft-server-case/index.md): Case study · Reimplements the server side of Minecraft’s Alpha- and Beta-era multiplayer in Python on Twisted; its documentation calls it a reverse-engineered implementation written from scratch, credits network traffic dumps and says general Minecraft data went to a community wiki. The final 2.0 release speaks the 1.4.x client protocol for login, chunk transfer, entities, server-side inventories, lighting, physics and Anvil saves, while deliberately changing behaviour such as chunk loading and item stacking. A pluggable architecture adds terrain generation, seasons and commands, and small scripts inspect packets, NBT and region files.
- [Weeping of the Empire: statically recompiling Tears of the Kingdom for Windows](https://awesomerea.org/resources/weeping-of-the-empire-case/index.md): Case study · Weeping of the Empire builds a native Windows port of The Legend of Zelda: Tears of the Kingdom from the user's Switch game dump. It recompiles ARM64 code ahead of time to x86-64, supplies Switch services through a host runtime and renders through Vulkan. The engine documentation credits totk-recomp as the starting point and identifies the added Windows port, renderer, controls and menus.
- [GTA Mode: reverse-engineering SimCity 3000 Unlimited for a native plugin](https://awesomerea.org/resources/simcity-3000-gta-mode-case/index.md): Case study · GTA Mode is a native plugin that adds direct control of spawned citizens and cars to SimCity 3000 Unlimited. It uses findings from Ghidra analysis of the game's binaries, GZCOM plugin loading, in-memory city structures and sprite archives. The C plugin runs in the original game, reads city data from its memory and decodes art from the user's installation; MODLOG.md records addresses, formats and dead ends.
- [FH2MP: reconstructed Forza Horizon 2 online services](https://awesomerea.org/resources/fh2mp-case/index.md): Case study · FH2MP restores Forza Horizon 2 multiplayer with a replacement server based on protocol behavior recovered from the Xbox One game client. An in-game shim redirects sockets and web-service calls, while Python and Go servers handle lobbies, worlds and online features; a launcher manages setup and updates.
- [Cursed Lands: a Godot engine for Evil Islands and Lost in Astral](https://awesomerea.org/resources/cursed-lands-case/index.md): Case study · Cursed Lands reimplements the engine for Evil Islands and Lost in Astral in Godot, reading maps, models, audio, scripts and tables from the player's own game copy. Its native rendering, combat, AI, scripting and interface systems follow the original game's rules, with releases for desktop, Android and browsers.
- [nfs-mw: a Rust reconstruction of Need for Speed: Most Wanted](https://awesomerea.org/resources/nfs-mw-case/index.md): Case study · nfs-mw reconstructs Need for Speed: Most Wanted 2005 PC v1.3 in Rust using data read from the user's installation. Its format readers decode bChunk, JDLZ, HUFF, cars, textures, and the streamed city; the current runtime provides viewers, driving, menus, and free roam.
- [bf-private-server: a Brave Frontier revival server](https://awesomerea.org/resources/bf-private-server-case/index.md): Case study · bf-private-server recreates a self-hosted server for Brave Frontier client version 2.19.6. Its C++23 service answers the game's HTTP requests, stores saves in SQLite and works with CDN workers and a patcher for the user's Android client; request tables and boot-flow notes document the protocol investigation. The server builds on an earlier emulator fork.
- [OpenLF2: a Little Fighter 2 engine reimplementation](https://awesomerea.org/resources/openlf2-case/index.md): Case study · OpenLF2 reimplements Little Fighter 2 v2.0a as a playable C++ and Lua engine. It loads resources from the original game installer and provides local modes, replays, mods and network matches between OpenLF2 players. The author states that gameplay compatibility is still being refined.