Reverse-engineering case studies.

Runs Spider-Man Remastered and Arkham Knight together, streaming Gotham collision into Spider-Man’s physics world and compositing his rendered frame into Arkham. It is an experimental runtime bridge between the two running games.

AscNet reconstructs a server for Punishing: Gray Raven. Its C# code includes TCP game sessions, HTTP account and configuration endpoints, and handlers for game features. A companion parser reads packet captures, reassembles length-prefixed TCP messages, decrypts them and decodes MessagePack requests, responses and pushes into JSON.

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.

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.

Bandersnatch annotates a disassembly of ZX Spectrum code featured in Black Mirror: Bandersnatch. The repository contains compressed and decompressed assembly files, a checksum helper and a run script. The source can be assembled with z80asm and run in a ZX Spectrum emulator.

Banjo-Kazooie provides a workflow to extract from a user-supplied base ROM and build the game in full or by module. It lists US, Japanese and PAL ROM variants; the author reports 100.0000% progress.

C# server emulator for the 2015 Steam client of Batla 3D, covering HTTP account, shop and room services and Lidgren UDP gameplay. It includes a client-assembly patcher and protocol notes that distinguish recovered client evidence from emulator rules.

BFH-Master-Protocol documents the proprietary master-server communication of Battlefield Heroes. It describes exchanges involving game clients, game servers, FESL authentication, Magma HTTPS account services and Theater session services. Some protocol details remain unresolved.

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.

Battlezone documents a SkoolKit disassembly of the ZX Spectrum game and provides scripts that generate a browsable HTML listing. The repository contains the game's SkoolKit source, control file and reference files.

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.

Between Us is an offline couple game rebuilt after analysis of the Action ou Vérité Android APK. The report records the original's React Native and Hermes packaging, card database and gameplay model; the replacement uses original Chinese card text, browser JavaScript and a small Android WebView shell.

bf-private-server recreates a self-hosted server for Brave Frontier client version 2.19.6. Its C++23 service answers the game's HTTP requests, stores saves in SQLite and works with CDN workers and a patcher for the user's Android client; request tables and boot-flow notes document the protocol investigation. The server builds on an earlier emulator fork.

BG3SE-macOS rebuilds the Baldur's Gate 3 Script Extender for macOS using Ghidra analysis of the Mac game binary and the Windows extender's architecture as a reference. It patches a Mach-O load command to inject a dylib, hooks game functions, and exposes Lua scripting APIs for mods; the author reports partial behavioral parity with the Windows implementation.

Reconstructs the sound ROM of the Williams arcade game Blaster in assembly and supplies a separate address-by-address disassembly. Source comments compare reused sound routines with related Williams games and identify newer routines whose names remain unknown.

Booty documents the ZX Spectrum game through a SkoolKit disassembly and associated reference files. The repository provides a script that generates a browsable HTML version from its development sources.

butterfly emulates the e-AMUSEMENT service used by DDR A so the game can connect to a local server. Its Java code handles profiles, scores, options and rivals, with support code for the service's packet encryption and compression.

Call of Duty 2: Big Red One runs on Linux and Windows through a native loader that maps the original Xbox x86 game code into a PC process and replaces Xbox platform services. Parts of the renderer, sound system and game code are rewritten as source, with function names grounded in Ghidra analysis and rewritten functions checked against the original through a comparison harness.

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.

The Castlevania III disassembly organizes the NES game's PRG code and data as assembly source, with scripts for data extraction and tilemap generation. Its build links the reconstructed PRG content with a user-supplied original CHR ROM.

cc94 remakes the 1994 Sid Meier's Colonization game for web browsers and Linux. Its source implements game and editor controls, while play depends on graphics files from a copy of the original game. The author labels version 0.2.0 an early preview.

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.

Chrono Tales reconstructs part of the 2012 MMORPG as a three.js browser world viewer using terrain, scenery and a character decoded from the original GBox2 archives. Its Python toolchain extracts .gpak archives, decodes game formats including maps, meshes and animation clips, and exports glTF assets. A format specification records findings from static analysis of chronotales.exe.

Citadel recreates the 1994 System Shock in Unity, aiming to retain the original game while adding 3D models, station details, particles and sound effects. Its Unity project contains gameplay scripts and assets, and it reads audio from the user's System Shock RES data.

ClassicUO recreates the Ultima Online Classic Client in C# on FNA-XNA. Its source includes game asset loaders and client logic for a separately obtained installation, and the authors describe testing primarily against free shards.

CMaNGOS develops server software to emulate a World of Warcraft service, using the service’s behavior to guide its implementation. The repository contains server code, SQL files, and client-data extraction tools.

Columns Disassembly organizes the Sega Master System game into assembly modules for audio, input, entities, menus, interrupts and data. The project aims to document the game's disassembly and build the USA and Europe ROM identified by its published SHA-1.

