# Curated reverse engineering resources · Page 6

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

## Games (100)

- [Atlantis Native: porting the Atlantis and Atlantis II engines to Rust](https://awesomerea.org/resources/atlantis-native-case/index.md): Case study · Atlantis Native ports the reverse-engineered CryOmni3D Atlantis engine to Rust for Atlantis: The Lost Tales and Atlantis II. It reads files from the user's own game copies and runs their scripts, panoramas, cinematics and puzzles on desktop systems and in browsers, with optional display and bug fixes.
- [SF2Recomp: statically recompiling Shadow Fight 2 for native platforms](https://awesomerea.org/resources/sf2recomp-case/index.md): Case study · SF2Recomp converts a user's Shadow Fight 2 Nintendo Switch game files into native builds for Linux, Windows, macOS, and Android. Its converter combines translated game code with a runtime and user-supplied assets, adding controls, graphics options, sparring, and LAN play.
- [Devil May Cry: an experimental PS2 static recompilation](https://awesomerea.org/resources/dmc-recomp-case/index.md): Case study · dmc-recomp translates the PlayStation 2 PAL release of Devil May Cry into native PC code through PS2Recomp and a project runtime. Its pipeline rebuilds generated code locally from the user’s own game executable, while research notes and patches track boot, CD services, MPEG playback, rendering and gameplay behavior.
- [Sin & Punishment: a work-in-progress N64 static recompilation](https://awesomerea.org/resources/sin-punishment-recompiled-case/index.md): Case study · Sin & Punishment: Recompiled uses N64Recomp and RSPRecomp to build an experimental native C++ port from a user-supplied Japanese N64 ROM and the repository's symbol maps, with RT64 rendering. The author reports that it reaches the title screen; menu navigation, gameplay, audio validation, and a public pipeline for its patched working image remain unfinished.
- [scvk: replacing SimCity 4's renderer with Vulkan](https://awesomerea.org/resources/scvk-case/index.md): Case study · scvk reconstructs SimCity 4's renderer interface as a native Vulkan DLL loaded through the game's GZCOM plugin system. It claims existing renderer class IDs and emulates the cIGZGDriver fixed-function API with pipeline state and shaders for terrain, buildings, lighting, textures and interface drawing.
- [Salamander UEFI: a disassembly-based UEFI port of the NES game](https://awesomerea.org/resources/salamander-uefi-case/index.md): Case study · Salamander UEFI ports the NES game Salamander to a native UEFI Shell application by translating its 6502 disassembly into a platform-independent C core. The repository includes a 6502 disassembler, a user-ROM resource extractor, host tests and a fidelity checklist. UEFI GOP, input and timing services replace the original console environment.
- [tMock-Server: reconstructing Terraria server handshakes](https://awesomerea.org/resources/tmock-server-case/index.md): Case study · tMock-Server is an unfinished C++ reimplementation of the Terraria server's initial network flow. It uses socket code and packet classes to accept connections, check protocol versions, request passwords, and assign player slots; the README records packet IDs, fields, directions, and structures informed by traffic analysis.
- [NuVelocity Engine: reimplementing Reflexive's Velocity Engine](https://awesomerea.org/resources/nuvelocity-engine-case/index.md): Case study · NuVelocity Engine reimplements Reflexive Entertainment's Velocity Engine as a C++ and SDL3 game engine. It provides modular 2D rendering, asset and resource loading, audio playback, screen management, and a property-based object system, with decoder source included in the repository.
- [FreeRS42: reimplementing Ricochet Xtreme](https://awesomerea.org/resources/freers42-ricochet-xtreme-case/index.md): Case study · FreeRS42 is a C++ project to reimplement the PC game Ricochet Xtreme using the NuVelocity engine. The repository contains source for game objects, playfield behavior and screens, with a CMake build that includes the engine submodule.
- [Metroid Dread: a hand decompilation in progress](https://awesomerea.org/resources/dreadcomp-case/index.md): Case study · DreadComp is an in-progress hand decompilation of Metroid Dread that recreates game source code in C++. The repository includes initial source files, build tooling and symbol data; building requires assets and the version 2.1.0 executable from the user's own game copy.
- [MTG Arena Collection Export: reconstructing the Frontdoor collection request](https://awesomerea.org/resources/mtg-arena-collection-export-case/index.md): Case study · MTG Arena Collection Export reconstructs the Frontdoor request needed to export owned cards from Magic: The Gathering Arena. The Python client uses an account refresh token, opens a TLS Frontdoor socket, authenticates with the 2026 version 4 frame and protobuf command envelope, and requests Card_GetAllCards. A separate protocol document records the recovered wire format.
- [Void Client: rebuilding the Starblast.io client](https://awesomerea.org/resources/void-client-case/index.md): Case study · Void Client is an unfinished JavaScript rewrite of the Starblast.io browser game client based on study of its network protocol. Its current Node.js and browser components provide game-mode selection, server discovery, local WebSocket communication, and parsing and JSON export of some received packets.
- [OpenPigeon: reconstructing GamePigeon iMessage game messages](https://awesomerea.org/resources/openpigeon-case/index.md): Case study · OpenPigeon is a TypeScript codec for reading GamePigeon iMessage game state and encoding caller-supplied moves for eleven turn-based games. Its protocol documentation describes balloon identity, encrypted move URLs, the length-seeded cipher and the state envelope; captured-message vectors support codec tests.
- [Cosmo: a native port of Cosmo's Cosmic Adventure](https://awesomerea.org/resources/cosmo-native-port-case/index.md): Case study · Cosmo ports the reconstructed source of Cosmo's Cosmic Adventure: Forbidden Planet to macOS, Linux and Windows. It retains the game's logic and supplies an emulated EGA adapter, timer, keyboard controller, PC speaker and AdLib layer for the original code. The build uses the user's game data files.
- [Left 4 Dead 2: recovering the AI Director's behavior](https://awesomerea.org/resources/l4d2-director-research-case/index.md): Case study · This Left 4 Dead 2 study reconstructs the AI Director's pacing, intensity, encounter placement and music rules from an identified x86 server.dll and sanitized runtime traces. It publishes disassembly-derived findings, analysis scripts, evidence files and implementation specifications; a reference game library is in a separate repository.
- [MechRewired: rebuilding MechWarrior 2 from original game data](https://awesomerea.org/resources/mechrewired-mechwarrior-2-case/index.md): Case study · MechRewired rebuilds the MechWarrior 2: 31st Century Combat experience around data imported from a user's DOS copy. Its code loads original resources and missions, while providing a new cockpit, terrain rendering and combat simulation for modern platforms.
- [d2mac-linux: porting the Diablo II Mac executable to 32-bit Linux](https://awesomerea.org/resources/d2mac-linux-case/index.md): Case study · d2mac-linux ports the Diablo II 1.14d Mac executable to 32-bit Linux by converting its i386 Mach-O container to ELF and reimplementing imported Darwin, Carbon and AGL interfaces in Zig. The shim translates graphics to GLX and adapts threading, files and sockets. The author reports that the game reaches its menu and character creation.
- [Spider-Man 2 PS2 Recomp: a static recompilation checkpoint](https://awesomerea.org/resources/spider-man-2-ps2-recomp-case/index.md): Case study · Spider-Man 2 PS2 Recomp applies static recompilation to the USA PlayStation 2 release SLUS-20776 for native PC execution. It combines a game-specific Ghidra function map with PS2Recomp source, runtime fixes and hardware comparison tests. The author reports that a native Windows build reaches the legal splash; the port is not playable.
- [touhou-engine: a Python reimplementation of Touhou gameplay](https://awesomerea.org/resources/touhou-engine-case/index.md): Case study · touhou-engine reimplements Touhou danmaku gameplay in Python, with TH07: Perfect Cherry Blossom as its reference game. The author says its engine logic was ported frame by frame against a decompilation, while the new architecture supplies an event stream, replay handling, headless stepping, and a pygame renderer. It reads original game archives supplied by the user.
- [OpenLara: Tomb Raider engine reimplementation](https://awesomerea.org/resources/openlara/index.md): Case study · Open-source engine for classic Tomb Raider, with a WebGL build and a standalone release. Its format code defines object types for Tomb Raider 1 through 4.
- [Thyme: Command & Conquer Generals: Zero Hour reimplementation](https://awesomerea.org/resources/thyme/index.md): Case study · Thyme is an open source reimplementation of Command & Conquer Generals: Zero Hour. It rewrites the game from the ground up and uses the original binary for functions it has not yet replaced.
- [Chariot: Age of Empires engine reimplementation](https://awesomerea.org/resources/chariot/index.md): Case study · Chariot is an open-source effort to reimplement the engine of the original Age of Empires (1997). It aims to support ports and enhancements; the README describes it as a work in progress with asset-loading demonstrations, not a playable game.
- [OpenDiablo2: Diablo 2 engine reimplementation](https://awesomerea.org/resources/opendiablo2/index.md): Case study · OpenDiablo2 is a cross-platform ARPG engine written in Go that supports playing Diablo 2. The project is being split into a separate engine and toolset, called Abyss Engine, and a game project retaining the OpenDiablo2 name.
- [OpenTomb: Tomb Raider engine reimplementation](https://awesomerea.org/resources/opentomb/index.md): Case study · OpenTomb is an open-source reimplementation of the classic Tomb Raider engine for playing levels from Tomb Raider 1–5 and custom TRLE levels. It is no longer maintained.
- [Savage Wind Recomp: statically recompiling The Legend of Zelda: Breath of the Wild](https://awesomerea.org/resources/savagewindrecomp/index.md): Case study · Savage Wind Recomp is an in-progress static recompilation of the Nintendo Switch version of The Legend of Zelda: Breath of the Wild for Windows and Linux. It builds native game code locally from the player's extracted files; the README reports playable early areas but says the full story remains unconfirmed.
- [retruxx: reverse-engineered Hard Truck Apocalypse](https://awesomerea.org/resources/retruxx/index.md): Case study · retruxx is a reverse-engineered Hard Truck Apocalypse project that builds the game executable and separate renderer, input, and sound DLLs. Its 32-bit build matches the original game's memory layouts.
- [COGBox: static recompilation ports of Xbox 360 Gears of War games](https://awesomerea.org/resources/cogbox-gears-native-case/index.md): Case study · COGBox packages native Windows ports of Gears of War 2, Gears of War 3, and Gears of War: Judgment built by translating Xbox 360 code to C++ ahead of time. A launcher imports the user's game copies and required title updates; the project supplies a Direct3D 12 renderer and experimental Vulkan option.
- [Downhill Revived: a matching decompilation and PC port of Downhill Domination](https://awesomerea.org/resources/downhill-revived-case/index.md): Case study · Downhill Revived ports the PlayStation 2 game Downhill Domination to native 64-bit Windows using C/C++ source matched byte for byte to the original game program. Native platform code replaces PS2 hardware interfaces, and game data is read from the user's USA disc image. The author reports 4,527 of 4,593 target game and engine functions matched.
- [Dark Souls PS2: a PlayStation 2 port of Dark Souls Remastered](https://awesomerea.org/resources/dark-souls-ps2-case/index.md): Case study · Dark Souls PS2 ports parts of Dark Souls Remastered to PlayStation 2 with a new C engine and hand-written VU1 programs. Python exporters convert maps, characters, animations, collision, scripts, and menus from the user's PC copy; executable findings document constants and rules used to reproduce behavior. The author describes it as an early prototype covering only the first few areas.
- [God of War — Native Port: a PS2 static recompilation with native hardware services](https://awesomerea.org/resources/god-of-war-native-port-case/index.md): Case study · God of War — Native Port translates the NTSC-U PlayStation 2 game's executable into C++ with PS2Recomp and supplies native replacements for graphics, sound, input, memory cards, and other PS2 services. The repository provides configurations, overrides, code generators, build instructions, and zone tests for its Windows port.
- [Colin McRae Rally 2005: an Xbox XBE recompilation for Windows](https://awesomerea.org/resources/colin-mcrae-rally-2005-recomp-case/index.md): Case study · A Colin McRae Rally 2005 port recompiles the US original-Xbox game for native Windows execution using Xbox XBE Recomp. The bundled runtime supplies Xbox kernel and XDK replacements, Direct3D 12 rendering, audio and controller support, while game code and assets come from the user's own copy. The port adds display settings and rendering fixes.
- [SWBF2 Browser Reconstruction: rebuilding Battlefront II maps in a browser](https://awesomerea.org/resources/swbf2-browser-reconstruction-case/index.md): Case study · SWBF2 Browser Reconstruction rebuilds parts of Star Wars Battlefront II (2017) in a three.js browser runtime using data extracted from the user's installed game. The pipeline converts Frostbite meshes, textures, lighting, animations, audio and gameplay values; its reference scene is Death Star II with Blast and Free for All modes.
- [Aion 2: reconstruction of the client-to-server network protocol](https://awesomerea.org/resources/aion2-protocol-research-case/index.md): Case study · Aion 2 Network Protocol Research reconstructs parts of the game's client-to-server network protocol from captures and client inspection. It documents unsigned-varint framing, LZ4 bundles, an RSA-OAEP-SHA1 world handshake and continuous RC4 over post-handshake client frame bodies. Python tools analyze captures, recover session material and implement client cryptographic primitives.
- [Crysis 2: running the Mod SDK's x64 engine as a game client](https://awesomerea.org/resources/crysis2-64bit-case/index.md): Case study · crysis2-64bit launches Crysis 2 through the x64 engine DLLs supplied with its Mod SDK. The accompanying findings investigate a 64 FPS timer ceiling, renderer faults and truncated pointers in engine modules, while the launcher applies targeted runtime corrections and borderless display handling.
- [th06-headless: deterministic Touhou 6 logic runtime](https://awesomerea.org/resources/th06-headless-case/index.md): Case study · th06-headless adapts reconstructed Touhou 6 game logic into a deterministic Linux runtime for replay and learning research. It removes window, audio and frame-pacing requirements, accepts seeded per-tick actions, exports JSONL state, and offers a lockstep observation/action interface. The fork builds on GensokyoClub/th06 and uses the user's original Japanese game data.
- [pc-dragonquestswords: a partial static recompilation of Dragon Quest Swords for PC](https://awesomerea.org/resources/pc-dragonquestswords-case/index.md): Case study · pc-dragonquestswords ports the European Wii release of Dragon Quest Swords toward native PC execution by statically recompiling its PowerPC code to C++ and providing a replacement runtime through wiikit. Its notes map the disc, FPK archives and stripped executable; the author reports that the current port reaches the opening and early tutorial battles.
- [pc-virtualhydlide: statically recompiling Virtual Hydlide for PC](https://awesomerea.org/resources/pc-virtualhydlide-case/index.md): Case study · pc-virtualhydlide ports the European Sega Saturn release of Virtual Hydlide toward PC by statically recompiling fifteen SH-2 programs to C++ and running them with saturnkit. Its notes document disc structure, game files, executable behavior, video and sound; the author reports playable output and an optional interpolated display between the game's logic frames.
- [WCW Nitro: a checksum-checked PlayStation decompilation](https://awesomerea.org/resources/wcw-nitro-decomp-case/index.md): Case study · WCW Nitro is a PlayStation game decompilation that rebuilds code from the SLUS_003.97 executable and WGAME.BIN and WMENU.BIN overlays. Its source tree contains reconstructed C files and build configurations; users supply files from their own disc, then run a checksum check on the generated binaries.
- [geow2: a native Geometry Wars: Retro Evolved 2 port](https://awesomerea.org/resources/geow2-case/index.md): Case study · geow2 rebuilds Geometry Wars: Retro Evolved 2 as a native Windows, macOS, and Linux game based on analysis of the Xbox 360 executable. It implements the six original modes and local multiplayer, while a bundled extractor prepares data from the player's own XBLA release.
- [Top Spin 4 decompilation: matching Xbox 360 functions against three XEX modules](https://awesomerea.org/resources/top-spin-4-decomp-case/index.md): Case study · Top Spin 4 decompilation reconstructs C source for the Xbox 360 game and compares compiled functions against code in three retail XEX modules. The repository includes reconstructed functions, Ghidra analysis tooling, build configuration and progress reports; the author reports partial exact compiler matches.
- [Adventure Island II: a static recompilation of the NES game](https://awesomerea.org/resources/adventure-island-ii-nes-static-recomp-case/index.md): Case study · Adventure Island II is statically recompiled from its NES ROM into a generated C catalog of fixed bank and program-counter identities for a native Windows frontend. The runtime includes NES CPU bus, PPU, APU, DMA, controls and MMC3B mapper behavior, validates a user-supplied USA ROM by SHA-256, and stops on unknown execution identities.
- [SimCity 4 Deluxe: static recompilation from the Steam executable](https://awesomerea.org/resources/simcity-4-static-recompilation-case/index.md): Case study · SimCity 4 Deluxe statically recompiles the user's Steam game executable into locally generated C with pcrecomp and runs it in a native32 host. The repository supplies setup, lift and runtime code while excluding generated game source and assets. The author reports that scripted runs load a region and city, simulate a month and save data the original game can load.
- [NHL 14 Recomp: a static Xbox 360 recompilation and franchise-mode investigation](https://awesomerea.org/resources/nhl-14-recomp-case/index.md): Case study · NHL 14 Recomp translates a user-supplied Xbox 360 NHL 14 executable into C++ for a native PC build using ReXGlue. The repository also provides host runtime code, save and roster tools, and documented findings about Be a GM rules derived from game code and saves.
- [Solomon's Key: byte-identical source reconstruction of three NES releases](https://awesomerea.org/resources/solomons-key-nes-reconstruction-case/index.md): Case study · Solomon's Key NES source reconstruction rebuilds the USA, European, and Japanese releases from shared ca65 assembly. The build extracts private CHR data from a user-supplied ROM, then compares rebuilt revisions byte for byte with the originals. Documentation covers the game architecture, RAM map, data formats, and subsystem behavior.
- [Need for Speed: Porsche Unleashed: differential x86 source recovery](https://awesomerea.org/resources/nfs-porsche-unleashed-recovery-case/index.md): Case study · prsche-disasm recovers C/C++ source for Need for Speed: Porsche Unleashed from its Windows x86 binaries. It indexes original modules and addresses, studies resource formats, and compares recovered functions with recorded original inputs, state, outputs, and ABI behavior. The recovered C++ modules build separately, but the full game does not yet link into a playable executable.
- [inFAMOUS: First Light — a native Windows port through a PS4 compatibility runtime](https://awesomerea.org/resources/infamous-first-light-pc-edition-case/index.md): Case study · inFAMOUS: First Light — PC Edition runs the user's PS4 game files on Windows through a compatibility runtime while executing the game's x86-64 code on the PC CPU. It adds First Light-specific imports, system services, and hash-checked engine hooks to a runtime shared with Second Son, with a Vulkan 1.3 backend and GCN-to-SPIR-V shader translation. The author reports that the early build reaches open-world gameplay.
- [LittleBigPlanet PSP: a matching decompilation of EBOOT.BIN](https://awesomerea.org/resources/lbp-psp-decomp-case/index.md): Case study · LittleBigPlanet PSP reconstructs code from the game's UCUS98744 disc version 2.00 executable as C and C++. Its checker compiles each source with a recorded compiler profile and compares the resulting function bytes with the original. The author reports 5,020 individually matched functions; a whole-module build of the published proofs has not been measured.
- [GT5 Native Recomp: an early Gran Turismo 5 static recompilation](https://awesomerea.org/resources/gt5-native-recomp-case/index.md): Case study · GT5 Native Recomp is an early static recompilation of Gran Turismo 5 for Windows x86-64. Its pipeline lifts PS3 PPU and SPU code ahead of time into a native runtime that supplies PS3 services and uses Vulkan for RSX commands; the author reports reaching audio and controller initialization without a game frame.
- [RTAGlass: a Windows reimplementation of Road Trip](https://awesomerea.org/resources/rtaglass-case/index.md): Case study · RTAGlass reimplements the PS2 game Road Trip as a C++ Windows port. Its build analyzes the user's own USA disc image, generates tables and VU1 microcode conversions from the executable, converts models, textures and sound, and assembles a playable Windows build.
- [h4r: rebuilding the Heroes of Might and Magic IV engine](https://awesomerea.org/resources/h4r-case/index.md): Case study · h4r reimplements the Heroes of Might and Magic IV engine in Rust using data from a player's installation. It parses .h4r archives and .h4c maps, renders an adventure-map prototype and reconstructs selected movement and combat rules, with a separate harness comparing some rule outputs to the original executable.
- [Doraemon: a byte-identical Famicom source reconstruction](https://awesomerea.org/resources/doraemon-nes-source-reconstruction-case/index.md): Case study · Doraemon reconstructs the Japanese release of Hudson Soft's 1986 Famicom game as ca65 assembly source. The build extracts private assets from the user's ROM, assembles and links the source, then compares the resulting ROM byte for byte with the original. Documentation covers cartridge architecture, memory, subsystems, and data formats.
- [Scooby-Doo! Night of 100 Frights: matching GameCube decompilation](https://awesomerea.org/resources/scooby-doo-night-of-100-frights-case/index.md): Case study · The Scooby-Doo! Night of 100 Frights project reconstructs GameCube source for two USA disc revisions and builds main.dol executables checked against original SHA-1 hashes. It uses decomp-toolkit, target-specific split and symbol maps, compiler profiles and reconstructed C/C++ source. Users provide their own game disc; original disc files remain outside the repository.
- [Super Mario Galaxy 2: selected gravity behavior and format reconstruction](https://awesomerea.org/resources/smg2-reverse-engineering-case/index.md): Case study · Super Mario Galaxy 2: selected gravity behavior and format reconstruction implements host-side C++ versions of selected CubeGravity, PlanetGravity and PointGravity operations. It provides bounds-checked readers for Yaz0, RARC, U8, BCSV/JMap, Wii FST and selected J3D metadata, with synthetic-input tests.
- [Secret of Evermore: reconstructing ROM formats and game assets](https://awesomerea.org/resources/evermore-re-case/index.md): Case study · Secret of Evermore: reverse engineering documents the Europe/PAL game's ROM layout, compression, maps, sprites, text, scripts and audio. Python extractors use a user-supplied ROM; Mesen2 scripts capture game-rendered results, and Ghidra labels support routine analysis. A pygame viewer displays extracted maps and sprites.
- [Tekken 3 Recomp: lifting PlayStation game code into Rust](https://awesomerea.org/resources/tekken-3-recomp-case/index.md): Case study · Tekken 3 Recomp statically recompiles the US PlayStation release of Tekken 3 by extracting its MIPS executable and overlays from a user-supplied disc. Ghidra exports instructions and p-code to CSV sheets, a generator translates them into Rust, and a custom PlayStation runtime hosts the result inside a Bevy app.
- [Tekken 5 Recomp: statically recompiling the PS2 game to Rust](https://awesomerea.org/resources/tekken-5-recomp-case/index.md): Case study · Tekken 5 Recomp statically translates the PlayStation 2 game's Emotion Engine programs, IOP modules, and VU microcode into native Rust. Its pipeline extracts a user's disc image, analyzes programs with Ghidra, generates instruction sheets and Rust code, and runs the result in a Bevy app with a project-specific PS2 runtime.
- [Limbo: restoring Fortnite Save the World OT6.5 missions](https://awesomerea.org/resources/limbo-fortnite-ot65-case/index.md): Case study · Limbo restores mission play in the 2016 Fortnite Save the World OT6.5 client using an injected game-server DLL and a separate backend. Its development notes describe UE 4.12 name and object table discovery, ProcessEvent tracing, executable analysis and hooks used to rebuild mission behavior. The author reports up to four-player cooperative play, while some missions and enemy behaviors remain incomplete.
- [Rogue Byte: matching decompilation of Sly 2: Band of Thieves](https://awesomerea.org/resources/rogue-byte-sly-2-case/index.md): Case study · Rogue Byte reconstructs the USA PlayStation 2 release of Sly 2: Band of Thieves as readable C/C++ through a matching decompilation workflow. It splits a user-supplied executable, compiles recovered functions with the original compiler and checks the linked image byte for byte; the same C is also checked against the optional PAL executable.
- [rustify-doom: reconstructing Doom in Rust from a stripped binary](https://awesomerea.org/resources/rustify-doom-case/index.md): Case study · rustify-doom reconstructs the Doom engine in Rust from a stripped doomgeneric binary using Rustify. Its source covers game systems, rendering and SDL integration, and its compatibility report compares replay scenarios and recovered requirements against the original build with Freedoom data.
- [openSA: reimplementing the GTA San Andreas runtime](https://awesomerea.org/resources/opensa-case/index.md): Case study · openSA is an early C++ reimplementation of the GTA San Andreas runtime built on librw. It parses original IMG, IDE, IPL, model and texture data, and supplies viewers for streaming world geometry. The author documents comparisons with the owned 1.0 US executable while noting that the result is not yet a playable game.
- [Pokémon Dash: a byte-matched Nintendo DS decompilation](https://awesomerea.org/resources/pokemon-dash-decomp-case/index.md): Case study · pokemon-dash-decomp reconstructs source for the USA Nintendo DS release of Pokémon Dash and checks functions against exact compiled bytes while rebuilding the ROM byte for byte. It uses Metrowerks mwccarm and contains generated source, configuration and progress data; the author reports partial code matching.
- [LMA Manager 2007: an Xbox 360 static recompilation in Rust](https://awesomerea.org/resources/lma-2007-static-recomp-case/index.md): Case study · LMA Manager 2007 statically translates the Xbox 360 game's PowerPC code into Rust from a user's disc image. A native runtime replaces console kernel, graphics and audio services, and the repository includes XEX loading, decoding, translation and application crates. The author reports that the game plays with career mode, 3D matches, saves and sound.
- [Rollerbot: a reconstructed Android and Linux runtime](https://awesomerea.org/resources/rollerbot-android-case/index.md): Case study · Rollerbot-Android reconstructs the 2000 game Rollerbot: A Time Journey for Android and Linux from its original scripts and user-supplied assets. It implements gameplay, scene, audio and platform components, with an Android disc importer and a Linux Flatpak. Supporting notes map Direct3D Retained Mode call sites in the original executable.
- [Kuru Kuru Kururin: functional GBA decompilation and PC port](https://awesomerea.org/resources/kururin-case/index.md): Case study · kururin reconstructs the European Game Boy Advance Kuru Kuru Kururin in C for functional rather than byte-identical behavior, and builds an SDL2 PC port for Linux and Windows. The author's reported tests run the original and rebuilt ROMs side by side through recorded input, comparing RAM, sound and video; the port loads game data from the user's own ROM.
- [pc-finalfantasy12revenantwings: a static recompilation port of Final Fantasy XII: Revenant Wings](https://awesomerea.org/resources/pc-finalfantasy12revenantwings-case/index.md): Case study · pc-finalfantasy12revenantwings ports the European Nintendo DS release of Final Fantasy XII: Revenant Wings to PC by statically recompiling its ARM9 and ARM7 programs and six overlays to C++. The ndskit runtime replaces DS hardware, while repository tools and notes examine the cartridge, packed data, movies and executable layout. The author reports playing from a new game into the second chapter.
- [Snowboard Kids Plus: a matching PlayStation decompilation](https://awesomerea.org/resources/snowboard-kids-plus-case/index.md): Case study · Snowboard Kids Plus reconstructs C for the Japanese PlayStation release SLPS-01823 and rebuilds its boot executable with remaining assembly. A build script extracts data from the user's disc image and checks that the resulting executable matches the original byte for byte. The SNB.DAT data file is extracted unchanged.
- [Dragon Ball GT: Final Bout: a native static recompilation of the PS1 game](https://awesomerea.org/resources/dragon-ball-gt-final-bout-recomp-case/index.md): Case study · Dragon Ball GT: Final Bout statically translates MIPS code from the user's NTSC-U PlayStation disc into C and compiles it for Windows or Linux. Its own runtime handles GPU, GTE, SPU, MDEC/XA, CD, and memory-card functions. The author reports playing the main game modes on Windows; Linux builds and launches but has not received equivalent gameplay testing.
- [ReverseSanta: a reconstruction of Santa Claus in Trouble](https://awesomerea.org/resources/reversesanta-case/index.md): Case study · ReverseSanta is a C++ reimplementation of Joymania's Santa Claus in Trouble built from study of the original without disassembly tools. Its source includes game, level, graphics, and editor components using DirectX 9. The author describes the result as inaccurate to the original and has not tested it from start to finish.
- [MegaVoltsPP: reconstructing the MicroVolts game backend](https://awesomerea.org/resources/megavoltspp-case/index.md): Case study · MegaVoltsPP rebuilds a backend for MicroVolts Plaza 1.0.0–1.0.3 in C++23 after analysis of the game binary. Its Front, Main and Cast processes handle authentication, lobby state and matches for the retail client, using a documented binary TCP packet format and RC5/RC6 encryption.
- [Hyper Street Fighter Zero Gold: byte-matched PS2 source recovery](https://awesomerea.org/resources/hyper-street-fighter-zero-gold-case/index.md): Case study · Hyper Street Fighter Zero Gold reconstructs the hidden PS2 game Hyper Street Fighter Zero as C source, with one file per matched function. Its round-trip tools compile the recovered C, assemble remaining code, link a full image and compare it byte for byte with the user's original. The author reports the project is about 91% complete; a native PC hardware-abstraction layer remains unfinished.
- [Boulder Dash: an NES disassembly and C/SDL2 port](https://awesomerea.org/resources/boulder-dash-nes-decomp-case/index.md): Case study · Boulder Dash reconstructs an annotated disassembly of the USA NES game and translates its routines into a native C11 and SDL2 port. A local ROM supplies game data and generated assembly; recording tools capture original RAM changes and hardware accesses for routine-by-routine comparison with the C implementation.
- [Tekken 5 × Tekken 3 Merge: Tekken 3 characters reconstructed in Tekken 5](https://awesomerea.org/resources/tekken5-t3-merge-case/index.md): Case study · Tekken 5 × Tekken 3 Merge adds five Tekken 3 characters to a statically recompiled Tekken 5. Its tools extract programs from the user’s discs, analyse them with Ghidra, generate Rust code from instruction sheets, and convert models, movesets, animations, and portraits for the expanded roster. The project documents patches and character-specific findings in its merge plan.
- [Devil Within Co-op: statically recompiling Tekken 5's Devil Within mode](https://awesomerea.org/resources/devil-within-coop-case/index.md): Case study · Devil Within Co-op statically recompiles the Devil Within mode from a user's Tekken 5 USA disc into generated Rust, then runs it through a Rust PS2 runtime and Bevy application. Its pipeline extracts the compressed ELF, exports Ghidra analysis and generates code locally; added hooks provide cooperative play, a mod menu and reconstructed developer menus.
- [StarCombat Offline: reconstructing a discontinued game's backend](https://awesomerea.org/resources/starcombat-offline-case/index.md): Case study · StarCombat Offline reconstructs backend services for the discontinued mobile game Star Combat: Space battle Online. Original Python and Android mock servers handle its HTTP and TCP exchanges, while scripts patch a user-supplied Unity IL2CPP client for local addresses and offline behavior; Frida probes support the investigation.
- [Dogfish: reconstructing Conquest of Skyrim's strategic systems](https://awesomerea.org/resources/dogfish-conquest-of-skyrim-case/index.md): Case study · Dogfish investigates the Conquest of Skyrim mod for Skyrim Special Edition and reconstructs its strategic systems as a standalone Rust simulation. Its documents cover behavioral contracts, original Papyrus and binary research, and an experimental SKSE integration bridge. The project reports that in-game execution checks remain blocked pending human playtesting.
- [My biggest work: reconstructing Brawlhalla replay simulation](https://awesomerea.org/resources/my-biggest-work-brawlhalla-case/index.md): Case study · My biggest work investigates how Brawlhalla patch 11.00 replays matches from recorded inputs, aiming to reproduce the simulation outside the game. Its Python toolkit parses replay, SWF, ABC and SWZ data, while notes map the tick loop, random generator and movement; the full simulator and player-position rendering remain unfinished.
- [th07: reconstructing Touhou 7 retail 1.00b](https://awesomerea.org/resources/cirno-th07-case/index.md): Case study · th07 reconstructs C++ for the retail 1.00b executable of Touhou 7: Perfect Cherry Blossom using Ghidra analysis, the original Visual C++ .NET 2002 toolchain and byte comparisons against a user supplied game copy. The author reports that its standalone executable matches all 650,752 bytes of the original and documents replay trace comparisons.
- [th06: an independently matching Touhou 6 decompilation](https://awesomerea.org/resources/cirno-labs-th06-case/index.md): Case study · th06 reconstructs C++ source for Touhou 6: Embodiment of Scarlet Devil retail version 1.02h from the original executable. The workflow uses headless Ghidra analysis, the original MSVC and DirectX toolchain under Wine, and byte comparisons of functions and the whole executable. The author reports that all 511 game functions and the rebuilt executable match the original, with replay traces compared separately.
- [ReJet: running Jet Set Radio Future's Xbox code on Windows](https://awesomerea.org/resources/rejet-case/index.md): Case study · ReJet runs the European Xbox release of Jet Set Radio Future on Windows from the user's own disc image or extracted files. It loads the game's original x86 code and replaces Xbox graphics, sound and controller interfaces with PC implementations, adding configurable display options.
- [Slip Stream: static recompilation of a Sega System 32 arcade game](https://awesomerea.org/resources/slipstream-recomp-case/index.md): Case study · Slip Stream translates the arcade game's V60 program from the player's ROM into C and runs it with a Sega System 32 board model on Windows or Linux. The translation driver follows reference execution to emit functions. The author reports matching state hashes against a MAME based reference runner over 1,800 frames and a separate video comparison during development; the port remains unfinished.
- [CyberStrike Server Specification: DOS client protocol and map format](https://awesomerea.org/resources/cyberstrike-server-specification-case/index.md): Case study · CyberStrike Server Specification reconstructs the server-facing behavior of the 1994 DOS client of CyberStrike from observation of the client and its printed manual. Four documents describe serial transport, session phases, messages, client rules, server policy, implementation steps and the CBD city-map format so a replacement server can interoperate with the original game.
- [Touhou 8: an independent matching decompilation of Imperishable Night](https://awesomerea.org/resources/cirno-labs-th08-case/index.md): Case study · Cirno-Labs/th08 reconstructs Touhou 8: Imperishable Night retail 1.00d in C++ and checks the build against the user's original game. The author reports byte matches for all game functions and the standalone executable, using the original MSVC toolchain, per-function comparisons and replay traces.
- [Destruction Derby 2: portable C port of the PlayStation game](https://awesomerea.org/resources/destruction-derby-2-port-case/index.md): Case study · Destruction Derby 2 is ported from its USA PlayStation executable and overlays into portable C11 using SDL3. The source replaces the game's PSX SDK calls for graphics, sound, disc access, controls and memory cards, and builds its asset directory from the user's own disc image.
- [Between Us: an offline remake informed by Action ou Vérité APK analysis](https://awesomerea.org/resources/between-us-android-remake-case/index.md): Case study · Between Us is an offline couple game rebuilt after analysis of the Action ou Vérité Android APK. The report records the original's React Native and Hermes packaging, card database and gameplay model; the replacement uses original Chinese card text, browser JavaScript and a small Android WebView shell.
- [Castlevania: Belmont’s Curse: a paused native Apple Silicon port](https://awesomerea.org/resources/castlevania-belmonts-curse-native-case/index.md): Case study · Castlevania: Belmont’s Curse native preserves a paused Apple Silicon port adaptation of the game. Its source supplies Horizon service replacements, IL2CPP and SDK startup integration, NVN-to-Metal rendering, input support and loader diagnostics. The author reports reaching a title loading screen on macOS; menu, gameplay and iPhone operation remain unconfirmed.
- [The Oregon Trail: mapping the Apple II disks, programs and data formats](https://awesomerea.org/resources/apple2-theoregontrail-doc-case/index.md): Case study · The Oregon Trail investigation maps the two disk sides of the Apple II game from their bytes. It documents the DOS 3.3 layout, sector-addressed loader, Applesoft programs, machine-language commands, saved variables, picture packing and music files, with Python readers and recorded outputs.
- [Wizardry IV: Apple II disk and format investigation](https://awesomerea.org/resources/apple2-wizardryiv-doc-case/index.md): Case study · An investigation of the Apple II release of Wizardry IV uses SYSTEM.RELOC to map five disk sides into a virtual volume and examines the separate sixth side. It studies the game's p-machine program, Huffman text, level maps and leftover files, with purpose-built readers and saved command output supporting the format findings.
- [The Witcher 3: bounded native function recovery for ARM64](https://awesomerea.org/resources/witcher-3-native-research-case/index.md): Case study · The Witcher 3 native research recovers selected vector, VM, and decoder functions from The Witcher 3: Wild Hunt for ARM64 port experiments. Ghidra helpers extract references, while C models and harnesses compare x64 and ARM64 behavior; the author reports checks of 21 small function bodies and no complete engine or playable port.
- [Chrono Tales: a browser world viewer built from decoded GBox2 archives](https://awesomerea.org/resources/chrono-tales-browser-revival-case/index.md): Case study · Chrono Tales reconstructs part of the 2012 MMORPG as a three.js browser world viewer using terrain, scenery and a character decoded from the original GBox2 archives. Its Python toolchain extracts .gpak archives, decodes game formats including maps, meshes and animation clips, and exports glTF assets. A format specification records findings from static analysis of chronotales.exe.
- [lp-engine: rebuilding the LovePlus+ runtime](https://awesomerea.org/resources/lp-engine-case/index.md): Case study · lp-engine runs the Nintendo DS game LovePlus+ on desktop systems using the player’s own Japanese game dump. Its Rust runtime executes the original game logic while recreating graphics, sound, input, clock and save services, with higher-resolution rendering and an English translation delta. Research notes document the script VM, game flow and save format.
- [DW3 Remake: reimplementing Digimon World 2003](https://awesomerea.org/resources/dw3-remake-case/index.md): Case study · DW3 Remake reimplements the PlayStation game Digimon World 2003 in Godot 4 and C#. Its extractor decodes a user-supplied European BIN/CUE disc into a private SQLite and image data pack, which the new game runtime reads. Exploration and dialogue are playable; combat remains in progress.
- [mc4.sav: reconstructing the Midnight Club: Los Angeles save format](https://awesomerea.org/resources/mcla-save-editor-case/index.md): Case study · mc4.sav documents the save format written by the Midnight Club: Los Angeles recompiled PC runtime. It maps big-endian section records, career values, garage slots and performance-upgrade bytes from observed saves, and supplies a browser editor and PowerShell commands for inspecting and changing supported fields.
- [Eternal Fighter Zero -Memorial-: exact-function source reconstruction](https://awesomerea.org/resources/eternal-fighter-zero-case/index.md): Case study · Eternal Fighter Zero -Memorial- reconstructs source from a locally supplied game executable using Ghidra analysis and a VC7.1 build oracle. Its comparison checks complete COFF function extents after explicitly binding relocation fields. The author reports two exact functions totaling 434 code bytes; the full game and runtime comparison remain unfinished.
- [Super Mario Bros.: ca65 reconstruction of seven releases](https://awesomerea.org/resources/super-mario-bros-disassembly-case/index.md): Case study · Super Mario Bros. Disassembly reconstructs seven NES, Vs. System, and Famicom Disk System releases as readable ca65 modules. Its build splits assets from user supplied images, rebuilds each supported revision, and compares the result byte for byte with the original; documentation maps source modules and game data formats.
- [Diep.io Parser: reconstructing game packet structure](https://awesomerea.org/resources/diep-lb-bot-case/index.md): Case study · Diep.io Parser documents packet structures used by the Diep.io game client and server. Its notes describe update packets, entity deletion and creation fields, and per-build XOR values; a JavaScript parser parses incoming packets and generates outgoing packets.
- [Blake Stone: static recompilation of Aliens of Gold and Planet Strike](https://awesomerea.org/resources/blakestone-case/index.md): Case study · Blakestone statically recompiles Blake Stone: Aliens of Gold and Planet Strike from user-supplied DOS executables into native Windows, Linux and macOS programs. Its lift driver uses pcrecomp to translate 16-bit x86 functions to C, while a local runtime implements the DOS, video, audio and input services the games expect.
- [NosCore.ClientLab: statically recompiling the NosTale client for browser tests](https://awesomerea.org/resources/noscore-clientlab-case/index.md): Case study · NosCore.ClientLab statically recompiles a user-supplied NosTale Windows client from x86 into C and WebAssembly for automated tests against a NosCore server. Ghidra and IDR provide function information, a custom lifter translates instructions, and a browser host replaces Windows graphics, audio and networking services.
- [Robotech: Battlecry: statically recompiling the Xbox game for PC](https://awesomerea.org/resources/robotech-battlecry-native-port-case/index.md): Case study · Robotech: Battlecry ports the 2002 Xbox game to PC by statically recompiling a user-supplied XBE into C and linking it to a replacement Xbox runtime. The project adds an x86 frontend, symbol maps, handwritten engine code and Direct3D 11, sound and input bridges. The author reports that the menu and selected missions run, with frame comparisons against xemu.
- [Juiced: static recompilation of the Windows game executable](https://awesomerea.org/resources/juiced-recomp-case/index.md): Case study · Juiced documents an x86-32 static recompilation of the 2005 Windows game executable into portable C using pcrecomp. Ghidra analysis, PE-section findings, build scripts, a runtime entry point and differential-test work accompany the pipeline. The original executable and generated lifted units stay outside the repository.
- [Skies of Arcadia Legends: matching GameCube decompilation](https://awesomerea.org/resources/skies-of-arcadia-legends-decomp-case/index.md): Case study · The Skies of Arcadia Legends project reconstructs C source for the USA GameCube release and builds a byte-identical main.dol from a user-provided disc image. It tracks function-level matches, uses objdiff for comparison and documents compiler behavior affecting Sega's Ninja graphics library; some matched library code is imported with attribution.