# Curated reverse engineering resources · Page 9

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

## Games (100)

- [Cadence: reimplementing Geometry Dash 2.2091 in Rust](https://awesomerea.org/resources/cadence-geometry-dash-case/index.md): Case study · Cadence reimplements Geometry Dash 2.2091 in Rust for desktop and browser play using the user's game resources. Its notes record binary analysis, level-data study and runtime traces; comparison tools check physics and camera behavior against the original. The author reports step-by-step position and velocity matches on 135 recorded runs, while the project remains in early development.
- [OpenSRO: porting Silkroad Online v1.150 to a browser game stack](https://awesomerea.org/resources/opensro-case/index.md): Case study · OpenSRO ports Silkroad Online v1.150 into a TypeScript and WebGPU browser client with a Go game server. Function-address evidence accompanies ported behavior, and an asset pipeline turns the user's own v1.150 client installation into data for the browser and server.
- [RO3Emu: reconstructing a Ragnarok Online 3 server](https://awesomerea.org/resources/ro3emu-server-case/index.md): Case study · RO3Emu reconstructs a server for the Ragnarok Online 3: Genesis game client. Its C# and .NET 10 code implements multiplayer systems and client-facing message routes, while research notes document observed client behavior and mark uncertain behavior as guesses. The launcher can find an existing game installation or download the game from its update servers.
- [Betrock++: reimplementing the Minecraft Beta 1.7.x server](https://awesomerea.org/resources/betrockplusplus-case/index.md): Case study · Betrock++ reimplements the Minecraft Beta 1.7.x server in C++, aiming to replace the Java server while prioritizing compatibility. Its source covers packet handling, player sessions, world behavior and server commands, and the project allows extensions.
- [NeMo2: reimplementing the Virtools game engine libraries](https://awesomerea.org/resources/nemo2-case/index.md): Case study · NeMo2 reimplements the Virtools game engine's CK2 and VxMath libraries in C++. It provides Virtools object, behavior and scene handling, math and rendering support, and loading and saving for CMO and NMO files, with a Windows 32-bit build targeting Virtools compatibility.
- [OpenDW: porting the original Mac Deepworld client to Windows](https://awesomerea.org/resources/opendw-case/index.md): Case study · OpenDW reverse engineers and ports the original Mac Deepworld client to Windows in C++ with Axmol. The source implements game entities, world rendering, inventory and interface components; builds require user-provided assets, and play requires a compatible server.
- [Mystic Nights Online: reconstructing the PS2 multiplayer server](https://awesomerea.org/resources/mystic-nights-online-case/index.md): Case study · Mystic Nights Online recreates multiplayer services for the PlayStation 2 game Mystic Nights in a Python server. The author derived expected packet replies through Ghidra decompilation of client parsing code, PCSX2 memory inspection and packet fuzzing; the server handles accounts, lobbies and game synchronization.
- [War Storm: reconstructing Sudden Strike II 2.2](https://awesomerea.org/resources/war-storm-case/index.md): Case study · War Storm reconstructs source for Sudden Strike II 2.2 from the game's original binaries. Its code covers the launcher, three resolution-specific renderer modules, menu, and game components, while the author describes a complete playable implementation and 64-bit support as future goals.
- [Seedra: reimplementing Minecraft Legacy Console Edition world generation](https://awesomerea.org/resources/seedra-case/index.md): Case study · Seedra reimplements Minecraft Legacy Console Edition world generation in a C++ library. It generates chunks, maps biomes, locates structures and spawn points, and computes structure loot from seeds, with examples selecting console, game version, world size, and biome scale.
- [AZHS: reconstructing Need for Speed: High Stakes 4.50](https://awesomerea.org/resources/azhs-case/index.md): Case study · AZHS reconstructs Need for Speed: High Stakes 4.50 source from the original game binaries. Its technical notes map Watcom and Visual C++ calling conventions, the eacsnd.dll sound module, and several DirectX 6 and 7 renderer variants; complete playability and broader platform support remain goals.
- [AZMCO: reconstructing Motor City Online and its renderers](https://awesomerea.org/resources/azmco-case/index.md): Case study · AZMCO reconstructs parts of Motor City Online, including an offline launcher and DirectX renderer modules. The author traces most source to reverse engineering original binaries and distinguishes the game's DirectX 7 and DirectX 8 renderer versions; the game is still incomplete.
- [FragmentServer.NetSlum: rebuilding the .hack//Fragment server](https://awesomerea.org/resources/fragmentserver-case/index.md): Case study · FragmentServer.NetSlum reimplements the server for .hack//Fragment in C#. Its networking code handles game request packets, while project documentation covers message framing, encoding and area-server hosting.
- [Gemnet: a Rumble Fighter/Gem Fighter server emulator](https://awesomerea.org/resources/gemnet-case/index.md): Case study · Gemnet reconstructs a server for Rumble Fighter/Gem Fighter, with handlers for inventory, avatars, lobby, chat and P2P gameplay. Its C# packet processor parses message headers, handles optional decryption and dispatches packet types and actions to game-specific handlers.
- [OpenIsolation: reconstructing Alien: Isolation libraries](https://awesomerea.org/resources/openisolation-case/index.md): Case study · OpenIsolation is an early-stage project to reverse-engineer Alien: Isolation's libraries and game code. Current work centers on the CATHODE core library; its C++ source and notes cover original binaries, symbols, class-layout recovery, and platform variants.
- [GunBound: a Swift server reconstruction of GunBound Classic](https://awesomerea.org/resources/gunbound-classic-server-case/index.md): Case study · GunBound reconstructs GunBound Classic's world and broker servers in Swift, with client code for authentication, channels, rooms and matches. Its packet code handles encrypted messages, including AES processing and opcode based checksums.
- [Rerun: rebuilding the Sonic Runners server](https://awesomerea.org/resources/rerun-server-case/index.md): Case study · Rerun rebuilds the Sonic Runners server in C# and ASP.NET Core using earlier research and the Outrun server as a basis. Its source includes login, game, store, leaderboard, and player controllers, while the author says the emulator cannot yet reach the game's main menu and its database setup remains incomplete.
- [sh3-evil-effect: reconstructing Silent Hill 3's Another World Evil effect](https://awesomerea.org/resources/sh3-evil-effect-case/index.md): Case study · sh3-evil-effect recreates the Another World Evil procedural texturing effect from Silent Hill 3. Its implementation uses graphics libraries including GLEW, GLFW, GLM and FreeImage.
- [ORPHEUS: reconstructing an Overwatch 1.74 server](https://awesomerea.org/resources/orpheus-overwatch-server-case/index.md): Case study · ORPHEUS reimplements server behavior for Overwatch 1 retail build 1.74.0.0.104319. Its Python and Rust code covers local login, lobby handoff, encrypted UDP, player input and selected Practice Range simulation for Soldier: 76. The project records observed original-client behavior and tests for selected fixtures, while broader modes and client acceptance remain in progress.
- [My Simulation: reimplementing The Sims Online client](https://awesomerea.org/resources/my-simulation-case/index.md): Case study · My Simulation is an experimental reimplementation of The Sims Online as a multiplayer game. Its client is written in Zig with Raylib, uses NioTSO libraries to read the game's proprietary formats, and connects to a FreeSO-based API server.
- [OpenDW: porting Dragon Wars to a C game engine](https://awesomerea.org/resources/opendw-dragon-wars-case/index.md): Case study · OpenDW ports Dragon Wars from its 16-bit DOS implementation toward a C game engine for modern environments. It builds an SDL2 frontend and uses the player's original DRAGON.COM, DATA1 and DATA2 files; the repository also includes resource extraction tools.
- [Reuromancer: porting Neuromancer to 64-bit Windows](https://awesomerea.org/resources/reuromancer-case/index.md): Case study · Reuromancer ports the MS-DOS game Neuromancer to 64-bit Windows. Its engine uses reverse-engineered game routines and adapted disassembled code, while a separate resource browser examines and exports resources from the game's DAT files. Running the port requires the user's own DOS game data.
- [mm5sound: translating the Mega Man 5 sound driver to C++](https://awesomerea.org/resources/mm5sound-case/index.md): Case study · mm5sound translates Mega Man 5's 6502 assembly sound driver into C++ while retaining ROM addresses near related code. Its comparison workflow builds register-write logs from the user's ROM and checks them against logs from NSFPlay.
- [hearthstone-deck-format: mapping Hearthstone deck strings](https://awesomerea.org/resources/hearthstone-deck-format-case/index.md): Case study · hearthstone-deck-format documents the encoded deck strings used by Hearthstone. It breaks a base64-decoded example into header, hero, single-copy card, double-copy card and footer fields, and explains varint card identifiers. The author incorporated corrections from HearthSim's algorithms and includes Python format and parser files.
- [Flicky: byte-identical Mega Drive source reconstruction](https://awesomerea.org/resources/flicky-src-case/index.md): Case study · Flicky reconstructs the Sega Mega Drive game's 68000 code and Z80 sound driver as annotated assembly. Build scripts split data from the user's ROM, assemble the source, and compare the resulting cartridge image byte for byte; recorded input movies support runtime checks in MAME.
- [Conker: Live & Reloaded — static recompilation of the Xbox game](https://awesomerea.org/resources/conker-live-reloaded-recomp-case/index.md): Case study · Conker: Live & Reloaded translates the European original Xbox game's x86 XBE code into C++ for a native Windows x64 build. Game-specific configuration and hooks work with an Xbox runtime that replaces kernel, graphics, sound, and input services; technical notes document fixes for inlined Direct3D state.
- [ReNFS: rebuilding The Need for Speed Special Edition](https://awesomerea.org/resources/renfs-case/index.md): Case study · ReNFS rebuilds the 1996 DOS release of The Need for Speed Special Edition as a native C and SDL2 game for Linux, Windows and macOS. The author studied NFS_DOS.EXE with Ghidra, rewrote routines by hand and compared racing, physics, rendering and replay behavior with the original. The port reads game tables and assets from the user's own Special Edition CD.
- [pc-castlevaniajudgment: statically recompiling Castlevania Judgment for PC](https://awesomerea.org/resources/pc-castlevaniajudgment-case/index.md): Case study · pc-castlevaniajudgment builds a native PC port of the Wii game Castlevania Judgment by translating its PowerPC executable to C++ with wiikit. Game-specific scripts identify functions using Dolphin symbols and a related executable, while a hook layer maps controller state. The author reports reaching menus, save creation and fights in an initial session.
- [YW4 Recomp: statically recompiling Yo-kai Watch 4++ for PC](https://awesomerea.org/resources/yw4-recomp-case/index.md): Case study · YW4 Recomp translates the ARM64 code of Yo-kai Watch 4++ update 2.2.0 into a native Windows program. Its project runtime and Vulkan renderer support portions of the game from boot through early play and selected later scenes, with graphics changes including ultrawide output and revised shadows.
- [mine-a1.1.2_01-rev: preparing a Minecraft Alpha decompilation for study](https://awesomerea.org/resources/mine-a1-1-2-01-rev-case/index.md): Case study · mine-a1.1.2_01-rev prepares a user-supplied Minecraft Alpha a1.1.2_01 JAR for study with Windows batch scripts and repository patches. Its setup uses IntelliJ and a Java 8 SDK, and the author notes using an MCP patch to correct decompilation artifacts. The work is described as incomplete.
- [Overwatch: mapping highlight-file metadata](https://awesomerea.org/resources/overwatch-highlights-case/index.md): Case study · Overwatch highlight reverse engineering maps metadata embedded near the end of the game's MP4 highlight videos. Its documentation describes the Base64 and UTF-16LE encoded structure and fields for map, hero, skin and highlight type, alongside Java code for working with the findings.
- [pc-demolitionman: statically recompiling the 3DO Demolition Man](https://awesomerea.org/resources/pc-demolitionman-case/index.md): Case study · pc-demolitionman documents a static-recompilation port of the 3DO game Demolition Man using 3dokit. It translates the game's ARM60 programs into C++, boots a user-supplied disc through a Portfolio runtime, and records Gamegun input and boot behavior. The author reports reaching the attract loop and playing light-gun levels in a window.
- [Ratchet & Clank 3: matching PlayStation 2 decompilation](https://awesomerea.org/resources/rac3-matching-decomp-case/index.md): Case study · rac3-decomp reconstructs Ratchet & Clank 3 PlayStation 2 core and level programs from C and assembly, checking compiled functions against PAL and NTSC-U retail code. It tracks shared functions across versions and links functions at retail addresses; the author reports substantial matching progress while many level functions remain in assembly.
- [The Need for Speed: static recompilation of the 3DO release](https://awesomerea.org/resources/the-need-for-speed-3do-recomp-case/index.md): Case study · pc-theneedforspeed documents a native PC run of the 1994 3DO The Need for Speed through 3dokit static recompilation of ARM60 programs. It records disc structure, Portfolio boot behavior, replay inputs and runtime additions; the author reports reaching the race and driving in a window from a user-supplied disc.
- [OpenBoxer: incremental reconstruction of Месть боксера game functions](https://awesomerea.org/resources/openboxer-case/index.md): Case study · OpenBoxer reconstructs selected functions of the Windows game Месть боксера. Московский криминалитет as an injected replacement DLL. The project documents behavior contracts and paired checks for MS3D loading, rendering, animation and bounded attack paths; unsupported states return to the original game functions.
- [Epic Pinball HD: reimplementing the DOS pinball engine for macOS](https://awesomerea.org/resources/epic-pinball-hd-case/index.md): Case study · Epic Pinball HD reimplements the DOS Epic Pinball engine as a native macOS app with classic and enhanced modes. It imports tables and media from the user's own copy, runs some original executable rules through a small x86 runtime and compares classic-mode behavior with original code in Unicorn. Across all 13 tables, the author reports matches in 415/415 physics scenarios, 415/415 rules scenarios and 413/415 full-main-loop scenarios.
- [Perfect Dark on Android: porting the decompilation-based game](https://awesomerea.org/resources/perfect-dark-android-case/index.md): Case study · Ports the decompilation-based Perfect Dark game to Android through a platform layer, on-screen controls and a Gradle build. It builds on an existing desktop port and requires the player's own Perfect Dark ROM. The Android guide describes touch input, landscape orientation and a launcher that imports mod folders.
- [God of War: Ascension — static recompilation of the PS3 game](https://awesomerea.org/resources/god-of-war-ascension-recompiled-case/index.md): Case study · Statically recompiles God of War: Ascension's PS3 code into a native Windows executable with ps3recomp's PPU and SPU lifters. The repository supplies game-specific runtime hooks, analysis scripts and build guidance; users provide their own game dump and decrypted ELF. The author describes the result as an early, nonplayable research build.
- [tModLoader Mobile: reconstructing selected mod behavior in Android Terraria](https://awesomerea.org/resources/tmodloader-mobile-case/index.md): Case study · tModLoader Mobile investigates selected PC Terraria mod behavior inside Android Terraria through an independently written managed compatibility layer and native bridges. The prototype includes item and time demonstrations, a respawn adapter, texture experiments and research notes; the author reports bounded test outcomes and an unresolved in-process stability issue.
- [Angelica Wardrobe: rebuilding Perfect World's fashion window](https://awesomerea.org/resources/angelica-wardrobe-case/index.md): Case study · Rebuilds the Vietnamese Perfect World client's fashion collection window as a standalone 3D app. Python readers decode package, mesh, skeleton, animation and UI formats; the project also recreates face morphing, body-shape rules and shaders identified in the client's x86 code. It generates assets locally from the user's game client.
- [OpenCE-macOS: porting Halo: Combat Evolved to Apple silicon](https://awesomerea.org/resources/opence-macos-case/index.md): Case study · OpenCE-macOS ports OpenCE's Halo: Combat Evolved decompilation to Apple silicon Macs. It builds a native macOS app, maps the game's 32-bit code into a 4 GB address window, and renders through ANGLE on Metal. At first launch, the app imports maps from the user's Xbox disc image.
- [Primal Rage: DOS engine reconstruction and SDL3 port](https://awesomerea.org/resources/primal-rage-reconstruction-case/index.md): Case study · Primal Rage RE reconstructs the DOS game's engine in C over a memory layout matching PRAGE.EXE and runs it with SDL3 using the user's game data. The project includes Ghidra analysis scripts, LE and resource-format documentation, captures and differential checks; the author reports all 759 game-owned functions ported.
- [Tombi!: matching PlayStation decompilation and native port](https://awesomerea.org/resources/tombi-matching-decomp-case/index.md): Case study · Tombi-Decomp reconstructs PlayStation Tombi! code as C compiled against the original discs and also builds a native Windows, Linux and Android port. Its progress reports compare individual functions byte for byte across PAL, US, Japanese and demo versions; the author reports 99.68% matching game code for the PAL reference.
- [Dig Dug: translating arcade routines and modeling triple-Z80 hardware](https://awesomerea.org/resources/digdug-decomp-case/index.md): Case study · Dig Dug translates routines from the 1982 arcade game's Rev 2 ROMs into Rust and models its three Z80 processors and Namco I/O, video and audio hardware. It includes a disassembler, memory-map report, native windowed port and differential checks against a separate Z80 interpreter. The author states that translation coverage and full hardware equivalence remain incomplete.
- [Diddy Kong Racing on Xbox: a UWP port of Golden Balloon](https://awesomerea.org/resources/dkr-xbox-case/index.md): Case study · Ports Golden Balloon's Diddy Kong Racing source port to an Xbox Series X UWP package. The repository adds a WinRT entry point, compatibility patches, build translation and packaging tools for a user's own Golden Balloon checkout and ROM. The author reports completing the game's modes on Series X and matching 900 of 900 simulation hashes against a PC run.
- [BattleTanx: Global Assault: matching PlayStation executable reconstruction](https://awesomerea.org/resources/battletanx-global-assault-ps1-case/index.md): Case study · BattleTanx: Global Assault reconstructs the US PlayStation game's executable from matching C and readable assembly. Its build compares the linked output with the user's retail executable, while separate tools decode formats including TEX, IMG, FUL, MMM/3MDL and VAGS.SFX. The author reports complete exact executable reconstruction and structural decoding of the disc corpus.
- [Mega Man X6: matching PlayStation code and overlay decompilation](https://awesomerea.org/resources/mega-man-x6-matching-decomp-case/index.md): Case study · mmx6 reconstructs the US v1.1 PlayStation Mega Man X6 boot executable and ROCK_X6.BIN code overlays as C source. Its build uses the era's toolchain and checks each produced binary against the original hash; the repository includes source, overlay configurations and matching workflow documentation.
- [Castlevania: The Adventure ReBirth: a PowerPC lifted PC port](https://awesomerea.org/resources/castlevania-adventure-rebirth-port-case/index.md): Case study · Castlevania: The Adventure ReBirth is translated from its WiiWare PowerPC executable into C++ for a native PC runtime. The project supplies a lifter, SDL2 and OpenGL runtime, audio and input replacements, and hand-written readable game functions; the author reports that the port reaches Stage 1.
- [FIFA 96: reconstructing the DOS loader, formats and game systems](https://awesomerea.org/resources/fifa-96-re-case/index.md): Case study · FIFA 96 reconstructs the DOS game's real-mode loader, appended protected-mode image behavior and formats including QFS, POG, TGV, VIV and EACS. A C11 port implements file readers, codecs, audio and match systems, while an SDL3 engine runs from the user's CD image. The author reports complete implementation of its counted native dispatch bodies but identifies remaining runtime wiring.
- [Chulip: matching reconstruction of the USA PlayStation 2 game](https://awesomerea.org/resources/chulip-decomp-case/index.md): Case study · Reconstructs readable C source for the USA PlayStation 2 release of Chulip and checks functions against the original executable. Its build compares the full loaded image with a user-supplied disc dump, using compiler-specific profiles and match ledgers. The author reports 1,492 matching functions out of 2,189 provisional functions.
- [Rage of Mages / Allods: matching reconstruction of the 1998 engine](https://awesomerea.org/resources/rom1-decomp-case/index.md): Case study · Reconstructs C++ source for the 1998 Rage of Mages / Allods engine and compares compiled functions with a specified ALLODS.EXE build. The project records executable structure, relocations and serialization findings, alongside build and matching tools. The author reports 329 exact functions out of 6,897 engine functions.
- [AGS 2.x Decompilation: matching the Adventure Game Studio runtime](https://awesomerea.org/resources/ags2-decomp-case/index.md): Case study · AGS 2.x Decompilation reconstructs the Adventure Game Studio runtime engine from reverse engineering, prior source and instruction comparisons. Its build supports DOS through DJGPP and, from version 2.03, Windows through MSVC. The author reports version 2.00 complete and a demo game playable; later versions remain in progress.
- [hyperblade-decomp: matching HyperBlade's Windows executable](https://awesomerea.org/resources/hyperblade-decomp-case/index.md): Case study · hyperblade-decomp reconstructs the HyperBlade HYPERX.EXE v1.0.0.1 source and scores byte matches per function with reccmp. Its source is organized by game subsystem and compiled with Visual C++ 6.0 SP3; a separate bring-up build runs a basic game mode. The author reports that most game functions match exactly.
- [libadlib: reconstructing HyperBlade's ADLIB behavior system](https://awesomerea.org/resources/libadlib-case/index.md): Case study · libadlib reconstructs the ADLIB behavior system shipped with HyperBlade, including its language, PBN compiler and host-independent runtime. Its tools decompile and inspect PBN plans, draw behavior graphs, compare files and trace execution. The author reports byte-identical compiler output for the game's 32 shipped plans in compatibility mode.
- [Digimon World 4: a matching PS2 decompilation](https://awesomerea.org/resources/digimon-world-4-decomp-case/index.md): Case study · A work-in-progress matching decompilation reconstructs the USA PS2 release of Digimon World 4 as readable C and C++ source. The build compares recovered functions byte for byte with a user-provided retail executable and links remaining code from that executable; the author's progress report lists 76.5% of code bytes as fully matched.
- [Naruto: The Broken Bond — an Android ARM64 port of the Xbox 360 recompilation](https://awesomerea.org/resources/naruto-the-broken-bond-android-port-case/index.md): Case study · An experimental Android ARM64 port adapts the existing static recompilation of the Xbox 360 game Naruto: The Broken Bond, compiling translated PowerPC code with ReXGlue and bringing its runtime, Vulkan renderer and touch input to Android. The author reports that the original intro, menus and a training fight render on an OPPO A58 at about 1 FPS.
- [Sonic 3 and Sonic & Knuckles: a byte-identical source reconstruction fork](https://awesomerea.org/resources/sonic3k-source-reconstruction-case/index.md): Case study · A source reconstruction fork rebuilds three regional Sonic the Hedgehog 3 ROMs, Sonic & Knuckles and the Sonic 3 & Knuckles lock-on composition byte for byte from user-provided images. Beyond the inherited disassembly, it organizes 68000 and Z80 source by subsystem and adds ROM identity checks, MAME runtime comparisons and bounded content round trips and edits.
- [siglus_rs: reimplementing four visual game engines in Rust](https://awesomerea.org/resources/siglus-rs-case/index.md): Case study · siglus_rs reimplements the UK2, AVG32, RealLive and SiglusEngine game engines in Rust, with its main focus on SiglusEngine. Launchers identify engines from game-directory formats and import games on supported platforms; the web launcher runs SiglusEngine, RealLive and AVG32, while UK2 runs on desktop, iOS and Android.
- [rlapi: reconstructing Rocket League’s internal APIs](https://awesomerea.org/resources/rlapi-rocket-league-case/index.md): Case study · rlapi reconstructs Rocket League’s internal HTTP and WebSocket APIs and supplies a Go SDK for them. The documentation maps authentication, custom WebSocket messages, PsySig HMAC signatures, and selected endpoints. Bundled Frida hooks and a local proxy capture traffic, while a PE scanner extracts build information from the game executable.
- [War Action: re-engineering Sudden Strike Gold 1.2.1](https://awesomerea.org/resources/war-action-case/index.md): Case study · War Action reconstructs Sudden Strike Gold 1.2.1 from its original binaries as separate launcher, renderer, menu and game modules. It documents DirectDraw rendering at three screen sizes, added windowed-mode work and partial menu and gameplay progress; multiplayer remains in progress.
- [Waygate: reconstructing Elden Ring matchmaking services](https://awesomerea.org/resources/waygate-server-case/index.md): Case study · Waygate reconstructs an Elden Ring matchmaking server around the game's multiplayer protocol. Its Rust workspace includes wire serialization, message types, protocol handling and server features for summoning, invasions, player messages, bloodstains and ghosts.
- [Summit: reconstructing a World of Warcraft 3.3.5a server](https://awesomerea.org/resources/summit-wow-server-case/index.md): Case study · Summit rebuilds a World of Warcraft 3.3.5a server in Go, with authentication, world-server and packet-handling components. Its supporting tools include a proxy for capturing authentication traffic, a packet dumper and a DBC converter; the author describes using Ghidra during development.
- [Flipper Zero Lego Dimensions ToyPad Emulator: rebuilding the USB accessory](https://awesomerea.org/resources/flipper-lego-toypad-case/index.md): Case study · Flipper Zero Lego Dimensions ToyPad Emulator reproduces the game accessory’s USB behavior on a Flipper Zero. Its C app lets players place characters and vehicles on ToyPad positions, save upgraded vehicles, and select favorites. The README credits earlier ToyPad emulators for research and code used during development.
- [tpp-server-emulator: a Metal Gear Solid V backend reconstruction](https://awesomerea.org/resources/tpp-server-emulator-case/index.md): Case study · tpp-server-emulator rebuilds the backend used by Metal Gear Solid V: The Phantom Pain. Its C++ server implements game command handlers and database models, while the documentation tracks command coverage and shows how Lua scripts can handle client requests. Configuration supports MySQL or SQLite3.
- [SMB Vanilla: a C reconstruction of two NES Mario games](https://awesomerea.org/resources/smb-vanilla-case/index.md): Case study · SMB Vanilla reconstructs the gameplay of Super Mario Bros. and Super Mario Bros. 2 Japan in C. It runs against a user-supplied ROM for level and graphical data and aims to preserve original behavior, including many glitches. The author reports both games are beatable; refactoring of Ghidra-derived code, tests, and some audio remain unfinished.
- [OpenCloud: a Dark Cloud 2 reimplementation](https://awesomerea.org/resources/opencloud-dark-cloud-case/index.md): Case study · OpenCloud is a C++ reimplementation effort for Dark Cloud 2. Its source tree contains engine systems, character code, and handlers for game data such as ISO content and packed files. The project identifies Dark Cloud 1 as a later goal and states that it excludes original game art and sound.
- [msattack: reconstructing the Metal Slug Attack backend](https://awesomerea.org/resources/msattack-server-case/index.md): Case study · msattack is a Go reimplementation effort for the Metal Slug Attack backend. The author describes capturing traffic between the game and its server to infer private API behavior, then writing a replacement service and proxy scripts. The documented setup also requires game data obtained separately from observed traffic or another source.
- [shin: reimplementing the engine of Entergram visual games](https://awesomerea.org/resources/shin-engine-case/index.md): Case study · shin reimplements a game engine used by Entergram visual games, initially targeting the Switch release of Umineko no Naku Koro ni Saku. It runs original game data and includes a core library and CLI for extracting .rom, .bup, .pic, .nxa and other resources; .snr scenarios have execution tracing rather than decompilation.
- [Another Life: reconstructing The Witcher 3 save state](https://awesomerea.org/resources/another-life-w3-case/index.md): Case study · Another Life reconstructs parts of The Witcher 3 Remastered save format and quest state to generate new saves from a player's story choices. Its Rust crates read and write the save container, variable table and token tree, then patch game facts, journal entries and quest graphs into a user-provided template save. The author reports limited successful in-game checks on patch 5.01.
- [Open Van Buren: reconstructing the Fallout 3 tech demo engine](https://awesomerea.org/resources/open-vanburen-case/index.md): Case study · Open Van Buren reconstructs the Fallout 3 Van Buren tech demo as a native C++17 Linux engine using the user's own game data. It parses archives, maps, models, animations, effects and Pawn/Small scripts, with documented format findings and a playable first pass of the tutorial content.
- [dream-server: reconstructing a Pokémon Dream World server](https://awesomerea.org/resources/dream-server-case/index.md): Case study · dream-server reconstructs server behavior for Pokémon Dream World, including Game Sync save uploads and downloads. Its Flask handlers track sleeping Pokémon state, store save data and assemble byte responses; code comments record observations about how the game interprets parts of a download response.
- [TOD Tools: reconstructing Total Overdose and Kapow Engine](https://awesomerea.org/resources/tod-tools-case/index.md): Case study · TOD Tools reconstructs Total Overdose game and Kapow Engine code in C++. It builds a dinput8.dll that can call functions in the original game, develops a replacement executable, and includes tools to read and extract selected assets from unpacked archives.
- [vakfu: reconstructing Wakfu map rendering](https://awesomerea.org/resources/vakfu-case/index.md): Case study · vakfu reconstructs Wakfu's isometric map rendering in a Rust application that loads assets from the user's game copy. Its engine reference describes map chunks, sprite definitions, element ordering, lighting and binary fields, alongside gaps in the current implementation.
- [Novluno: parsing Redmoon Online data for a modern client](https://awesomerea.org/resources/novluno-case/index.md): Case study · Novluno investigates Redmoon Online data files and builds a Rust client that reads the original files. Its core_compat crate parses LST lists, RLE sprites, RMD data, RMM maps and RMI information files; format notes trace references between map, data, list and sprite files.
- [Mario vs. Donkey Kong: a Game Boy Advance disassembly](https://awesomerea.org/resources/mariovsdk-case/index.md): Case study · Mario vs. Donkey Kong is disassembled into ARM assembly and C sources that build a Game Boy Advance ROM with a specified MD5 hash. The build uses a user-provided US ROM, devkitARM and pokeruby-tools.
- [MDK in C# and SDL3: reconstructing the 1997 game](https://awesomerea.org/resources/mdk-sdl-case/index.md): Case study · MDK in C# and SDL3 ports the 1997 game using reconstructed data formats and behavior from MDKD3D.EXE. It reads levels, textures, models, sound and scripts from the user's installed copy and implements the original's BSP collision and script-driven gameplay on SDL3.
- [Alien Soldier: byte-identical Mega Drive cartridge reconstruction](https://awesomerea.org/resources/alien-soldier-src-case/index.md): Case study · Alien Soldier source reconstruction rebuilds the Japanese and European Mega Drive cartridges from shared 68000 assembly and a separate Z80 sound-program source. The author reports byte-identical builds from user-supplied ROM dumps and provides format documentation, content-editing tools and a MAME attract-sequence check.
- [PES6 decompilation: matching the PS2 PAL executable and overlays](https://awesomerea.org/resources/pes6decomp-case/index.md): Case study · PES6 decompilation reconstructs C source for the PlayStation 2 PAL release of Pro Evolution Soccer 6, covering its resident executable, 26 executable overlays and an auxiliary ELF. Local builds compare recovered functions with the user's game inputs; the author reports 10,930 exact function matches and separately tracks provisional nonmatching C.
- [Rogue Squadron 3D: a native PC port by static recompilation](https://awesomerea.org/resources/rogue-squadron-3d-recomp-case/index.md): Case study · Rogue Squadron 3D recompiles the Steam PC release of Star Wars: Rogue Squadron 3D from x86 machine code to C with pcrecomp and runs the result in a 32-bit Windows host. The host adapts DirectDraw display handling and input, while generated code and original game files are produced or copied from the user's installation.
- [International Rally Championship: an x86-to-C native recompilation](https://awesomerea.org/resources/international-rally-championship-recomp-case/index.md): Case study · ircrecomp statically translates International Rally Championship's RAL.EXE x86 functions into C and compiles a native 64-bit Windows game from the user's CD image. An SDL3 runtime replaces Windows 98 and DirectX 5 interfaces; analysis covers code discovery, relocations and jump tables.
- [MVP Baseball 2005: matching GameCube decompilation](https://awesomerea.org/resources/mvp-baseball-2005-decomp-case/index.md): Case study · MVP Baseball 2005 reconstructs C++ source for the USA GameCube release and compares built functions with the retail main.dol. Its configured units include Nintendo and EA libraries plus early game geometry code; the remaining program is assembled from a user-supplied disc image.
- [SmashUpDerby: reconstructing the Smash Up Derby player](https://awesomerea.org/resources/smashupderby-case/index.md): Case study · SmashUpDerby reconstructs the Smash Up Derby player in C++. The source creates a Windows window, reads player settings from the registry, loads Virtools plugins and initializes a render context.
- [CTR Reload Edition: extending a native Crash Team Racing port](https://awesomerea.org/resources/ctr-reload-edition-case/index.md): Case study · CTR Reload Edition extends the ctr-native Crash Team Racing port into a Windows edition with a Vulkan renderer and tools for custom tracks and characters. It runs the original game logic while a native engine draws selected races and reads game content from the user's NTSC-U disc image.
- [Legaia 2: Duel Saga: matching the PAL PlayStation 2 executable](https://awesomerea.org/resources/legaia2-decomp-case/index.md): Case study · Legaia2-Decomp reconstructs the PAL PlayStation 2 release of Legaia 2: Duel Saga as readable C with a byte-for-byte executable match as its goal. Its tree includes recovered source, Ghidra scripts, build tools and a browser viewer for models, textures, audio, motions and effects from the user's disc image.
- [Grand Prix 4 Decompilation: behavior-matched GP4.exe functions](https://awesomerea.org/resources/grand-prix-4-decomp-case/index.md): Case study · Grand Prix 4 Decompilation reconstructs GP4.exe functions as C++ and compares each candidate with the original under generated emulator inputs. Its repository includes a function ledger, input layouts and an in-game hook; the author reports 5,669 functions accepted by differential emulation while a playable replacement remains unfinished.
- [Twilight Princess VR: porting the game to Apple Vision Pro](https://awesomerea.org/resources/tpvr-visionos-case/index.md): Case study · Twilight Princess VR ports The Legend of Zelda: Twilight Princess to Apple Vision Pro using Dusklight's decompilation-based PC version and the TPVR mod. Its visionOS app runs the game framework with immersive, portal and window views, and loads a disc image supplied by the user.
- [sead: reconstructing Nintendo EAD engine libraries used by NSMBU](https://awesomerea.org/resources/nsmbu-sead-case/index.md): Case study · sead reconstructs Nintendo EAD engine and library code found in New Super Mario Bros. U and other games. Its C++ tree covers framework, containers, graphics, audio and file devices, with a current goal of matching the original functionality rather than its compiled bytes.
- [Tourist Trophy: matching decompilation of the PS2 CORE.TT executable](https://awesomerea.org/resources/tourist-trophy-decomp-case/index.md): Case study · Tourist Trophy decompilation reconstructs functions from the PS2 game's CORE.TT executable as C and C++ compiled with Sony ee-gcc 2.96. Its tools decrypt and split a user-provided executable, compare individual functions and check the complete linked build against the original.
- [Harvest Moon: Back to Nature: matching PS1 executable reconstruction](https://awesomerea.org/resources/backtonature-decompiled-case/index.md): Case study · backtonature-decompiled reconstructs the US PlayStation release of Harvest Moon: Back to Nature as C that compiles to a byte-identical SLUS_011.15 executable. Its build generates reference assembly and game data locally from a user-provided copy, then checks individual functions and the full executable.
- [Virtua Cop: statically recompiling the Model 2 arcade game](https://awesomerea.org/resources/virtua-cop-static-recomp-case/index.md): Case study · Virtua Cop statically recompiles the Sega Model 2 arcade game's i960 program ROM into C for a native Windows build. A ROM loader prepares flat images from the user's ROM set, and the generated C links with model2recomp to model the board and render the game. The author reports that the game boots and plays a stage; sound is unimplemented.
- [Digimon World 2003: a native PC port from decompiled C](https://awesomerea.org/resources/dw3-native-port-case/index.md): Case study · Digimon World 2003 is ported from decompiled C code for the European PlayStation release into a native Windows program. The port replaces console graphics, audio, files, controls and memory card services with PC implementations using OpenGL and SDL, and reads game content from the user's disc image.
- [ct-recomp: statically recompiling Chrono Trigger](https://awesomerea.org/resources/ct-recomp-case/index.md): Case study · ct-recomp statically translates Chrono Trigger US 1.0's 65816 routines into C and runs them with a C runtime, interpreter fallback and SDL2 front end. Its tools compare memory, images and instruction traces with Mesen 2. The author reports 1,414 of 2,036 known functions compiled to C.
- [Sightline: a native GoldenEye 007 engine port](https://awesomerea.org/resources/sightline-goldeneye-port-case/index.md): Case study · Sightline ports the GoldenEye 007 Nintendo 64 decompilation to a native Windows executable with a platform layer and OpenGL renderer. It reads game content from the user's USA ROM and retains a matching build and per-tick trace harness for checking changes to game logic.
- [Crazy Taxi decomp: rebuilding the European Dreamcast game from C](https://awesomerea.org/resources/crazy-taxi-decomp-case/index.md): Case study · Crazy Taxi decomp reconstructs the European Dreamcast game's executable with recovered C and per-function SH-4 assembly generated from the user's disc. Its pipeline maps game assets, checks C functions against original behavior and builds a disc image with the reconstructed executable. The author reports a byte-for-byte executable rebuild and a playable game.
- [mh3u-port: statically recompiling MH3U for PC](https://awesomerea.org/resources/mh3u-port-case/index.md): Case study · mh3u-port statically recompiles the USA v32 Wii U release of MH3U for Windows and Linux. It translates the game's PowerPC functions into C, runs them with a Rust replacement for Wii U system libraries, and converts GPU shader programs to WGSL. The author reports that it reaches the village and runs quests, with some graphics effects unfinished.
- [DoConfig-Decompilation: reconstructing Cave Story's options program](https://awesomerea.org/resources/doconfig-decompilation-case/index.md): Case study · DoConfig-Decompilation reconstructs the options program for Cave Story as recompilable C++ source. The author reports that the rebuilt program behaves like the original.
- [ChronoRET: matching 65816 reconstruction of Chrono Trigger](https://awesomerea.org/resources/chronoret-case/index.md): Case study · ChronoRET reconstructs the US SNES release of Chrono Trigger as labelled 65816 assembly. Its build extracts remaining data from a user-supplied ROM, assembles a complete image and compares it byte for byte with the original; progress records separate code matching from data coverage.
- [Disruptor Recompiled: rebuilding the PlayStation game for Windows](https://awesomerea.org/resources/disruptor-recomp-case/index.md): Case study · Disruptor Recompiled translates the USA PlayStation release of Disruptor into C with PSXRecomp and builds a native Windows executable from the player's disc image. Its repository adds framework patches and game-specific code for widescreen display, input and presentation changes.
- [Wizardry 8 decompilation: reconstructing the Windows game and libraries](https://awesomerea.org/resources/wizardry-8-decomp-case/index.md): Case study · Wizardry 8 decompilation reconstructs the Windows game's executable and supporting libraries as C and C++ and compares rebuilt functions with retail code. Its workflow combines Ghidra analysis, Visual C++ 6 builds, reccmp comparisons and runtime tests; the recovered executable runs with original game data.
- [WinTex: an Under a Killing Moon engine reimplementation](https://awesomerea.org/resources/wintex-under-a-killing-moon-case/index.md): Case study · WinTex reimplements a Windows-native engine for Under a Killing Moon using files from the original game. Its C++ source reads game data, extracts graphics from AP resources and renders them with a DirectX-based interface; support for The Pandora Directive is planned.
- [Road Rash 64 Recompiled: a native PC port of the N64 game](https://awesomerea.org/resources/road-rash-64-recompiled-case/index.md): Case study · Road Rash 64 Recompiled builds a PC version of the N64 game from the user's USA v1.0 ROM. The project provides Windows and experimental Linux packages, game-specific rendering and input changes, and optional local import of Mario Kart 64 tracks from a second user-supplied ROM.