cor64 is a work-in-progress Nintendo 64 emulator written in C#. The README builds and runs it with nuke, and lists .NET Framework or Mono, .NET Core 3.x or newer, and GLFW development libraries on Linux. Global dotnet tools named in the README are Paket and nuke.globaltool.

Croc 2 reconstructs part of the Game Boy Color game as RGBDS assembly for modding and randomization. Its Makefile assembles the source with a supplied baserom.gbc and checks the resulting croc2.gbc against a recorded SHA-1.

Publishes a SkoolKit-generated RAM disassembly of Cruising on Broadway. Linked maps organize routines, data, messages and unused addresses, while individual pages show annotated instructions.

crysis2-64bit launches Crysis 2 through the x64 engine DLLs supplied with its Mod SDK. The accompanying findings investigate a 64 FPS timer ceiling, renderer faults and truncated pointers in engine modules, while the launcher applies targeted runtime corrections and borderless display handling.

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.

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.

cuwo reconstructs a Cube World server in Python and C++ and documents implemented player, combat, world and object messages. A bundled MITM proxy supports reverse engineering by manipulating and injecting packets between the client and server.

CyberStrike Server Specification reconstructs the server-facing behavior of the 1994 DOS client of CyberStrike from observation of the client and its printed manual. Four documents describe serial transport, session phases, messages, client rules, server policy, implementation steps and the CBD city-map format so a replacement server can interoperate with the original game.

Cypress reconstructs dedicated-server behavior for Plants vs. Zombies: Garden Warfare 1, Garden Warfare 2 and Battle for Neighborville. A C++ DLL loaded by each game hooks Frostbite functions for connections, level loading and commands, while a desktop launcher and backend services provide server discovery and relay functions. The project targets specified game versions and requires a legally owned copy.

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.

Runs the Nintendo Switch release’s own aarch64 program natively on iPhone, iPad and Apple silicon Macs, rewriting only instructions that depend on the Horizon kernel and supplying its system services and the NVN graphics API on Metal. Shaders are translated offline from the user’s files, and the project adds its own touch interface and endgame features. It is a rehosting compatibility layer.

d3b-emu reconstructs a server for Diablo III Beta client version 0.3.0.7447 in C# and .NET 8. Based on an earlier mooege version, it updates opcodes and message definitions and implements beta-era game systems, while Battle.net handling, item persistence and skill accuracy remain incomplete.

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.

Darkflame Universe reconstructs a LEGO Universe server for use with the original game client. Its C++ source contains authentication, chat and game-server components, while the setup guide describes local server configuration and database options.

Patches the Darling macOS compatibility layer so that Riot’s macOS League of Legends client and game run on x86-64 Linux. The changes span Darling and 30 of its components, including Metal/Indium, AppKit, QuartzCore, CoreAudio, the kernel shim and darlingserver, with build, install and launch tooling. It is an experimental rehosting layer; playability and frame-rate results are author-reported.

deathchase documents the 1983 game Deathchase as an annotated disassembly. Its SkoolKit source files hold the game and loader disassemblies, accompanied by a reference file.

Defender-Source-Code documents the Williams Defender arcade game in an annotated disassembly. It labels PCB registers, RAM variables and game routines, with separate notes for palette values and ROM check bytes.

A dated research report on the Sunrise/Dawn reconstruction of the archived Destiny 2 build 86657 client, which emulates platform sign-on and the examined Bungie service contracts locally and adds reconstructed mission host policy. It records transport, decoding, object creation, presentation and gameplay results separately, and keeps superseded conclusions with their cited sources. It documents the case; playthroughs and native results remain project-reported.

Diep.io Parser documents packet structures used by the Diep.io game client and server. Its notes describe update packets, entity deletion and creation fields, and per-build XOR values; a JavaScript parser parses incoming packets and generates outgoing packets.

Re-implements DirectMusic, the adaptive-soundtrack API Microsoft shipped with early DirectX, as a portable C11 library that loads a game’s segment, style and DLS instrument files and renders the music to PCM. The README lists only the Gothic and Gothic II (Night of the Raven) soundtracks as tested, and as working “somewhat” correctly; the project calls itself incomplete and under heavy development. Instruments play through a vendored TinySoundFont synthesizer after DLS-to-SoundFont conversion.

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.

Reimplements the neural-rendering network of NVIDIA’s DLSS 5 library as Vulkan compute shaders for AMD RX 9000 (RDNA4) cards and supplies it to games through an NGX-compatible core and ReShade or Vulkan-layer routes. The weights are not distributed: installers extract them, hash-checked, from the user’s own nvngx_dlssnr.dll 310.9.16 or 310.8.0. The project compares its output with NVIDIA’s DLL on an RTX 5090 and reports close, not bit-identical, pictures.

