Reverse-engineering case studies.

OpenSAGE reimplements the SAGE strategy-game engine with an initial focus on Command & Conquer: Generals and Zero Hour. Its code parses original formats including .map, .w3d and .ini, and the author describes studying data files and observed game behavior. Rendering and game logic remain incomplete.

OpenSC2K recreates SimCity 2000 with a Godot front end and Rust libraries for simulation, file formats, rendering, audio and scripting. It imports graphics, text, sound and music from the player's own game copy and supports original .sc2 city files alongside its extended .sc2x format.

Reimplements SimCity 4 as a Godot project in GDScript that reads DBPF archives, region folders and city saves from the user’s own SimCity 4 installation. The code draws a region view with city thumbnails and interface elements built from the game’s UI definitions, opens a saved city’s terrain and water in 3D, and includes a DAT explorer for previewing archive subfiles. It is an early, inactive engine case without simulation gameplay.

OpenScreamer reimplements the DOS games Screamer and Screamer 2 as a C/SDL2 program for Linux and Windows. It reads files from the user's game folders and includes unpackers, Ghidra scripts, viewers and notes mapping game formats and behavior to the original programs.

OpenSE4 reimplements the Space Empires IV Deluxe engine in C++23, loading art, sound and data from the player's own installation. Its rule specifications combine the original manual, data files, observed behavior and executable analysis; the engine covers economy, movement, combat, research, diplomacy and computer players, with remaining parity differences documented.

OpenSHC is an open-source reimplementation of Stronghold Crusader. It builds as a DLL loaded at game start and hooks functions that have a functionally identical reimplementation. The README requires Stronghold Crusader 1.41 in a Latin-language version such as English or German.

opensims2 reimplements The Sims 2 engine in C++ for 64-bit macOS and Windows, reading content from the user's own game installation. The repository includes DBPF and game-data analysis, executable findings, gameplay systems and command-line inspection tools.

OpenSith reimplements the engine of Star Wars: Jedi Knight — Dark Forces II in Unity. It renders JKL levels and animates 3DO models. There is no COG parser or COG virtual machine, so the game is not playable, though a level can be walked around.

OpenStrike is an early C++ reimplementation of Desert Strike and Jungle Strike. Its tools unpack original DAT archives and display graphics and complete levels; the game skeleton loads and renders some sprites and animations. The author describes the game as not yet playable.

OpenTennis rebuilds the 2007 PlayStation 2 game Hot Shots Tennis in Rust and Bevy for desktop, mobile and browser play. It reads models, textures and other game data from the user’s US disc image at runtime. The author compares ball physics, timing, rules and AI frame by frame with recordings of the original; research tools inspect executable overlays and game formats.

OpenTESArena rebuilds the 1994 DOS game The Elder Scrolls: Arena in a new C++ engine using separately obtained game assets. It implements combat, items, shops, citizens, travel, and most character creation, while documenting original-game behavior and parsing Arena asset formats. Quests, spells, and saving remain unfinished.

OpenTIE reimplements Star Wars: TIE Fighter for Windows, macOS and Linux using data from the original 1995 Collector's CD-ROM or 1998 Windows release. Its engine supports each edition and can combine the 1995 menus, cutscenes and iMUSE music with the 1998 flight simulation and assets.

OpenTomb is an open-source reimplementation of the classic Tomb Raider engine for playing levels from Tomb Raider 1–5 and custom TRLE levels. It is no longer maintained.

OpenTPW reimplements Bullfrog's 1999 game Theme Park World, also released as Sim Theme Park. It needs a full copy of the original game and its assets. The project page says the project is early and not playable yet. Texture, settings, sound, and string formats are marked implemented. Models, map data, ride scripts, and saves are partial. Fonts, lip sync, materials, and video are not implemented. Format notes are at opentpw.gu3.me/formats.

Reimplements The Sims 2 in the Unity engine, reading the user’s Ultimate Collection installation through its own C# code for the game’s DBPF packages and asset formats, which the project also aims to offer as modular libraries. README reports an early stage: a basic main menu with a neighborhood chooser, neighborhood previews and a basic neighborhood view, while the tree also holds lot, build-mode, Sim and SimAntics code. README credits FreeSO for much of its code and structure.

OpenTS reconstructs the Command & Conquer: Tiberian Sun 2.03 Firestorm engine as a standalone program. It combines GPL-released source from related Command & Conquer games with reverse engineering of the original executable, and uses assets from the user's installed game.

OpenTTD recreates Transport Tycoon Deluxe as an open-source transport simulation game, aiming to mimic the original while adding features. It runs with free OpenGFX, OpenSFX and OpenMSX data sets, or with graphics, sound and music files copied from the user's original game.

OpenUG2 reimplements the Need for Speed: Underground 2 engine as a native racing prototype that reads the player's original game data. It parses STREAM*.BUN scenery, GEOMETRY.BIN car geometry and TEXTURES.BIN textures, then renders drivable circuits with AI opponents, laps and standings.

OpenUT2k4 recreates Unreal Tournament 2004 in C++ on Unreal Engine 5.8 using maps, characters, audio and music converted locally from the player's installation. It builds maps at runtime and implements UT2004 network compatibility so its client and server can play alongside the original game.

OpenVIII rewrites the Final Fantasy VIII game engine in C# and MonoGame for Windows and Linux. Its replacement engine reads the user's original game files and contains code for archives, battle systems, audiovisual playback and other game systems.

Reimplements MicroProse’s UFO: Enemy Unknown (X-COM: UFO Defense) and X-COM: Terror from the Deep as a C++/SDL engine that runs on the user’s original game resources. Game data such as items, craft, research and missions is expressed in YAML rulesets, which also carry its standard mods and a wider modding ecosystem. It is a clone that reuses original content, not recovered MicroProse code.

OpenXeen is a Java engine rewrite for Might and Magic IV and V: World of Xeen. Its current code parses CC archives and some graphics, audio and map information, creates file proxies and renders selected game components. The author states that the software is not ready for release.

OpenXvT reimplements Star Wars: X-Wing vs. TIE Fighter and its Balance of Power expansion for Windows, macOS and Linux using the player's original game data. Its source includes flight, asset, audio and rendering systems, with classic and enhanced graphics modes and cross-platform multiplayer.

OpenXW rebuilds Star Wars: X-Wing as a desktop program that reads data from installed 1994 or 1998 editions. It lets users select menus, flight simulation and music from either edition, and implements adaptive iMUSE playback alongside modern rendering and controls.

