Reverse-engineering case studies.

e17p reconstructs storage formats used by the visual novels Ever17 and Remember11 while developing a Python engine for their data. Its tools extract LNK and AFS archives, convert CPS and T2P images and WAF audio, and inspect script data; several script semantics remain unknown.

EasyRPG Player recreates runtime support for RPG Maker 2000 and 2003 games through an independent game interpreter. It reads project data with liblcf and runs from the game's project folder alongside RPG_RT.exe; the implementation also supports EasyRPG games.

engge 2 reimplements the Thimbleweed Park adventure engine in Nim. It runs on ThimbleweedPark.ggpack1 and ggpack2 copied from a player's game installation, with optional save files and DLC packs. Its source includes game logic, scripting, scene rendering and ggpack handling.

engge reimplements the Thimbleweed Park adventure engine in C++ and runs with ThimbleweedPark.ggpack1 and ggpack2 copied from the user's installation. It uses an SDL2-based framework and a modified Squirrel library; the author reports the game can be finished despite bugs.

Epic Pinball HD reimplements the DOS Epic Pinball engine as a native macOS app with classic and enhanced modes. It imports tables and media from the user's own copy, runs some original executable rules through a small x86 runtime and compares classic-mode behavior with original code in Unicorn. Across all 13 tables, the author reports matches in 415/415 physics scenarios, 415/415 rules scenarios and 413/415 full-main-loop scenarios.

evnova-decomp reimplements the Escape Velocity Nova engine in C++23 and SDL3 using data from a local Windows Community Edition installation. Its research notes cover resource formats, missions and gameplay behavior, while Ghidra-based tools support comparison with original functions. The author reports a playable storyline but notes missing features and timing differences.

eZeus reimplements Zeus: Master of Olympus and its Poseidon expansion as a C++ game using the player's original files. It supports the original adventures and adds optional behavior such as an alternate walker implementation and building two cities at once.

F.LF rebuilds Little Fighter 2 as a JavaScript and HTML5 game engine for desktop and mobile browsers. It converts the original game's dat files to JSON and implements characters, backgrounds, versus matches, WebSocket player networking, and selectable AI. Its core library supplies graphics, controls, and network modules.

f2bgl reimplements the engine of the 1995 game Fade To Black in C++. It loads files from the original PC release or demo and provides rendering, input, audio and save-state handling through an SDL2-based build.

FA Remastered reimplements the Supreme Commander: Forged Alliance engine in C++ around the user's game data, Lua scripts and mods. It provides a multithreaded simulation, renderer and interface, and compares replay states beat by beat with the original. The author reports identical results for sixteen test replays; local skirmishes are playable.

Fallout 2 Community Edition reimplements Fallout 2 as a cross-platform game engine that uses data from the player's own copy. The C++ source includes combat, art, audio, and interface components; the project adds engine fixes and quality-of-life changes while retaining the original gameplay.

Fallout Community Edition reimplements Fallout for Windows, Linux, macOS, Android and iOS. It replaces the original executable while reading game assets from the user's copy, and includes engine bug fixes and quality-of-life improvements.

Falltergeist reimplements the Fallout 2 engine in C++ and SDL for desktop platforms. It loads the user's original master.dat and critter.dat data and includes readers for game formats, while gameplay systems such as combat AI and full scripting remain on its roadmap.

FC3 Bevy rebuilds a Far Cry 3 runtime in Rust and Bevy using archives from the user's installed game. It converts game data to a local cache and implements world rendering and simulation; accompanying research documents Dunia 2 animation, DARE audio containers and RNV navigation meshes.

fheroes2 reimplements the Heroes of Might and Magic II engine from scratch and runs on resources from a full or demo copy of the game. It adds higher-resolution graphics, AI changes, fixes and interface improvements across several platforms.

Firestaff rebuilds runtime paths for Dungeon Master, Chaos Strikes Back, Dungeon Master II and Theron's Quest using original media supplied by the player. It identifies editions by content hash and keeps their data separate from its native engine. Source-linked reports and regression checks document supported startup and gameplay slices; Nexus currently reaches a limited Saturn title presentation path.

FPC Atomic recreates Atomic Bomberman multiplayer in Free Pascal, replacing its IPX networking with TCP/IP and adding custom AI and SDL2 controller support. Players can extract assets from their own game disc or generate original graphics and sounds with the included asset generator.

Free in the Dark is an engine reimplementation of the Alone in the Dark games released from 1992 to 1995. The README focuses on the versions sold on Steam and GOG and says some other releases, including the Windows version of Alone in the Dark 3, are incompatible for now.

Cross-platform reimplementation of the Diablo 1 game engine. The README says the project is archived, that original data files are required, and that the current build can walk the town, animate players and NPCs, enter the dungeon, fight with melee and limited ranged and magic attacks, drop loot, and buy and sell items.

freeaoe rebuilds an Age of Empires 2 engine in C++ from observed gameplay and public knowledge. It loads original game data directly, including scenarios, campaigns, graphics and AI scripts; support for Star Wars: Galactic Battlegrounds remains in progress.

FreeGunman is a clean-room reimplementation of Gunman Chronicles in QuakeC. It is cloned into the Nuclide SDK as the directory rewolf. The build is Nuclide's build_game.sh, or make inside rewolf/src. Nuclide needs fteqw and fteqcc set up.

FreeHeroes recreates Heroes of Might and Magic III in a C++ engine with a battle emulator and a one-time converter for original SoD, HotA and HD game resources. It can also start with substitute resources; the author describes the project as unfinished.

Freenukum recreates the 1991 DOS game Duke Nukem 1 using Rust and the original game's graphics data. It provides a data installation tool and is still missing opponents and some level items.

FreeRS42 is a C++ project to reimplement the PC game Ricochet Xtreme using the NuVelocity engine. The repository contains source for game objects, playfield behavior and screens, with a CMake build that includes the engine submodule.

FreeSims recreates The Sims 1 engine in C# and runs on files from the user's original game installation. Its SimsVille source covers game content loading, characters, houses and a neighborhood, with build instructions for Windows and Linux.

FreeSynd reimplements the engine for Bullfrog's Syndicate using the original game's data files. Its source covers missions, rendering, sound and gameplay; the changelog documents work on vehicle pathfinding and mission inspection. The project runs on Windows, Linux and Mac.

FreeTFC is a clean-room reimplementation of Team Fortress Classic in QuakeC. It is cloned into the Nuclide SDK as the directory tfc. The build is Nuclide's build_game.sh, or make inside tfc/src. Nuclide needs fteqw and fteqcc set up.