dndserver reconstructs a Python server for the Dark and Darker Playtest 5 client. It implements accounts, characters, inventory and lobby features, with an HTTP discovery step leading the client to a TCP lobby server; its development guide calls for packet analysis and protobuf knowledge.

Dodge It is an annotated disassembly of the Fairchild Video Entertainment System game. It documents F8 scratchpad use, the game's two-level calling convention, a call graph and unused routines, and gives a dasm build command.

An essay on REA’s site by N0zoM1z0 (13 October 2026) uses dated Touhou reconstruction commits to ask whether exact function matching needs a larger general model, a compiler-specialist model or better retrieval. It walks through TH09, TH095, TH04 and TH08 cases where later GPT-6-series sessions closed stubborn matches, and the TH08 audit that found accepted functions with wrong floating constants. Specialist and reinforcement-learning comparisons are proposed as future experiments; no trained specialist was evaluated.

Dogfish investigates the Conquest of Skyrim mod for Skyrim Special Edition and reconstructs its strategic systems as a standalone Rust simulation. Its documents cover behavioral contracts, original Papyrus and binary research, and an experimental SKSE integration bridge. The project reports that in-game execution checks remain blocked pending human playtesting.

Doki Doki/Super Mario Bros. 2 Disassembly covers Yume Kojo: Doki Doki Panic for the Famicom Disk System and Super Mario Bros. 2 and Super Mario USA for NES/Famicom. It provides a modifiable disassembly, includes bintofdf and fdtc for building a disk image, and extracts required assets from a game image.

DOLSharp rebuilds a server for Dark Age of Camelot. It provides network communication for the game client, stores characters and world data in MySQL or SQLite, and supplies a persistent framework for game rules and behavior.

Donkey Kong Country reconstructs assembly for the USA v1.0 SNES release. The repository includes ROM, RAM, and SPC700 maps plus scripts that extract assets from the user's clean, headerless ROM for use with the disassembly.

DoomIIRPG-RE reconstructs Doom II RPG game systems in C++. Its source implements gameplay, rendering, script execution, and resource loading from the game's package layout, with CMake configuration for a desktop build.

Dragon Ball Z: Buu's Fury disassembly rebuilds the US Game Boy Advance release from ARM and Thumb assembly, a small amount of C, and generators that recover assets from the user's ROM. The build checks the result against the retail digest and tracks which bytes still come from raw slices. The author reports that 94.0959% of ROM bytes are produced from tracked source.

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.

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.

Dragon Quest Monsters German is a Game Boy Color disassembly organized into banked assembly files. Its RGBDS Makefile assembles the source and links a game.gbc ROM.

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.

dream reconstructs the SNES prototype Dream: Land of Giants through a byte-matching 65816 and SPC700 disassembly and a C reimplementation. A harness runs the original ROM beside converted routines and compares memory, graphics, audio, and processor state under scripted input.

DriveClub Recomp runs the PS4 release of DriveClub 1.28 on Windows and Linux using the game's own x86-64 code. It reimplements PS4 system libraries, translates GPU commands to Vulkan and loads the update and base-game data from the player's dumps. Its online notes document lobby messages and service calls found in the game's eboot.

ds3os reconstructs online servers for Dark Souls 2: Scholar of the First Sin and Dark Souls 3, with matchmaking, profiles and multiplayer features. It includes a loader that redirects the games to a custom server and protobuf definitions for network traffic; some server calls and message fields remain unresolved.

EATF presents a disassembly of Eric & the Floaters, with game routines in address-ranged assembly files and data in separate files. Its sources can be assembled with SjASM+.

Elite is a disassembly of the 1987 MSX game organized by its boot sector, loader, main program and data files. The assembly assigns symbolic names to routines and data and uses macros to explain constants; the README documents the disk's sector layout.

Encounter HD rebuilds the 1983 Oric text adventure in C and assembly for floppy-based Oric hardware. The new version revises item interactions and hazards, replaces action-count timing with a clock, and adds graphics, audio and alternative routes through some obstacles.

Epoch & Equinox is one native player for The Legend of Zelda: Oracle of Ages and Oracle of Seasons. The USA/Australia Ages ROM roms/tlozooa.gbc has SHA-1 880374fb978b18af4aa529e2e32f7ffb4d7dd2f4. The USA/Australia Seasons ROM roms/tlozoos.gbc has SHA-1 ba1268290fb2b1b70505d2d7b5825fc8a4816a4b. The runtime interprets the loaded ROM. Rewind covers about 12 seconds. A voxel mode rebuilds rooms from the game's collision data. Platforms are Linux, Apple silicon macOS, and Windows.