OpenXWA reimplements the 1999 game Star Wars: X-Wing Alliance as a native Windows, macOS and Linux program that reads an original installation. Its code covers game systems, OPT models and digital iMUSE audio, with classic and enhanced graphics modes and modern input options. The author reports that the original functions outside multiplayer have been reimplemented.

OpenYR reimplements the engine behavior of Command & Conquer: Yuri's Revenge in C++ from observed gameplay, disassembly research and documentation. Its modules cover game state, combat, AI and audio, with parsers planned or implemented for Mix, INI, SHP and VXL resources.

OpenZ recreates the 1996 strategy game Z as a Unity 6 game with 3D battlefields, units, and newly produced media. It reproduces territory capture and factory-based combat, adds new content, and ports its computer opponent from the open-source Zod Engine.

OpenZT2 reimplements the Zoo Tycoon 2 engine in Rust and Bevy for use with the player's own game files. It renders original materials through Bevy with patched vkd3d-shader and MojoShader libraries and includes game systems for animals, construction, and visitors.

Oracles reconstructs The Legend of Zelda: Oracle of Ages and Oracle of Seasons with a shared C# engine in Godot. It imports data from a pinned disassembly and uses original ROM behavior for timing, object order, collisions and state. Ages is described as playable; Seasons currently covers its opening and selected early-game rooms and events.

Ordoor rebuilds the Strategy Engine used by Warhammer 40,000: Chaos Gate, Soldiers At War, Squad Leader, and Wages of War. Its format work and viewers cover maps, menus, graphics, sound, and video to varying degrees; gameplay mechanics remain unfinished.

Ozymandias (Julius) adapts the Julius/Augustus city-building engine to run Pharaoh and its Cleopatra expansion using the player's original assets. The unfinished implementation loads original saves and supports early campaign missions, with systems including houses, farming, trading and campaign progression.

Ozymandias recreates the engine of the city-building games Pharaoh, Zeus and related titles in Godot 3.6 Mono. Its project tree contains game-system scripts, scenes and interface code that use files from an original game installation. The author describes the current implementation as early, with basic structure and menu logic.

Reimplements P.T.’s game logic in C++ on a new Vulkan engine that reads levels, models, textures, sounds, scripts and cutscenes from the user’s own PS4 copy at run time. The author documents reverse-engineered file formats and used the shadPS4 emulator as a behavior and frame reference. Fidelity to the original is author-reported, and the use of AI coding tools is disclosed.

Pal3.Unity reimplements The Legend of Sword and Fairy 3 and its Wenqing Pian expansion in C# and Unity. It rewrites game logic and reproduces behaviour and effects while loading assets from the user's original game installation.

PanzerChasm recreates Chasm: The Rift in C++ as an SDL2 game that loads the player's original CSM.BIN data file. The repository includes game and rendering source, shaders, and notes on the game's binary formats.

PanzerMortyr reimplements the Mortyr 2093-1944 engine as a replacement executable that loads original game data. The author reports reverse engineering archive, map and model formats and recreating observed enemy behavior, movement physics and game balance. Written mostly in Ü, it supports Windows and GNU/Linux; game data can come from an installation or a CD image.

Pentagram reimplements the Ultima 8 engine. The documentation dated 9 November 2011 says the supported games are the English versions of Ultima 8, both before and after the patch. German, French, and Spanish versions are listed as less tested.

Phoenix rebuilds Emperor of the Fading Suns as a Java game using data from the user's EFS 1.4 installation. Its source includes game systems, a GUI, FLC animation handling and galaxy-file readers. The project aims to reproduce EFS.EXE behavior while keeping the original data outside its distribution.

physics_RT reconstructs Ballance physics behavior as a Win32 Virtools DLL using IVP numerical kernels. It covers collision geometry, force handling and simulation timing, with differential tests against an original DLL and documented runtime comparisons.

Pinball Fantasies Reassembled recreates the 1993 DOS game engine in Rust using files from an original copy. Its technical notes map the MZ executables, per-table PRG programs, interrupt interfaces, sound drivers and user-data formats. The source includes asset readers, table simulation and tools for dissecting original files.

Pizza Legacy rebuilds the 1994 DOS game Pizza Tycoon, also released as Pizza Connection, in a C++20 engine that loads the original game's assets. The author reports that the major gameplay systems support a complete playthrough. The remake also adds optional bug fixes, autosaving, and support for modern displays and controls.

pokerecomp is a Godot 4 reimplementation, written in GDScript, of the Game Boy Pokémon games. Gold, Silver, Crystal, Red, Blue, and Yellow are playable from the bedroom through the Hall of Fame and their credits. A cartridge dump is checked by SHA-1, decoded once into a cache, and then released.

Portémon Nitro reimplements the Pokémon HeartGold and SoulSilver engine in LÖVE for PCs and mobile devices. It reads a user-owned Nintendo DS ROM, derives game data locally, and separates ROM interpretation from runtime behavior and the app interface. The repository contains Lua game code, Nintendo DS and game-specific libraries, and ROM import tooling.

Powerslave EX reconstructs the PlayStation Powerslave game on Kex Engine 3.0, combining recovered game logic with new collision and AI systems. Its research files document MIPS disassembly, extraction code and partial findings about the ZED format; the engine uses converted game data rather than the CD data directly.

Powerslide Remake reconstructs the arcade racer's main features in a cross-platform C++ application built on Ogre. It reads the original game's data.pf, gameshell.pf and store.pf archives and provides racing, AI and multiplayer features. Builds target Windows, Linux and Android.

ppengine recreates Atari's Pole Position as a 3D game using logic reverse engineered from the arcade ROMs. Its C source builds a playable client with steering, braking, acceleration and gear changes, while the title screen remains unfinished.

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.

Project ANISE is a C++ interpreter for Japanese adventure games built on the AI5V or SILV scripting engines. Its source includes script operations, graphics, sound and input components. The project was developed on Windows with SDL, and the author reports compiling and running it on Linux.

Project Carrot develops a C++ engine modeled on Jazz Jackrabbit 2 using converted resources from a user's copy. Its source includes game systems and JJ2 format handling; companion tools extract Anims.j2a assets and convert tilesets and levels. The author describes the project as progressing slowly.

Project Dollhouse reconstructs The Sims Online in C# with client and server components that use an installed copy of the game. The codebase includes readers for original DBPF, FAR and IFF resources alongside game screens, entities and server code.