G-Engine reimplements the engine needed to play Gabriel Knight 3: Blood of the Sacred, Blood of the Damned on Windows, macOS and Linux using the original game's data. Its C++ code parses Barn asset bundles and handles the game's Bink and AVI videos; the source credits earlier reverse engineering of BRN, BSP and ACT formats. The author reports a completable game with remaining bugs and missing noncritical features.

Galaxian2 reimplements Galaxy on Fire 2 as a Godot engine using content imported from the player's Mac Full HD or Android HD release. The importer prepares ships, missions, audio and other resources locally and reads static declarations from the original executable. The source describes a playable campaign and add-ons with release-specific content paths.

Galaxian reimplements the iPhone edition of Galaxy on Fire 1 as a Godot engine. It imports ships, missions, artwork and other resources from the player's IPA, reads AEM and AEI formats, and extracts selected embedded Mach-O definitions into a local cache. The remake adds its own controls and play modes alongside the reconstructed campaign.

Game Creator implements a cross-platform .NET engine for games created with classic Game Maker versions through 8.1. It derives compatibility from observed API and gameplay behavior and includes game logic, function and action libraries, with interpreter, editor and file compatibility work distributed across branches.

Gauntlet Dark Legacy is ported to Windows and Linux through a C++ and Vulkan reconstruction of its engine. The build reads the game's asset tree extracted from the user's USA GameCube disc; the repository supplies engine code, shaders and asset setup scripts.

GearsUE3 is developing a native engine port for the Xbox 360 Gears of War games, with Gears of War 1 as its active target. Its planned product combines Xenia Xenon dynarecs and system services with title-specific native function overrides. The repository records code maps and reverse-engineering findings. The current launcher cannot start that product because image loading and runtime composition remain unwired.

gen2recomp recreates Pokémon Gold, Silver and Crystal in LÖVE2D with a handwritten Lua engine and Generation II script VM. Its importer checks a player-supplied ROM and decodes game tables, text and graphics into a private cache. The same launcher also offers early support for selected Generation III through V games.

GLKeeper, also titled Grim Lands Keeper, is an open-source reimplementation of Dungeon Keeper 2. The README says it is not playable yet.

GLSMAC is an OpenGL and SDL2 reimplementation of Sid Meier's Alpha Centauri and Alien Crossfire. The current version heading is v0.3+. The first launch asks for the original installation path and loads its images and sounds. cmake -S . -B build -DCMAKE_BUILD_TYPE=Release && make -C build is the release build. Linux packages include CMake, SDL2, SDL2_image, FreeType, GLU, GLEW, ossp-uuid, and yaml-cpp. Windows builds use Visual Studio 2022.

Gorc is an early-stage C++14 recreation of the Jedi Knight: Dark Forces II engine intended to replace the original executable and run its single-player and multiplayer levels. The project includes game code, a test harness and a GOB utility for inspecting episode contents. Its current client requires manual selection of an episode GOB and level file.

GT3 Revisited reimplements the Gran Turismo 3 A-Spec engine for Windows, macOS, Linux, Android, iOS, and Meta Quest. It reads an ISO or CHD disc image at runtime. The project status says GT Mode, Arcade, licenses, split-screen, the Replay Theater, movies, music, and physics are playable. Online battle supports up to six players. Releases publish SHA256SUMS. Khronos OpenGL ES 3.0 headers are MIT and Apache 2.0. Windows packages include ANGLE under the BSD 3-Clause license.

GTA4Unity reconstructs GTA IV world loading and rendering in Unity 6 using the player's original game files. It parses IMG archives, WDR/WFT models, WTD textures, IDE definitions and IPL/WPL placements, converts RAGE coordinates to Unity space and streams world geometry through Unity's Entity Component System.

A Rust/Bevy port reads GunZ: The Duel files from the user’s installation and provides native releases, browser build tooling, screenshots and a documented REA/Ghidra investigation framework. Its LAN uses the port’s own protocol, with retail-server compatibility unverified; movement behavior is inferred, with gameplay parity unproven.

h4r reimplements the Heroes of Might and Magic IV engine in Rust using data from a player's installation. It parses .h4r archives and .h4c maps, renders an adventure-map prototype and reconstructs selected movement and combat rules, with a separate harness comparing some rule outputs to the original executable.

Harold reimplements the Fallout 2 engine in TypeScript and Python for WebGL 2 browsers, building on darkfo. Setup converts archives and assets from a user's installed copy; the current engine covers map loading, movement, dialogue and some quests while documenting incomplete combat and saving.

Hazard: Revenge rebuilds the engine of the Korean action RPG Hazard, routing its Windows and DirectX calls through SDL while retaining the game's logic. It supports desktop and iOS builds and reads three separately supplied game PAK files.

Helion rebuilds a Doom-compatible engine with static rendering and state management for dynamic map changes. It reads user-supplied IWAD game data and supports WADs targeting vanilla Doom, Boom, MBF, MBF21, ID24 and part of UDMF.

HERCULAN Engine reimplements Earthsiege 2 in .NET from analysis of its retail executables and data formats. It reads original CD or ISO files, recreates gameplay and rendering on Windows and Linux, and includes HercWorks tools plus documentation of the game's archives, simulation, and shell behavior.

hercules-native reimplements the 1997 Disney's Hercules Action Game engine in C11 and SDL2 for Apple silicon Macs. It reads scripts, state tables and assets from the user's PC game files, with decoders for HERCULES.FS, sprite banks, maps and ETV videos; the author reports all levels playable with some missing effects.

This reimplements the DOS game 金庸群侠传 (The Legend of Jin Yong Heroes). The program is hojy.exe. With -DBUILD_TOOLS=ON, makedata takes the original game directory, a target directory, and a font file, then writes data, config.toml, and the merged map pictures. SDL2 is zlib-licensed. libADLMIDI and zita-resampler are GPLv3. soxr is LGPLv2.1.

Hexwaste reimplements part of the Fallout 2 engine in C# and MonoGame using files from the user's own installation. It reads DAT archives, maps, sprites, scripts, audio, and cutscenes, and implements exploration, dialogue, combat, travel, and persistent state. Its research notes compare behavior and formats with fallout2-ce while documenting the playable scope.

hi-octane202x is a C++ reconstruction of Bullfrog's Hi-Octane that uses data extracted from the user's original game files. It implements vehicle physics, weapons and HUD elements, with basic computer-driver steering and attacks. Its level editor can change textures, terrain heights, columns and map entities.

HL2-RS partially reconstructs Half-Life 2 in Rust and Bevy, reading maps, models, textures, animations, and sounds from an installed copy. Its source separates Source asset readers, simulation, UI, and rendering; the author reports working menus and selected city sequences while the campaign remains incomplete.