Erupe reconstructs Monster Hunter Frontier's online server in Go, providing sign-in, entrance and channel services for game clients. Its code handles game messages and quest data, and an accompanying TCP observer decrypts and records position-bearing packets for protocol work.

EVESharp is a C# EVE Online server emulator aiming to provide a cluster-based server compatible with Apocrypha 6.14.101786. The repository also documents an adapted evedec utility that finds a key in blue.dll, decrypts EVE Python files and passes them to uncompyle2.

Exolon recreates the 1987 ZX Spectrum game as an HTML5 game built with melonJS. Its repository includes JavaScript game code and TMX level maps, and the author recommends Firefox or Chrome for play.

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.

FH2MP restores Forza Horizon 2 multiplayer with a replacement server based on protocol behavior recovered from the Xbox One game client. An in-game shim redirects sockets and web-service calls, while Python and Go servers handle lobbies, worlds and online features; a launcher manages setup and updates.

ff2 collects a disassembly and ROM reference for the NES version of Final Fantasy II. The repository includes an assembly file, ROM and RAM maps, and files for events, NPCs, text, and songs.

Final Fantasy Legend II is an assembly-language disassembly of the English Game Boy release of SaGa 2. The repository separates ROM banks and RAM areas, records the target ROM's SHA-1, and documents its MBC1 mapper and memory layout.

Final Fantasy Legends 2 Disassembly maps Game Boy game code into assembly files for battle, audio, maps, menus and system functions. Its memory map labels RAM and hardware registers and uses an external FinalFantasyLegend2.gb image as the assembly background.

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.

FinFan remakes the original Final Fantasy in C++ and Allegro using graphics and data tables extracted from a user-supplied US ROM. The author based much of the game code on a published disassembly, disassembled further sections and inferred behavior from observation, while changing several menus and battle features.

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.

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.

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.

Freedom investigates Freedom Fighters map-data formats used by the Glacier engine. Python tools dump GMS entities, PRM geometry, TEX textures, LOC localization, and ZGF font data; the author reports exporting scenes and models to OBJ while several format fields remain unresolved.

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.

FreeSci reimplements Scientist Hunt, a Half-Life multiplayer mod about containing rapidly multiplying scientists, as a QuakeC game for FreeHL and the Nuclide SDK. The source covers client HUD and team menus, server rules for the hunt, stealth, slaughter, madness, invasion and fear modes, scientist monster behaviour, spawn-data parsing, player movement and entity definitions for the mod's weapons.

FreQuency reconstructs source and runtime components for the 2001 PlayStation 2 rhythm game. Its build uses ps2dev compilers for the Emotion Engine and IOP, reconstructed Sony library routines, and an optional user-supplied disc image to create a Mode 2 CD image with rebuilt executable and EZMIDI.IRX files.

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.

Game and Watch for FPGAs reconstructs Sharp handheld CPU and LCD behavior as a SystemVerilog core for Analogue Pocket and MiSTer. It covers SM510, its Tiger variant and SM5a, documents instructions and ROM formats, and supplies a converter for MAME ROMs.

The project maps the Game Boy Camera SRAM save format through comparisons of dumps from real hardware. Its notes identify image-slot state vectors, mirrored fields and checksums, while GNU Octave and MATLAB scripts inspect slots, extract pictures and inject custom images. The repository also includes sample saves for several camera variants.

Custom firmware for the Mario and Zelda Game & Watch consoles that patches new C code into the user's own stock firmware backups, so the original firmware runs alongside the retro-go emulator. A Python patcher hooks stock function calls, relocates and LZMA-compresses stock code and data to free flash, and can merge both models' firmware into one image. Committed symbol maps, a cross-reference mapper and an analysis-ELF builder support the reverse engineering, and a journal records the author's first firmware-patching work.

Ganbare Goemon Kirakira Douchuu is being disassembled bank by bank for the Super Famicom v1.0 ROM. The build extracts assets from the user's original ROM, assembles source with Asar, and can compare the rebuilt SHA-1. Code and data identification remain incomplete, and later ROM revisions are not supported.

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.

GFXFileManager implements a reverse-engineered replacement for Silkroad Online's Joymax File Manager interface. Its DLL loads game files directly from disk instead of the pk2 container and logs function calls. The implementation remains incomplete: file creation, deletion, directory handling and archive browsing are unavailable.

GMDprivateServer implements a PHP server emulator for Geometry Dash versions 1.0 through 2.2. It uses a MySQL or MariaDB database and requires redirecting the game's executable to the replacement endpoints; its code includes account, messaging and game-specific hash handling.

Golden Sun reconstructs the Game Boy Advance game's known code as symbolized assembly. Its build compares the generated US ROM by SHA-1 and checks uncompressed map-code overlays separately against data from a user-supplied ROM.

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.

