# Curated reverse engineering resources · Page 8

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

## Games (100)

- [Firestaff: rebuilding the Dungeon Master game engines](https://awesomerea.org/resources/firestaff-dungeon-master-case/index.md): Case study · Firestaff rebuilds runtime paths for Dungeon Master, Chaos Strikes Back, Dungeon Master II and Theron's Quest using original media supplied by the player. It identifies editions by content hash and keeps their data separate from its native engine. Source-linked reports and regression checks document supported startup and gameplay slices; Nexus currently reaches a limited Saturn title presentation path.
- [Freelancer.Reverse.Runtime: reconstructing the game's dacom.dll interface](https://awesomerea.org/resources/freelancer-reverse-runtime-case/index.md): Case study · Freelancer.Reverse.Runtime reconstructs part of Freelancer (2003)'s runtime DLL interface through a compatible dacom.dll proxy. The proxy loads the original module, forwards exports, and logs calls associated with hashing, string comparison, telemetry, and initialization; the author reports using it in a running game.
- [Wolfenstein (2009) SP: reconstructing the single-player engine](https://awesomerea.org/resources/wolfenstein-2009-sp-case/index.md): Case study · Wolfenstein (2009) SP rebuilds single-player engine behavior in C++ on idTech4A++, using game data from the user's PC copy. It implements SP PK4, SPK and MPK readers and native tests for player, MP40, actor and trainyard behavior; research notes record findings from the original executables.
- [Chicken Invaders 1: rebuilding the 1999 game](https://awesomerea.org/resources/chicken-invaders-1-case/index.md): Case study · Chicken Invaders 1 rebuilds the original 1999 game in C++ with a separate UveDX engine layer. Its reverse-engineering notes cover game classes, scoring and file formats, while the author reports that the current build is playable despite remaining bugs and decompiled variable names.
- [recherno: investigating Chernobyl: The Legacy Continues in a custom virtual machine](https://awesomerea.org/resources/recherno-chernobyl-case/index.md): Case study · recherno investigates Chernobyl: The Legacy Continues by running its original Fortran/Win32 engine inside a custom virtual machine. It uses Unicorn to execute the engine and Capstone for debugging. Engine API reconstruction and a Qt GUI for controlling game functions are in progress, with removal of the original binary blobs planned later.
- [Goldenland 2: documenting the game’s data formats](https://awesomerea.org/resources/goldenland-2-cold-heaven-case/index.md): Case study · Goldenland 2 format research maps the game’s PAK archives, CSX sprites, SDB string databases and ITM item records. It includes Kaitai Struct schemas, a Total Commander viewer for ITM and SDB, and an XnView CSX plugin.
- [WCW/nWo Thunder: a PlayStation decompilation](https://awesomerea.org/resources/wcw-nwo-thunder-case/index.md): Case study · WCW/nWo Thunder reconstructs source for the PlayStation game from a work-in-progress disassembly. Its build takes SLUS_007.79, WGAME.BIN and WMENU.BIN from the user's disc and checks generated binaries against expected checksums.
- [alive-serv: reconstructing the SIF2 MIRACLE LIVE! server](https://awesomerea.org/resources/alive-serv-case/index.md): Case study · alive-serv reconstructs part of the SIF2 MIRACLE LIVE! game server in C from the global client's server protocol. Its four endpoints return an asset hash, initiate login, return a startup token and log client errors; the client can reach the title screen and part of login.
- [TL2BetaMiniLobby: reconstructing the Torchlight 2 beta lobby](https://awesomerea.org/resources/tl2-beta-mini-lobby-case/index.md): Case study · TL2BetaMiniLobby reconstructs the lobby service required by the May 2012 Torchlight 2 beta. Its C# server handles lobby messages so the beta client can start offline after its configured lobby host is changed to localhost; the author reports testing client version 0.20.8.1.
- [Uncharted Waters: New Horizons — a native Windows static recompilation](https://awesomerea.org/resources/uncharted-waters-new-horizons-static-recomp-case/index.md): Case study · Uncharted Waters: New Horizons is statically recompiled into a native Windows 10/11 application that uses the player's own USA/Canada NTSC ROM. The source includes generated native code, a target core and an SDL frontend, with an optional headless connector. Widescreen support remains experimental.
- [Battalion Wars 2: a Rust and Bevy engine reconstruction](https://awesomerea.org/resources/battalion-wars-2-rust-decomp-case/index.md): Case study · Battalion Wars 2 is reconstructed as a native Rust and Bevy engine that loads archives, models, terrain, audio and Lua 5.0 mission bytecode from a user-supplied Wii disc image. The project documents PowerPC main.dol analysis used to implement native Lua bindings. The author reports playable campaign and multiplayer maps while listing remaining physics, AI and shader parity work.
- [Rayman: matching decompilation of the PAL PS2 main executable](https://awesomerea.org/resources/rayman-pal-ps2-decomp-case/index.md): Case study · This project decompiles the PAL PlayStation 2 Rayman main executable, SLES_500.44, into C and hand-written assembly. Its build links an ELF at the original addresses and compares the main image and individual functions byte for byte with a locally supplied reference. The author reports 856 of 5,645 functions matching.
- [AutoZone Hot Pursuit: reconstructing Need for Speed: Hot Pursuit](https://awesomerea.org/resources/autozone-hot-pursuit-case/index.md): Case study · AutoZone Hot Pursuit reconstructs the 1998 Need for Speed: Hot Pursuit and Modern Patch in C++ from analysis of their binaries. Its source includes a game framework, a sound module and DirectX 5, 6 and 7 renderer implementations, with documented calling conventions and module callbacks.
- [wotb-dvp: mapping WOTB DVPM and DVPD file structures](https://awesomerea.org/resources/wotb-dvp-case/index.md): Case study · wotb-dvp reconstructs the layout of WOTB DVPM files and the DVPD footer. Its specification maps DVPM metadata, file entries, LZ4 and RFC1951 compression identifiers, CRC32 fields and both footer structures.
- [Haxball Rooms API: decoding the binary room listing](https://awesomerea.org/resources/haxball-rooms-api-case/index.md): Case study · Haxball Rooms API documents the binary room-listing response used by the Haxball game and displays parsed rooms in a browser table. Its layout notes identify length fields, room IDs, names, flags, coordinates, password status and player counts by byte offset.
- [Splitgate Backend: a local replacement for game service endpoints](https://awesomerea.org/resources/splitgate-backend-case/index.md): Case study · Splitgate Backend implements local TypeScript service routes for the game's backend and redirects Splitgate's AccelByte requests to them through Fiddler or mitmproxy. The repository includes authentication, lobby, profile and WebSocket routes. Its data workflow captures HTTP calls for item and section information.
- [Dragon Ball Z: The Legacy of Goku — a byte-exact GBA disassembly](https://awesomerea.org/resources/legacy-of-goku-disasm-case/index.md): Case study · This project disassembles code from the USA Game Boy Advance release of Dragon Ball Z: The Legacy of Goku into ARM and Thumb assembly and reports a byte-identical ROM rebuild using data from the user's own copy. Build scripts generate assembly for identified code, rebuild compressed streams and compare the resulting image digest with the retail ROM. The author reports that much of the image is source-generated while remaining bytes come from local ROM slices.
- [MDK in Godot: a port from game data and executable analysis](https://awesomerea.org/resources/mdk-godot-case/index.md): Case study · MDK in Godot ports the 1997 game MDK to Godot 4.7 using analysis of its data files and MDKD3D.EXE. It loads levels, media and scripts from the player's installed game and documents file formats, engine behavior and the script virtual machine. The author reports that all six levels run, while playtesting and bug fixing continue.
- [Paper Hexagon: a reconstructed Super Hexagon port for Linux and Playdate](https://awesomerea.org/resources/paper-hexagon-super-hexagon-case/index.md): Case study · Paper Hexagon ports reconstructed Super Hexagon game code from the GOG Linux build to modern Linux and Playdate. Its Playdate shim replaces openFrameworks rendering, audio, input and persistence interfaces while retaining the game logic. The research documents byte-matching functions and behavioral trace comparisons; users supply their own music and sound assets.
- [TFM2DB Field Notes: mapping Teamfight Manager 2 database records](https://awesomerea.org/resources/tfm2db-field-notes-case/index.md): Case study · TFM2DB Field Notes maps selected Teamfight Manager 2 database records and provides template-based CSV roundtrip tools. The notes cover the TFM2 gzip wrapper, CRC32, record kinds, dynamic player offsets and fixed-width fields that the importer can patch in a matching database.
- [Speedos: a black-box replica of the Spe_ed game model](https://awesomerea.org/resources/speedos-case/index.md): Case study · Speedos reconstructs the Spe_ed game rules as a Mesa model with interfaces shared by the original game. Multi-Minimax agents use the model to simulate future actions, with a Voronoi heuristic for evaluation and iterative deepening for search. The repository includes recorded games from the original for testing the model.
- [AFS Volume 2.00 specification: reconstructing Tenchu archives](https://awesomerea.org/resources/afs200tools-case/index.md): Case study · AFS200Tools documents the AFS Volume 2.00 archive format found in PlayStation Tenchu games. It records the big-endian header, 36-byte file entries, file table placement and a tentative filename scheme, alongside C# source for handling volumes.
- [Zelda: The Wand of Gamelon: a matching CD-i decompilation](https://awesomerea.org/resources/zelda-wand-of-gamelon-decomp-case/index.md): Case study · Zelda: The Wand of Gamelon's CD-i main program is reconstructed as C compiled with Apple MPW C 3.0. The author reports byte-identical builds for English, French, German and Dutch versions after extracting data from the user's disc and checking each output hash.
- [som-decomp: reconstructing Secret of Mana from a cartridge ROM](https://awesomerea.org/resources/som-decomp-case/index.md): Case study · som-decomp reconstructs the North American SNES release of Secret of Mana with matching 65816 and SPC700 assembly, readable C routines and documentation of combat, AI, maps, menus and audio. Its build extracts data from the user's ROM and the author reports a byte-exact rebuilt image; captured-state differential checks cover much of the recovered C.
- [Jade Empire: a native port by x86-to-Odin static recompilation](https://awesomerea.org/resources/jade-empire-recomp-case/index.md): Case study · A native Jade Empire: Special Edition port statically translates the user's x86 game executable into Odin. It replaces Windows, Direct3D 9, DirectSound and Bink services with SDL3, OpenGL and FFmpeg and adds controller support and two-player co-op.
- [Sengoku Basara 4 Sumeragi: rehosting the PS4 game on Windows](https://awesomerea.org/resources/basara-4-sumeragi-native-pc-case/index.md): Case study · Sengoku Basara 4 Sumeragi Native PC provides a Windows runtime for a user-supplied PS4 game folder. It links the game's executable and system modules and adapts shadPS4 graphics components to a Vulkan presentation layer, with launcher controls for display and input.
- [nfsu2_decomp: a native reconstruction of Need for Speed: Underground 2](https://awesomerea.org/resources/nfsu2-decomp-case/index.md): Case study · nfsu2_decomp rewrites logic from the PS2 PAL release of Need for Speed: Underground 2 as native Linux C++ and uses the user's disc data at runtime. The implementation replaces PS2 graphics and audio paths with OpenGL and SDL2, reads ZDIR.BIN and ZZDATA archives, and documents recovered vehicle physics and file decoding. The project describes its current build as a playable prototype.
- [TH05: reconstructing Touhou 5's PC-98 programs](https://awesomerea.org/resources/th05-reconstruction-case/index.md): Case study · TH05 reconstructs source for the Japanese PC-98 Touhou 5: Mystic Square programs MAIN.EXE, OP.EXE, MAINE.EXE and ZUN.COM. Maintained C/C++ and reviewed assembly are compared against bounded original code and data extents, including raw bytes and relocation order. The project reports accepted units separately from its still unmeasured overall authored-byte goal.
- [Thrasher: Skate and Destroy: a matching PlayStation decompilation](https://awesomerea.org/resources/thrasher-skate-decomp-case/index.md): Case study · Thrasher: Skate and Destroy is being reconstructed function by function as C for its US PlayStation executable. The author reports a byte-identical full build from C and assembly, using a pinned PsyQ-era compiler, per-function comparison and a final SHA-1 check.
- [xmen2-pc: a matching decompilation and native port of X-Men 2: Clone Wars](https://awesomerea.org/resources/xmen2-pc-case/index.md): Case study · xmen2-pc reconstructs X-Men 2: Clone Wars as handwritten C and ports it to Windows and Linux without 68000 emulation. Its workflow uses a byte-matching disassembly, static recompilation and the original Apple MPW C 3.3 compiler; the author reports machine-code matches for 3,047 C functions and instruction-level comparisons for 117 assembly functions. The port loads graphics, sound and levels from the user's ROM and adds widescreen play, higher display rates and rollback netplay.
- [xmen2disasm: rebuilding X-Men 2 from a matching disassembly](https://awesomerea.org/resources/xmen2disasm-case/index.md): Case study · xmen2disasm reconstructs the Sega Genesis game X-Men 2: Clone Wars as a byte-matching 68000 disassembly. Its build reads data from the user's ROM, and emulator traces support function boundaries, labels and coverage checks. The author reports a byte-identical ROM rebuild; the related C reconstruction and native PC port reside in xmen2-pc.
- [TH06: reconstructing Japanese 1.02h authored functions](https://awesomerea.org/resources/th06-strict-reconstruction-case/index.md): Case study · TH06 reconstructs the Japanese 1.02h game executable using a maintained source tree based on GensokyoClub/th06 and a pinned VC7.0 build. Its scripts compare complete function extents and COFF relocations; the author reports exact matches for 493 reviewed authored functions.
- [Playcard Cosmic: a native port from executable analysis](https://awesomerea.org/resources/playcard-cosmic-port-case/index.md): Case study · Playcard Cosmic recreates the 2000 Windows shoot-'em-up in C++20 and SDL3 for Windows, Linux and macOS. Its analysis maps original executable functions and Win32 resources; the port reads graphics and sound from the user's COSMIC.EXE and replaces DirectX subsystems.
- [Phantom Blade Zero: documenting the PBZS v3 save format](https://awesomerea.org/resources/phantom-blade-zero-save-format-case/index.md): Case study · Phantom Blade Zero Save Format documents the PBZS v3 save container used by the game's Steam PC release. It maps the cleartext header, AES-256-GCM block framing, directory records and slot compression codes, and includes a Node.js script that checks file structure and SHA-256.
- [Ignition: porting the 1997 racing game from executable analysis](https://awesomerea.org/resources/ignition-port-case/index.md): Case study · Ignition ports the 1997 racing game by reading routines in its Windows executable with IDA and rewriting their behaviour in portable C99. The port loads data from the user's disc image and provides races, championships, audio and multiple platform hosts. Source files, executable-analysis notes and per-routine progress records document the reconstruction.
- [KULT: a C reconstruction of the Atari ST game's core](https://awesomerea.org/resources/kult-atari-st-c-case/index.md): Case study · kult-atari-st-c hand-reimplements the core of the Atari ST game Kult: The Temple of Flying Saucers in documented C, using an assembly decompilation as its behavioral reference. A Musashi-based differential harness runs original routines and compares memory and registers with the C candidates. The repository supplies core code and tests.
- [Dragon Ball Z on the Nintendo 64: recompiling two GBA games for N64](https://awesomerea.org/resources/dbz64-case/index.md): Case study · Dragon Ball Z on the Nintendo 64 statically recompiles ARM and Thumb code from The Legacy of Goku II and Buu's Fury into C for N64 builds. Its runtime supplies GBA graphics, sound, DMA, timers, interrupts and saves, with an RDP renderer and wider field view. The author reports both games playable on real hardware.
- [Katten Project: Plus+ and Touch Pets server reimplementation](https://awesomerea.org/resources/katten-case/index.md): Case study · Katten Project reimplements server behavior for the Plus+ social gaming network and the Touch Pets games. Python modules provide account, session, cloud-save and leaderboard endpoints, while research notes describe XML elements parsed by Touch Pets clients. The project also includes a script that patches a user's game binary to stop using HTTPS.
- [DEArmoredcoreV: statically recompiling Armored Core V for Linux](https://awesomerea.org/resources/dearmoredcorev-case/index.md): Case study · DEArmoredcoreV develops a Linux port of the Xbox 360 game Armored Core V by translating PowerPC instructions to C++ through ReXGlue. Its tools inspect BHD5/BDT, BND3, FLVER, TPF and Xbox 360 texture resources, while research notes track reconstructed behavior by address and function. The author reports an existing Linux package and an unresolved Mission 2 black-screen hang.
- [PC-3Ddot: statically recompiling 3D Dot Game Heroes for PC](https://awesomerea.org/resources/pc-3ddot-case/index.md): Case study · PC-3Ddot develops a native PC port of the PS3 game 3D Dot Game Heroes by statically recompiling its EBOOT for the ps3kit runtime. It includes a disc reader, file-format documentation and tools for inspecting the executable and assets. The author reports that the recompiled game reaches playable field maps, including combat and movement between maps.
- [TH11: byte-exact source reconstruction of Subterranean Animism](https://awesomerea.org/resources/th11-reconstruction-case/index.md): Case study · TH11 reconstructs source for the original Japanese 1.00a executable of Touhou 11: Subterranean Animism. It records function boundaries and origins, compiles maintained C and C++ with a pinned VC9 toolchain, and compares complete generated code and relocations with the target.
- [Link: The Faces of Evil: matching CD-i program decompilation](https://awesomerea.org/resources/link-faces-of-evil-decomp-case/index.md): Case study · Link: The Faces of Evil Decompilation reconstructs the Philips CD-i game's cdi_link main program as C source. Its build compiles functions with Apple MPW C 3.0, places them in the module and compares the resulting SHA-1 with the original from a user's disc. The author reports matching builds for English, French, German and Dutch releases.
- [358/2 Days for Android: porting Kingdom Hearts to dual-screen devices](https://awesomerea.org/resources/khdays-358-android-case/index.md): Case study · 358/2 Days for Android ports Kingdom Hearts 358/2 Days to Android using the upstream khdays-port and its decompiled C game code. It adds an Android app, ROM import, touch controls and a two-screen layout for the AYN Thor; on one-screen devices, both game screens share the display.
- [Nagano Winter Olympics '98: matching Nintendo 64 decompilation](https://awesomerea.org/resources/nagano-winter-olympics-98-decomp-case/index.md): Case study · Nagano Winter Olympics '98 decompilation reconstructs the USA Nintendo 64 release with compiled source and a mapped ROM data region. Its verification commands compare relocated program bytes with a user-provided retail ROM, while analysis files classify and reproduce non-code intervals. The author reports complete byte matching for catalogued functions and initialized data.
- [pc-abelsmt: statically recompiling ABEL for PC](https://awesomerea.org/resources/pc-abelsmt-case/index.md): Case study · pc-abelsmt ports the FM Towns game ABEL - Shin Mokushiroku Taisen to PC by statically recompiling its 386 programs and TBIOS to C++ on fmtownskit. It includes a runtime, extraction and comparison tools, and notes on disc and executable formats. The author reports that early screens match MAME pixel for pixel.
- [Madden Football 64: matching Nintendo 64 decompilation](https://awesomerea.org/resources/madden-football-64-decomp-case/index.md): Case study · Madden Football 64 decompilation reconstructs portions of the USA Rev 0 Nintendo 64 game's code and maps its packed ROM layout. Build commands recover the resident program, compare compiled C units byte for byte with retail code and track assembly references separately. The author reports 19.60% of whole-program code as matching decompiled C at the documented snapshot.
- [Rugrats: Scavenger Hunt: matching reconstruction of the USA N64 release](https://awesomerea.org/resources/rugrats-scavenger-hunt-case/index.md): Case study · Rugrats: Scavenger Hunt reconstructs the USA Nintendo 64 game with matching C, reviewed assembly, symbolic RSP code and descriptions of initialized data. Its tools rebuild CPU units with recorded compiler pipelines and compare code and non-code regions with a player-supplied ROM. The author reports complete executable-byte and ROM-inventory coverage.
- [Ninja Gaiden Black: running Xbox game code on a native Windows runtime](https://awesomerea.org/resources/ninja-gaiden-black-port-case/index.md): Case study · Ninja Gaiden Black native PC port runs the original Xbox game's x86 code inside a 32-bit Windows process. Its C runtime supplies an XBE loader, replacement Xbox kernel, NV2A-to-OpenGL renderer and APU audio engine; Python tools and notes document game formats and executable behaviour. The launcher imports files from the user's disc.
- [poketaka-sim: reconstructing PokéTaka battle rules from replays](https://awesomerea.org/resources/poketaka-sim-case/index.md): Case study · poketaka-sim reconstructs PokéTaka battle behavior from replay logs and simulates a recorded match hit by hit. It converts damage observations into interval constraints, compares candidate critical-hit and rounding rules, and checks the inferred model against held-out hits. The author reports exact reproduction of 255 observed hits in the example battle.
- [SOCOM Legacy: a browser reconstruction of SOCOM II](https://awesomerea.org/resources/socom-legacy-case/index.md): Case study · SOCOM Legacy rebuilds SOCOM II U.S. Navy SEALs in TypeScript and three.js for browser multiplayer, loading maps and other game data from the user's own disc. The project records values read from disc data and game code, and tracks parity for menus, online flow, maps, and matches while its multiplayer implementation continues to develop.
- [Tony Hawk's Underground: a matching PS2 decompilation](https://awesomerea.org/resources/tony-hawks-underground-ps2-decomp-case/index.md): Case study · Tony Hawk's Underground is being reconstructed as matching C++ for the NTSC-U PlayStation 2 release SLUS-20731. The project splits the ELF into functions, compiles each recovered function with a pinned SN Systems toolchain and compares instructions; remaining functions are assembled so the complete build can be checked against the user's disc by SHA-1.
- [Soleanna: a static recompilation of Sonic the Hedgehog (2006) for PC](https://awesomerea.org/resources/soleanna-sonic-2006-case/index.md): Case study · Soleanna builds a native Windows port of the PlayStation 3 version of Sonic the Hedgehog (2006) from the user's BLES00028 disc. Its launcher decrypts EBOOT.BIN with RPCS3, uses ps3recomp to translate PowerPC code to C, and compiles an x86-64 executable with a high-level PS3 runtime and Direct3D 12 rendering.
- [P3P3DS: running Persona 3 Portable on New Nintendo 3DS](https://awesomerea.org/resources/p3p3ds-case/index.md): Case study · P3P3DS adapts Persona 3 Portable's North American PSP release for New Nintendo 3DS through static MIPS-to-C++ recompilation, an interpreter fallback and a PSP service runtime. Its research documents the game's ELF32 PRX executable, relocations and imports. The author reports early playable progress on hardware, with sound and opening video still absent.
- [wc2-re: a matching Wing Commander II reconstruction and SDL2 port](https://awesomerea.org/resources/wc2-re-case/index.md): Case study · wc2-re reconstructs Wing Commander II source from its Kilrathi Saga Win32 release and provides an SDL2 port. The C game core and C++ audio library rebuild with Visual C++ 4.1; the author reports that the resulting WC2.EXE matches all 714,752 bytes of the retail executable. The port runs with user-supplied game data on Windows, Linux and macOS.
- [Abyssal: a Godot engine for DEEP using the player's JAR](https://awesomerea.org/resources/abyssal-deep-case/index.md): Case study · Abyssal reimplements the mobile game DEEP in a Godot engine for desktop, browser and Android. It converts a player-provided MIDlet JAR locally, decoding resources and evaluating selected class-file data tables to supply the engine. The implementation covers submarine piloting, stations, trading, missions and combat.
- [CSVM: a Crimson Skies engine built from game-data and executable analysis](https://awesomerea.org/resources/csvm-case/index.md): Case study · CSVM reimplements the Crimson Skies (2000) engine in Godot and reads game data from the player's own install or disc. Its C# readers handle original formats, while format and behavior notes draw on data inspection, comparison with the game, and static analysis of crimson.exe. The build covers campaign, Instant Action and multiplayer modes.
- [d2-dedicated-server: reconstructing a Diablo II realm and game-server stack](https://awesomerea.org/resources/d2-dedicated-server-case/index.md): Case study · d2-dedicated-server rebuilds a self-hosted Diablo II realm and headless game-server stack. Its Zig services handle Battle.net-style login, character and game operations, while an ingress reads the game's GAMELOGON token to route connections. A separate native variant maps the 1.14d macOS Mach-O game image onto i386 Linux.
- [accd: reconstructing the Assetto Corsa Competizione dedicated server](https://awesomerea.org/resources/accd-assetto-corsa-competizione-server-case/index.md): Case study · accd reconstructs the Assetto Corsa Competizione dedicated server in C99 for Linux and BSD systems. It accepts unmodified game clients and implements the observed connection handshake, session scheduling, car updates, results and telemetry messages. The repository includes server source and protocol validation tools.
- [Pokémon Generation I: static recompilation with trace-driven testing](https://awesomerea.org/resources/pokemon-generation-one-recomp-case/index.md): Case study · Pokémon Red, Blue and Yellow are built as native executables by translating their Game Boy SM83 code into C with gb-recompiled. The repository adds game-specific build recipes, PyBoy trace capture and a headless Red and Blue bridge for differential memory and frame testing. The author reports Red gameplay, Blue reaching its title screen and Yellow's opening sequence rendering.
- [HMC47: reconstructing Hitman: Codename 47](https://awesomerea.org/resources/hmc47-case/index.md): Case study · HMC47 reconstructs Hitman: Codename 47 from the original game binaries as a modular C++ implementation. Its source covers a launcher and modules for DirectPlay, shared engine data, graphics and sound, while full playability and 64-bit support remain goals.
- [AfroSamuraiRecomp: an Xbox 360 static recompilation of Afro Samurai](https://awesomerea.org/resources/afrosamurairecomp-case/index.md): Case study · AfroSamuraiRecomp statically translates the Europe Xbox 360 release of Afro Samurai into a native Windows x64 program using ReXGlue. The repository supplies game-specific function boundaries, hooks, a launcher and GPU and audio patches; the author reports playable 30 FPS operation on one PC.
- [OpenPlatinum: rebuilding Pokémon Platinum in a native engine](https://awesomerea.org/resources/openplatinum-case/index.md): Case study · OpenPlatinum reimplements Pokémon Platinum's field engine in C++17 with SDL3 and OpenGL for Windows and macOS. It reads the user's French or US .nds dump, parses cartridge formats and runs game scripts on its own VM, using the pret decompilation as a behavior reference; several gameplay systems remain partial.
- [hercules-native: rebuilding Disney's Hercules Action Game on Apple silicon](https://awesomerea.org/resources/hercules-native-case/index.md): Case study · hercules-native reimplements the 1997 Disney's Hercules Action Game engine in C11 and SDL2 for Apple silicon Macs. It reads scripts, state tables and assets from the user's PC game files, with decoders for HERCULES.FS, sprite banks, maps and ETV videos; the author reports all levels playable with some missing effects.
- [reEgg: an Egg, Inc. server emulator for version 1.12.13](https://awesomerea.org/resources/reegg-case/index.md): Case study · reEgg reconstructs part of the server behavior used by Egg, Inc. mobile game version 1.12.13 in Python. Developed alongside research into the game's protobuf API, it provides responses for selected first-contact, calendar, contract and event functions while its roadmap lists unfinished services.
- [gopenfusion: reconstructing FusionFall packet services](https://awesomerea.org/resources/gopenfusion-case/index.md): Case study · gopenfusion reconstructs part of FusionFall's packet protocol and server services in Go. Its login server and dummy shard support basic joining, movement, chat and limited NPC interactions; a generator derives structures from a decompiled game assembly.
- [PTD2 Server: rebuilding Pokémon Tower Defense 2 services](https://awesomerea.org/resources/ptd2-server-case/index.md): Case study · PTD2 Server reconstructs online services for the Flash game Pokémon Tower Defense 2 from analysis of its original SWF. Its PHP endpoints and save codecs support story, gym, one-on-one and trainer-versus modes, with MySQL-backed saves.
- [Reko-Btech: Crescent Hawks image and map format findings](https://awesomerea.org/resources/reko-btech-case/index.md): Case study · Reko-Btech investigates the 1988 MS-DOS game Crescent Hawks: Inception using Reko decompilation project files. Its findings describe run-length encoding in ICN and CMP images and two layout schemes for MTP map files. Following the project requires the user's own game executable and data files.
- [MobiGoEmu: reconstructing the VTech MobiGo console](https://awesomerea.org/resources/mobigoemu-case/index.md): Case study · MobiGoEmu reconstructs the VTech MobiGo handheld in C so user-provided system ROM and cartridge images can run with touch, keyboard, pad and sound support. Its research covers the GeneralPlus u'nSP CPU and cartridge-derived ADPCM36 audio format, supported by a small disassembler and CPU comparison tools.
- [fh2-world-formats: reconstructing Forza Horizon 2 world file formats](https://awesomerea.org/resources/fh2-world-formats-case/index.md): Case study · fh2-world-formats reconstructs the file formats behind the Forza Horizon 2 world and supplies Python tools for reading and changing them. Its research covers PGZP GeoChunk archives, ChunkMap indexes, ModelBin meshes, PhysicsTemplate collision, placement cells and WVAN navigation data; the author reports byte-exact round trips and a visible custom-geometry experiment.
- [FSGCore: reconstructing the DJ Hero 2 core library](https://awesomerea.org/resources/fsgcore-case/index.md): Case study · FSGCore reconstructs the C++ core library used by DJ Hero 2 to support decompilation of the game. The repository contains headers and implementations for strings, math, memory, files, logging and system facilities, assembled as a shared library with CMake.
- [Chao Resort Island X: rebuilding the Chao Resort webserver](https://awesomerea.org/resources/chaoresortwebserver-case/index.md): Case study · ChaoResortWebserver recreates the Chao Resort server in Flask for the Chao Resort Island X mod. The repository contains Python server and database modules; the author reports that the replacement is functional and faster than the original implementation.
- [RECAR: rebuilding the RACER Chrome Experiment server](https://awesomerea.org/resources/recar-racer-server-case/index.md): Case study · RECAR rebuilds the server for the RACER Chrome Experiment game. Its Node.js code provides HTTPS and WebSocket services, with instructions for connecting a separately downloaded official client to the replacement server.
- [Ganbare Goemon 3: a checksum-checked SFC disassembly](https://awesomerea.org/resources/ganbare-goemon-3-disassembly-case/index.md): Case study · The Ganbare Goemon 3 project reconstructs the Super Famicom game's ROM as assembly, with bank maps and notes on asset, compression and text formats. Its build extracts required data from the user's unmodified v1.0 ROM and can compare the result with the documented SHA-1.
- [TamagoC: a Tamagotchi implementation from observation](https://awesomerea.org/resources/tamagoc-case/index.md): Case study · TamagoC implements Tamagotchi-style virtual-pet behaviour from observation. Its C core models feeding, health, happiness, discipline, waste and a play outcome counter.
- [Marble Knights Recompiled: an iOS game port by static recompilation](https://awesomerea.org/resources/marble-knights-recompiled-case/index.md): Case study · Marble Knights Recompiled ports the iOS game to Windows by translating ARM64 functions in its UnityFramework into C and compiling them into a GameAssembly.dll for the Unity 2019.4.17f1 Windows player. A compatibility layer replaces iOS services, while preparation scripts process the player's own game data; the project also describes an Android path using a Mach-O loader.
- [Prineo_RE: PriPara arcade model-format investigation](https://awesomerea.org/resources/prineo-re-case/index.md): Case study · Prineo_RE investigates the PriPara arcade games' model and resource formats and provides a Noesis addon to load skinned meshes, encrypted assets and texture bindings. Its notes describe BIN containers, MDJ geometry and scene chunks, and modified hashing and pseudorandom routines encountered during format analysis.
- [Wizardry 6: reconstructing game formats and systems](https://awesomerea.org/resources/wizardry-6-reconstruction-case/index.md): Case study · Wizardry 6 investigates the data formats and systems of Bane of the Cosmic Forge, with parsers and viewers for graphics, maps, scenario records, text and sound. It includes portrait and character-roster editors and a developing Python game engine that reads original game data.
- [Reverse Engineering Scorcher: extracting its resource archive and images](https://awesomerea.org/resources/reverse-engineering-scorcher-case/index.md): Case study · Reverse Engineering Scorcher investigates the 1996 game's asset formats through a Python extractor. The script opens TAGDEN.BIN, extracts its resources and converts R0V images to PNG; the format inventory identifies additional files, including WL3 models and HMP heightmaps, that remain undecoded.
- [Precursor: Android ARM64 port of the Jak and Daxter trilogy](https://awesomerea.org/resources/precursor-android-jak-case/index.md): Case study · Precursor ports the Jak and Daxter trilogy to Android ARM64 using OpenGOAL's recovered GOAL code and tools. It adds an AArch64 compiler backend, C++–GOAL call bridges, an OpenGL ES 3.2 renderer, and a phone launcher that extracts and compiles game data from the user's PS2 ISO. The author reports that all three games boot on a phone, with different portions playable.
- [Grand Prix Circuit: a native Rust port of the 1988 DOS game](https://awesomerea.org/resources/grand-prix-circuit-recomp-case/index.md): Case study · Grand Prix Circuit is a Rust port of the 1988 DOS racing game that loads the user's GPEGA.EXE and game assets. Its code handles EXEPACK unpacking, x86 instruction execution, EGA graphics, and DOS/BIOS services; the port also offers 60 FPS motion interpolation and a Commodore 64 display and audio mode.
- [OpenInsaniquarium: reimplementing Insaniquarium Deluxe](https://awesomerea.org/resources/openinsaniquarium-case/index.md): Case study · OpenInsaniquarium reimplements Insaniquarium Deluxe 1.1 in Rust with a deterministic simulation and Bevy presentation layer. It loads assets from the user's game installation and uses captured original-game traces for tick-by-tick comparisons; the author reports that the preview covers Adventure's first tank and all 24 pets in testing.
- [Durak NX: running the Durak Android game on Nintendo Switch](https://awesomerea.org/resources/durak-nx-case/index.md): Case study · Durak NX runs the Android ARM64 Unity game Durak 25.0 on Nintendo Switch through a target-specific compatibility layer for graphics, audio, files and input. The project documents ELF and IL2CPP analysis of the game's libraries and loads locally extracted files from the user's own Android package; the author reports menus, gameplay and sound working on Switch hardware.
- [OpenCE PS4: porting Halo: Combat Evolved to PlayStation 4](https://awesomerea.org/resources/opence-ps4-case/index.md): Case study · OpenCE PS4 ports OpenCE's reconstructed Halo: Combat Evolved code to a jailbroken PlayStation 4. It builds the game as x32 code inside a PS4 host, maps platform services and DualShock 4 input, and routes OpenGL ES rendering through Mesa Zink and RADV; game maps come from the user's own Xbox copy.
- [SR1 Creator: rebuilding the Saints Row character creator](https://awesomerea.org/resources/sr1-creator-case/index.md): Case study · SR1 Creator recreates the Saints Row (2006) character creator in a browser using meshes, morph targets, textures and tables read from the user's Saints Reborn folder. JavaScript readers handle VPP packfiles, PEG textures, character meshes and morphs; the author reports comparing geometry and camera behavior with the running game. A photo-fitting view estimates face sliders from landmarks.
- [Dragon Ball Z: The Legacy of Goku II: a byte-matching GBA disassembly](https://awesomerea.org/resources/legacy-of-goku-ii-disassembly-case/index.md): Case study · Dragon Ball Z: The Legacy of Goku II is reconstructed as a byte-matching GBA disassembly using ARM and Thumb assembly generated from the user's USA ROM. The build also re-encodes game containers, carries remaining bytes as slices of that ROM and compares the output with the retail digest. The author reports that 68.2846% of the ROM builds from tracked source.
- [LSD: Dream Emulator: a matching PlayStation decompilation](https://awesomerea.org/resources/lsd-decomp-case/index.md): Case study · lsd-decomp reconstructs C source for the SLPS-01556 PlayStation release of LSD: Dream Emulator and checks the rebuilt executable by SHA-1. It documents the dream graph, links, randomness and engine systems with function addresses, alongside emulator-based observations; the author reports that all game functions rebuild to the retail bytes.
- [Battle Engine Aquila: a matching PC decompilation](https://awesomerea.org/resources/onslaught-decomp-case/index.md): Case study · onslaught-decomp reconstructs Battle Engine Aquila's PC game code from a published GPL source release and retail executable evidence. It compiles C++ with Visual C++ 6.0 SP5 and compares function sections with BEA.exe; the author reports matches for 5,449 of 5,482 retail functions, with the remaining 33 tied to omitted DirectX sample files.
- [ash: reimplementing a Dark Souls slice for PSP](https://awesomerea.org/resources/ash-dark-souls-case/index.md): Case study · ash reimplements a limited Dark Souls: Remastered experience in a C99 engine for Sony PSP hardware. Local converters prepare models, animations and parameters from the user's game copy; the engine provides combat, rendering and AI bytecode execution. The author reports playing from the Northern Undead Asylum to Firelink Shrine on a PSP Street E1000.
- [rrt2-decomp: a Rust reimplementation of Railroad Tycoon II](https://awesomerea.org/resources/rrt2-decomp-case/index.md): Case study · rrt2-decomp reimplements Railroad Tycoon II in Rust after studying the Platinum executable, game data and simulation rules. Its crates parse PK2 archives, LAD sprites, maps and saves, while a differential harness runs original functions for comparison; the new game uses the player's installed assets and a wgpu renderer.
- [Onslaught CE: a native Battle Engine Aquila port](https://awesomerea.org/resources/onslaught-ce-case/index.md): Case study · Onslaught CE ports Battle Engine Aquila to native 32-bit Linux and Windows builds using the game's public source and a separate matching decompilation. Its SDL3 platform layer supplies window, input and audio support, with Direct3D 9 through dxvk-native on Linux and the system implementation on Windows; retail data comes from the user's installation.
- [Tony Hawk's Pro Skater: a matching Nintendo 64 decompilation](https://awesomerea.org/resources/thps64-case/index.md): Case study · thps64 reconstructs the C source of Tony Hawk's Pro Skater for Nintendo 64 (US V1.1) from a user-supplied ROM. It splits compressed game code into functions and compares compiled instructions with the original. The author reports a byte-identical default build, 2,449 matching functions and 62 more represented by nonmatching C.
- [Quake 4 Definitive Edition: recovering Xbox 360 controller behavior for PC](https://awesomerea.org/resources/quake4-definitive-case/index.md): Case study · Quake 4 Definitive Edition ports selected Xbox 360 controller behavior into openQ4 patches for the PC game. The project documents analysis of default.xex to recover stick dead zones, a square gate, look curves and turn speeds, then adds controller settings and aim-assist behavior to the engine.
- [Luna Purpura: reimplementing Purple Moon game formats and playback](https://awesomerea.org/resources/luna-purpura-case/index.md): Case study · Luna Purpura works toward a portable interpreter for 1990s Purple Moon games, including Rockett's New School, using the user's original CD-ROM files. Ruby format-research tools, C decoders and Lua bindings support a developing LÖVE-based player. The author describes the implementation as an early research-stage work.
- [Digimon World 2003: a handheld port of the matching decompilation](https://awesomerea.org/resources/dw3-handheld-port-case/index.md): Case study · Digimon World 2003 adapts an upstream matching decompilation and PC port for RK3326 Linux handhelds including the R36S and XF35H. The fork adds direct framebuffer output, a Mali GLES renderer, Cortex-A35 and NEON performance work, a gamepad menu and PortMaster packaging. The decompilation and PC port originate with gascarcella/dw2003recomp.
- [Shadow the Hedgehog: a matching GameCube decompilation](https://awesomerea.org/resources/shadow-gc-decomp-case/index.md): Case study · Shadow the Hedgehog reconstructs C++ source for the USA Rev 0 GameCube release using the original Metrowerks toolchain. The project compares its rebuilt main.dol with the retail executable byte for byte and publishes function progress, symbols and compiler research notes.
- [Final Fantasy Crystal Chronicles: Echoes of Time: a Wii static recompilation for PC](https://awesomerea.org/resources/pc-ffcceotwii-case/index.md): Case study · pc-ffcceotwii statically recompiles the European Wii release of Final Fantasy Crystal Chronicles: Echoes of Time into C++ for PC on the wiikit runtime. Game-specific tools name the stripped DOL using related executables and signatures, while an input layer maps keyboard and mouse controls to Wii Remote, Nunchuk and pointer actions. The author reports reaching gameplay.
- [Hamtaro: Ham-Ham Heartbreak: a matching GBA decompilation](https://awesomerea.org/resources/hamtaro-heartbreak-decomp-case/index.md): Case study · Hamtaro: Ham-Ham Heartbreak reconstructs the European AH3P revision 0 GBA game as C and assembly that builds a specified 16 MiB ROM. Its technical notes cover startup, graphics, actors, scripts, text, sound and saves, and describe ROM equality checks against the original image.
- [pc-4ddriving: a native port of 4D Driving](https://awesomerea.org/resources/pc-4ddriving-case/index.md): Case study · pc-4ddriving ports the FM Towns Marty game 4D Driving by recompiling its 386 program and TBIOS into C++ with fmtownskit. Its SDL3 runtime supports windowed and headless play, and the project compares frames, races and audio with MAME while documenting the disc layout and game resource formats.
- [pc-thequeenofduellist: a native port of The Queen of Duellist](https://awesomerea.org/resources/pc-thequeenofduellist-case/index.md): Case study · pc-thequeenofduellist ports the FM Towns game The Queen of Duellist by recompiling its 386 program and TBIOS code into C++ with fmtownskit. Its runtime displays the game in an SDL3 window, while tools compare frames and audio against MAME; the repository also documents the disc layout, executable and resource formats.
- [NGPC–Dreamcast link cable: reconstructing retail game uploads](https://awesomerea.org/resources/ngpc-dreamcast-link-cable-case/index.md): Case study · The NGPC–Dreamcast link-cable project reconstructs serial exchanges between SNK vs. Capcom: The Match of the Millennium and Capcom vs. SNK: Millennium Fight 2000. A beetle-ngp patch and Python bridge connect RetroArch to Flycast's BattleCable interface; protocol notes and byte logs document the upload sequence. The author reports successful retail transfers in emulation and a prototype transfer to a homebrew responder on a real Dreamcast.