# Reverse-engineering case studies · Page 12

> Page 12 of 21, cases 2,201–2,400. 4,025 case studies from 5,191 curated resources, with documented reconstruction methods, scope, and original evidence.

- HTML: <https://awesomerea.org/cases/page/12/>
- 简体中文: <https://awesomerea.org/zh/cases/page/12/index.md>

## Games (200)

- [e17p: reconstructing Ever17 and Remember11 storage formats](https://awesomerea.org/resources/e17p-ever17-remember11-case/index.md): Case study · 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: an RPG Maker 2000 and 2003 game interpreter](https://awesomerea.org/resources/easyrpg-player-case/index.md): Case study · 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: a Thimbleweed Park engine remake](https://awesomerea.org/resources/engge2-thimbleweed-park-case/index.md): Case study · 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: a Thimbleweed Park engine remake](https://awesomerea.org/resources/engge-case/index.md): Case study · 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: reimplementing the DOS pinball engine for macOS](https://awesomerea.org/resources/epic-pinball-hd-case/index.md): Case study · Epic Pinball HD reimplements the DOS Epic Pinball engine as a native macOS app with classic and enhanced modes. It imports tables and media from the user's own copy, runs some original executable rules through a small x86 runtime and compares classic-mode behavior with original code in Unicorn. Across all 13 tables, the author reports matches in 415/415 physics scenarios, 415/415 rules scenarios and 413/415 full-main-loop scenarios.
- [Escape Velocity Nova: an engine reimplementation guided by decompilation](https://awesomerea.org/resources/escape-velocity-nova-reimplementation-case/index.md): Case study · 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: rebuilding Zeus: Master of Olympus from original game files](https://awesomerea.org/resources/ezeus-case/index.md): Case study · 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: rebuilding Little Fighter 2 for the web](https://awesomerea.org/resources/f-lf-case/index.md): Case study · 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: reimplementing the Fade To Black engine](https://awesomerea.org/resources/f2bgl-case/index.md): Case study · 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: rebuilding the Supreme Commander: Forged Alliance engine](https://awesomerea.org/resources/fa-remastered-case/index.md): Case study · 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: a cross-platform Fallout 2 reimplementation](https://awesomerea.org/resources/fallout-2-community-edition-case/index.md): Case study · 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: reimplementing the Fallout engine](https://awesomerea.org/resources/fallout-community-edition-case/index.md): Case study · 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: reimplementing the Fallout 2 engine](https://awesomerea.org/resources/falltergeist-fallout-2-case/index.md): Case study · 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: a Far Cry 3 runtime built from original game data](https://awesomerea.org/resources/fc3-bevy-case/index.md): Case study · 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: a Heroes of Might and Magic II engine recreation](https://awesomerea.org/resources/fheroes2-case/index.md): Case study · 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: rebuilding the Dungeon Master game engines](https://awesomerea.org/resources/firestaff-dungeon-master-case/index.md): Case study · Firestaff rebuilds runtime paths for Dungeon Master, Chaos Strikes Back, Dungeon Master II and Theron's Quest using original media supplied by the player. It identifies editions by content hash and keeps their data separate from its native engine. Source-linked reports and regression checks document supported startup and gameplay slices; Nexus currently reaches a limited Saturn title presentation path.
- [FPC Atomic: reconstructing Atomic Bomberman multiplayer](https://awesomerea.org/resources/fpc-atomic-bomberman-case/index.md): Case study · 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: reimplementation of Alone in the Dark](https://awesomerea.org/resources/fitd-case/index.md): Case study · 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.
- [freeablo: a cross-platform reimplementation of the Diablo 1 engine](https://awesomerea.org/resources/freeablo/index.md): Case study · 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: an Age of Empires 2 engine rebuilt from observation](https://awesomerea.org/resources/freeaoe-case/index.md): Case study · 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: reimplementing Gunman Chronicles in QuakeC](https://awesomerea.org/resources/freegunman/index.md): Case study · 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: a Heroes of Might and Magic III engine recreation](https://awesomerea.org/resources/freeheroes-case/index.md): Case study · 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: a Duke Nukem 1 clone](https://awesomerea.org/resources/freenukum-case/index.md): Case study · 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: reimplementing Ricochet Xtreme](https://awesomerea.org/resources/freers42-ricochet-xtreme-case/index.md): Case study · 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: recreating The Sims 1 engine](https://awesomerea.org/resources/freesims-case/index.md): Case study · 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: Syndicate engine reimplementation](https://awesomerea.org/resources/freesynd-case/index.md): Case study · 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: reimplementing Team Fortress Classic](https://awesomerea.org/resources/freetfc/index.md): Case study · 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: rebuilding Gabriel Knight 3 around its original data](https://awesomerea.org/resources/g-engine-gabriel-knight-3-case/index.md): Case study · 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: reimplementing Galaxy on Fire 2 in Godot](https://awesomerea.org/resources/galaxian2-gof2-case/index.md): Case study · 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: reimplementing Galaxy on Fire 1 for Godot](https://awesomerea.org/resources/galaxian-gof1-case/index.md): Case study · 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: reconstructing the classic Game Maker engine](https://awesomerea.org/resources/game-creator-game-maker-case/index.md): Case study · 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: a C++ and Vulkan engine reconstruction](https://awesomerea.org/resources/gauntlet-dark-legacy-pc-port-case/index.md): Case study · 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: rebuilding Gears of War around Xenia dynarecs](https://awesomerea.org/resources/gearsue3-case/index.md): Case study · 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: recreating Pokémon games from cartridge data](https://awesomerea.org/resources/gen2recomp-case/index.md): Case study · 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: reimplementing Dungeon Keeper 2](https://awesomerea.org/resources/glkeeper/index.md): Case study · GLKeeper, also titled Grim Lands Keeper, is an open-source reimplementation of Dungeon Keeper 2. The README says it is not playable yet.
- [GLSMAC: reimplementing Alpha Centauri and Alien Crossfire](https://awesomerea.org/resources/glsmac/index.md): Case study · 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: rebuilding the Dark Forces II engine](https://awesomerea.org/resources/gorc-dark-forces-ii-case/index.md): Case study · 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: reimplementing the Gran Turismo 3 A-Spec engine](https://awesomerea.org/resources/gt3-revisited/index.md): Case study · 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: reconstructing the GTA IV world in Unity](https://awesomerea.org/resources/gta4unity-case/index.md): Case study · 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.
- [GunZRs: a Rust reimplementation of GunZ: The Duel](https://awesomerea.org/resources/gunzrs-rea-rust-reimplementation-case/index.md): Case study · 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: rebuilding the Heroes of Might and Magic IV engine](https://awesomerea.org/resources/h4r-case/index.md): Case study · 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: reimplementing the Fallout 2 engine for browsers](https://awesomerea.org/resources/harold-fallout-2-case/index.md): Case study · 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 — a reconstructed Hazard engine using SDL](https://awesomerea.org/resources/hazard-revenge-case/index.md): Case study · 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: rebuilding a Doom-compatible engine](https://awesomerea.org/resources/helion-doom-engine-case/index.md): Case study · 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: reimplementing Earthsiege 2 from retail binaries](https://awesomerea.org/resources/herculan-earthsiege-2-case/index.md): Case study · 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: rebuilding Disney's Hercules Action Game on Apple silicon](https://awesomerea.org/resources/hercules-native-case/index.md): Case study · hercules-native reimplements the 1997 Disney's Hercules Action Game engine in C11 and SDL2 for Apple silicon Macs. It reads scripts, state tables and assets from the user's PC game files, with decoders for HERCULES.FS, sprite banks, maps and ETV videos; the author reports all levels playable with some missing effects.
- [Heroes of Jin Yong: reimplementing the DOS game](https://awesomerea.org/resources/heroes-of-jinyong/index.md): Case study · 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: reimplementing a slice of the Fallout 2 engine](https://awesomerea.org/resources/hexwaste-case/index.md): Case study · 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: reconstructing Hi-Octane and its level editor](https://awesomerea.org/resources/hi-octane202x-case/index.md): Case study · 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: a partial Rust reconstruction of Half-Life 2](https://awesomerea.org/resources/hl2-rs-case/index.md): Case study · 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: reconstructing Hitman: Codename 47](https://awesomerea.org/resources/hmc47-case/index.md): Case study · HMC47 reconstructs Hitman: Codename 47 from the original game binaries as a modular C++ implementation. Its source covers a launcher and modules for DirectPlay, shared engine data, graphics and sound, while full playability and 64-bit support remain goals.
- [hode: a Heart of Darkness engine reimplementation](https://awesomerea.org/resources/hode-case/index.md): Case study · 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.
- [Horizon: a Rust rewrite of Minecraft: Java Edition 26.3 with REA bytecode queries](https://awesomerea.org/resources/horizon-minecraft-rust-rewrite-case/index.md): Case study · 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: reconstructing Horn of the Abyss battle mechanics](https://awesomerea.org/resources/hotasim-case/index.md): Case study · 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 Sauce engine: reconstructing a game VM and asset formats](https://awesomerea.org/resources/hulabee-sauce-engine-case/index.md): Case study · 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: reimplementing Interstate ’76 in Godot](https://awesomerea.org/resources/i26-interstate/index.md): Case study · 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.
- [impacto: a reimplementation of the MAGES. visual-novel engine](https://awesomerea.org/resources/impacto-mages-engine-case/index.md): Case study · 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: reconstructing Irisu Syndrome! normal mode](https://awesomerea.org/resources/irisu-ml-case/index.md): Case study · 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.
- [IW4L: a Rust runtime that plays Modern Warfare 2 from the user’s installed game](https://awesomerea.org/resources/iw4l-mw2-rust-runtime-case/index.md): Case study · 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: a Rust engine reimplementation](https://awesomerea.org/resources/jade-cocoon-on-bevy-case/index.md): Case study · 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.
- [Jazz² Resurrection: a native C++ reimplementation of Jazz Jackrabbit 2](https://awesomerea.org/resources/jazz2-resurrection-engine-case/index.md): Case study · 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: a native PSP reconstruction of Jet Grind Radio](https://awesomerea.org/resources/jgr-portable-case/index.md): Case study · 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: rebuilding Jurassic Park: Operation Genesis and Toshi](https://awesomerea.org/resources/jpog-decomp-case/index.md): Case study · 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: a Java remake of The Settlers III](https://awesomerea.org/resources/jsettlers-case/index.md): Case study · 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: recreating Caesar III's gameplay logic](https://awesomerea.org/resources/julius-caesar-iii-case/index.md): Case study · 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: a native reconstruction of the Kabus 22 engine](https://awesomerea.org/resources/kabus22-linux-case/index.md): Case study · 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.
- [Kinoko: reimplementing Mario Kart Wii’s physics engine for exact ghost replay](https://awesomerea.org/resources/kinoko-mkwii-physics-reimplementation-case/index.md): Case study · 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: reimplementing Game Boy Tetris behavior](https://awesomerea.org/resources/kirpich-case/index.md): Case study · 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: rebuilding the Star Trek: Klingon FMV player](https://awesomerea.org/resources/klingonwin10wpf-case/index.md): Case study · 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: a C++ remake of 金庸群侠传](https://awesomerea.org/resources/kys-cpp-jin-yong-heroes-case/index.md): Case study · 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: reconstructing the CP/M arcade game in Go](https://awesomerea.org/resources/ladder-cpm-case/index.md): Case study · 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: reconstructing the Lain Bootleg minigame](https://awesomerea.org/resources/lain-bootleg-bootleg-case/index.md): Case study · 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: reimplementing The Sims 2](https://awesomerea.org/resources/las-marionetas/index.md): Case study · 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.
- [LBA2 Remake: a Little Big Adventure 1 and 2 reimplementation in TypeScript and Three.js](https://awesomerea.org/resources/lba2remake-little-big-adventure-case/index.md): Case study · 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.
- [Legend of Legaia: a Rust port with disc-local browser tooling](https://awesomerea.org/resources/legend-of-legaia-rust-port-case/index.md): Case study · 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: rebuilding Lemmings for the browser](https://awesomerea.org/resources/lemmings-ts-case/index.md): Case study · 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.
- [libd2: Diablo II 1.14d engine-core libraries](https://awesomerea.org/resources/libd2-engine-core-reconstruction-case/index.md): Case study · 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: reimplementing the Nitroplus visual-novel engine](https://awesomerea.org/resources/libnpengine/index.md): Case study · 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.
- [librw: a re-implementation of the RenderWare Graphics engine](https://awesomerea.org/resources/librw-renderware-reimplementation-case/index.md): Case study · 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: reconstructing Dark Salvation engine support](https://awesomerea.org/resources/lilium-salvation-case/index.md): Case study · 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: a Yaga game runtime for Pajama Sam and Putt-Putt](https://awesomerea.org/resources/linyaga-yaga-engine-case/index.md): Case study · 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: rebuilding American McGee's Alice in Rust](https://awesomerea.org/resources/looking-glass-alice-case/index.md): Case study · 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: rebuilding the LovePlus+ runtime](https://awesomerea.org/resources/lp-engine-case/index.md): Case study · 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: reimplementing Purple Moon game formats and playback](https://awesomerea.org/resources/luna-purpura-case/index.md): Case study · Luna Purpura works toward a portable interpreter for 1990s Purple Moon games, including Rockett's New School, using the user's original CD-ROM files. Ruby format-research tools, C decoders and Lua bindings support a developing LÖVE-based player. The author describes the implementation as an early research-stage work.
- [Master Of Olympus Java Remake: an unfinished Java reconstruction](https://awesomerea.org/resources/master-of-olympus-java-remake-case/index.md): Case study · 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.
- [Mech Commander 2: reconstructing the closed engine from interface headers](https://awesomerea.org/resources/mc2-mech-commander-2-case/index.md): Case study · 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: rebuilding MechWarrior 2 from original game data](https://awesomerea.org/resources/mechrewired-mechwarrior-2-case/index.md): Case study · 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: reconstructing the Kenshi engine](https://awesomerea.org/resources/meitouclient-kenshi-case/index.md): Case study · 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: a Rust reconstruction of World in Flames](https://awesomerea.org/resources/mercenaries-2-rust-reconstruction-case/index.md): Case study · 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: a browser engine reconstructed from the DOS game](https://awesomerea.org/resources/metal-mutant-web-case/index.md): Case study · 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: reconstructing the Magic Carpet games with turn comparisons](https://awesomerea.org/resources/mgcarpet-case/index.md): Case study · 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: reimplementing engines for Moorhuhn games](https://awesomerea.org/resources/mhlib-moorhuhn-case/index.md): Case study · 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: reimplementing RPG Maker's RGSS runtime](https://awesomerea.org/resources/mkxp-rgss-case/index.md): Case study · 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: LSW game scene and character reconstruction](https://awesomerea.org/resources/mortar-eng-lsw-case/index.md): Case study · 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: reconstructing Brawlhalla replay simulation](https://awesomerea.org/resources/my-biggest-work-brawlhalla-case/index.md): Case study · 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: reimplementing The Sims Online client](https://awesomerea.org/resources/my-simulation-case/index.md): Case study · My Simulation is an experimental reimplementation of The Sims Online as a multiplayer game. Its client is written in Zig with Raylib, uses NioTSO libraries to read the game's proprietary formats, and connects to a FreeSO-based API server.
- [Nanolathe: a documented Total Annihilation engine reimplementation](https://awesomerea.org/resources/nanolathe-case/index.md): Case study · 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: reimplementing the Virtools game engine libraries](https://awesomerea.org/resources/nemo2-case/index.md): Case study · NeMo2 reimplements the Virtools game engine's CK2 and VxMath libraries in C++. It provides Virtools object, behavior and scene handling, math and rendering support, and loading and saving for CMO and NMO files, with a Windows 32-bit build targeting Virtools compatibility.
- [NEOTOKYO Rebuild: rebuilding the NEOTOKYO multiplayer game](https://awesomerea.org/resources/neotokyo-rebuild/index.md): Case study · 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: rebuilding The Sims 2 engine](https://awesomerea.org/resources/neots2-case/index.md): Case study · 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: a Rust reconstruction of Need for Speed: Most Wanted](https://awesomerea.org/resources/nfs-mw-case/index.md): Case study · 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: reimplementing the N2System visual novel engine](https://awesomerea.org/resources/nitrosharp/index.md): Case study · 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: reimplementing Reflexive's Velocity Engine](https://awesomerea.org/resources/nuvelocity-engine-case/index.md): Case study · 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: an engine for Ultima VI and its companions](https://awesomerea.org/resources/nuvie-case/index.md): Case study · 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: reconstructing the Prehistorik engine](https://awesomerea.org/resources/olduvai-prehistorik-case/index.md): Case study · 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: reconstructing the Omikron game engine](https://awesomerea.org/resources/omk-omikron-engine-case/index.md): Case study · 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: a Total Annihilation engine reimplementation](https://awesomerea.org/resources/open-annihilation-case/index.md): Case study · 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: a from-scratch Greedy XP rewrite](https://awesomerea.org/resources/open-greedy-case/index.md): Case study · 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: rebuilding Ace Combat: Assault Horizon rendering and physics](https://awesomerea.org/resources/open-horizon-ace-combat-case/index.md): Case study · 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: a Killing Floor reimplementation in Rust and Bevy](https://awesomerea.org/resources/open-kf-killing-floor-case/index.md): Case study · 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: reimplementing Cultures - 8th Wonder of the World](https://awesomerea.org/resources/open-northland-case/index.md): Case study · 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: an early RollerCoaster Tycoon 3 reimplementation](https://awesomerea.org/resources/open-rct3-case/index.md): Case study · 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: rebuilding the Sword of Moonlight runtime](https://awesomerea.org/resources/open-som-runtime-case/index.md): Case study · 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: reconstructing the 1981 Apple II Ultima engine](https://awesomerea.org/resources/open-sosaria-ultima-case/index.md): Case study · 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: reconstructing the Fallout 3 tech demo engine](https://awesomerea.org/resources/open-vanburen-case/index.md): Case study · Open Van Buren reconstructs the Fallout 3 Van Buren tech demo as a native C++17 Linux engine using the user's own game data. It parses archives, maps, models, animations, effects and Pawn/Small scripts, with documented format findings and a playable first pass of the tutorial content.
- [Open Wages: a Wages of War engine reimplementation](https://awesomerea.org/resources/open-wages-case/index.md): Case study · 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: an Interstate '76 engine reimplementation](https://awesomerea.org/resources/open76-case/index.md): Case study · 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: reimplementing Interstate '76 in Unity](https://awesomerea.org/resources/open76/index.md): Case study · 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: a Genie Engine reconstruction for Age of Empires games](https://awesomerea.org/resources/openage-case/index.md): Case study · 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: rebuilding the X-COM: Apocalypse engine](https://awesomerea.org/resources/openapoc-case/index.md): Case study · 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: an Airline Tycoon Deluxe remake with original-data import](https://awesomerea.org/resources/openatdeluxe-case/index.md): Case study · 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.
- [OpenAWE: an open reimplementation of Remedy’s Alan Wake engine](https://awesomerea.org/resources/openawe-alan-wake-engine-case/index.md): Case study · 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.
- [OpenBattlefield2: an unfinished Refractor 2 engine reimplementation](https://awesomerea.org/resources/openbattlefield2-refractor-engine-case/index.md): Case study · 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: reimplementing the Battlespire engine](https://awesomerea.org/resources/openbattlespire-case/index.md): Case study · 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: a Go engine reimplementation of Resident Evil 2](https://awesomerea.org/resources/openbiohazard2-case/index.md): Case study · 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: rebuilding Black & White from original game data](https://awesomerea.org/resources/openblack-engine-case/index.md): Case study · 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: reconstructing the classic Alien Breed games](https://awesomerea.org/resources/openbreed-case/index.md): Case study · 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: a Carmageddon engine remake](https://awesomerea.org/resources/openc1-case/index.md): Case study · 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: reimplementing the Creatures game engine](https://awesomerea.org/resources/openc2e-creatures-case/index.md): Case study · 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: rebuilding a Dying Light runtime from game data](https://awesomerea.org/resources/openchrome-case/index.md): Case study · 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: rebuilding Civilization III in Godot](https://awesomerea.org/resources/openciv3-case/index.md): Case study · 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: reimplementing Captain Claw](https://awesomerea.org/resources/openclaw/index.md): Case study · 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: a Dark Cloud 2 reimplementation](https://awesomerea.org/resources/opencloud-dark-cloud-case/index.md): Case study · OpenCloud is a C++ reimplementation effort for Dark Cloud 2. Its source tree contains engine systems, character code, and handlers for game data such as ISO content and packed files. The project identifies Dark Cloud 1 as a later goal and states that it excludes original game art and sound.
- [OpenCoD1: a Call of Duty multiplayer reconstruction](https://awesomerea.org/resources/opencod1-call-of-duty-case/index.md): Case study · 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: reconstructing the Chrono Cross engine](https://awesomerea.org/resources/opencross-case/index.md): Case study · 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: rebuilding the Diablo II engine](https://awesomerea.org/resources/opend2-diablo-ii-case/index.md): Case study · 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: reimplementing The Daedalus Encounter](https://awesomerea.org/resources/opendaed-case/index.md): Case study · 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: a C11 reimplementation of Solomon's Key 2](https://awesomerea.org/resources/opendana-case/index.md): Case study · 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: recreating Just Dance gameplay in GML](https://awesomerea.org/resources/opendance-just-dance-case/index.md): Case study · 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: rebuilding support for Dark Engine game data](https://awesomerea.org/resources/opendarkengine-case/index.md): Case study · 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: Desperados file readers and script disassembly](https://awesomerea.org/resources/opendeathvalley-case/index.md): Case study · 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: a Daggerfall engine reconstruction](https://awesomerea.org/resources/opendf-case/index.md): Case study · 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: Diablo 2 engine reimplementation](https://awesomerea.org/resources/opendiablo2/index.md): Case study · 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: reconstructing Drakan's Riot Engine](https://awesomerea.org/resources/opendrakan-case/index.md): Case study · 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: a shared engine reconstruction for Driver 1 and 2](https://awesomerea.org/resources/opendriverengine-case/index.md): Case study · 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: a native recreation of Dune II](https://awesomerea.org/resources/opendune-case/index.md): Case study · 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: an OpenRA remake of Earth 2140](https://awesomerea.org/resources/opene2140-earth-2140-remake-case/index.md): Case study · 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: Earth 2140 gameplay reimplemented in C++](https://awesomerea.org/resources/opene2140-cpp-case/index.md): Case study · 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: reimplementing Emperor: Rise of the Middle Kingdom](https://awesomerea.org/resources/openemperor/index.md): Case study · 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: reimplementing the Might and Magic VI–VIII engine](https://awesomerea.org/resources/openenroth/index.md): Case study · 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: a Geometry Dash gameplay reimplementation](https://awesomerea.org/resources/opengd-case/index.md): Case study · 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: rebuilding Gearhead Garage from observed rules and data formats](https://awesomerea.org/resources/opengg-gearhead-garage-case/index.md): Case study · 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: reconstructing the GameMaker Classic runner and projects](https://awesomerea.org/resources/opengmk-case/index.md): Case study · 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: reimplementing the Gothic 2: Night of the Raven client](https://awesomerea.org/resources/opengothic/index.md): Case study · 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: reconstructing the Sigma Games engine](https://awesomerea.org/resources/opengromada-case/index.md): Case study · 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: reimplementing Gran Turismo 4 for Windows](https://awesomerea.org/resources/opengt4/index.md): Case study · 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: rebuilding GTA2 from its game files](https://awesomerea.org/resources/opengta2-case/index.md): Case study · 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: GUIMO gameplay reimplemented in Godot](https://awesomerea.org/resources/openguimo-case/index.md): Case study · 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: reimplementing the Heroes of Might and Magic IV engine](https://awesomerea.org/resources/openh4-case/index.md): Case study · 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: rebuilding Hogs of War from its game data](https://awesomerea.org/resources/openhow-hogs-of-war-case/index.md): Case study · 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: a C# engine reimplementation for Project I.G.I. and I.G.I. 2](https://awesomerea.org/resources/openigi-engine-case/index.md): Case study · 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: reimplementing Insaniquarium Deluxe](https://awesomerea.org/resources/openinsaniquarium-case/index.md): Case study · OpenInsaniquarium reimplements Insaniquarium Deluxe 1.1 in Rust with a deterministic simulation and Bevy presentation layer. It loads assets from the user's game installation and uses captured original-game traces for tick-by-tick comparisons; the author reports that the preview covers Adventure's first tank and all 24 pets in testing.
- [OpenJazz: a Jazz Jackrabbit 1 engine reimplementation](https://awesomerea.org/resources/openjazz-case/index.md): Case study · 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: C reimplementation of Jedi Knight: Dark Forces II](https://awesomerea.org/resources/openjkdf2/index.md): Case study · 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: reconstructing the Indiana Jones and the Infernal Machine engine](https://awesomerea.org/resources/openjones3d-case/index.md): Case study · 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: rebuilding Jedi Power Battles for PC](https://awesomerea.org/resources/openjpb-case/index.md): Case study · 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: a Dungeon Keeper II game and engine remake](https://awesomerea.org/resources/openkeeper-dungeon-keeper-ii-case/index.md): Case study · 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: reconstructing the Total Annihilation: Kingdoms engine](https://awesomerea.org/resources/openkingdoms-case/index.md): Case study · 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.
- [OpenLara: Tomb Raider engine reimplementation](https://awesomerea.org/resources/openlara/index.md): Case study · 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: a Little Fighter 2 engine reimplementation](https://awesomerea.org/resources/openlf2-case/index.md): Case study · 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 rebuilding LEGO Rock Raiders](https://awesomerea.org/resources/openlrr-rock-raiders-case/index.md): Case study · 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: reimplementing The Wing of Madoola](https://awesomerea.org/resources/openmadoola/index.md): Case study · 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: a Motocross Madness 2 engine reimplementation](https://awesomerea.org/resources/openmcm2-case/index.md): Case study · 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: a Rust engine reconstruction of Motocross Madness 2](https://awesomerea.org/resources/xshxdex98-openmcm2-case/index.md): Case study · 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: a bottom-up Midtown Madness 2 rewrite](https://awesomerea.org/resources/openmm2-case/index.md): Case study · 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: reconstructing Master of Magic](https://awesomerea.org/resources/openmom-case/index.md): Case study · 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: reimplementing Moonstone from its original game files](https://awesomerea.org/resources/openmoonstone-case/index.md): Case study · 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: a reconstructed MU Online server and packet reference](https://awesomerea.org/resources/openmu-case/index.md): Case study · 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.
- [OpenMW: replacing Morrowind’s engine while reusing original content](https://awesomerea.org/resources/openmw-engine-case/index.md): Case study · 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: reimplementation of Elona](https://awesomerea.org/resources/opennefia-case/index.md): Case study · 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: rebuilding the original Need for Speed from CD data](https://awesomerea.org/resources/opennfs1-case/index.md): Case study · 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: rebuilding classic Need for Speed games](https://awesomerea.org/resources/opennfs-classic-nfs-case/index.md): Case study · 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: reimplementing Nitemare 3D in C#](https://awesomerea.org/resources/opennitemare3d/index.md): Case study · 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: a multi-platform remake of One Must Fall 2097](https://awesomerea.org/resources/openomf-one-must-fall-2097-case/index.md): Case study · 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: a partial Master of Orion II remake and save viewer](https://awesomerea.org/resources/openorion2-case/index.md): Case study · 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: rebuilding Pokémon Platinum in a native engine](https://awesomerea.org/resources/openplatinum-case/index.md): Case study · OpenPlatinum reimplements Pokémon Platinum's field engine in C++17 with SDL3 and OpenGL for Windows and macOS. It reads the user's French or US .nds dump, parses cartridge formats and runs game scripts on its own VM, using the pret decompilation as a behavior reference; several gameplay systems remain partial.
- [OpenPol: an early Polanie reimplementation](https://awesomerea.org/resources/openpol-polanie-case/index.md): Case study · 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: reconstructing Wing Commander: Privateer](https://awesomerea.org/resources/openprivateer-case/index.md): Case study · 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: replacing the Quake 4 engine and game binaries](https://awesomerea.org/resources/openq4-quake-4-case/index.md): Case study · 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.
- [OpenRA: an engine reimplementation reimagining early Westwood RTS games](https://awesomerea.org/resources/openra-engine-case/index.md): Case study · 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: a rewritten engine for Tomb Raider 1–3](https://awesomerea.org/resources/openraider-rewrite-case/index.md): Case study · 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.
- [OpenRCT2: an open re-implementation of RollerCoaster Tycoon 2](https://awesomerea.org/resources/openrct2-engine-case/index.md): Case study · 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: recreating Guilty Gear -Strive-'s battle system](https://awesomerea.org/resources/openred-case/index.md): Case study · 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: reconstructing Red Faction for PC and Original Xbox](https://awesomerea.org/resources/open-red-faction-case/index.md): Case study · 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: a Big Red Racing engine reimplementation](https://awesomerea.org/resources/openredracing-big-red-racing-case/index.md): Case study · 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: reimplementing the StarLancer engine](https://awesomerea.org/resources/openreliant/index.md): Case study · 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.
- [OpenRiseOfNations: a native macOS engine reimplementation](https://awesomerea.org/resources/openriseofnations-engine-case/index.md): Case study · 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: a SkyRoads reimplementation using original data files](https://awesomerea.org/resources/openroads-case/index.md): Case study · 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.
- [OpenRW: an open re-implementation of the Grand Theft Auto III engine](https://awesomerea.org/resources/openrw-gta3-engine-case/index.md): Case study · 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: reimplementing the GTA San Andreas runtime](https://awesomerea.org/resources/opensa-case/index.md): Case study · 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.