The Goof Troop SNES disassembly provides assembly source and asset-extraction scripts for the USA release. It uses the author's SNES ROM framework and takes a clean, headerless original ROM for extracting assets needed by the project.

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.

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.

GTA Mode is a native plugin that adds direct control of spawned citizens and cars to SimCity 3000 Unlimited. It uses findings from Ghidra analysis of the game's binaries, GZCOM plugin loading, in-memory city structures and sprite archives. The C plugin runs in the original game, reads city data from its memory and decodes art from the user's installation; MODLOG.md records addresses, formats and dead ends.

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.

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.

guzzler-disasm documents a game through dissected, commented assembly and hardware, RAM and graphics definitions. Its Makefile builds a ROM from the disassembly, while a comparison script checks the result against the original. A planned web view for screens and sprites is marked TODO.

Habbo recreates server-side services for the Habbo Flash client in Node.js. Its source accepts TCP connections, dispatches client packets and defines handshake, user, navigator and room messages; the README presents development screenshots of a running Flash client.

HamHamGamesDecomp is an early assembly-stage reconstruction of Hamtaro: Ham-Ham Games for Game Boy Advance. Its build script uses DevKitARM tools to generate the PAL(E) ROM from an original ROM and checks the output against a stored SHA-1.

Hamtaro in Pieces disassembles the North American Game Boy Color release of Hamtaro: Ham-Hams Unite!. RGBDS assembles the recovered source, using a user-supplied base ROM for incomplete regions, and the Makefile compares the resulting ROM with the original. Crystal tools support the build.

harrierattack records a SkoolKit disassembly of the ZX Spectrum game Harrier Attack. Its source files generate browsable HTML listings in hexadecimal and decimal views.

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.

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.

Disassembles the Nintendo 64 game Hey You, Pikachu! into assembly files organized under versioned directories. The project includes MIPS disassembly and extraction tools and a Makefile with a ROM build and optional MD5 comparison.

Hitman 5 Server reconstructs the web services used by Hitman: Absolution and Hitman: Sniper Challenge, with C# endpoints and a configurable client hook. Its documentation traces client startup requests, metadata parsing and message templates; the author says much of the server currently responds with mocked data.

Hong Kong 97 is a rough disassembly of the SNES game with separate main-program and APU assembly files.

Igor runs the Spanish CD release of Igor: Objetivo Uikokahonia through an x86 decoder and interpreter built from analysis of the original executable. It extracts game data and replaces higher-level palette, display and input routines, with separate notes on the executable's structure.

Runs the PS4 inFAMOUS Second Son’s own x86-64 code natively on Windows and Linux: a runtime reimplements the PS4 system libraries the game uses, and a shadPS4-derived core translates its GPU commands and shaders to Vulkan. The project reports a playable, in-development port that reaches gameplay and the first chapters, with unstable performance and remaining graphics glitches. It is a compatibility-runtime port rather than a decompilation, and its results remain project-reported.

inFAMOUS: First Light — PC Edition runs the user's PS4 game files on Windows through a compatibility runtime while executing the game's x86-64 code on the PC CPU. It adds First Light-specific imports, system services, and hash-checked engine hooks to a runtime shared with Second Son, with a Vulkan 1.3 backend and GCN-to-SPIR-V shader translation. The author reports that the early build reaches open-world gameplay.

Disassembles the sound ROM of Williams Electronics' 1984 arcade game Inferno. The repository contains an assembly listing and sound-studio preset notes.

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.

International Superstar Soccer Deluxe is an SNES disassembly based on the USA ROM. Its assembly files cover ROM mapping, RAM mapping, macros, SPC700 material, and asset pointers, while batch scripts extract assets from a user-supplied clean, headerless ROM using the author's SNES ROM framework.

jsSMS is a JavaScript emulator for Sega Master System and Game Gear ROMs, written to run quickly in mobile browsers. The README says it began as a port of JavaGear and later replaced the interpreter with a dynamic recompiler in src/compiler.

Documents a Z80 disassembly of the arcade game Jungle King, with labeled routines and memory-mapped input and video notes. A Python script applies post-processing changes to converted assembly.

The Jurassic Park SNES disassembly provides assembly source and scripts for the USA V1.0 release. Its asset extraction step takes a clean, headerless copy of the supported ROM, identified by an MD5 hash, and uses the author's SNES ROM framework.

KAR-Decomp uses decomp-toolkit to build an annotated Kirby Air Ride disassembly that preserves ROM offsets and adds or revises symbol names. Its DTK branch contains assembly and reports a compiling North American version; the Japanese and PAL editions currently generate splits and assembly.

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.

Kirby's Adventure is reconstructed as a work-in-progress NES assembly source tree with program and graphics banks. Build scripts configure the toolchain and assemble a ROM, while bundled helpers include an Actionscript bytecode dumper for the game.