HMC47 reconstructs Hitman: Codename 47 from the original game binaries as a modular C++ implementation. Its source covers a launcher and modules for DirectPlay, shared engine data, graphics and sound, while full playability and 64-bit support remain goals.

hode reimplements the engine of Heart of Darkness and reads data files from the original Windows demo or CD release. Its C++ source includes game, level, resource, video and audio handling, with command-line options for data paths, levels and checkpoints.

Rewrites Minecraft: Java Edition 26.3 as a native Rust client, dedicated server and launcher that prepare their resources from the user’s own copy of the game. Contributors are told to read the vanilla code first, and tools/rea_vanilla.py runs a pinned REA release with a headless JADX engine over the shipped client and server jars to inspect classes, methods and callers. Differential harnesses run Java oracles against the real game and Rust probes against Horizon; README reports all 281 passing, which covers only what they compare.

HotaSim reimplements selected Heroes III: Horn of the Abyss battle mechanics in C++ and uses them in a battle simulator. The author describes reverse-engineering game code, recording Cheat Engine addresses and annotating AI disassembly. The simulator currently handles simple melee units without additional abilities.

hulabee reconstructs the Sauce engine used by Hulabee Entertainment games as an SDL2 virtual machine. It includes opcode tracing, tools for extracting and converting .pan and .gg assets, and notes on the engine's language and file formats. The VM documentation names Moop and Dreadly in the Treasure on Bing Bong Island and Ollo in the Sunny Valley Fair as supported games.

I26 reimplements Interstate '76 in Godot. It includes the single-player campaign, scenarios, auto melee, multiplayer, online co-op, a 3D map editor, and a garage. F12 switches to the original 1997 graphics.

Reimplements the MAGES. visual-novel engine, used by the Science Adventure and Memories Off series, in C++ with OpenGL, running supported titles from the user’s original data files through per-game Lua profiles in one binary. README says all endings can be reached in at least one game, Memories Off 6 T-Wave, but no game is fully complete. The project’s tracking issue lists partial support for titles including Chaos;Head Love Chu Chu, Chaos;Child Love Chu Chu, Steins;Gate and Robotics;Notes Elite.

Irisu ML reconstructs Irisu Syndrome! v2.03 normal mode as a deterministic C++20 simulator, Python learning environment and playable browser client. It models input timing, seeded spawning, scoring, chains and progression, with original-format replay support. The author reports event-level matches on four eligible instrumented playbacks and a selected-seed high-score replay.

Implements a standalone runtime for Call of Duty: Modern Warfare 2 (2009) in Rust on Bevy and wgpu, loading maps, models, textures and weapons from the user’s installed game through native FastFile readers and translating its Direct3D 9 shaders to WGSL. Bots, demo recording and replay, and multiplayer over custom UDP with a QUIC master are implemented, while README warns that gameplay remains incomplete, with missing behavior, bugs and desyncs. README states that the whole project is written by an LLM; NOTICE names the community projects consulted and says the original binaries were read with Ghidra.

Jade Cocoon on Bevy reimplements Jade Cocoon: Story of the Tamamayu in Rust and Bevy for Windows. It reads tables and scene scripts from the user's European PlayStation disc image. The author reports story progression through the ending, with battles, creature systems, media and local saves, while noting remaining differences.

Reimplements Jazz Jackrabbit 2 (1998) as a native C++ game on an extensively modified nCine engine, converting the user’s original game files into its own cache on first start. It runs on desktop, mobile, web and many homebrew console targets, with multiplayer, an enhanced Reforged mode and partial JJ2+ and MLLE support. A two-sided trajectory probe checks its non-Reforged movement against the original game, and the project reports 376 of 406 scenarios within 25 px/s.

JGR Portable rebuilds Jet Grind Radio as a native PSP game using reconstructed game and DSP behavior. Its conversion tools process a user-supplied Dreamcast GDI image locally into the data needed by the PSP program. The repository includes PSP source, format converters and build documentation; the author describes performance as scene-dependent.

jpog-decomp rebuilds Jurassic Park: Operation Genesis and its Toshi engine in C++20, replacing original functions one at a time. Its 32-bit Windows build compares reconstructed DLL exports with the original, while a portable SDL3 and bgfx shell targets Windows, Linux and macOS. The author reports that the hybrid build opens a game window and that the portable build remains an early developer shell.

JSettlers recreates The Settlers III as a Java game for Windows, Linux and Android. Its own engine and game code use GFX and SND files from an original or demo installation, with MAP files optional. The author describes the project as alpha software.

Julius reimplements Caesar III's gameplay logic and reads the original game's files to run across desktop, mobile and browser platforms. It preserves compatibility with Caesar III saves while adding widescreen and other interface improvements.

Kabus22 Linux reimplements the 3D GameStudio A6 and A7 engine behavior used by Kabus 22 in C++20. Its native runtime reads the user's original WDL scripts and assets, with OpenGL and optional Vulkan rendering, and the repository documents executable analysis and asset formats.

Re-implements Mario Kart Wii’s physics engine in C++ as a command-line simulator, continuing stblr/Hanachan’s goal of perfectly accurate time-trial ghost replay. Each test case replays a recorded ghost through the engine and compares kart position, rotation, velocities, speed and checkpoint state frame by frame with a trace captured from the original game. It reimplements only the physics behavior and runs through a command-line interface without a graphical frontend.

Kirpich recreates the Game Boy Tetris game in native C++ on Polyrhythm using behavior specifications derived from the original. It reads graphics and sound from the player's ROM and runs the original randomization and sound routines in a narrow SM83 virtual-machine host; desktop builds add optional modes and controls.

KlingonWin10WPF rebuilds the FMV player for Star Trek: Klingon Immersion Studies as a Windows application using the user's original disc videos. Its code handles scenes, clickable hotspots and saves, with video playback through libVLC. The author reports missing button lighting in one scene, no save prompt on exit and hotspot drift after some window resizing.

kys-cpp recreates the DOS game 金庸群侠传 in C++ with SDL3 and several selectable combat modes. Companion tools convert original IDX/GRP graphics, dialogue, event instructions and saves for the new engine; the application uses a separately supplied game resource directory.

Ladder reimplements the 1982 CP/M arcade game in Go. The author observes the original in a CP/M emulator and consults an earlier Java version while rebuilding its platform, ladder and falling-object gameplay; development remains in progress.

lain-bootleg-bootleg reconstructs the Lain Bootleg minigame in C using assets extracted from the player's original files. Python scripts unpack lain_win.dat, lain_mov.dat and lain_win.exe, while the native program implements scenes, animations, sound, video and minigame systems.

Las Marionetas is an open-source reimplementation of The Sims 2. Unimplemented functions still come from the original binary. The README says it currently runs on Windows and needs The Sims 2: Ultimate Edition installed.

