# Curated reverse engineering resources · Page 7

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

## Games (100)

- [OpenCrown PC: a native Dragon's Crown Pro host for console dumps](https://awesomerea.org/resources/opencrown-pc-case/index.md): Case study · OpenCrown PC runs Dragon's Crown Pro from a user-supplied decrypted PS4 or PS5 dump on Windows and Linux. Its native loader executes the game's code while replacing PS4 libraries, rendering, input, saves and online services; the repository includes format readers and a separate Linux host.
- [HotaSim: reconstructing Horn of the Abyss battle mechanics](https://awesomerea.org/resources/hotasim-case/index.md): Case study · HotaSim reimplements selected Heroes III: Horn of the Abyss battle mechanics in C++ and uses them in a battle simulator. The author describes reverse-engineering game code, recording Cheat Engine addresses and annotating AI disassembly. The simulator currently handles simple melee units without additional abilities.
- [4x4e: reconstructing 4x4 Evolution Build 57](https://awesomerea.org/resources/4x4e-case/index.md): Case study · 4x4e reconstructs source for Terminal Reality's 4x4 Evolution Build 57 from analysis of the original binaries. The repository contains game code and DirectX and OpenGL renderers. Its stated goal is a playable implementation; the source is incompatible with the original Build 44 release.
- [Blood Omen 2: functional decompilation toward a Switch port](https://awesomerea.org/resources/bloodomen2nx-case/index.md): Case study · BloodOmen2NX functionally decompiles the Spanish Windows PC release of Blood Omen 2 into C++17 for a planned Nintendo Switch port. The Linux host build reads game formats and renders a level for comparison with the original under Wine. The author reports that no chapter can yet be completed and the Switch backend has not begun.
- [ReChan: reimplementing Jackie Chan Stuntmaster for PC](https://awesomerea.org/resources/rechan-case/index.md): Case study · ReChan reimplements Jackie Chan Stuntmaster's PlayStation game logic and systems in C++ for x86_64 Windows and Linux. It rebuilds data structures and formats, extracts required assets locally from a user's NTSC-U disc image, and adds widescreen, higher-resolution and keyboard-and-mouse support.
- [Link: The Faces of Evil — a native PC port of the CD-i decompilation](https://awesomerea.org/resources/link-faces-of-evil-pc-case/index.md): Case study · A native Windows port of Link: The Faces of Evil runs C code from the Philips CD-i game decompilation and replaces CD-i video, audio, disc and input services with an SDL3 host. It reads the player's own raw disc image and includes a small 68000 interpreter for enemy graphics stored on the disc.
- [Zelda: The Wand of Gamelon: a Windows port of decompiled CD-i code](https://awesomerea.org/resources/zelda-wand-of-gamelon-pc-case/index.md): Case study · The Zelda: The Wand of Gamelon PC port runs the CD-i game's decompiled C code natively on Windows. An SDL3-based layer replaces video, audio, disc and input hardware behavior while loading game data from the user's own disc image. The port supports five regional releases.
- [Crackdown 2: byte-matched Xbox 360 decompilation](https://awesomerea.org/resources/crackdown-2-decomp-case/index.md): Case study · Crackdown2-Decomp reconstructs C++ source for the Xbox 360 title-update build of Crackdown 2. It uses the original XDK compiler and game flags to compare each compiled function byte for byte with the user's executable, while additional checks compare references, source ownership, and a full split-game relink.
- [Forza Horizon 6: asset formats and executable findings](https://awesomerea.org/resources/fh6-modding-tools-case/index.md): Case study · Forza Horizon 6 format notes and tools document the PC game's asset layout and investigated swatchbin textures, FMOD/FSB5 audio, Bink 2 video, PGZP containers and .str text tables. Python tools read or repack selected files, while separate scripts inspect RTTI and disassembly in the game's executable.
- [Tom and Jerry Tales: matching decompilation of the EU Nintendo DS game](https://awesomerea.org/resources/tom-and-jerry-tales-decomp-case/index.md): Case study · Tom and Jerry Tales reconstructs C source for the EU Nintendo DS game with Metrowerks mwccarm. Its matching process counts a function only when its compiled bytes match the original and the user's ROM still rebuilds byte for byte; the author reports 92.10% matched code and 1889 of 1931 functions in the dated progress table.
- [Final Fantasy Tactics: a matching PlayStation decompilation](https://awesomerea.org/resources/final-fantasy-tactics-decomp-case/index.md): Case study · Final Fantasy Tactics decompilation reconstructs the North American PlayStation release SCUS-94221 as C and assembly source. The author reports that its build reproduces the original disc byte for byte; build checks compare functions against stored hashes, and the repository includes architecture and game-mechanics documentation. It extends an acknowledged earlier decompilation.
- [Sonic the Hedgehog 2: byte-identical REV00 and REV01 source reconstruction](https://awesomerea.org/resources/sonic-the-hedgehog-2-source-reconstruction-case/index.md): Case study · The Sonic the Hedgehog 2 Source Reconstruction extends Sonic Retro's disassembly into shared 68000 and Z80 source for retail REV00 and REV01. It organizes modules by subsystem, models selected game data formats, and checks rebuilt ROMs byte for byte against the user's own images; the author also reports MAME runtime comparisons.
- [Dishonored: reconstructing Windows XP compatible storefront DLLs](https://awesomerea.org/resources/dishonored-xp-stub-case/index.md): Case study · The Dishonored XP stub project replaces two GOG storefront DLLs so the GOG Definitive Edition can run on Windows XP SP3 with local saves. The author traced incompatible imports, Steamworks exports, vtable calls and save routines in the game executable, then implemented XP-targeted common.dll and libcurl.dll substitutes. The author reports successful play and save/load on an XP system.
- [DKB Recomp: static recompilation of Donkey Kong Bananza](https://awesomerea.org/resources/dkb-recomp-case/index.md): Case study · DKB Recomp statically translates Donkey Kong Bananza's Switch 2 ARM64 code to C and builds a native Windows x86-64 application. A Horizon host, NVN 2 implementation, shader translation, and Vulkan renderer handle game services and graphics. The author reports title-screen and tutorial rendering, with crashes and missing effects.
- [tmnt-recomp: porting the NES Teenage Mutant Ninja Turtles game to C](https://awesomerea.org/resources/tmnt-recomp-case/index.md): Case study · tmnt-recomp ports the 1989 NES Teenage Mutant Ninja Turtles game to C from analysis of its 6502 code. It loads a user-provided European or American ROM at runtime, implements game logic and needed NES hardware behavior, and compares recorded runs with emulator traces.
- [TempleRun-RL: reconstructing Temple Run mechanics for simulator training](https://awesomerea.org/resources/templerun-rl-case/index.md): Case study · TempleRun-RL reconstructs Temple Run's track generation, hazards, and runner physics in a headless training simulator. A Frida gadget reads live state and calls game methods on an arm64 Android phone so the project can measure behavior and evaluate a PPO policy against the original. The author reports a longest device run of 16,782 metres.
- [Bumpy's Arcade Fantasy: reconstructing a DOS game in C](https://awesomerea.org/resources/bumpys-arcade-fantasy-decomp-case/index.md): Case study · Bumpy's Arcade Fantasy reconstructs the 1992 DOS game's engine as C source guided by Ghidra analysis. It includes a build target for a faithful executable and a playable target with a host layer, plus Python decoders for PAV, DEC, BUM, VEC, BIN and CAR resources. The original game files are supplied separately by the user.
- [Hexwaste: reimplementing a slice of the Fallout 2 engine](https://awesomerea.org/resources/hexwaste-case/index.md): Case study · Hexwaste reimplements part of the Fallout 2 engine in C# and MonoGame using files from the user's own installation. It reads DAT archives, maps, sprites, scripts, audio, and cutscenes, and implements exploration, dialogue, combat, travel, and persistent state. Its research notes compare behavior and formats with fallout2-ce while documenting the playable scope.
- [The Last Story: mapping the LastWorld engine and game formats](https://awesomerea.org/resources/the-last-story-re-case/index.md): Case study · The Last Story research documents the Wii game's LastWorld engine and provides parsers and extractors for archives, text, textures, audio, models and scenes. Its executable analysis uses a custom DOL loader and Gekko SLEIGH language to examine main.dol, including the archive path hash and engine structures. The author reports format coverage and validation against game data.
- [DARK: reconstructing the video plugin path for Proton cutscenes](https://awesomerea.org/resources/dark-render-re-case/index.md): Case study · dark-render-re reconstructs the video texture upload path used by DARK (2013) to restore WMV cutscenes under Proton. Its proxy loads the original VideoEnginePlugin, forwards the game's timing and UI controls, and uploads BGRA frames decoded by 32-bit Windows FFmpeg through VTextureObject::UpdateRect.
- [Kid Icarus: Of Myths and Monsters: a Game Boy disassembly](https://awesomerea.org/resources/kid-icarus-omm-disassembly-case/index.md): Case study · Kid Icarus: Of Myths and Monsters reconstructs the Game Boy game's code and data as a documented RGBDS disassembly. The build uses an owner-supplied baserom.gb, extracts graphics and assembles a ROM; the project gives an MD5 value for checking the result.
- [Pac-Man NES Source Reconstruction: seven byte-identical cartridge revisions](https://awesomerea.org/resources/pac-man-nes-source-reconstruction-case/index.md): Case study · Pac-Man NES Source Reconstruction rebuilds seven official Famicom and NES Pac-Man revisions from shared, annotated 6502 ca65 modules. Its build rules extract data from a user's ROM and compare assembled output byte for byte with each available original; a relocated build also has a recorded longplay check in MAME.
- [AvalonEmu: reconstructing an Albion Online local server](https://awesomerea.org/resources/avalonemu-case/index.md): Case study · AvalonEmu reconstructs an Albion Online local server for a specific client build in C# and .NET 10. It implements Photon UDP transport, Protocol18 serialization, encrypted handshakes, login and world systems, and a decoder for packet captures. The server loads GameData from the user's own client installation.
- [Azazel6: an experimental Tekken 6 PSP static recompilation for Android](https://awesomerea.org/resources/azazel6-case/index.md): Case study · Azazel6 researches a native Android ARM64 port of Tekken 6 for PSP by translating selected Allegrex/MIPS code ahead of time to C++ and building a PSP service host. It includes executable analysis, an import inventory and bounded startup probes. The author reports that translated startup reaches graphics initialization; the game remains unplayable.
- [Vault Engine: rebuilding Fallout and Fallout 2 in Rust](https://awesomerea.org/resources/vault-engine-case/index.md): Case study · Vault Engine reimplements Fallout and Fallout 2 as a Rust engine that reads the user's retail DAT archives. Its modules cover DAT formats, the INT script VM, combat, AI, saves and rendering, with behavior built from written clean-room specifications and checked through state hashes and trace oracles.
- [Drakengard: an experimental PAL PlayStation 2 static recompilation](https://awesomerea.org/resources/drakengard-1-europe-case/index.md): Case study · A source-only Drakengard project statically recompiles the European PlayStation 2 release toward a native PC port, with a runtime for original hardware and service behavior. The author reports a diagnostic runner reaching Chapter I scenes and rendering Caim, terrain, objects, radar and HUD; sustained gameplay remains unfinished.
- [Drakengard 3: a Windows port through static recompilation](https://awesomerea.org/resources/drakengard-3-recompile-case/index.md): Case study · Drakengard 3 Recompile translates the PS3 release of Drakengard 3 into native Windows x64 code and replaces platform services in a local runtime. It targets NPUB31251 version 1.01 and builds from the user's game files; the author reports intro, audio, menu and story-scene milestones, with controlled gameplay still unconfirmed.
- [Metropolismania PC: porting a PS2 game function by function](https://awesomerea.org/resources/metropolismania-pc-case/index.md): Case study · Metropolismania PC rebuilds the PS2 game as readable C++ while using PS2Recomp output from the user's disc as a running scaffold. Functions are replaced individually and compared with recorded original calls; the author reports all 1,481 game functions rewritten, with 1,432 passing differential checks, while playthrough remains unfinished.
- [Sonic Adventure decomp: rebuilding the Dreamcast executable from a local disc](https://awesomerea.org/resources/sonic-adventure-decomp-case/index.md): Case study · Sonic Adventure decomp reconstructs the European Dreamcast game's executable from a user-supplied disc, using per-function SH-4 assembly files as a byte-matching build baseline. Its tools split the executable, map text and models, disassemble SH-4 code, and compare recovered C functions against original behavior; the author reports that no C functions are complete yet.
- [openmx: porting the MX Unleashed simulation to Rust](https://awesomerea.org/resources/openmx-case/index.md): Case study · openmx ports the PlayStation 2 game MX Unleashed's riding simulation to Rust and supplies new desktop and browser presentation. It reads tracks, vehicles, art and sound from the user's disc dump; the author reports comparing simulation functions, PCSX2 captures and frame-by-frame replay state hashes with the original.
- [Saint Seiya: The Hades: a PS2 static recompilation for Linux](https://awesomerea.org/resources/saint-seiya-recomp-case/index.md): Case study · Saint Seiya: The Hades is ported to Linux by translating the European PS2 executable's MIPS R5900 functions to C and building them with a native runtime. The runtime models PS2 CPU, IOP, graphics and audio services, reads the user's disc image, and renders through Vulkan or a software GS; the author reports that the separate assembly rebuild matches the original byte for byte.
- [Driver 1 decomp: matching Driver and porting it to Linux](https://awesomerea.org/resources/driver-1-decomp-case/index.md): Case study · Driver 1 decomp reconstructs Driver: You Are the Wheelman for PlayStation in C while retaining original hand-written assembly routines, and compares rebuilt code with the original executable and overlays. Its Linux port runs the reconstructed game through PsyCross with SDL2 and OpenGL using data extracted from the user's own US Rev 1 disc. The author reports 1248 of 1259 game functions matched across the listed binaries.
- [OpenPopTB-MacOS: static recompilation of Populous: The Beginning for Apple Silicon](https://awesomerea.org/resources/openpoptb-macos-case/index.md): Case study · OpenPopTB-MacOS statically recompiles Populous: The Beginning and Undiscovered Worlds from a user's Windows executables into native Apple Silicon applications. A Python recompiler translates discovered x86 functions to C, while a C runtime provides guest memory and Win32 and DirectX behavior through SDL3. The author reports single-player playability and instruction-level and function-level differential checks.
- [reRBR: reimplementing Richard Burns Rally 1.02](https://awesomerea.org/resources/rerbr-case/index.md): Case study · reRBR reimplements Richard Burns Rally 1.02 for Linux, macOS and Windows, using the player's game files and NGP 7.4.778 physics. Its Rust code covers game formats, stages, cars, race flow, damage, saves and rendering; the author reports comparing gameplay behavior with recordings of the original. BTB stage support remains experimental.
- [CTRNativePorted: rehosting Crash Team Racing Nitro-Fueled on Windows](https://awesomerea.org/resources/ctrnativeported-case/index.md): Case study · CTRNativePorted rehosts Crash Team Racing Nitro-Fueled on Windows by loading the original PS4 x86-64 code from a user-owned dump. It replaces imported PS4 system services, supplies Direct3D 11 and Vulkan rendering paths, and provides a local service for online play; the author reports that the game is playable from start to finish.
- [OpenBattlespire: reimplementing the Battlespire engine](https://awesomerea.org/resources/openbattlespire-case/index.md): Case study · OpenBattlespire reimplements the engine of An Elder Scrolls Legend: Battlespire in C and reads the user’s original game files at runtime. Its source includes game systems, format parsers and data tools; research notes analyze GAME.EXE and document BSA, BS6, save and other formats. The README describes playable movement, combat, dialogue and save behavior.
- [Champions: Return to Arms: PS2 code research and native recompilation](https://awesomerea.org/resources/champions-return-to-arms-re-case/index.md): Case study · Champions: Return to Arms research maps the US PS2 game's executable, symbols, level scripts, file formats and online behavior. Its tools disassemble and compare original functions, then translate a player-supplied executable to C++ for a native runtime and Godot host; the author maintains an address-based findings ledger.
- [cyrus: rebuilding The Elder Scrolls Adventures: Redguard in Rust and Bevy](https://awesomerea.org/resources/cyrus-redguard-case/index.md): Case study · cyrus rebuilds The Elder Scrolls Adventures: Redguard in Rust and Bevy using files from a local GOG installation. It loads game worlds and formats for native and browser viewing, while its fidelity mode aims to reproduce visuals, audio, controls, timing, and outcomes.
- [FA Remastered: rebuilding the Supreme Commander: Forged Alliance engine](https://awesomerea.org/resources/fa-remastered-case/index.md): Case study · FA Remastered reimplements the Supreme Commander: Forged Alliance engine in C++ around the user's game data, Lua scripts and mods. It provides a multithreaded simulation, renderer and interface, and compares replay states beat by beat with the original. The author reports identical results for sixteen test replays; local skirmishes are playable.
- [MineStrike 1.6: reconstructing Counter-Strike interfaces for a Minecraft mod](https://awesomerea.org/resources/minestrike-1-6-case/index.md): Case study · MineStrike 1.6 reconstructs interfaces of Counter-Strike 1.6's closed client and engine binaries to add Minecraft-style gameplay inside GoldSrc. A client proxy forwards and wraps exports, while server hooks add blocks, inventory and crafting; its installer builds a block version of de_dust2 from the user's game data.
- [Infinite Crisis: reconstructing a preservation server](https://awesomerea.org/resources/infinite-crisis-server-case/index.md): Case study · The Infinite Crisis preservation server reconstructs login, menus, Tutorial 1 and versus-AI matches for the 2015 Steam client. It uses decompilation notes and mapped network messages, while loading champions, maps and scripts from the player's game installation; the author reports broad match coverage with remaining tutorial and rendering gaps.
- [AgainROM: a new engine for Rage of Mages](https://awesomerea.org/resources/againrom-rage-of-mages-case/index.md): Case study · AgainROM reimplements the Rage of Mages engine in Go to run the original campaign on Windows, macOS and Linux. It loads the user's RES archives, graphics, audio, movies and saves, and includes a map editor; research notes document recovered resource formats and known behavior differences.
- [NMS Shipwright: reconstructing No Man's Sky ship generation and saves](https://awesomerea.org/resources/nms-shipwright-case/index.md): Case study · NMS Shipwright investigates No Man's Sky ship generation and save structures through the user's installed game. It reads game archives, runs the game's generator code offline with Unicorn, finds seeds for chosen ship designs, locates ships in star systems, and edits ships and other save fields after creating a backup.
- [Tiberian Sun and Firestorm: static recompilation of Game.exe](https://awesomerea.org/resources/tiberian-sun-firestorm-recomp-case/index.md): Case study · Tiberian Sun and Firestorm recompiles the games' Win32 Game.exe into native C with pcrecomp and a game-specific host. The author reports playable menus, skirmishes and early campaign missions, with high-resolution display and a native Linux build. Lifted C is generated locally from the owner's game copy.
- [Star Wars: Knights of the Old Republic: a Win32 static recompilation](https://awesomerea.org/resources/kotor-static-recomp-case/index.md): Case study · Star Wars: Knights of the Old Republic is statically recompiled from a user-owned Steam swkotor.exe 1.03 into native C using pcrecomp. The repository supplies the lift driver, a 32-bit Windows host, and conformance scripts; the author reports an alpha build that reaches gameplay on the Endar Spire.
- [openchrome: rebuilding a Dying Light runtime from game data](https://awesomerea.org/resources/openchrome-case/index.md): Case study · openchrome is a C++ runtime and viewer for Dying Light 1 game data, using Vulkan and SDL2 to read resources from the user's installation. Its parsers and format notes cover rpack containers, textures, meshes, materials, map placement, lighting, animation and sound banks. The author reports that the viewer renders environments and provides a stand-in walk mode.
- [HL2-RS: a partial Rust reconstruction of Half-Life 2](https://awesomerea.org/resources/hl2-rs-case/index.md): Case study · HL2-RS partially reconstructs Half-Life 2 in Rust and Bevy, reading maps, models, textures, animations, and sounds from an installed copy. Its source separates Source asset readers, simulation, UI, and rendering; the author reports working menus and selected city sequences while the campaign remains incomplete.
- [pc-thelaststory: statically recompiling The Last Story for PC](https://awesomerea.org/resources/pc-thelaststory-case/index.md): Case study · pc-thelaststory statically recompiles the European Wii release of The Last Story for a native PC port. Its tools identify functions in the stripped PowerPC executable and use wiikit to translate them to C++ while a runtime replaces Wii services. The author reports play from the title screen into the first chapter at 30 frames per second.
- [Civilization III: Conquests — static recompilation of the Steam release](https://awesomerea.org/resources/civilization-iii-conquests-recomp-case/index.md): Case study · Civilization III: Conquests statically recompiles the user's Steam Win32 game executable into C with pcrecomp and builds native Windows and Linux hosts. The repository supplies lift scripts, runtime shims and scripted tests; the author reports matching original game state across 19 turns in one differential run.
- [pc-monsterhunter3: a static recompilation of Monster Hunter Tri](https://awesomerea.org/resources/pc-monsterhunter3-case/index.md): Case study · pc-monsterhunter3 ports the European Wii release of Monster Hunter Tri to PC by translating its PowerPC executable and 21 RSO modules into C++ with wiikit. The repository records disc and code findings and supplies game-specific hooks. The author reports reaching the village and a first quest with gamepad input.
- [Hover!: statically recompiling the Windows 95 game to native C](https://awesomerea.org/resources/hover-static-recompilation-case/index.md): Case study · Hover! statically recompiles the Windows 95 game Microsoft Hover! from the owner's HOVER.EXE into generated C and builds a 32-bit native host. Its pcrecomp pipeline catalogs functions, lifts game code and binds Windows imports; the author reports playable level-one runs and conformance checks, while host code adds presentation and multiplayer features.
- [Bunghole in One: statically recompiling a Win32 mini-golf game](https://awesomerea.org/resources/bunghole-in-one-case/index.md): Case study · Bunghole in One statically recompiles the 1998 Windows mini-golf game's EXE and DLL into C with pcrecomp, generating the lifted code from a user's own disc. A 32-bit host binds the modules and provides software DirectDraw, while a conformance harness tracks boot and play milestones.
- [OpenSE4: reimplementing the Space Empires IV Deluxe engine](https://awesomerea.org/resources/opense4-case/index.md): Case study · OpenSE4 reimplements the Space Empires IV Deluxe engine in C++23, loading art, sound and data from the player's own installation. Its rule specifications combine the original manual, data files, observed behavior and executable analysis; the engine covers economy, movement, combat, research, diplomacy and computer players, with remaining parity differences documented.
- [CS:GO Legacy: reconstructing Game Coordinator matchmaking](https://awesomerea.org/resources/csgo-legacy-matchmaking-case/index.md): Case study · CS:GO Legacy matchmaking research reconstructs a Game Coordinator path for starting and joining matches in the archived game. It combines a JavaScript coordinator, protobuf definitions, client and Linux server patches, and findings about reservation messages, match draft data, and map transitions; the author reports completing a match with map veto.
- [QuestEditorRe: rebuilding the Alien Shooter quest editor](https://awesomerea.org/resources/questeditorre-case/index.md): Case study · QuestEditorRe rebuilds the original QuestEditor as a standalone Windows application and a Win32 DLL compatible with map editors for Alien Shooter 2 and related games. Its C++ implementation edits levels.cfg, levels.db and mission.txt while preserving unknown fields and unchanged bytes where possible, and supports quest links, properties and backups.
- [midway: statically recompiling Midway Arcade Origins for Windows](https://awesomerea.org/resources/midway-ps3-case/index.md): Case study · midway statically recompiles the PS3 disc release of Midway Arcade Origins for native Windows using ps3recomp and a user-supplied game dump. Its scripts lift the EBOOT and two SPURS render jobs, then build against the shared runtime. The author reports that the front end reaches an arcade ROM set and displays the Vindicators Part II attract loop.
- [crazytaxi-ps3: statically recompiling Crazy Taxi for Windows](https://awesomerea.org/resources/crazytaxi-ps3-case/index.md): Case study · crazytaxi-ps3 statically recompiles the PS3/PSN release of Crazy Taxi for native Windows using ps3recomp. Its scripts prepare a user-supplied EBOOT, lift PPU and SPU code, and build against the shared runtime; the author reports the title screen and in-engine attract demo rendering while gameplay remains unreached.
- [pc-deepfear: statically recompiling Deep Fear for PC](https://awesomerea.org/resources/pc-deepfear-case/index.md): Case study · pc-deepfear investigates the European Sega Saturn release of Deep Fear and statically recompiles its program toward a native PC port using saturnkit. Its notes map both discs, data formats, SH-2 code and the SCU DSP, while local scripts build and compare the translated C++ against an interpreter. The author reports reaching the first playable room.
- [gh3: statically recompiling Guitar Hero III for Windows](https://awesomerea.org/resources/gh3-guitar-hero-iii-case/index.md): Case study · gh3 statically recompiles the PS3 disc release of Guitar Hero III: Legends of Rock with ps3recomp for native Windows execution. Its build scripts lift the game, apply import handling and run it against the user's dumped disc; the author reports playable Quickplay songs while guitar input and timing work remain.
- [pc-arcrisefantasia: statically recompiling Arc Rise Fantasia for PC](https://awesomerea.org/resources/pc-arcrisefantasia-case/index.md): Case study · pc-arcrisefantasia builds a native PC port of the North American Wii release of Arc Rise Fantasia by translating its PowerPC code to C++ and running it on wiikit's replacement Wii runtime. Its tools extract the user's disc, identify functions in the stripped DOL with signatures and manual evidence, and compile the translated code. The author reports gameplay through the first battle.
- [pc-conduit2: statically recompiling Conduit 2 for PC](https://awesomerea.org/resources/pc-conduit2-case/index.md): Case study · pc-conduit2 statically recompiles the North American Wii release of Conduit 2 from PowerPC code to C++ for a native PC port. Its tools and notes map the disc and stripped main.dol, recover function names, and integrate with wiikit; the author reports gameplay through the first level with keyboard, mouse, or gamepad input.
- [EVA-Decomp: matching Neon Genesis Evangelion on Nintendo 64](https://awesomerea.org/resources/eva-decomp-case/index.md): Case study · EVA-Decomp reconstructs Neon Genesis Evangelion for Nintendo 64 as C and selected original assembly routines. Its build uses historical compilers and a user-provided ROM, then checks the resulting image by SHA-1. The author reports byte-identical output for the main program and eight overlays; a native PC port remains in preparation.
- [Snowboard Kids Recompiled: a native N64 recompilation for PC](https://awesomerea.org/resources/snowboard-kids-recompiled-case/index.md): Case study · Snowboard Kids Recompiled runs the USA Nintendo 64 game as a native Linux or Windows application using N64Recomp, RT64 and a separate game module. It validates a player-supplied ROM and adds desktop input, Controller Pak persistence, savestates and rendering settings around the recompiled game logic.
- [LibreGrimrock: 64-bit reconstructions of the Legend of Grimrock engines](https://awesomerea.org/resources/libregrimrock-case/index.md): Case study · LibreGrimrock reconstructs the engines of Legend of Grimrock and Legend of Grimrock 2 as native 64-bit C++ modules from their original executables. The work follows recovered compilation units, class layouts and Lua bindings, while adapting platform libraries and loading data from owners' game installations.
- [battlepod: reconstructing the BattleTech arcade cockpit](https://awesomerea.org/resources/battlepod-case/index.md): Case study · battlepod reconstructs the Virtual World Entertainment BattleTech cockpit as a bring-up harness and playable emulator. It runs the cockpit's 68020 software from a user-supplied image, models serial and Remote I/O devices, decodes display lists, and records hardware and inter-pod protocol findings.
- [mcg-recomp: statically recompiling MechCommander Gold for Windows](https://awesomerea.org/resources/mcg-recomp-case/index.md): Case study · mcg-recomp statically translates MechCommander Gold's MCX.EXE into C and runs the generated code in a native Windows host. It extracts CodeView function information, bridges imports, and provides graphics, sound, movie, and conformance support; the author reports playing the first campaign mission through its debriefing.
- [Advanced Daisenryaku PC: a native Windows port of the Mega Drive game](https://awesomerea.org/resources/advanced-daisenryaku-pc-case/index.md): Case study · Advanced Daisenryaku PC ports the Sega Mega Drive strategy game to native Windows in C/C++ using statically translated game logic. It reconstructs cartridge flow, turn-based combat, campaign state, graphics and input around a user-supplied ROM. Its development reports describe ROM differential tests and selected presentation comparisons.
- [Toy Story disassembly: rebuilding the Mega Drive ROM from generated source](https://awesomerea.org/resources/toy-story-mega-drive-disasm-case/index.md): Case study · Toy Story disassembly reconstructs the Mega Drive game's ROM as generated assembly source and compares the rebuilt ROM byte for byte with the user's copy. Its 68000 tracer, ROM maps, RNC decoder, and sprite tools support ongoing recovery of routines, text, and graphics formats. The author reports that the rebuild matches while equivalent named source remains incomplete.
- [Dragon Ball Z: L'Appel du Destin: rebuilding the Mega Drive ROM from source](https://awesomerea.org/resources/dbzbr-disasm-case/index.md): Case study · Dragon Ball Z: L'Appel du Destin disassembly reconstructs the French Mega Drive ROM as generated assembly and compares it byte for byte with a user-provided original. A recursive 68000 tracer, labelled listing, ROM region map, text decoder, and LZSS decoder record the game's code and data formats. The author reports a matching rebuild with substantial naming work still open.
- [jgalbs cod4: porting the Call of Duty 4 multiplayer client to Apple Silicon](https://awesomerea.org/resources/jgalbs-cod4-case/index.md): Case study · jgalbs cod4 ports the KisakCOD Call of Duty 4 multiplayer client to Apple Silicon macOS. Its native Metal renderer and platform work support menus, maps, input, audio, hosting and multiplayer gameplay while loading assets from a user's compatible game installation. The source documents ongoing development and tested feature boundaries.
- [TWD · Source Recovery: reconstructing The Walking Dead: Season One functions](https://awesomerea.org/resources/twd-source-recovery-case/index.md): Case study · TWD · Source Recovery reconstructs selected functions from The Walking Dead: Season One as C++ replacements for an experimental hybrid runtime. It publishes geometry, hash and symbol code, comparison harnesses, analysis scripts and progress reports. The author reports 14 replacements among 18,299 recognized functions; the standalone source engine remains unfinished.
- [Yu-Gi-Oh! Online 3: reconstructing early server exchanges and YPK extraction](https://awesomerea.org/resources/ygo3-research-case/index.md): Case study · ygo3-research reconstructs early Yu-Gi-Oh! Online 3 server exchanges and provides a YPK archive extractor. Its experimental Python server responds to observed authentication, profile, player-list and selection requests and documents packet encryption, length masking and nested data encoding. The client currently stops after player selection.
- [Tiger Woods PGA Tour 2004 - XBE Recomp: a native PC port of the Xbox game](https://awesomerea.org/resources/tiger-woods-pga-tour-2004-xbe-recomp-case/index.md): Case study · Tiger Woods PGA Tour 2004 - XBE Recomp ports the original Xbox game to Windows by statically recompiling its XBE with Xbox XBE Recomp and building the game code from the user's copy on first launch. The port adds widescreen display, graphics settings, and PC controls, alongside an emulated Xbox audio DSP.
- [Casiolator: reimplementing Casio PV-1000, PV-2000 and Loopy consoles](https://awesomerea.org/resources/casiolator-case/index.md): Case study · Casiolator emulates the Casio PV-1000, PV-2000 and Loopy cartridge consoles using its own Z80, SH-1, video and sound implementations. The project draws on hardware documentation and records original Loopy ROM and sound-chip findings; users provide cartridge dumps, BIOS ROMs and, for Loopy music, a sample ROM.
- [Tales of Eternia: structural analysis of the Japanese PlayStation disc](https://awesomerea.org/resources/ps1-talesofeternia-doc-case/index.md): Case study · Tales of Eternia is a structural investigation of disc 1 of the Japanese PlayStation release SLPS-03050. Python tools and committed reports examine ISO 9660 and CD-XA layout, the PS-EXE, LZSS blocks, archive indexes, TIM graphics, audio, video and Shift-JIS text.
- [FINAL FANTASY V: analysis of the 2015 Windows release](https://awesomerea.org/resources/pc-ff5-doc-case/index.md): Case study · FINAL FANTASY V examines the 2015 Windows game's ICP, INP, mtxs and offset-table containers, string tables, assets and executable metadata. Python tools identify and extract resources from a user's installation, while reference tables inventory images, audio and language slots.
- [Open SoM Runtime: rebuilding the Sword of Moonlight runtime](https://awesomerea.org/resources/open-som-runtime-case/index.md): Case study · Open SoM Runtime recreates Sword of Moonlight's game runtime in Unity, including content loading, event parsing, menus and explorable maps. The author reports partial event support and describes compatibility limits for Dark Destiny, SoM Ex games and some video codecs.
- [REFLEC BEAT plus: reconstructed iOS game source](https://awesomerea.org/resources/reflec-beat-plus-source-case/index.md): Case study · REFLEC BEAT plus reconstructs Objective-C and C++ source for version 4.5.8 of the iOS rhythm game. The project uses Objective-C metadata, C++ RTTI, embedded strings, and original path fragments to organize the recovered routines; a separate OpenAPI file describes requests observed in the client. Building requires a user-supplied IPA for game assets.
- [Irisu ML: reconstructing Irisu Syndrome! normal mode](https://awesomerea.org/resources/irisu-ml-case/index.md): Case study · Irisu ML reconstructs Irisu Syndrome! v2.03 normal mode as a deterministic C++20 simulator, Python learning environment and playable browser client. It models input timing, seeded spawning, scoring, chains and progression, with original-format replay support. The author reports event-level matches on four eligible instrumented playbacks and a selected-seed high-score replay.
- [Rondorecomp: a partial static recompilation of Castlevania: Rondo of Blood](https://awesomerea.org/resources/rondorecomp-case/index.md): Case study · Rondorecomp translates Castlevania: Rondo of Blood’s PC Engine CD HuC6280 code into C at build time and runs it against C models of the console’s CPU, video, CD, input, and System Card services. Its analysis directory contains boot-chain disassembly and tools for code discovery and data decoding. The author reports rendering the intro and file-select screens and reaching the prologue, with much of the game still unverified.
- [Splashdown: a matching PS2 decompilation and Linux port](https://awesomerea.org/resources/splashdown-case/index.md): Case study · Splashdown reconstructs C++ source for the NTSC-U PlayStation 2 game and builds a native Linux x86-64 port from it. The project checks reconstructed functions and the linked executable against retail bytes and a SHA-1 hash. The author reports that all 4,356 game functions match and that the Linux port plays the full game at 30 FPS.
- [Dicing Knight. — a native port by static recompilation](https://awesomerea.org/resources/dicing-knight-static-recomp-case/index.md): Case study · Dicing Knight. — Native Recompilation translates the WonderSwan Color game’s V30 MZ machine code into C11 ahead of time and compiles it with a recreated hardware layer. Its Python recompiler discovers code from entry seeds and execution traces; the C layer models video, timers, input, EEPROM, and audio. The author reports playable Windows sections through the tower, while the ending and Android device build remain unverified.
- [TimeSplitters: Future Perfect — native PC rebuild](https://awesomerea.org/resources/timesplitters-future-perfect-pc-rebuild-case/index.md): Case study · TimeSplitters: Future Perfect is being rebuilt as a native PC game using data imported from the user's Xbox copy. The launcher identifies the disc by the hash of default.xbe, extracts and checks game files, and manages settings and mods. The repository also contains game reconstruction code and a decompilation analysis toolchain.
- [tp-vita: porting Twilight Princess to PS Vita](https://awesomerea.org/resources/tp-vita-case/index.md): Case study · tp-vita ports Dusklight's GameCube Twilight Princess code to PS Vita by compiling the game and JSystem sources for ARM. It retains Aurora's GX command processor and adds a vitaGL GLES2 renderer. The author reports a VPK that boots and renders in Vita3K; audio is disabled, and a memory-card prompt blocks progress past file select.
- [TM2020-Sim: extending Trackmania physics simulation](https://awesomerea.org/resources/tm2020-sim-trackmania-case/index.md): Case study · TM2020-Sim extends Gearbox's Trackmania physics and asset loading into a headless simulator with a native C++ and Rust SDK. It adds parallel environments, replay analysis, driving-controller research and validation tools for local game observations.
- [physics_RT: reconstructing Ballance physics behavior](https://awesomerea.org/resources/physics-rt-ballance-case/index.md): Case study · physics_RT reconstructs Ballance physics behavior as a Win32 Virtools DLL using IVP numerical kernels. It covers collision geometry, force handling and simulation timing, with differential tests against an original DLL and documented runtime comparisons.
- [Angry Birds PC engine: reimplementing the game engine from executable analysis](https://awesomerea.org/resources/angry-birds-pc-engine-case/index.md): Case study · Angry Birds PC engine reimplements the game's native engine in C++ from analysis of the 1.6.2 executable. It hosts the user's original Lua scripts and data with SDL2, OpenGL, Lua 5.1 and Box2D, covering menus, levels, physics, rendering and audio across several Angry Birds PC releases.
- [Touhou Reiiden: a C# port built around original PC-98 game data](https://awesomerea.org/resources/touhou-reiiden-port-case/index.md): Case study · Touhou Reiiden is a C# and .NET 8 port of the 1997 PC-98 game that loads assets from the user's own disk image or game folder. It rebuilds stages, bosses, menus, scoring, and audio, using ReC98 as a behavioral and file-format reference and measurements of the original for selected boss sequences.
- [NeoTS2: rebuilding The Sims 2 engine](https://awesomerea.org/resources/neots2-case/index.md): Case study · NeoTS2 rebuilds The Sims 2 as a native 64-bit engine that reads the user's installed game files. Its C++ implementation loads neighborhoods, lots, objects, Sims, behavior scripts, models and UI resources, then renders them through modern graphics APIs; current development builds let users visit neighborhoods and lots.
- [Galaxian2: reimplementing Galaxy on Fire 2 in Godot](https://awesomerea.org/resources/galaxian2-gof2-case/index.md): Case study · Galaxian2 reimplements Galaxy on Fire 2 as a Godot engine using content imported from the player's Mac Full HD or Android HD release. The importer prepares ships, missions, audio and other resources locally and reads static declarations from the original executable. The source describes a playable campaign and add-ons with release-specific content paths.
- [skynet-godot: porting SkyNET and Future Shock to Godot](https://awesomerea.org/resources/skynet-godot-case/index.md): Case study · skynet-godot ports the 1996 XnGine shooters SkyNET and Future Shock to a rewritten Godot 4 engine. It decodes BSA archives, WLD heightmaps, textures, maps and audio from the player's installations, while DOS executable disassembly informs movers, weapons, AI and mission behavior. The author reports bounded campaign and deathmatch support.
- [Galaxian: reimplementing Galaxy on Fire 1 for Godot](https://awesomerea.org/resources/galaxian-gof1-case/index.md): Case study · Galaxian reimplements the iPhone edition of Galaxy on Fire 1 as a Godot engine. It imports ships, missions, artwork and other resources from the player's IPA, reads AEM and AEI formats, and extracts selected embedded Mach-O definitions into a local cache. The remake adds its own controls and play modes alongside the reconstructed campaign.
- [OpenGromada: reconstructing the Sigma Games engine](https://awesomerea.org/resources/opengromada-case/index.md): Case study · OpenGromada reconstructs the engine used by Sigma Games titles including AS1/ZS1, Theseus, Crazy Lunch and Locoland/Steamland. Its C++20 executable reads the user's game resources and supports multiple platforms and architectures, widescreen display and gamepads.
- [Need for Speed: Most Wanted: rehosting the Android release on R36S](https://awesomerea.org/resources/nfsmw-r36s-case/index.md): Case study · The R36S port runs the 2012 Android release of Need for Speed: Most Wanted on ArkOS using the owner's game files. An ARMv7 loader maps the original libraries, while Bionic, JNI and soft-float bridges connect them to Linux graphics, controls and audio; the author reports playable races in the public alpha.
- [zkTH06: reconstructing Touhou 6 gameplay transitions](https://awesomerea.org/resources/zkth06-case/index.md): Case study · zkTH06 reconstructs selected Touhou Koumakyou v1.02h gameplay transitions for replay-driven execution in OpenVM. It compares a Linux reference with observations of the shipped Windows game, implements bounded player, bullet, enemy, and item state transitions, and records differential results and proof obligations. The author reports matching projections over specified replay prefixes.
- [9mm Vita: rehosting 9mm HD Android on PS Vita](https://awesomerea.org/resources/9mm-vita-case/index.md): Case study · 9mm Vita ports 9mm HD Android to PS Vita by loading the user's ARMv7 game executable into memory. Its native compatibility layer resolves imports, patches a checked game build and maps Vita controls, while the user's APK and downloaded game data supply the original program and assets.
- [ngp-link: reconstructing the Neo Geo Pocket Color link cable](https://awesomerea.org/resources/ngp-link-case/index.md): Case study · ngp-link reconstructs the Neo Geo Pocket Color serial link cable and uses the recovered behavior for browser netplay. A hardware sniffer, ROM disassembler and headless emulator compare real traffic with game link code. The documentation covers UART framing, BIOS COM calls, handshake states and games that drive the serial chip directly.
- [dreamREfactory: rebuilding CyberFlix's DreamFactory engine](https://awesomerea.org/resources/dreamrefactory-case/index.md): Case study · dreamREfactory rebuilds CyberFlix's DreamFactory game engine in TypeScript for browser play using the owner's game data. It decodes container formats, interprets scripts and supports titles including Titanic: Adventure Out of Time, Dust, Timelapse and RedJack; executable disassembly supplies logic for Skull Cracker, Lunicus and Jump Raven.
- [GunBound Java Emulator: reconstructing Thor's Hammer servers](https://awesomerea.org/resources/gunbound-java-server-case/index.md): Case study · GunBound Java Emulator recreates Broker, Game, and Buddy services for the Thor's Hammer versions of GunBound using Java and Netty. It documents the client protocol's packet framing, command opcodes, AES-based session encryption, and sequence checks, with handlers for authentication, lobbies, rooms, gameplay, and friends.
- [Neverness to Everness: mapping a TCP connection's records](https://awesomerea.org/resources/nte-network-traffic-analysis-case/index.md): Case study · This investigation maps one Neverness to Everness TCP connection from locally captured PCAPs. Python scripts decode length-prefixed frames, FlatBuffers messages and player or quest records; the documented connection may cover login and initialization rather than live gameplay.