Kirby's Dream Land is reconstructed as Game Boy assembly that can be assembled into a ROM and compared with the original. The repository contains assembly source and a Makefile using rgbasm, rgblink and rgbfix before the ROM comparison.

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.

LandSandBoat implements a server emulator for FFXI. The repository contains server code and game data definitions, while its mission-status notes map values in a field of packet 0x56 to mission events.

lastwar-client reconstructs the network layer of the mobile game Last War: Survival Game in Go. Based on APK analysis and captured traffic, it implements GSL RSA/AES bootstrap, SFS2X framing and the SFSObject binary codec, and publishes a dossier of commands, fields and live observations.

This Left 4 Dead 2 study reconstructs the AI Director's pacing, intensity, encounter placement and music rules from an identified x86 server.dll and sanitized runtime traces. It publishes disassembly-derived findings, analysis scripts, evidence files and implementation specifications; a reference game library is in a separate repository.

Lester the Unlikely Disassembly reconstructs the USA SNES game in assembly with RAM and ROM maps and asset-extraction scripts. It uses the project's included SNES ROM framework and requires the user's clean, headerless ROM to extract game assets.

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.

Limbo restores mission play in the 2016 Fortnite Save the World OT6.5 client using an injected game-server DLL and a separate backend. Its development notes describe UE 4.12 name and object table discovery, ProcessEvent tracing, executable analysis and hooks used to rebuild mission behavior. The author reports up to four-player cooperative play, while some missions and enemy behaviors remain incomplete.

Lolo implements portions of an OverField server for a client connected through a configured proxy. The bundled Iridium tool captures and decodes the game's TCP traffic, exposes live packets through a web view and JSON API, and saves per-session NDJSON for protocol analysis.

LOZ remakes the original The Legend of Zelda in C++ and Allegro, using graphics and data tables extracted from the player's ROM. The author built disassembly tools and examined much of the original game code to guide the remake; the extractor and game are separate Visual Studio projects.

LunarCore is a Java reimplementation of the Star Rail game server for a 4.2.0 client. ./gradlew jar builds LunarCore.jar, and java -jar LunarCore.jar starts it. The resources directory needs the Config, TextMap, and ExcelBin folders from the StarRailData set. Java 21 is required. The server can use its built-in database, and the README also recommends MongoDB 4.0 or newer. Login, teams, inventory, monster battles, shops, gacha, mail, Forgotten Hall, Pure Fiction, and a partial Simulated Universe are listed as present.

major-havoc-dasm publishes a disassembly of Major Havoc across assembly files for the game's alpha, gamma, and vector ROM components.

MangosZero reconstructs the authentication and world servers for Vanilla World of Warcraft clients 1.12.1 through 1.12.3. Its C++17 server reads client data with StormLib and stores game and account data in MySQL or MariaDB.

Maniac Mansion's Commodore 64 engine and special disk loaders are documented in a reconstructed, commented disassembly. The material groups more than 500 routines into modules covering rendering, audio, input, resource loading and the script interpreter; the author reports that all code is commented.

This repository is a commented disassembly of Maniac Mansion scripts for the v0 demo and the retail release, plus spreadsheets of rooms, objects, variables, and sounds. The README says the files are not meant to be recompiled. The .c extension is only for highlighting.

Maple2 reconstructs a MapleStory2 server in C# and investigates the client's expected server-to-client packet layouts. Its PacketStructureResolver sends partial packets, uses client error reports to refine their structure, and saves the results for the server implementation.

mgolf provides an assembly disassembly of Mario Golf for Game Boy Color. Its build workflow uses RGBDS and make or redo to produce the USA ROM and debug symbols; the repository includes bank-level assembly and a ROM SHA-1 target.

mc4.sav documents the save format written by the Midnight Club: Los Angeles recompiled PC runtime. It maps big-endian section records, career values, garage slots and performance-upgrade bytes from observed saves, and supplies a browser editor and PowerShell commands for inspecting and changing supported fields.

MMX1-Disassembly presents Mega Man X as a large assembly listing with ROM addresses, instruction bytes and labels. The listing exposes control flow and instruction-level behavior for analysis.

MegaVoltsPP rebuilds a backend for MicroVolts Plaza 1.0.0–1.0.3 in C++23 after analysis of the game binary. Its Front, Main and Cast processes handle authentication, lobby state and matches for the retail client, using a documented binary TCP packet format and RC5/RC6 encryption.

MHServerEmu recreates the backend for Marvel Heroes clients using C# server code and versioned protocol definitions. Its documentation covers client-server packet structure, authentication, and game-data formats; the author reports full support for client 1.52.0.1700 and preliminary support for several others.

milondasm provides an annotated assembly reconstruction of the North American NES release of Milon's Secret Castle. The author reports that it can assemble to the original when the user supplies graphics binaries; the repository also includes music transcriptions generated from ROM data.

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.

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.