Reimplements the engine of Little Big Adventure 2, and now also Little Big Adventure 1, in TypeScript, Three.js and React so that it runs in a browser on resources imported from the user’s copy of the game. README calls it a full re-engineering rather than a disassembly-based approach: every island and building can be explored and most graphics and part of the gameplay work, but the game cannot yet be completed. It adds an editor with an actor-script debugger, VR support and fan-made 3D replacement models for the isometric scenes.

A from-scratch Rust port of the North American PlayStation Legend of Legaia includes native/browser play, asset extraction and disc patching. The author documents Ghidra/emulator research and a full-game ladder for this fresh implementation.

Lemmings.ts recreates Lemmings as a TypeScript browser game that reads original Lemmings, Oh No! More Lemmings and Holiday Lemmings data files. Its game code includes level and graphics readers and interprets adlib.dat music through an Adlib emulator. The source lists gameplay fixes and touch support as unfinished.

Zig libraries reconstructing Diablo II 1.14d seeded maps, item generation, saves, simulation rules and network formats. Selected components expose native and WebAssembly interfaces; verification notes distinguish retail map comparisons from weaker subsystem evidence.

libnpengine is a free implementation of the Nitroplus visual-novel engine. The README says it can run Steins;Gate and names other games from the same authors.

Re-implements a large part of the RenderWare Graphics middleware API as a portable C++ library that reads and writes its DFF model and TXD texture files for PS2, D3D8, D3D9 and Xbox and is meant to convert them between platforms. Direct3D 9 and OpenGL backends render the scenes, while PS2 rendering works only as a test. README names rendering GTA as its use; BSP world files are not supported.

Lilium Salvation reimplements engine support for Dark Salvation on a Lilium Arena codebase. It runs the game's existing QVMs from user-supplied data files and adds display modes; the author says versions 1.0.6 and 1.0.7 were tried through the first level.

linyaga supplies a replacement runtime for two Humongous Entertainment Yaga games: Pajama Sam: Life is Rough When You Lose Your Stuff and Putt-Putt: Pep's Birthday Surprise. Its C host exposes resource, animation, video and audio functions to Python code and reads the user's original game files.

Looking Glass rebuilds the engine and gameplay of American McGee's Alice in Rust, reading the player's compatible 2011 game data without using the original executable or gameplay DLL. It implements campaign progression, combat, traversal, scenes and saves in an experimental Windows preview.

lp-engine runs the Nintendo DS game LovePlus+ on desktop systems using the player’s own Japanese game dump. Its Rust runtime executes the original game logic while recreating graphics, sound, input, clock and save services, with higher-resolution rendering and an English translation delta. Research notes document the script VM, game flow and save format.

Luna Purpura works toward a portable interpreter for 1990s Purple Moon games, including Rockett's New School, using the user's original CD-ROM files. Ruby format-research tools, C decoders and Lua bindings support a developing LÖVE-based player. The author describes the implementation as an early research-stage work.

Master Of Olympus Java Remake recreates parts of Master of Olympus in Java, including city, building, AI, map and rendering systems. The author says the game is at an early, unfinished stage and requires assets from the original game.

mc2 reimplements the closed Mech Commander 2 engine using available interface headers and ports the game to 64-bit Linux and Windows. The author reports finishing the game on Linux; networking and parts of the sound system remain incomplete.

MechRewired rebuilds the MechWarrior 2: 31st Century Combat experience around data imported from a user's DOS copy. Its code loads original resources and missions, while providing a new cockpit, terrain rendering and combat simulation for modern platforms.

MeitouClient is a C# and .NET 10 reimplementation of the Kenshi engine that aims to run original game content, mods and saves unchanged. Its documentation records Kenshi data-file load order, format details and behavior derived from analysis of the original executable. An installed copy of Kenshi is required.

Mercenaries 2: World in Flames is reconstructed as a Rust game engine that loads models, terrain, scripts, menus, audio and other data from the user's PC installation. The project traces the Xbox 360 program in Ghidra to recover engine behavior and uses game data and original footage for other behavior. The author reports a playable single-player story on Windows, while shared-world co-op remains unfinished.

Metal Mutant in the browser reimplements the 1991 DOS game's engine in JavaScript and runs the player's original scripts, graphics and sounds. It rewrites the interpreter, object scheduler, renderer, interrupts and PC-speaker audio routine by routine; the author reports frame-by-frame memory and screen comparisons with the original.

mgcarpet rebuilds Magic Carpet, Hidden Worlds and Magic Carpet 2 in a Rust engine that imports data from the user's game copies. Its simulation is compared turn by turn with state and input recorded from retail executables in instrumented DOSBox; the author reports matching certified recordings while tracking exceptions. Rendering and audio are rewritten separately, with deliberate differences documented.

MHLIB reimplements parts of several Moorhuhn game engines in Rust and Godot, loading assets from the user's original installations. Its reported support centers on Moorhuhn Kart 3 and Schatzjäger 1–3, with code for archive reading, asset preprocessing and Godot scenes.

mkxp implements the RGSS interface used by RPG Maker XP, VX, and VX Ace, with the goal of running games made with those tools natively. Its C++ engine handles rendering, audio, input, and files, and provides MRI and experimental mruby bindings for game scripts.

mortar-eng reconstructs parts of an LSW game runtime in C++. Its NUP and HGP readers load scene models and character data, including meshes, textures, joints and transforms, into resource objects used by scene-loading and rendering code.

My biggest work investigates how Brawlhalla patch 11.00 replays matches from recorded inputs, aiming to reproduce the simulation outside the game. Its Python toolkit parses replay, SWF, ABC and SWZ data, while notes map the tick loop, random generator and movement; the full simulator and player-position rendering remain unfinished.

My Simulation is an experimental reimplementation of The Sims Online as a multiplayer game. Its client is written in Zig with Raylib, uses NioTSO libraries to read the game's proprietary formats, and connects to a FreeSO-based API server.

Reimplements a Total Annihilation-compatible strategy-game engine in Go, with public file-format research and separate gameplay profiles. It distinguishes intended retail 3.1 behavior from community-patch research and deliberate modern changes, and separates synthetic checks from tests requiring original game data.

NeMo2 reimplements the Virtools game engine's CK2 and VxMath libraries in C++. It provides Virtools object, behavior and scene handling, math and rendering support, and loading and saving for CMO and NMO files, with a Windows 32-bit build targeting Virtools compatibility.

NEOTOKYO Rebuild is a rebuild of NEOTOKYO in the Source SDK 2013 multiplayer branch, updated for the 2025 Team Fortress 2 SDK. The README says it is forked from NeotokyoRevamp/neo.