Cross-platform reimplementation of Plants vs. Zombies: Game of the Year Edition. The README says the code is a manual reimplementation from community research, . It names Linux, Windows, macOS, Android, iOS, WebAssembly, and Switch, using OpenGL ES 2.0 and SDL, with a browser build that still needs the player's game data.

Pyskool reimplements the ZX Spectrum games Skool Daze and Back to Skool in Python and Pygame. Its shared engine supports configuration-file and Python-code customization, and its setup generates the launchers, images, configuration and sounds used to play.

R.E.L.I.V.E. develops a cross-platform engine intended to replace the original PC executables for Abe’s Oddysee and Abe’s Exoddus. It runs with the player's game files and provides controller support, display options, and a level editor. The project reports that both games are playable, with bugs and crashes still possible.

RA2 Engine rebuilds Command & Conquer: Red Alert 2 with Yuri's Revenge as a C++17 and SDL2 engine for Windows and Android. It reads the player's original MIX and CSF files, including rulesmd.ini, and implements combat, movement, AI and timing from observed game behavior. The author describes version 0.9 as a playable beta.

Rad-Therapy is a QuakeC game for the FTE engine that plays the 1998 Half-Life campaign and deathmatch. Menus, client, server, and the network sub-protocol run in QuakeC. The release file package_valve.pk3 goes in HL1/valve/. A source build clones the game into the Nuclide SDK and runs make game GAME=valve. Launch can pass -halflife, and mods use fteqw -halflife -game.

RAD recreates the engine of the 1995 DOS game Radix: Beyond the Void and loads radix.dat from the original v2 remix release. The replacement adds software and OpenGL rendering, dynamic lighting, audio format support and PascalScript scripting.

Rails rebuilds the 1990 Railroad Tycoon game in OCaml, implementing railroad construction, train management, AI rivals and economy systems. It loads the user's original DOS PIC, PAN and DTA data files and uses SDL2 for its interface and presentation.

RappelzCore and RappelzRust reconstruct a Rappelz NoLimits server and game client in Rust from analysis of the customized SFrame.exe client. The author documents REA and Ghidra work on client functions, resource formats and packet layouts; both components are described as under development.

raw(gl) reimplements the Another World engine while reading data from the original game. Its interpreter supports Amiga, Atari, DOS, Windows 3.1, 3DO and anniversary releases; accompanying notes describe virtual-machine bytecode and platform-specific resource formats.

rawpsx rewrites the Another World engine in C for the original PlayStation, adapting the earlier rawgl implementation with PSn00bSDK. It reads BANKxx and MEMLIST.BIN from a player's DOS copy and builds a PlayStation ISO. The author reports that the software-rendering branch runs the full DOS version.

Re-Comprehend reimplements the Comprehend and Graphics Magician engines for Penguin Software adventures including Transylvania, Crimson Crown and OO-Topos. It reads the user's original DOS game files, preserves the original save format, and offers data dumps and runtime commands for inspecting objects, rooms and state.

Reimplements Resident Evil 2’s PS1 game rules in a native Nintendo DS engine, with converters that turn data from the user’s own disc into DS formats. A helper wraps the PS1 executable as an ELF for REA’s Ghidra lane, analysis notes name the PS1 functions and tables each part follows, and the Reddit post linking it credits REA and Claude Code. Leon’s disc 1 is reported playable, while Claire’s disc, most enemy types and some menus remain unfinished.

rea-doom-term rebuilds DOOM (1993) as a playable Rust terminal game with WAD parsing, fixed-point math, movement, combat, and text raycasting. Its evidence log links reconstructed subsystems to original source functions and tests; the terminal renderer uses a different visibility and texturing approach.

reB3 reconstructs Xbox Burnout 3: Takedown as a C runtime using equations and behavior recovered from default.xbe and formats read from the user's disc. Its notes cite executable addresses for physics, collision, scoring and AI, while extraction code loads track and vehicle material at runtime. The author reports a playable racing harness with career mode absent.

Rebellion 2 recreates the 1998 strategy game Star Wars: Rebellion in Unity. The source includes campaign simulation, AI, interfaces and modding support; the author reports that the single-player campaign is playable while multiplayer and replacement 3D tactical combat remain unfinished. Installation requires ownership of a supported original game.

Reburn 3 is a work-in-progress open-source reimplementation of Burnout 3: Takedown. The README calls it a rewrite and says it is currently playable on Windows and Wine through Cxbx-Reloaded.

ReChan reimplements Jackie Chan Stuntmaster's PlayStation game logic and systems in C++ for x86_64 Windows and Linux. It rebuilds data structures and formats, extracts required assets locally from a user's NTSC-U disc image, and adds widescreen, higher-resolution and keyboard-and-mouse support.

ReFlood reconstructs the Amiga game Flood as a C99 program with an SDL2 host, using assets extracted from the player's own disk image. Its reports map the game's custom disk layout and document behavior recovered from the original, while the build also offers a headless core and a level editor.

REGoth-bs reimplements the zEngine used by Gothic and Gothic II. The reviewed README says there is no official release yet. Nightly Windows builds are on the Azure Pipelines page for definition 1. Building and running on Linux or Windows are documented at regoth-project.github.io/REGoth-bs.

REGoth reimplements the zEngine used by Gothic and Gothic II. The reviewed README says the project restarted at REGoth-project/REGoth-bs. This tree's latest tagged Windows and Android builds are version 0.4. git clone --recursive, CMake 3.1 or newer, and a C++14 compiler are required, along with libsndfile. The tested compilers are GCC 6, MinGW, and Visual Studio 2015 or 2017. REGoth -g takes a Gothic I or II installation and -w takes a zen file such as newworld.zen. The binary is in build/bin.

REinforced extends the REminiscence reimplementation of the 1992 Flashback game engine. Its C++ engine reads original PC, Amiga or Macintosh files and offers widescreen display modes, graphics scaling, saves and audio playback.

ReksioEngine reimplements the BlooMoo and Piklib engines used by the Przygody Reksia games. It runs the original assets and scripts in a web browser.

REminiscence reimplements the engine of the 1992 game Flashback and runs on data files from the user's DOS, Amiga, Macintosh or PC-98 release. Its SDL-based code handles game logic, graphics, cutscenes, audio and saves, with command-line options for scaling, widescreen display and language.

reone reconstructs an engine for Star Wars: Knights of the Old Republic and The Sith Lords in C++ using public file-format information and observations of the games and their resources. It loads files from a legally obtained copy, with SDL 2 and OpenGL 3.3 used by the custom engine.