Moonlight Madness is a SkoolKit disassembly of the ZX Spectrum game. Its source tree includes a .skool listing, reference files, and scripts that generate browsable hexadecimal and decimal views. SkoolKit is needed to build the development version.

Ms. Pac-Man records an assembly disassembly of the 1990 Tengen NES release, with source files for game data, maze layouts, sounds, and routines. The build uses CC65; graphics must be extracted from the user's ROM.

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.

MTG Arena Collection Export reconstructs the Frontdoor request needed to export owned cards from Magic: The Gathering Arena. The Python client uses an account refresh token, opens a TLS Frontdoor socket, authenticates with the 2026 version 4 frame and protobuf command envelope, and requests Card_GetAllCards. A separate protocol document records the recovered wire format.

mw-tools develops a MythWar I server from scratch using the game client. The project seeks old gameplay videos or recordings to help replicate original features. Its TypeScript code targets Node 16 and includes a script that creates the client's door.dat server-list file for local play. The server currently lacks data storage, multiplayer and most game features.

Disassembles the sound ROM of the 1984 Williams Electronics arcade game Mystic Marathon. The repository contains a source listing and sound-studio preset notes.

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.

Nebula emulates a server for an anime game and connects to regional PC clients through redirected requests. Its documented features include characters, inventory, quests, gacha, friends and several game modes. The server uses game data placed in a resources directory.

NeoXResearch investigates NetEase's NeoX game engine through static analysis and dynamic debugging of its native library. It documents NPK archive headers and metadata entries, the file-loading and decryption path, and changes to Python bytecode opcodes. Python scripts support NPK unpacking, decryption and bytecode repair.

NetspherePirates recreates a server for the S4 League Patch 34 client, identified as EU v1139 Season 1. Its C# source defines game login outcomes, channel responses and serialized server information.

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.

NexusForever reconstructs a server for WildStar client build 16042 in C#. Its source tree includes authentication, character and game-service components, with database schemas and message handling for the matching game client.

NFS Online Server reconstructs online services for Need for Speed: Underground 2, Most Wanted (2005) and Carbon. Python services handle game-specific bootstrap, lobby, race relay and Carbon FESL traffic, while three Zig-built Windows ASI plugins connect the original clients to the replacement services.

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.

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.

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.

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.

O21 rebuilds the 1995 Windows game U95 as an F# open-source remake. Its author describes a black-box process based on observing the running game and reading its data files; the current engine includes rendering, menus, bonuses and some enemy behaviour but is not yet playable.

zelda_oot assembles an Ocarina of Time ROM from game assembly and files extracted from a base ROM. Its Makefile checks the resulting image against an MD5 checksum, while included NTSC 1.0 notes map save data, inventory fields, and instruction addresses.

The Ocarina of Time 1.0 disassembly provides a labelled MIPS assembly listing and a function-address index. The listing records instructions under function labels and memory addresses for inspection of the game's code.

open-iw investigates the packed resources inside the DOS game Inner Worlds 1.2 while working toward a rebuild. Its notes describe the executable's resource header, file-list entries, offsets and alignment uncertainty; a C utility supports extraction experiments.

Open1560 partially reimplements Midtown Madness Sneak Preview Beta build 1560 in C++, retaining assembly for functions not yet rewritten. Its source adds an OpenGL renderer, controller support and fixes, while its methodology notes identify builds and discuss disassembly. Running it requires data from a user's installation of the original game.

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.

OpenDAoC recreates a Dark Age of Camelot server focused on the 1.65 game experience. Its C# code handles game sessions and packets, and its protocol notes describe optional RSA key transport and RC4 packet encryption for 1.127 and 1.130 clients.

Opengate remakes NetDevil's online space game Jumpgate in C++ as a game client, a game server and a state server built on OGRE, CEGUI, Bullet and Boost asio, which log in through a metaserver whose requests the project documents. Its data recreates the Jumpgate sector map with jumpgate links and faction ships such as the Tauseti Lady Kickstart, and its design notes list item prices, scale ships from NetDevil's DirectX models and include an item data set that uses data extracted from NetDevil's JOSSH database.

OpenLGR rehosts the Windows release of Lego Racers using x86 CPU emulation and implementations of the Windows functions the game uses. It patches replacement open-source code into the game at runtime, while still running original code and loading original game assets.

OpenMC2 incrementally rewrites Midnight Club 2 while calling the installed game's original binary for functions it has yet to replace. Its Windows source and hooks support a partial reconstruction that runs alongside the original executable; development is abandoned.

OpenMM1 incrementally rewrites Midtown Madness 1 in C++, using the original game binary for functions still unimplemented. It targets the specified original release, runs alongside the installed game and uses dgVoodoo 2 for modern graphics compatibility.