NeoTS2 rebuilds The Sims 2 as a native 64-bit engine that reads the user's installed game files. Its C++ implementation loads neighborhoods, lots, objects, Sims, behavior scripts, models and UI resources, then renders them through modern graphics APIs; current development builds let users visit neighborhoods and lots.

nfs-mw reconstructs Need for Speed: Most Wanted 2005 PC v1.3 in Rust using data read from the user's installation. Its format readers decode bChunk, JDLZ, HUFF, cars, textures, and the streamed city; the current runtime provides viewers, driving, menus, and free roam.

NitroSharp is an open-source reimplementation of N2System, the visual-novel engine used by Nitroplus. The current target is Chaos;Head Noah on Windows x64, with Direct3D 11 and Vulkan, and on Linux x64 with Vulkan. The Linux build has no sound.

NuVelocity Engine reimplements Reflexive Entertainment's Velocity Engine as a C++ and SDL3 game engine. It provides modular 2D rendering, asset and resource loading, audio playback, screen management, and a property-based object system, with decoder source included in the repository.

Nuvie reimplements an engine for Ultima VI, Martian Dreams and The Savage Empire that reads the original game data. It runs on Linux, macOS and Windows, and its development has moved to ScummVM.

Olduvai reimplements the 1991 Prehistorik engine in C++ and SDL2 for desktop and Linux handhelds, reading data from a user's game copy. Its documented method studies the DOS executable with disassemblers and checks behavior against a separate reference implementation frame by frame; the author reports a playable release candidate.

OMK reimplements the engine of Omikron: The Nomad Soul in C++20 using files from a user's game copy. Its documentation records asset formats, the script VM and game state, while the engine covers opening sequences, city exploration, menus and combat; the author reports that a cold-start event trace matches all 42 recorded original events.

Open Annihilation reimplements a Total Annihilation game engine in C++20 and runs it with data from the player's copy of the original game. Its source covers the simulation, user interface, multiplayer, mod handling, and platform support, alongside module and file-format documentation.

Open Greedy reimplements Greedy XP as a C game written from scratch. Its source tree contains game logic, an engine and rendering code, and the documented build relies on SDL, SDL_mixer, OpenGL, libxmp-lite and zlib.

Open Horizon reimplements the rendering and physics of Ace Combat: Assault Horizon in C++ using resource files from the original game. Its source includes game, renderer, physics and container modules. Its contribution guide suggests clean-room design or documenting findings when direct disassembly is unavoidable.

Open KF reimplements the 2009 Killing Floor engine and gameplay in Rust and Bevy, reading maps, textures, audio and other resources from the user’s installed copy. Its ue-assets crate parses Unreal packages and provides commands to inspect objects, scripts, meshes and BSP data. The project offers single-player play and experimental cooperative multiplayer.

Open Northland reimplements Cultures - 8th Wonder of the World with a deterministic TypeScript simulation, a PixiJS isometric renderer and an offline asset pipeline. It decodes original game formats into local content and currently offers a playable settlement economy, building, combat, fog and a basic computer player.

Open RCT3 is an early-stage reimplementation of RollerCoaster Tycoon 3. Its C# code includes an OVL file reader and writer, while the published roadmap places terrain, scenery, rides and gameplay in unfinished phases. The project may require assets from the player's original game copy.

Open SoM Runtime recreates Sword of Moonlight's game runtime in Unity, including content loading, event parsing, menus and explorable maps. The author reports partial event support and describes compatibility limits for Dark Destiny, SoM Ex games and some video codecs.

Open Sosaria reimplements the 1981 Apple II Ultima engine in C99 for modern PCs. It parses the player's DOS 3.3 disk images, reconstructs game systems from observed behavior, and synthesizes some audio from disassembled 6502 timing loops; the author reports that the game can be completed.

Open Van Buren reconstructs the Fallout 3 Van Buren tech demo as a native C++17 Linux engine using the user's own game data. It parses archives, maps, models, animations, effects and Pawn/Small scripts, with documented format findings and a playable first pass of the tutorial content.

Open Wages reimplements the Wages of War: The Business of Battle engine in Rust and SDL2 using observed game behavior and parsers for the original data files. It covers mercenary hiring, contracts, isometric maps and tactical combat, with executable and format analysis recorded alongside the code.

Open76 reimplements the Interstate '76 engine in Unity using the game's installed data. It parses and renders levels and cars, reads compressed and uncompressed ZFS archives, and has a partial interpreter for mission stack machines.

Open76 is a Unity reimplementation of Interstate '76. It parses and renders level contents, including cars, and can run the mission stack machines. Driving and camera modes work. The README says the car simulation, including the engine and gearbox, still needs work.

openage reconstructs the Genie Engine used by Age of Empires, Age of Empires II and Star Wars: Galactic Battlegrounds. Its C++ engine and Python media converter use assets from the user's original games and convert them into openage formats. The author states that gameplay is currently almost nonfunctional while the simulation is rebuilt.

OpenApoc reimplements the X-COM: Apocalypse engine in C++ and SDL2 using files from the user's original game. It adds modern display support, XML-based save editing, modding facilities, and experimental skirmish play while tracking unfinished original-game features.

OpenATDeluxe rebuilds Airline Tycoon Deluxe as a Godot project that imports images from a user-provided installation. Its format notes describe .gli graphics archive headers and RGB565 image data; the airport and player character are implemented, while gameplay remains unfinished.

Reimplements Remedy Entertainment’s Alan Wake engine, later known as Northlight, in C++ and OpenGL, aiming to run Alan Wake and Alan Wake’s American Nightmare portably from the user’s game data, with Quantum Break and possibly Control as later goals. README documents only a free camera for moving through loaded game data, and the American Nightmare script table implements 16 of its 278 native functions. The repository also includes command-line tools for the games’ archive, texture, Havok and sound formats.

A C++20 reimplementation of Battlefield 2’s Refractor 2 engine reads original game data and documents menu rendering, level loading and server interoperability. Published crosshair research cites REA/Ghidra evidence IDs and binary addresses; major gameplay systems remain unfinished.

OpenBattlespire reimplements the engine of An Elder Scrolls Legend: Battlespire in C and reads the user’s original game files at runtime. Its source includes game systems, format parsers and data tools; research notes analyze GAME.EXE and document BSA, BS6, save and other formats. The README describes playable movement, combat, dialogue and save behavior.

OpenBiohazard2 reimplements the original Resident Evil 2 engine in Go with OpenGL rendering and data from the user's game installation. The code includes room scripts, game state, rendering and parsers for game file formats. Audio, enemy AI and several gameplay systems remain unfinished.