reRBR reimplements Richard Burns Rally 1.02 for Linux, macOS and Windows, using the player's game files and NGP 7.4.778 physics. Its Rust code covers game formats, stages, cars, race flow, damage, saves and rendering; the author reports comparing gameplay behavior with recordings of the original. BTB stage support remains experimental.

Return To The Roots rewrites The Settlers 2 for modern operating systems while using graphics and sounds from the player's original Gold Edition copy. The C++ project aims to add internet multiplayer and other changes, and provides build instructions for Linux, macOS and Windows.

ReverseSanta is a C++ reimplementation of Joymania's Santa Claus in Trouble built from study of the original without disassembly tools. Its source includes game, level, graphics, and editor components using DirectX 9. The author describes the result as inaccurate to the original and has not tested it from start to finish.

reWoodpecker rebuilds Woody Woodpecker: Escape from Buzz Buzzard Park for PSP with a C++ engine and a Qt converter for the user's PS2 disc. The runtime loads levels, handles collision and gameplay, executes EKO scripts and renders through the PSP GU.

Rigel Engine reimplements Duke Nukem II in C++ using findings from disassembly of the original game binaries. It replaces the DOS executable while reading the user's original game data, and adds widescreen display, smooth scrolling, quick saves and controller support.

Riiablo rebuilds Diablo II in Java with LibGDX, OpenGL, FlatBuffers, and Netty, loading game assets from the user's own installation. The current build can load supported saves and let characters move through the game, while an MPQ viewer and map viewer aid development. The author states that it is not yet playable.

rlvm reimplements the RealLive interpreter so VisualArts games can run on Linux and macOS using their own SEEN.TXT game directories. It supports KOE, NWK and OVK voice archives and implements rlBabel line breaking for compatible English patches.

Robot War Engine rebuilds a Total Annihilation-compatible strategy-game engine that runs on the player's original data files. Its C++ core parses HPI archives, GAF sprites, 3DO models and COB unit scripts, while a separate Electron launcher provides a multiplayer lobby.

roBrowser recreates a Ragnarok Online client for web browsers using JavaScript, HTML5 and WebGL. Its code includes game and login engines, resource viewers and loaders; deployment instructions use converted client data, a remote resource client and a WebSocket proxy to connect to a server.

Rockport Native reconstructs the PlayStation 2 release of Need for Speed: Most Wanted as a macOS game using a Swift and Metal engine and data converted from the player's ISO. The project documents disc formats, game systems and a Ghidra and REA disassembly workflow; the author reports a playable Mac release and remaining gameplay gaps.

RodLegacy reimplements Street Rod and Street Rod 2 in C++ for modern systems, reading game data from user-supplied Amiga disk images. Its game code covers cars, races, scenes, sound and save files, with optional car-set mixing and several soundtrack sources. The author describes both games as playable while development and bug fixing continue.

Rollerbot-Android reconstructs the 2000 game Rollerbot: A Time Journey for Android and Linux from its original scripts and user-supplied assets. It implements gameplay, scene, audio and platform components, with an Android disc importer and a Linux Flatpak. Supporting notes map Direct3D Retained Mode call sites in the original executable.

Rook reconstructs a Roblox-compatible engine in Rust so user-supplied places can run outside Roblox. It loads .rbxl, .rbxm, .rbxlx and .rbxmx files and implements Luau scripting, an instance model, physics and rendering; its behavior notes and conformance cases compare results with Roblox Studio.

rrt2-decomp reimplements Railroad Tycoon II in Rust after studying the Platinum executable, game data and simulation rules. Its crates parse PK2 archives, LAD sprites, maps and saves, while a differential harness runs original functions for comparison; the new game uses the player's installed assets and a wgpu renderer.

RTAGlass reimplements the PS2 game Road Trip as a C++ Windows port. Its build analyzes the user's own USA disc image, generates tables and VU1 microcode conversions from the executable, converts models, textures and sound, and assembles a playable Windows build.

rugrats reconstructs the North American PlayStation game Rugrats: Search for Reptar as a native Rust PC game using data read from the player's own disc. Separate readers decode models, rooms, animation, sound and cinematics, while a new runtime implements controls, physics, level rules and saving. The author reports start-to-finish playability and records reverse-engineering findings in a worklog and format reference.

rust-theft-auto reimplements the original Grand Theft Auto engine in Rust using map and style files from a player's installation. The source includes map structures, tile and style handling, and a renderer. Reimplementing gameplay and extending maps and missions are stated goals.

Rusty MCLA rebuilds Midnight Club: Los Angeles Complete Edition as a Rust game engine for Windows using data prepared from the user's Xbox 360 disc image. Its format tools handle the disc, archives, resources, scripts and shaders, while a function registry tracks work against the original executable. The author reports about 17 percent of functions closed and lists online play and several hardware features as later work.

RustyWorld reimplements the Another World game engine in Rust and runs on the user's original data. Its VM separates instruction decoding from execution and groups related opcodes, while minifb handles video and input and rodio handles audio.

sacengine reimplements the engine of Sacrifice, the game by Shiny Entertainment. It is written in D. LDC 1.41.0 is a known working compiler.