OpenPayload reimplements the Wiimmfi patch payload for Mario Kart Wii. Its hook table follows payload v96, with server connection and friend-room creation, joining and starting reported as tested. It uses CodeWarrior and the Kamek linker.

OpenPigeon is a TypeScript codec for reading GamePigeon iMessage game state and encoding caller-supplied moves for eleven turn-based games. Its protocol documentation describes balloon identity, encrypted move URLs, the length-seeded cipher and the state envelope; captured-message vectors support codec tests.

OpenRSC rebuilds a RuneScape Classic server framework using black-box reverse engineering and study of RSC+ gameplay replays. Its configurable server supports reconstructed game behavior and optional features such as quests, clans and an auction house.

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.

Reimplements the game server for the Sonic Runners mobile game as a Go service, so Android and iOS clients redirected to it can log in, play Timed and Story modes and use the shop, roulettes, character and Chao progression, events, notices and basic rankings. The README says it was reverse engineered from the Sonic Runners Revival server, on whose code it bases much of its own; it serves about 40 HTTP endpoints of the client's API, decrypts and encrypts AES-CBC request payloads and keeps player state in a bbolt database.

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.

PANGYA Mobile reconstructs a self-hosted service for game version 1.0.21 and patches the user's APK to connect to it. Its TypeScript server handles login, lobby, story, shops and other game functions, using game data from the APK and asset bundles; a protobuf schema describes network messages.

This Panzer Dragoon Saga project investigates Sega Saturn disc and asset formats. The repository documents MCB/CGB models, CPK video, PRG subtitles and audio formats, with Python extractors and browser viewers. The author reports results for model, video, music, font and texture extraction and conversion.

Perlica RS is a Rust game server. The README says it is compatible with the alpha client, and that the client patch replaces the server address so the client can talk to a local server. It documents login, characters, weapons, equipment, and missions.

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.

picowalker develops an RP2350-based recreation of the Pokéwalker accessory for Pokémon HeartGold and SoulSilver. This repository provides board drivers for the OLED display, IrDA, EEPROM, accelerometer, power management and USB save-data transfer; the application core is separate. Full compatibility with the games remains a goal.

Pocket Puyo Puyo Tsuu is a matching disassembly of the Japanese Game Boy game. Its banked assembly sources build a ROM with RGBDS v0.5.1, and a Makefile comparison target checks the output against a stored SHA-1. The project requires a base ROM while its source reconstruction remains in progress.

The Pocky & Rocky source file records a game disassembly with RAM and ROM maps, named routines and annotated instructions. It aligns machine-code bytes with assembly and C-like explanations for portions of the program.

POGOserver implements a JavaScript replacement server for Pokémon GO and accepts game-app traffic redirected to it. Its source organizes player, inventory, world, gym and encounter behavior into packet handlers backed by a MySQL database.

pokegold-ko is an incomplete disassembly of the Korean Pokémon Gold and Silver releases for Game Boy Color. The repository includes assembly banks and utilities, while the author states that further disassembly and labeling are required before it can rebuild either ROM.

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.

Pokémon Aurora Ticket Distribution's US GBA ROM is reconstructed as assembly and C source. The repository includes a Makefile, linker configuration and setup instructions for building auroraticket.gba against a user-provided original ROM.

Power Strike teardown analyzes the Sega Master System game's ROM, mapping its banks, boot and vblank paths, sound engine and tile compression. It includes a sound-bank disassembly excerpt and scripts that decode, re-encode and patch tile sheets within their original compressed size.

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.

Project Topaz recreates an online server for Final Fantasy XI with C++ services, Lua game scripts and SQL data. Some retail game behavior remains unimplemented.

Rebuilds the NTSC PlayStation 2 release of Sly Cooper and the Thievius Raccoonus as a native C++ game for Windows and Linux, running on data extracted from the player's own disc image. The README reports the full game as playable while work continues on accuracy and remaining differences from the original. It does not describe its reverse-engineering method or relate the port to the separate sly1 decompilation.

Prospect is an unfinished local server emulator for The Cycle: Frontier. An injected Windows component hooks the client’s PlayFab URL function to redirect requests to localhost, and a C# API contains handlers for Steam-ticket login and user data. Local redirection is implemented; authentication, lobby functionality and CloudScript remain unfinished.

ProTanki Server reimplements a ProTanki game server in Kotlin for client library-20221001-223140. Its source includes packet processing and handlers for authentication, battles, chat, garage and other game operations; a later protocol update prevents support for newer clients.

PTCGP Private Server replaces selected Pokémon TCG Pocket 1.8.1 online services with local HTTPS and gRPC endpoints for profiles, collections and pack openings. A Windows controller routes a rooted Android client's traffic to per-device servers, checks the client build and imports game data from the user's installation.