openblack reimplements Black & White (2001) in C++ with OpenGL and Vulkan rendering, loading assets extracted from the user's original game. Its repository includes utilities for game formats such as GLW visual effects and a library for LHVM script bytecode. Several non-desktop builds are described as experimental.

OpenBreed investigates and reimplements Alien Breed Special Edition 92, Alien Breed II and Alien Breed: Tower Assault. Its C# editor reads maps, sprites, tiles and image formats from original resources, while the author works to recover behavior and tables stored in the games' executables. The game engine lacks game-specific logic and is not yet playable.

OpenC1 is a C# remake of a driving and wrecking game by Stainless Software. Its source includes engine, vehicle, race, rendering and content handling code, and the listed prerequisites include XNA 3.0 and Nvidia PhysX.

openc2e reimplements an engine for the Creatures artificial life games and reads their original data directories. It targets Creatures 1–3, Docking Station, Playground and Adventures; agents, biochemistry and sound effects work, while creature support and world saving remain incomplete.

openchrome is a C++ runtime and viewer for Dying Light 1 game data, using Vulkan and SDL2 to read resources from the user's installation. Its parsers and format notes cover rpack containers, textures, meshes, materials, map placement, lighting, animation and sound banks. The author reports that the viewer renders environments and provides a stand-in walk mode.

OpenCiv3 rebuilds Civilization III as a Godot and C# strategy game with Lua gameplay rules. It can read BIQ and SAV data plus images and animations from a local Civ3 installation, while a standalone mode uses placeholder graphics; the author describes the current game as pre-alpha.

OpenClaw is a C++ reimplementation of the 1997 game Captain Claw. It uses SDL2, Box2D, and TinyXML, and reads the original CLAW.REZ archive from Build_Release. The assets in Build_Release/ASSETS are zipped to ASSETS.ZIP. Windows can open the Visual Studio 2017 solution or run cmake -G "Visual Studio 15 2017". Ubuntu installs the SDL2 development packages and then runs cmake and make. An Emscripten build produces openclaw.html, openclaw.js, openclaw.wasm, and openclaw.data.

OpenCloud is a C++ reimplementation effort for Dark Cloud 2. Its source tree contains engine systems, character code, and handlers for game data such as ISO content and packed files. The project identifies Dark Cloud 1 as a later goal and states that it excludes original game art and sound.

OpenCoD1 reconstructs the multiplayer engine, client, dedicated server and game modules of Call of Duty 1.1 from source. Its Windows and Visual Studio build produces executables and DLLs installed beside the user’s original game assets. The author describes the effects system and other subsystems as unfinished.

OpenCross rebuilds a native C++20 engine for Chrono Cross that reads an owner's Radical Dreamers Edition installation. It implements game rules and file-format importers, with documented comparisons against the original game and Ghidra scripts for examining the PC executable and PlayStation code.

OpenD2 rewrites the Diablo II game engine in C++ to use the original game’s data and save files. Its source includes MPQ archive, rendering, audio, networking, and game components. The README reports that most of the main menu works, while TCP/IP games stall during loading.

OpenDaed reimplements the interactive-movie puzzle game The Daedalus Encounter in C++ using the original CD data. Its source includes game-file readers, an interpreter, video playback and puzzle implementations. The author describes an early build that runs the opening scenes but is not yet playable end to end.

OpenDana reimplements the NES puzzle game Solomon's Key 2 / Fire 'n Ice with a deterministic C11 core and SDL2 front end. It imports levels, graphics, text and audio from the user's European ROM and adds a level editor, save states and JSON/PNG mods.

OpenDance Engine recreates Just Dance gameplay in GameMaker Language using hand-written code and findings from the UbiArt Framework and Bluestar Engine. It reads UbiArt CKD and Bluestar JSON files, plays video and audio, and implements KaraokeClip, PictogramClip, GoldMoveEffectClip and MainSequence support.

openDarkEngine rebuilds an engine for data files from the original Dark Engine games. Its current code displays levels and objects, while its documentation describes incomplete lighting, simulation and scripting and a planned replacement of the Ogre3D renderer.

OpenDeathValley develops an engine for Desperados: Wanted Dead or Alive around readers for the game's resource files. Its C code parses DVD, DVF, DVM, SCB and other formats, can extract selected images as BMP files, and includes an SCB script disassembler with named game functions.

OpenDF reconstructs an open engine for Daggerfall. Its C++ source includes BSA archive loading with named and indexed entries, alongside game-world, rendering and input components.

OpenDiablo2 is a cross-platform ARPG engine written in Go that supports playing Diablo 2. The project is being split into a separate engine and toolset, called Abyss Engine, and a game project retaining the OpenDiablo2 name.

OpenDrakan reconstructs Riot Engine for Drakan: Order of the Flame on GNU/Linux. Its C++ project loads original game levels, includes an SRSC data extractor, and documents database structures and UDP/TCP network exchanges.

OpenDriverEngine is a C++ project to run Driver 1 and Driver 2 content through a shared engine. Its TODO list marks LEV level, texture and model loading, Driver 2 physics, and a decompiled reimplementation of Driver 1 car cosmetics as done. The README specifies content conversion and Lua game logic as project goals.

OpenDUNE recreates Dune II in ANSI C for desktop systems and Atari TOS. Desktop builds use SDL or SDL2; the game reads original Dune II 1.07 data files, including dune2.exe, from a user-provided data directory.

OpenE2140 recreates Earth 2140 as an OpenRA-based game with C# logic, rules and loaders for the original game's files. It imports assets from a user's installed Earth 2140 copy on first startup and offers builds for multiple desktop platforms.

OpenE2140 is a C++ reimplementation of Earth 2140 gameplay that loads the original game's WD archives for sprites, effects and levels. It includes map drawing, basic entities and unit statistics; orders, weapons, audio, AI and multiplayer remain on its roadmap.

OpenEmperor 0.1.0-alpha.2 is a clean-room reimplementation of Emperor: Rise of the Middle Kingdom for Apple silicon macOS. It includes a playable city sandbox and an optional original-economy experiment. Original campaigns and save games are unsupported. The first launch asks for an installed or extracted Emperor data directory. The program is build/openemperor. Space pauses, and F5 and F9 save and load.

OpenEnroth reimplements the Might and Magic VI, VII, and VIII engine. Might and Magic VII is the playable game. It needs the ANIMS, DATA, MUSIC, and SOUNDS directories from that game. OPENENROTH_MM7_PATH selects the data directory. Windows, Linux, macOS, and an experimental Android build are listed. Source build steps are in HACKING.md.