Reimplements the Grand Theft Auto: San Andreas engine in Unity (C#), loading the archives, RenderWare models and textures, collision, animations, audio, text and item definitions from the user’s own PC installation. README says it will not be a complete reimplementation; it focuses on gameplay features, multiplayer and a framework for extending and modding the game through C# plugins. Development has stalled: the newest commit on any branch dates from 2022-09-30.

Sarien reimplements Sierra On-Line's Adventure Game Interpreter (AGI) in C so that AGI games such as Leisure Suit Larry, King's Quest II and Mixed-Up Mother Goose run across many platforms. It executes the compiled Logic bytecode and handles AGI graphic, text and sound resources, including Amiga and Apple IIgs versions and AGDS games, and adds extras such as a debugger console, picture and dictionary viewers and three-channel PCM sound. The Hacker's Guide documents the interpreter's architecture, drivers, graphics and sound; the project later merged into ScummVM.

Scion is a reference implementation of the Gonzo/Rizzo framework used by Maxis. It aims at the version in SimCity 4 Deluxe Edition. The README also names SimCity 3000, The Sims 2, and Spore as games that used the framework, and says identical machine code is a stretch goal.

The Scooby-Doo Mystery port reimplements the Sega Genesis game's engine in C++ with SFML 3, porting routines from 68000 code and reading graphics, text and scripts from a user ROM. The repository includes engine notes, script VM findings, Ghidra exports and emulator comparison tools.

Replaces the executables of classic adventure games and RPGs with one program that runs the user's original data files. It began with LucasArts SCUMM games and now names many other titles.

SDLPAL is an SDL reimplementation of the Chinese RPG Legend of Sword and Fairy, also called PAL. It builds for Windows desktop and UWP, GNU/Linux, macOS, Android, iOS, and several consoles. Windows desktop opens win32/sdlpal.sln in Visual Studio 2017 or later. GNU/Linux runs cd unix && make and needs SDL 2.0. The original resource files are copied into the same directory as the executable. On case-sensitive filesystems those filenames are lower-case. Versions are selected in the first-launch window or in sdlpal.cfg.

SDLPoP2 rebuilds the engine of Prince of Persia 2: The Shadow and the Flame from its DOS program as C for Linux and Windows. It reads the user's original game data, and its findings document DOSBox-X traces, reconstructed routines and equivalence tests; a headless core supports tool-assisted runs.

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.

sekiro-rs rebuilds parts of Sekiro: Shadows Die Twice in Rust and Bevy using data extracted from a user's Steam installation. It interprets Havok Script and behavior graphs, TAE events and Lua AI scripts, reads game formats including FLVER and MSB, and rewrites engine combat rules identified through static analysis.

sena-rs reimplements the SoftPAL engine in Rust for Koikake, with a PAL virtual machine, asset handling, script disassembly and decompiler components. It runs from an external game installation and provides builds for desktop, mobile, WebAssembly and experimental console targets. The author states that console hardware execution has not been tested.

Settlers.ts builds a browser-based Settlers 4 remake in TypeScript using files from the user's game installation. Its readers decode LIB archives, graphics, maps and saves, while WebGL renders map landscapes. Object drawing, settlers, buildings and game logic are listed as future work.

sh23ds rebuilds Silent Hill 2: Director's Cut as a native C engine for Nintendo 3DS using the player's PC game data. Game logic, camera, lighting and events were reconstructed from the PC executable; the research notes report analysis with Ghidra and REA. The author reports a complete playthrough in Azahar, while real-console testing and some PC behaviors remain unfinished.

sh3redux rebuilds the Silent Hill 3 engine in C++ with OpenGL rendering. Its source includes game engine, graphics and ARC archive structures, with a CMake build and a Code::Blocks project.

Shiloh is a Rust engine for The X-Files Game (1998), with an SDL2 window and a WebAssembly browser build. Complete playthroughs are reported for the English DVD Edition, program build 2.05, the Russian 1.00 release, and the German 7-CD release, program build 1.00.19. The browser build is served at 127.0.0.1:8640. Tables such as the computer, phone, and notes are read from the player's copy at run time.

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.

shock2quest recreates the Dark engine for a virtual-reality version of System Shock 2 on Meta Quest. Its runtime reads KPF archives and cutscenes copied from the user's 25th Anniversary Remaster installation; the Rust workspace includes engine, game and VR runtime components.

si78c is a C reimplementation of the 1978 arcade game Space Invaders. Running it matches the original memory state apart from the stack, and the frames match pixel for pixel. The ROM files go in inv1/. invaders.e is MD5 7d3b201f3e84af3b4fcb8ce8619ec9c6, invaders.f is 7709a2576adb6fedcdfe175759e5c17a, invaders.g is 9ec2dc89315a0d50c5e166f664f64a48, and invaders.h is e87815985f5208bfa25d567c3fb52418. make builds ./bin/si78c. It uses SDL2 and ucontext, and the documented builds use Ubuntu 18.04 and Mac OS X El Capitan on little-endian machines.

A C#/.NET 10 engine loads Dungeon Siege's original archives, scripts and models, with published alpha builds and an audit/parity ledger. The project also provides SiegeSmith modding tools, while describing remaining fidelity and playthrough risks.

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.

Sims 3 in Bevy reimplements The Sims 3 in Rust using Bevy and data from the player's installation. A separate baking step converts packages into a local cache of textures, meshes and world data; format notes document resource layouts and gameplay tuning used by the implementation.

SimUnity2 partially reconstructs The Sims 2 in Unity using files from a user's game installation. The author reports working neighborhood selection and neighborhood views; the C# source includes DBPF and other game-file readers.

Reimplements Skate 3’s skating, tricks, grinds and offboard movement in a new Rust and Bevy engine that runs on assets converted from the user’s own Xbox 360 copy, adding difficulty settings and a .skate custom-map format. Physics notes cite functions and constants read from the original executable in IDA, and audio research reads traces from a research-hooks branch of a separate Skate 3 static recompilation. README says gameplay parity is still a work in progress, credits dumbad’s years of format research and states that AI coding tools were used to write the rewrite.

skyroads-port reconstructs the DOS game SkyRoads as a portable C11 engine after disassembling SKYROADS.EXE and documenting its file formats and algorithms. It reads original data files supplied by the user, and the author reports that replaying DEMO.REC follows the original demo road tick for tick.

smw reimplements Super Mario World's game logic as a native program using levels and images extracted from the user's ROM. It also runs an emulated version in the background, compares RAM state every frame, and saves a snapshot when the states diverge.

The author uses REA’s Ghidra workflow to investigate the DOS Ski or Die binary, document Snowball War rules and rebuild that one minigame in Rust with SDL2. The public notes distinguish recovered tables and mechanics from approximations and deliberate presentation changes.

Sourcehold is an early open-source engine for Stronghold, the 2001 castle game by Firefly Studios. It uses SDL2, OpenAL, FFmpeg, zlib blast, and the EnTT, filesystem, and cxxopts submodules. git submodule update fetches those. Windows builds use vcpkg for sdl2, ffmpeg, and openal-soft, then cmake --build build. macOS runs apple/build.sh macos. The iOS path builds only the simulator. --path points at the game data, or the files go in a data directory with binks, fx, gfx, maps, and stronghold.mlb.

steins-gate is a GPL-licensed reimplementation of the Steins;Gate visual novel. Building it requires libnpa and libnpengine.

Street Rod SDL3 reconstructs the 1989 DOS game's behavior in C and runs it through SDL3 using the player's original files. The repository records function specifications and file formats for the game's picture libraries and data, and its port covers the VGA game, racing systems, saves, and PC speaker sound.

Subway Runner 3D is a procedural Three.js endless runner modeled on Subway Surfers movement and presentation. The author reports using REA and frame-by-frame observation of the original to derive speed, acceleration, jump and gravity values, then implementing lane movement, obstacles and power-ups for browsers and an Android WebView build.

Super Mario Bros Remastered recreates four Super Mario Bros. games in Godot, with revised physics, new levels and characters, and a custom level editor. Players supply an original SMB1 NES ROM; the project provides the Godot game source.

Surreal Engine reimplements Unreal Engine 1, currently for Unreal Gold and Unreal Tournament. The SurrealEngine executable adds game folders and launches a selected game. It runs on Windows 10 or newer, macOS 15 or newer, and a current Linux distribution, using Direct3D 11, OpenGL 3.2, Vulkan, or Metal 2. Build steps are in Docs/Building.md. SurrealEngine [--url=<mapname>] [--engineversion=X] takes a game-folder path.

SWBF2 Browser Reconstruction rebuilds parts of Star Wars Battlefront II (2017) in a three.js browser runtime using data extracted from the user's installed game. The pipeline converts Frostbite meshes, textures, lighting, animations, audio and gameplay values; its reference scene is Death Star II with Blast and Free for All modes.

T.O.R.E-Fighters rebuilds Jane's Fighters Anthology in Rust around observed player-visible behavior. It imports resources from the player's retail copy, implements flight and quick missions, and documents original formats, feature coverage and approximations where behavior remains uncertain.

TA3D rebuilds Total Annihilation gameplay in an OpenGL 3D engine that loads original game maps, units and animation scripts from separate resource files. It implements movement, construction, weapons and campaign play, with additional visual effects and a game console.

Tapir reimplements the RGSS, RGSS2 and RGSS3 runtimes used by RPG Maker XP, VX and VX Ace games. It provides a C runtime with graphics, audio and input components and documents Linux builds and RTP installation. A test suite is set up to exercise the original RGSS runtimes supplied by the user.

TempleRun-RL reconstructs Temple Run's track generation, hazards, and runner physics in a headless training simulator. A Frida gadget reads live state and calls game methods on an arm64 Android phone so the project can measure behavior and evaluate a PPO policy against the original. The author reports a longest device run of 16,782 metres.

Test Drive II Enhanced reimplements the EGA Test Drive II: The Duel executable in C and runs it through SDL3 with the player's original game files. Its replacement road renderer draws at higher resolution and 60 frames per second with a longer draw distance, while a classic mode retains the earlier view. A stage viewer reads the game's scenery data for camera exploration.

Test Drive II: The Duel is reimplemented in C for SDL3 from analysis of the DOS EGA game. The port loads the user's original executable and data, while accompanying tools unpack EXEPACK files, disassemble x86 code and decode resource archives. Function indexes, porting specifications and file-format notes document the reconstruction.

th10 reimplements Mountain of Faith 1.00a in C++ for a portable browser runtime. Its TH10-specific systems handle game rules, ANM and ECL data, numeric behavior and replay logic, while SDL and WebGL provide the platform layer.

Reimplements the engine of The Elder Scrolls III: Morrowind on the Crystal Space 3D engine, loading the BSA and ESM files of an installed Morrowind with Tribunal and Bloodmoon. Plugins cover a BSA virtual file system, NIF mesh loading through niflib, terrain, skybox and game logic. The docs describe how NIF scene trees and animations are converted, how plugin reference IDs are remapped when several master files load, and list original Morrowind bugs with their causes, fixes and status in the engine.

The Force Engine rebuilds the Jedi Engine to run Star Wars: Dark Forces on modern systems using the user's original game copy. Its source includes game and engine code derived from analysis of the original executables, alongside a software renderer, GPU renderer, mod loader, and level editor. Outlaws support is planned but is not yet playable.

hobbitgfx implements the graphics engine of Melbourne House's 1982 text adventure The Hobbit in JavaScript. The repository contains the engine script and HTML demo pages.

Thirdeye reimplements the AESOP/16 and AESOP/32 engine in C++ to run Eye of the Beholder 3 and Dungeon Hack from their original RES files and unchanged bytecode. It includes a SOP virtual machine, resource readers and a RES disassembler, alongside a modern runtime with SDL3 audio, input and display support.

Thyme is an open source reimplementation of Command & Conquer Generals: Zero Hour. It rewrites the game from the ground up and uses the original binary for functions it has not yet replaced.

TM2020-Sim extends Gearbox's Trackmania physics and asset loading into a headless simulator with a native C++ and Rust SDK. It adds parallel environments, replay analysis, driving-controller research and validation tools for local game observations.

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.

Torchlight Rekindled implements an engine for the 2009 game Torchlight, following the logic of its Xbox 360 release. It uses OGRE 14 and ParticleUniverse for rendering, runs on Switch, mobile and desktop platforms, and reads a user's PC or Xbox 360 game archive at runtime.

touhou-engine reimplements Touhou danmaku gameplay in Python, with TH07: Perfect Cherry Blossom as its reference game. The author says its engine logic was ported frame by frame against a decompilation, while the new architecture supplies an event stream, replay handling, headless stepping, and a pygame renderer. It reads original game archives supplied by the user.

Tower Toppler reimplements the rotating-tower puzzle platformer Nebulus with newly drawn graphics. The author reports behavior close to the original after comparison, and the current game uses SDL for graphics and sound. A level editor supports new towers and missions.

tower-together reconstructs SimTower's simulation as a multiplayer browser game. A TypeScript simulation core runs in a Cloudflare Worker and clients, while documented behavior notes and captured traces from the original executable guide comparisons of state at each tick. The project supplies its own interface and assets.

TurokEX reimplements the PC version of Turok on the Kex engine, with the game's actors, enemy AI, weapons, pickups, areas and HUD written as AngelScript classes. Its KPFGen converter reads the original CARTFILE.DAT and Turok.exe and packs their textures, fonts, sounds, models, levels and particle effects into a game.kpf archive. The engine side covers OpenGL rendering, collision and physics, OpenAL sound, a console, ENet networking and an SDL2 platform layer.

TwinEngine rewrites the Little Big Adventure 1 engine in C to run the original game from its installation files. Its source covers rendering, scenes, actors, scripts and HQR resources; the project describes the engine as beta-stage.

Twisted Metal reimplements the 2012 PS3 game's engine in Rust for Linux and macOS. Its tools extract a user's disc image, convert models, textures, collision and handling data, and support scene viewing and an early driving simulation with placeholder physics.

UA_source reimplements the Urban Assault engine in C++ and plays using files from the user's original game copy. It documents Linux and Windows builds with SDL2, OpenGL, OpenAL and other media libraries, and exposes options for rendering and original game behavior.

UAlbion reimplements the 1995 RPG Albion in C# using data from an original game installation. Its implemented features include 2D and 3D rendering, movement and environmental interaction in 2D areas, menus, inventory, dialogue and saves. Commands extract and repack game resources.

Ultima V Redux recreates Ultima V: Warriors of Destiny in Go using files from the player's MS-DOS PC copy. The engine adds modern presentation and a Debug Workbench, while companion guides describe game mechanics, compatibility formats and differences from the original.

Un-Banished rebuilds the Banished 1.0.7 engine in Rust for desktop and browser play using data from the user's own game copy. Its documented process uses Ghidra pseudocode, emulated original functions and comparisons of the new code with original behavior. The engine also reads existing saves and BanishedKit .pkm mods; the author reports a beta with known differences.

Unciv recreates Civilization V gameplay as a moddable Android and desktop game built with LibGDX. Its roadmap identifies Gods & Kings and Brave New World mechanics that remain to be added.

Underworld Adventures recreates Ultima Underworld I as a C++ engine for modern systems, loading the user's original game files. It uses OpenGL for 3D graphics, SDL2 for platform services and Lua for scripting, and includes documentation of Ultima Underworld I and II file formats.

Underworld Revisited reimplements Ultima Underworld: The Stygian Abyss (1992) in Unity. It reads the GOG or Steam copy. The checked GOG executable UW.EXE is 547,248 bytes. Windows releases are UnderworldRevisited-<version>-win64.zip and start with UR.exe. Linux releases since 0.3.0 are UnderworldRevisited-<version>-linux64.tar.gz and start with UR.x86_64. Saves use the installation folders UNDEROM1\SAVE1 through SAVE4.

An author-documented REA/Ghidra investigation of the shipped Untangle Windows binary produces a single-page playable rebuild and a claim-by-claim grading receipt. The report separates frozen findings, a later source-code answer key and a prior-knowledge audit.

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.

vange-rs reimplements Vangers in Rust with wgpu graphics, aiming to reproduce its worlds, vehicles and single-player behavior using original game resources. The repository includes a playable road binary, model and level viewers, resource conversion tools and technical notes on rendering and data formats.

Vault Engine reimplements Fallout and Fallout 2 as a Rust engine that reads the user's retail DAT archives. Its modules cover DAT formats, the INT script VM, combat, AI, saves and rendering, with behavior built from written clean-room specifications and checked through state hashes and trace oracles.

Vault13 reimplements the Fallout 2 engine in Rust using files from a local game directory. Its source covers DAT archives, maps, graphics, inventory, dialogue and script execution, while the documented demo offers limited movement and display controls.

VCMI recreates the Heroes of Might & Magic III engine in C++ for playing the original game with an open-source runtime. The repository includes game logic, battle AI, a client and documentation for mods and supported game file formats.

VERA20K rebuilds the Red Alert 2: Yuri's Revenge engine in Rust while reading the user's original game files. The project says coding agents study the original engine with Ghidra, implement its behavior in a new simulation and rendering architecture, and compare results with the original through tools and playtests.

Wacki is a cross-platform port of Wacki: Kosmiczna rozgrywka (1998), reconstructed from the decompiled WACKI.EXE. The English portion of the README says it runs on macOS, Linux, Windows, Android, Miyoo and other PortMaster handhelds, and PlayStation 2.

wage-engine reimplements the World Builder engine for classic Mac graphic text adventures in Java. It loads Mac resource data for scenes, characters, objects, sound, and scripts, and converts script bytes into readable commands.

Wanderer reimplements the 2002 game Project Nomads in Java with libGDX, using assets from the original game. Its documented asset formats include models converted from Nebula NVX, textures converted from NTX, and animations converted from NAX; a story guide maps the original TCL scripts to JavaScript. The project aims to retain the original gameplay while fixing flaws.

War1 reimplements Warcraft: Orcs & Humans in C as an RTS engine that reads the original game's DATA.WAR assets. It implements unit movement and training, building construction, resource gathering, fog of war, spells and basic enemy behavior; AI, cinematics and save/load are still listed as unfinished.

War1gus reimplements Warcraft: Orcs & Humans for the Stratagus engine using graphics and sounds extracted from the user’s original game. Its scripts and campaigns support modern mouse controls, larger unit selections, additional multiplayer factions and a map editor.

Warsmash reimplements Warcraft III gameplay on LibGDX using assets from the user's own game installation. A configurable virtual file system reads MPQ archives, extracted folders, or CASC sources according to the installed patch, while Java source implements simulation, rendering, interface, and scripting components.

WebFun recreates the engine behind Indiana Jones and His Desktop Adventures and Yoda Stories as a web application. The project shows game play, mobile controls, save inspection, asset editing, debug overlays, and script coverage views.

Weltall rebuilds the PlayStation game Xenogears as a native Unreal Engine 5 port that reads content from the user's disc images. Its source implements field and battle rendering, game systems, input, saves, and disc-data handling. The author reports checking gameplay behavior against the original code and completing a playthrough of both discs.

widebrim recreates the Nintendo DS Layton 2 engine in Python and pygame, informed by decompilation research on the European Professor Layton and Pandora's Box release. It reads a user-provided ROM and implements game modes, puzzles and saves while documenting behavior it approximates or omits.

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.

wipEout Rewrite reimplements the 1995 PlayStation racing game in C. It provides SDL2 and Sokol platform backends, OpenGL and software rendering options, and expects original game textures and models to be supplied separately.

Wizardry 6 investigates the data formats and systems of Bane of the Cosmic Forge, with parsers and viewers for graphics, maps, scenario records, text and sound. It includes portrait and character-roster editors and a developing Python game engine that reads original game data.

wkbre2 is an engine reimplementation for Warrior Kings and Warrior Kings Battles. It uses a client-server architecture and original game assets, and aims to load unit definitions and interpret gameplay scripts from the games' data.bcp archive. It supports Direct3D and OpenGL rendering and is in early development; it is not completely playable.

wkbre reimplements the Warrior Kings and Warrior Kings: Battles engine to open original game data, load levels and render the world. Its current editor can modify savegames and terrain and create skirmish maps for the original engine; gameplay in the replacement engine remains under development.

Wolfenshine is a cross-platform C# reimplementation of Wolfenstein 3D. It reads the maps, artwork, music, and sounds from the player's copy and renders them with a .NET engine, including a 320 by 200 software renderer and an enhanced lighting mode toggled with F2.

Wolfenstein (2009) SP rebuilds single-player engine behavior in C++ on idTech4A++, using game data from the user's PC copy. It implements SP PK4, SPK and MPK readers and native tests for player, MP40, actor and trainyard behavior; research notes record findings from the original executables.

WoodyRE reimplements the engine of Woody Woodpecker: Escape from Buzz Buzzard Park, the 2001 PC game. It checks the player's CD against the English 1.00 release and also accepts the Spanish CD and three February 2002 discs. Releases cover Windows, Linux, Android 7.0 or later on 64-bit devices, and an experimental Switch build.

X-Settlers is an early C++17 reimplementation effort for The Settlers 3/4 that renders map terrain and documents Settlers 3 map partitions. Its format notes identify map information, player and team data, previews, areas, buildings and resources. Loading graphics and maps directly from an original installation remains planned.

Reimplements BioWare’s Aurora engine and its later derivatives as a portable C++ engine that runs on the user’s installed game data, targeting nine games from Neverwinter Nights to Dragon Age II. Resource management, many Aurora file formats, graphics and sound are in place, and every target shows partial in-game areas in a free-flying spectator mode. README states that normal gameplay is not implemented yet.

XU4 recreates Ultima IV for modern systems while loading the original DOS game's data at runtime. Its implementation supports original EGA and upgraded VGA graphics, and its documentation maps file structures such as SHAPES.EGA.

YodaStoriesNG reimplements Star Wars: Yoda Stories and Indiana Jones and His Desktop Adventures in C# and SDL2 using each game's original data file. It parses tiles, zones, puzzles and IACT scripts, reconstructs world generation, and provides script disassembly and other inspection windows. The author reports complete Yoda Stories play and remaining Indiana Jones puzzle gaps.

Rebuilds Zelda II: The Adventure of Link (NES) in Rust for desktop, browser and Android by replacing the game’s 6502 routines one at a time. A built-in interpreter still runs the user’s ROM and hands ported routines to Rust, while a verifier compares RAM, sprites, palette and frames with a reference emulator. It is a behavioral, clean-room-style reconstruction guided by a community disassembly, with a standalone engine still in progress.

Zelda3 reimplements The Legend of Zelda: A Link to the Past in C, extracting levels and images from the user's US SNES ROM. It can run the original machine code beside the replacement and compare RAM state after each frame; the author reports that the game is playable from start to end.

Reconstructs Zeliard's DOS engine and resource handling as documented C code and an SDL2 port that reads the user's original game files. Its tools extract SAR archives, decode compressed payloads and regenerate disassembly; technical notes map the boot chain, overlays and driver interfaces.

ZGloom reimplements the Amiga first-person game Gloom, including Zombie Massacre. Windows builds need the Visual Studio 2013 runtime. Linux builds use SDL2, SDL2_mixer, and libXMP.

ZT1-Engine reimplements Zoo Tycoon 1 for modern Windows by recovering game rules from zoo.exe and comparing behavior with the original. It reads art, sound, and other files from the player's installation and includes a lab for examining original addresses and execution traces. The author describes base-game freeform play as available in alpha, while expansion features and save parity remain incomplete.

2ooM works toward a remake of Master of Orion II that runs on the original game's data files. Its liblbx library and the lbxtool and lbximg tools list and extract LBX archives and decode the game's multi-frame 256-colour LBX images to PNG, applying base palettes from fonts.lbx and override palettes for player colours, with an md5-based regression test against the original archives. Notes record the music format and map stream.lbx and streamhd.lbx entries to named tracks, and the engine repository holds a plugin-based skeleton with a virtual file system and SDL and FFmpeg modules.

AsarUSALTTPDisassembly reorganizes and annotates assembly for the US SNES release of The Legend of Zelda: A Link to the Past. It adapts earlier disassembly work for Asar, adds labels, RAM maps and notes based on the author's research, and aims for an exact ROM rebuild once its build is complete.

accd reconstructs the Assetto Corsa Competizione dedicated server in C99 for Linux and BSD systems. It accepts unmodified game clients and implements the observed connection handshake, session scheduling, car updates, results and telemetry messages. The repository includes server source and protocol validation tools.

ACEmulator rebuilds the Asheron's Call MMORPG server in C#, aiming to reproduce the game world as it was when the official servers closed in January 2017. The source implements the client network protocol (packets, game actions, events and messages), physics, world objects and a loader for the client's .dat files, backed by MySQL or MariaDB. Server options switch individual retail behaviours, such as door holding and fast buffing, on or off.

AFS200Tools documents the AFS Volume 2.00 archive format found in PlayStation Tenchu games. It records the big-endian header, 36-byte file entries, file table placement and a tentative filename scheme, alongside C# source for handling volumes.

Afterhours 2015 reconstructs online services for Need for Speed (2015) as a Rust server and local launcher. The workspace implements stream framing, tagged fields, typed backend and world messages, and content preparation from the player's installation; the author reports live checks for selected gameplay and garage flows.

agario-client is a Node.js implementation of an earlier agar.io client protocol. It connects over WebSockets, parses game packets, and provides API methods for movement, spawning and spectating alongside events for ball-state changes. The author stopped development after a later game update changed the client implementation.

Aion 2 Network Protocol Research reconstructs parts of the game's client-to-server network protocol from captures and client inspection. It documents unsigned-varint framing, LZ4 bundles, an RSA-OAEP-SHA1 world handshake and continuous RC4 over post-handshake client frame bodies. Python tools analyze captures, recover session material and implement client cryptographic primitives.

alive-serv reconstructs part of the SIF2 MIRACLE LIVE! game server in C from the global client's server protocol. Its four endpoints return an asset hash, initiate login, return a startup token and log client errors; the client can reach the title screen and part of login.

Alley Cat Disassembly is an in-progress effort to turn the DOS game's Ghidra disassembly into annotated NASM x86 assembly. Its source is divided into gameplay, graphics, input, sound and data modules, and progress notes document the MZ header, segment mapping and address translation. The build compares the assembled output with the original cat.exe.

Alleyway reconstructs the 1989 Game Boy game as assembly source organized by audio, display, input, physics, and stage code. Its build script emits a 32 KiB ROM with published CRC32 and SHA-1 hashes, and accompanying notes identify unused routines and behaviors.

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.

Arkanum reconstructs Arcanum game data formats as part of a Python engine recreation. Its code reads and extracts DAT archives and parses map-sector structures including tiles, roofs, scripts and blocked-tile arrays, with field layouts recorded beside the parsers.