OpenGD reimplements Geometry Dash gameplay in C++ on Axmol, aiming to match the original game. It requires resources from Geometry Dash 2.1 or 2.2; the documented gameplay rewrite currently leaves levels unplayable.

OpenGG reimplements Gearhead Garage: The Virtual Mechanic as a Godot and C# engine that loads cars, jobs, decals, sounds and scenes from a user's game folder. Its rules and interface follow observations of the running original, while its loaders parse data-file formats worked out from the original files.

OpenGMK reconstructs the GameMaker Classic runner and supplies tools for examining its games. GM8Decompiler extracts game data embedded in GameMaker 8 executables and rebuilds GMK or GM81 project files. Its companion emulator runs Classic games and records or replays TAS input; development remains in progress.

OpenGothic is a reimplementation of the Gothic 2: Night of the Raven client, using the original game data and mods. The README says the main quest and the addon can be completed. Development targets Gothic 2. Windows uses DirectX 12 or Vulkan, Linux uses Vulkan, and macOS uses Metal. git clone --recurse-submodules, then cmake -B build -DBUILD_SHARED_LIBS=ON -DCMAKE_BUILD_TYPE:STRING=RelWithDebInfo and make -C build. The executable is OpenGothic/build/opengothic. The macOS target is Gothic2Notr.

OpenGromada reconstructs the engine used by Sigma Games titles including AS1/ZS1, Theseus, Crazy Lunch and Locoland/Steamland. Its C++20 executable reads the user's game resources and supports multiple platforms and architectures, widescreen display and gamepads.

OpenGT4 is a native Windows port of Gran Turismo 4, reimplemented in C. The tested disc is NTSC-U SCUS-97328 version 2.00. CORE.GT4 on that disc has SHA-1 30031137ce494323816bb707b90d3ec0d07937d2. The player selects a disc image in the launcher. The release files are OpenGT4-<version>-setup.exe and OpenGT4-<version>-win64.zip.

OpenGTA2 rebuilds a playable GTA2 test world in C# and MonoGame using the player's game files. Its readers parse RIFF, .gmp maps, .sty styles, .sdt/.raw audio and .scr scripts; the client implements map rendering, player control and collision.

OpenGuimo recreates the 1997 DOS platformer GUIMO in Godot 4.7, translating rules recovered from guimo.exe 2.2 into GDScript. It reads levels, pictures, sound and music from the user's guimo.jbc archive and documents several bugs found while examining the original executable.

openh4 reimplements the Heroes of Might and Magic IV engine in C++23 using data from a player's own GOG copy. The repository contains the engine, a game application and h4-tool for inspecting and rendering game data. The author describes the project as unfinished.

OpenHoW is an early-stage reimplementation of Hogs of War designed to use content extracted from the PC release. Its extractor copies and updates original assets, and its research documents describe game model, map and texture formats, including MAD, MTD, PMG and POG.

OpenIGI reimplements the engine for Project I.G.I. and I.G.I. 2 in C# on .NET 10, reading missions, scripts and assets from the user's retail installations. It runs the games' QVM scripts in a reconstructed interpreter and provides a native renderer, launcher and modding layer. The author reports all 14 first-game missions playable, while I.G.I. 2 remains in development.

OpenInsaniquarium reimplements Insaniquarium Deluxe 1.1 in Rust with a deterministic simulation and Bevy presentation layer. It loads assets from the user's game installation and uses captured original-game traces for tick-by-tick comparisons; the author reports that the preview covers Adventure's first tank and all 24 pets in testing.

OpenJazz reimplements the Jazz Jackrabbit 1 engine in portable C++ and runs with data from the original game. It builds with CMake and SDL for desktop platforms, with further ports for consoles, handhelds and browsers.

OpenJKDF2 is a function-by-function reimplementation of Jedi Knight: Dark Forces II in C. The README lists 64-bit Windows, macOS, and Linux builds that use SDL2, OpenAL, and OpenGL 3.3, plus ARM64 Android, Nintendo DSi, Dreamcast, 32-bit Windows, and an Emscripten WebAssembly build. Source files follow the original game layout, using symbols from the Grim Fandango Remaster ports and assertions from other games, and the tree includes the byacc and flex versions used to parse COG scripts.

OpenJones3D reconstructs the Jones3D engine of Indiana Jones and the Infernal Machine in C. Its method analyses the original engine executable, debug symbols and strings, then replaces calls into the original binary with implemented functions while retaining the user's game assets.

OpenJPB rebuilds the Windows release of Star Wars: Episode I: Jedi Power Battles as a replacement engine. It derives game-owned structures and behavior from the retail executable and PDB, provides portable reconstructed modules and a Win32 host, and loads assets from the user's Steam or GOG installation.

OpenKeeper reimplements the Dungeon Keeper II game and engine as a cross-platform Java application using JMonkeyEngine. It targets version 1.7 and three bonus packs, loading assets from the user's original game copy.

OpenKingdoms reimplements the Total Annihilation: Kingdoms engine in C11 from observed game behavior. Its native and WebAssembly builds load the user's game files and reconstruct economy, combat, AI, animation, mission scripts, and map handling; the repository also records behavior and parity research.

Open-source engine for classic Tomb Raider, with a WebGL build and a standalone release. Its format code defines object types for Tomb Raider 1 through 4.

OpenLF2 reimplements Little Fighter 2 v2.0a as a playable C++ and Lua engine. It loads resources from the original game installer and provides local modes, replays, mods and network matches between OpenLF2 players. The author states that gameplay compatibility is still being refined.

OpenLRR incrementally rebuilds the PC game LEGO Rock Raiders by implementing and replacing game and engine functions. Unreplaced behavior continues to use the user’s original executable and game assets. Its MakeExe tool adds an import for openlrr.dll and redirects the original entry point to the replacement code.

OpenMadoola reimplements The Wing of Madoola and reads graphics and level data from a ROM. The ROM can be madoola.nes or the Steam collection file sharedassets0.assets. It also needs font.bin, 2c04.pal, nes.pal, and the demo and mml directories. GNU/Linux builds are on Flathub as com.infochunk.OpenMadoola. Windows builds are on Releases. macOS is built from source. libco is ISC. nes_ntsc is LGPL-2.1 or later.

OpenMCM2 reimplements Motocross Madness 2 in Rust for macOS, Windows, and Linux using files from the user's own game copy. It decodes archives, terrain, scenes, models, textures, and other game formats, and reconstructs riding physics and AI from study of the original. The author reports that some physics comparisons still differ.

OpenMCM2 rebuilds the Motocross Madness 2 engine in Rust from a study of the original game. It reads the user's game files, including RS2 archives, terrain, scenes, models and UI data, and implements racing, bike physics, menus and network races between OpenMCM2 copies. The author reports that some jump landings, rough ground and object collisions still differ from the original.

OpenMM2 rewrites Midtown Madness 2 from the bottom up in C++, using the installed game's original binary to supply functions that have not yet been reimplemented. The project aims to make game fixes, new features and ports possible, but its author describes it as mostly abandoned because of technical limits.

OpenMoM rebuilds Master of Magic as a C++14 and SDL2 game engine that reads the original game's LBX data. Its palette-based renderer aims to reproduce the game's graphics and animations, while documented LBX structures cover sprites, fonts and help text. Units, cities, combat and spells are described as prototypes.

OpenMoonstone reimplements the Amiga and DOS game Moonstone in Rust with SDL2. It loads resources from a user-supplied DOS copy and contains code for combat, campaign maps and resource extraction, along with IDA analysis scripts. The documented campaign map remains in development.

OpenMU reconstructs a MU Online server from scratch, focusing on the Season 6 Episode 3 English client protocol. Its C# implementation is accompanied by packet references that map identifiers, byte fields, send conditions and effects on the game client.

Provides an independent engine for playing Morrowind and an alternative editor, OpenMW-CS. It loads original game content through its own runtime and documents script and mod compatibility differences; it is an engine replacement rather than a recovered Bethesda source tree.

OpenNefia is an open-source, moddable engine reimplementation of the roguelike Elona. The README says the project is still a work in progress and that building it requires the .NET 8.0 SDK.

OpenNFS1 rebuilds the original Need for Speed in C# and MonoGame using data from the 1995 game CD. Its source includes parsers for track, vehicle, texture and audio data alongside a replacement racing engine.

OpenNFS is an early C++ engine project that aims to recreate Need for Speed 1–5 using original game data. It has loaders for tracks, cars, images and music from selected PC and PlayStation releases, Bullet-based vehicle dynamics and shaders for dynamic lighting and shadows; loader coverage and gameplay remain incomplete.

OpenNitemare3D is a C# reimplementation of the 1994 first-person game Nitemare 3D. It loads original bitmaps and maps, plays MIDI, and plays sound effects from the Windows version. The README says the active development branch is C-Rewrite.

OpenOMF is a remake of the 1994 DOS fighting game One Must Fall 2097 for Linux, macOS, Windows and other platforms. It includes networking intended to make multiplayer easier to use than the original game's IPX setup.

OpenOrion2 is a partial C++ remake of Master of Orion II: Battle at Antares that reads the original game's LBX resources and saved games. Its current interface can load existing saves as a viewer; starting a new game and gameplay remain unimplemented.

OpenPlatinum reimplements Pokémon Platinum's field engine in C++17 with SDL3 and OpenGL for Windows and macOS. It reads the user's French or US .nds dump, parses cartridge formats and runs game scripts on its own VM, using the pret decompilation as a behavior reference; several gameplay systems remain partial.

OpenPol reimplements the Polish RTS Polanie in Rust and includes tools for reading and extracting its data formats. The current program plays intros, loads some game files, and displays the main menu and cursor; other gameplay remains unfinished.

OpenPrivateer reconstructs Wing Commander: Privateer and its Righteous Fire add-on for modern systems using the player's original game files. Its engine loads original archives and saves, runs mission scripts, and recreates flight and combat using findings from game data and executable disassembly. Basic multiplayer and modding features are available, with further work in progress.

openQ4 replaces the Quake 4 engine and game binaries with a GPL engine and SDK-licensed game modules that use the player's retail game assets. The source adds modern display, audio and controller support, with experimental multiplayer and Vulkan rendering.

Provides a C# engine for early Westwood real-time strategy games, with mods that reimagine Command & Conquer: Red Alert, Tiberian Dawn and Dune 2000. It loads the original games’ content through its own file-system, MiniYAML rules and Lua mission layers. Gameplay and interface follow OpenRA’s own design.

OpenRaider reimplements an engine for Tomb Raider 1, 2 and 3 using their original asset files. Its C++ code includes level loaders for all three versions, rendering and audio components, and support for custom maps based on those engines.

Re-implements RollerCoaster Tycoon 2, originally written in x86 assembly, as a C++ engine that runs on the original game’s data. It loads RCT2 saves and scenarios, and RCT1 scenarios when those files are present, while saving to its own documented park format. Modern-platform support, interface and AI changes, higher limits and multiplayer are deliberate extensions.

OpenRED recreates Guilty Gear -Strive-'s battle system in an Unreal Engine project. Its C++ source covers battle states, events, objects and managers, with the aim of approximating the core logic.

OpenRedFaction reconstructs Red Faction game behavior in a shared C and C++ runtime targeting PC and a stock 64 MiB Original Xbox. It examines the installed PC executable and game archives, implements campaign systems, and compares focused PC and XEMU diagnostics.

OpenRedRacing reimplements Big Red Racing in a portable C++ engine using SDL2 and OpenGL 3.3. It reads the user's original game files, recreates circuits, vehicle handling and races, and includes level and vehicle viewers. The author reports Windows builds and tests; all seven championship rounds are implemented but have not been fully tried in game, and some handling and rendering details remain unfinished.

OpenReliant reimplements the engine of StarLancer, the 2000 space-combat game by Warthog and Digital Anvil. It is written in Zig on SDL3 and draws with Vulkan, or Metal on macOS. The README says the beta can play the whole campaign, and that saves from the original game carry over.

Reimplements the Rise of Nations: Extended Edition engine as a native macOS app with a Metal renderer, a deterministic simulation, a computer opponent and a compatible BigHugeScript compiler and virtual machine, loading art, maps, rules and scripts from the user’s own Windows installation. Subsystem specifications written from Ghidra study of the symbol-bearing executable, together with JavaScript reference tools, guided a C++17 implementation built with heavy Claude Code assistance. The alpha plays tutorials and scenarios, and its bit-exactness checks remain project-reported.

OpenRoads reimplements SkyRoads in TypeScript with HTML5 rendering while loading the original game's art, music and level files. The repository includes game code and notes on the original data and rendering, and the application can also run under Node.js with Oculus Rift support.

Re-implements Rockstar Games’ Grand Theft Auto III (2001) as a cross-platform C++ engine that runs on the data of a legitimate PC copy. It has its own loaders for the game’s RenderWare models, textures and archives, a script machine for the original mission scripts, and an optional Qt data viewer. Playability is partial: the project’s mission tracker marks six early Portland story missions as completable.

openSA is an early C++ reimplementation of the GTA San Andreas runtime built on librw. It parses original IMG, IDE, IPL, model and texture data, and supplies viewers for streaming world geometry. The author documents comparisons with the owned 1.0 US executable while noting that the result is not yet a playable game.