# Reverse-engineering case studies · Page 13

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

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

## Games (200)

- [OpenSAGE: rebuilding the SAGE engine for Command & Conquer: Generals](https://awesomerea.org/resources/opensage-engine-case/index.md): Case study · OpenSAGE reimplements the SAGE strategy-game engine with an initial focus on Command & Conquer: Generals and Zero Hour. Its code parses original formats including .map, .w3d and .ini, and the author describes studying data files and observed game behavior. Rendering and game logic remain incomplete.
- [OpenSC2K: recreating SimCity 2000 in Rust and Godot](https://awesomerea.org/resources/opensc2k-case/index.md): Case study · OpenSC2K recreates SimCity 2000 with a Godot front end and Rust libraries for simulation, file formats, rendering, audio and scripting. It imports graphics, text, sound and music from the player's own game copy and supports original .sc2 city files alongside its extended .sc2x format.
- [OpenSC4: an early open-source reimplementation of SimCity 4](https://awesomerea.org/resources/opensc4-simcity-4-reimplementation-case/index.md): Case study · Reimplements SimCity 4 as a Godot project in GDScript that reads DBPF archives, region folders and city saves from the user’s own SimCity 4 installation. The code draws a region view with city thumbnails and interface elements built from the game’s UI definitions, opens a saved city’s terrain and water in 3D, and includes a DAT explorer for previewing archive subfiles. It is an early, inactive engine case without simulation gameplay.
- [OpenScreamer: reconstructing Screamer and Screamer 2](https://awesomerea.org/resources/openscreamer-case/index.md): Case study · OpenScreamer reimplements the DOS games Screamer and Screamer 2 as a C/SDL2 program for Linux and Windows. It reads files from the user's game folders and includes unpackers, Ghidra scripts, viewers and notes mapping game formats and behavior to the original programs.
- [OpenSE4: reimplementing the Space Empires IV Deluxe engine](https://awesomerea.org/resources/opense4-case/index.md): Case study · OpenSE4 reimplements the Space Empires IV Deluxe engine in C++23, loading art, sound and data from the player's own installation. Its rule specifications combine the original manual, data files, observed behavior and executable analysis; the engine covers economy, movement, combat, research, diplomacy and computer players, with remaining parity differences documented.
- [OpenSHC: reimplementation of Stronghold Crusader](https://awesomerea.org/resources/openshc/index.md): Case study · OpenSHC is an open-source reimplementation of Stronghold Crusader. It builds as a DLL loaded at game start and hooks functions that have a functionally identical reimplementation. The README requires Stronghold Crusader 1.41 in a Latin-language version such as English or German.
- [opensims2: reconstructing The Sims 2 engine](https://awesomerea.org/resources/opensims2-engine-case/index.md): Case study · opensims2 reimplements The Sims 2 engine in C++ for 64-bit macOS and Windows, reading content from the user's own game installation. The repository includes DBPF and game-data analysis, executable findings, gameplay systems and command-line inspection tools.
- [OpenSith: reimplementing the Jedi Knight: Dark Forces II engine](https://awesomerea.org/resources/opensith/index.md): Case study · OpenSith reimplements the engine of Star Wars: Jedi Knight — Dark Forces II in Unity. It renders JKL levels and animates 3DO models. There is no COG parser or COG virtual machine, so the game is not playable, though a level can be walked around.
- [OpenStrike: reconstructing Desert Strike and Jungle Strike data and engine behavior](https://awesomerea.org/resources/openstrike-case/index.md): Case study · OpenStrike is an early C++ reimplementation of Desert Strike and Jungle Strike. Its tools unpack original DAT archives and display graphics and complete levels; the game skeleton loads and renders some sprites and animations. The author describes the game as not yet playable.
- [OpenTennis: a Hot Shots Tennis rewrite checked against the PS2 game](https://awesomerea.org/resources/opentennis-hot-shots-tennis-case/index.md): Case study · OpenTennis rebuilds the 2007 PlayStation 2 game Hot Shots Tennis in Rust and Bevy for desktop, mobile and browser play. It reads models, textures and other game data from the user’s US disc image at runtime. The author compares ball physics, timing, rules and AI frame by frame with recordings of the original; research tools inspect executable overlays and game formats.
- [OpenTESArena: a new engine for The Elder Scrolls: Arena](https://awesomerea.org/resources/opentesarena-case/index.md): Case study · OpenTESArena rebuilds the 1994 DOS game The Elder Scrolls: Arena in a new C++ engine using separately obtained game assets. It implements combat, items, shops, citizens, travel, and most character creation, while documenting original-game behavior and parsing Arena asset formats. Quests, spells, and saving remain unfinished.
- [OpenTIE: reimplementing Star Wars: TIE Fighter](https://awesomerea.org/resources/opentie-case/index.md): Case study · OpenTIE reimplements Star Wars: TIE Fighter for Windows, macOS and Linux using data from the original 1995 Collector's CD-ROM or 1998 Windows release. Its engine supports each edition and can combine the 1995 menus, cutscenes and iMUSE music with the 1998 flight simulation and assets.
- [OpenTomb: Tomb Raider engine reimplementation](https://awesomerea.org/resources/opentomb/index.md): Case study · OpenTomb is an open-source reimplementation of the classic Tomb Raider engine for playing levels from Tomb Raider 1–5 and custom TRLE levels. It is no longer maintained.
- [OpenTPW: reimplementing Theme Park World](https://awesomerea.org/resources/opentpw/index.md): Case study · OpenTPW reimplements Bullfrog's 1999 game Theme Park World, also released as Sim Theme Park. It needs a full copy of the original game and its assets. The project page says the project is early and not playable yet. Texture, settings, sound, and string formats are marked implemented. Models, map data, ride scripts, and saves are partial. Fonts, lip sync, materials, and video are not implemented. Format notes are at opentpw.gu3.me/formats.
- [OpenTS2: an open-source reimplementation of The Sims 2 in Unity](https://awesomerea.org/resources/opents2-sims2-engine-case/index.md): Case study · Reimplements The Sims 2 in the Unity engine, reading the user’s Ultimate Collection installation through its own C# code for the game’s DBPF packages and asset formats, which the project also aims to offer as modular libraries. README reports an early stage: a basic main menu with a neighborhood chooser, neighborhood previews and a basic neighborhood view, while the tree also holds lot, build-mode, Sim and SimAntics code. README credits FreeSO for much of its code and structure.
- [OpenTS: reconstructing the Tiberian Sun engine](https://awesomerea.org/resources/opents-case/index.md): Case study · OpenTS reconstructs the Command & Conquer: Tiberian Sun 2.03 Firestorm engine as a standalone program. It combines GPL-released source from related Command & Conquer games with reverse engineering of the original executable, and uses assets from the user's installed game.
- [OpenTTD: recreating Transport Tycoon Deluxe](https://awesomerea.org/resources/openttd-case/index.md): Case study · OpenTTD recreates Transport Tycoon Deluxe as an open-source transport simulation game, aiming to mimic the original while adding features. It runs with free OpenGFX, OpenSFX and OpenMSX data sets, or with graphics, sound and music files copied from the user's original game.
- [OpenUG2: a Need for Speed: Underground 2 engine reimplementation](https://awesomerea.org/resources/openug2-case/index.md): Case study · OpenUG2 reimplements the Need for Speed: Underground 2 engine as a native racing prototype that reads the player's original game data. It parses STREAM*.BUN scenery, GEOMETRY.BIN car geometry and TEXTURES.BIN textures, then renders drivable circuits with AI opponents, laps and standings.
- [OpenUT2k4: recreating Unreal Tournament 2004 in Unreal Engine 5.8](https://awesomerea.org/resources/openut2k4-case/index.md): Case study · OpenUT2k4 recreates Unreal Tournament 2004 in C++ on Unreal Engine 5.8 using maps, characters, audio and music converted locally from the player's installation. It builds maps at runtime and implements UT2004 network compatibility so its client and server can play alongside the original game.
- [OpenVIII: a C# engine reconstruction of Final Fantasy VIII](https://awesomerea.org/resources/openviii-monogame-case/index.md): Case study · OpenVIII rewrites the Final Fantasy VIII game engine in C# and MonoGame for Windows and Linux. Its replacement engine reads the user's original game files and contains code for archives, battle systems, audiovisual playback and other game systems.
- [OpenXcom: an open-source clone of X-COM: UFO Defense and Terror from the Deep](https://awesomerea.org/resources/openxcom-engine-case/index.md): Case study · Reimplements MicroProse’s UFO: Enemy Unknown (X-COM: UFO Defense) and X-COM: Terror from the Deep as a C++/SDL engine that runs on the user’s original game resources. Game data such as items, craft, research and missions is expressed in YAML rulesets, which also carry its standard mods and a wider modding ecosystem. It is a clone that reuses original content, not recovered MicroProse code.
- [OpenXeen: rebuilding the World of Xeen engine in Java](https://awesomerea.org/resources/openxeen-case/index.md): Case study · OpenXeen is a Java engine rewrite for Might and Magic IV and V: World of Xeen. Its current code parses CC archives and some graphics, audio and map information, creates file proxies and renders selected game components. The author states that the software is not ready for release.
- [OpenXvT: X-Wing vs. TIE Fighter reimplementation](https://awesomerea.org/resources/openxvt-case/index.md): Case study · OpenXvT reimplements Star Wars: X-Wing vs. TIE Fighter and its Balance of Power expansion for Windows, macOS and Linux using the player's original game data. Its source includes flight, asset, audio and rendering systems, with classic and enhanced graphics modes and cross-platform multiplayer.
- [OpenXW: reimplementing Star Wars: X-Wing for modern systems](https://awesomerea.org/resources/openxw-case/index.md): Case study · OpenXW rebuilds Star Wars: X-Wing as a desktop program that reads data from installed 1994 or 1998 editions. It lets users select menus, flight simulation and music from either edition, and implements adaptive iMUSE playback alongside modern rendering and controls.
- [OpenXWA: reimplementing Star Wars: X-Wing Alliance](https://awesomerea.org/resources/openxwa-case/index.md): Case study · OpenXWA reimplements the 1999 game Star Wars: X-Wing Alliance as a native Windows, macOS and Linux program that reads an original installation. Its code covers game systems, OPT models and digital iMUSE audio, with classic and enhanced graphics modes and modern input options. The author reports that the original functions outside multiplayer have been reimplemented.
- [OpenYR: reconstructing the Yuri's Revenge engine](https://awesomerea.org/resources/openyr-engine-case/index.md): Case study · OpenYR reimplements the engine behavior of Command & Conquer: Yuri's Revenge in C++ from observed gameplay, disassembly research and documentation. Its modules cover game state, combat, AI and audio, with parsers planned or implemented for Mix, INI, SHP and VXL resources.
- [OpenZ: reconstructing Z as a 3D strategy game](https://awesomerea.org/resources/openz-z-remake-case/index.md): Case study · OpenZ recreates the 1996 strategy game Z as a Unity 6 game with 3D battlefields, units, and newly produced media. It reproduces territory capture and factory-based combat, adds new content, and ports its computer opponent from the open-source Zod Engine.
- [OpenZT2: a Rust engine reimplementation of Zoo Tycoon 2](https://awesomerea.org/resources/openzt2-engine-case/index.md): Case study · OpenZT2 reimplements the Zoo Tycoon 2 engine in Rust and Bevy for use with the player's own game files. It renders original materials through Bevy with patched vkd3d-shader and MojoShader libraries and includes game systems for animals, construction, and visitors.
- [Oracles: reconstructing the Zelda Oracle games in Godot](https://awesomerea.org/resources/zelda-oracles-godot-reconstruction-case/index.md): Case study · Oracles reconstructs The Legend of Zelda: Oracle of Ages and Oracle of Seasons with a shared C# engine in Godot. It imports data from a pinned disassembly and uses original ROM behavior for timing, object order, collisions and state. Ages is described as playable; Seasons currently covers its opening and selected early-game rooms and events.
- [Ordoor: reimplementing the Strategy Engine for four games](https://awesomerea.org/resources/ordoor-strategy-engine-case/index.md): Case study · Ordoor rebuilds the Strategy Engine used by Warhammer 40,000: Chaos Gate, Soldiers At War, Squad Leader, and Wages of War. Its format work and viewers cover maps, menus, graphics, sound, and video to varying degrees; gameplay mechanics remain unfinished.
- [Ozymandias (Julius): adapting a city-building engine to Pharaoh](https://awesomerea.org/resources/ozymandias-julius-case/index.md): Case study · Ozymandias (Julius) adapts the Julius/Augustus city-building engine to run Pharaoh and its Cleopatra expansion using the player's original assets. The unfinished implementation loads original saves and supports early campaign missions, with systems including houses, farming, trading and campaign progression.
- [Ozymandias: a Godot engine reconstruction for Pharaoh and Zeus](https://awesomerea.org/resources/ozymandias-pharaoh-engine-case/index.md): Case study · Ozymandias recreates the engine of the city-building games Pharaoh, Zeus and related titles in Godot 3.6 Mono. Its project tree contains game-system scripts, scenes and interface code that use files from an original game installation. The author describes the current implementation as early, with basic structure and menu logic.
- [P.T. for PC: a behavior-based engine reimplementation that reads the PS4 data](https://awesomerea.org/resources/pt-pc-port-case/index.md): Case study · Reimplements P.T.’s game logic in C++ on a new Vulkan engine that reads levels, models, textures, sounds, scripts and cutscenes from the user’s own PS4 copy at run time. The author documents reverse-engineered file formats and used the shadPS4 emulator as a behavior and frame reference. Fidelity to the original is author-reported, and the use of AI coding tools is disclosed.
- [Pal3.Unity: reconstructing Sword and Fairy 3 and Wenqing Pian in Unity](https://awesomerea.org/resources/pal3-unity-case/index.md): Case study · Pal3.Unity reimplements The Legend of Sword and Fairy 3 and its Wenqing Pian expansion in C# and Unity. It rewrites game logic and reproduces behaviour and effects while loading assets from the user's original game installation.
- [PanzerChasm: recreating Chasm: The Rift with original game data](https://awesomerea.org/resources/panzerchasm-chasm-the-rift-case/index.md): Case study · PanzerChasm recreates Chasm: The Rift in C++ as an SDL2 game that loads the player's original CSM.BIN data file. The repository includes game and rendering source, shaders, and notes on the game's binary formats.
- [PanzerMortyr: a Mortyr 2093-1944 engine reimplementation](https://awesomerea.org/resources/panzermortyr-case/index.md): Case study · PanzerMortyr reimplements the Mortyr 2093-1944 engine as a replacement executable that loads original game data. The author reports reverse engineering archive, map and model formats and recreating observed enemy behavior, movement physics and game balance. Written mostly in Ü, it supports Windows and GNU/Linux; game data can come from an installation or a CD image.
- [Pentagram: reimplementing the Ultima 8 engine](https://awesomerea.org/resources/pentagram-u8/index.md): Case study · Pentagram reimplements the Ultima 8 engine. The documentation dated 9 November 2011 says the supported games are the English versions of Ultima 8, both before and after the patch. German, French, and Spanish versions are listed as less tested.
- [Phoenix: a Java remake of Emperor of the Fading Suns](https://awesomerea.org/resources/phoenix-efs-case/index.md): Case study · Phoenix rebuilds Emperor of the Fading Suns as a Java game using data from the user's EFS 1.4 installation. Its source includes game systems, a GUI, FLC animation handling and galaxy-file readers. The project aims to reproduce EFS.EXE behavior while keeping the original data outside its distribution.
- [physics_RT: reconstructing Ballance physics behavior](https://awesomerea.org/resources/physics-rt-ballance-case/index.md): Case study · physics_RT reconstructs Ballance physics behavior as a Win32 Virtools DLL using IVP numerical kernels. It covers collision geometry, force handling and simulation timing, with differential tests against an original DLL and documented runtime comparisons.
- [Pinball Fantasies Reassembled: recreating the DOS game engine](https://awesomerea.org/resources/pinball-fantasies-reassembled-case/index.md): Case study · Pinball Fantasies Reassembled recreates the 1993 DOS game engine in Rust using files from an original copy. Its technical notes map the MZ executables, per-table PRG programs, interrupt interfaces, sound drivers and user-data formats. The source includes asset readers, table simulation and tools for dissecting original files.
- [Pizza Legacy: reimplementing Pizza Tycoon](https://awesomerea.org/resources/pizza-legacy-case/index.md): Case study · Pizza Legacy rebuilds the 1994 DOS game Pizza Tycoon, also released as Pizza Connection, in a C++20 engine that loads the original game's assets. The author reports that the major gameplay systems support a complete playthrough. The remake also adds optional bug fixes, autosaving, and support for modern displays and controls.
- [pokerecomp: reimplementing the Game Boy Pokémon games](https://awesomerea.org/resources/pokerecomp/index.md): Case study · pokerecomp is a Godot 4 reimplementation, written in GDScript, of the Game Boy Pokémon games. Gold, Silver, Crystal, Red, Blue, and Yellow are playable from the bedroom through the Hall of Fame and their credits. A cartridge dump is checked by SHA-1, decoded once into a cache, and then released.
- [Portémon Nitro: a HeartGold and SoulSilver engine port](https://awesomerea.org/resources/portemon-nitro-hgss-case/index.md): Case study · Portémon Nitro reimplements the Pokémon HeartGold and SoulSilver engine in LÖVE for PCs and mobile devices. It reads a user-owned Nintendo DS ROM, derives game data locally, and separates ROM interpretation from runtime behavior and the app interface. The repository contains Lua game code, Nintendo DS and game-specific libraries, and ROM import tooling.
- [Powerslave EX: rebuilding the PlayStation game on Kex Engine](https://awesomerea.org/resources/powerslave-ex-case/index.md): Case study · Powerslave EX reconstructs the PlayStation Powerslave game on Kex Engine 3.0, combining recovered game logic with new collision and AI systems. Its research files document MIPS disassembly, extraction code and partial findings about the ZED format; the engine uses converted game data rather than the CD data directly.
- [Powerslide Remake: rebuilding the arcade racer on original game data](https://awesomerea.org/resources/powerslide-remake-case/index.md): Case study · Powerslide Remake reconstructs the arcade racer's main features in a cross-platform C++ application built on Ogre. It reads the original game's data.pf, gameshell.pf and store.pf archives and provides racing, AI and multiplayer features. Builds target Windows, Linux and Android.
- [ppengine: a Pole Position remake from arcade ROM analysis](https://awesomerea.org/resources/ppengine-case/index.md): Case study · ppengine recreates Atari's Pole Position as a 3D game using logic reverse engineered from the arcade ROMs. Its C source builds a playable client with steering, braking, acceleration and gear changes, while the title screen remains unfinished.
- [Primal Rage: DOS engine reconstruction and SDL3 port](https://awesomerea.org/resources/primal-rage-reconstruction-case/index.md): Case study · Primal Rage RE reconstructs the DOS game's engine in C over a memory layout matching PRAGE.EXE and runs it with SDL3 using the user's game data. The project includes Ghidra analysis scripts, LE and resource-format documentation, captures and differential checks; the author reports all 759 game-owned functions ported.
- [Project ANISE: an AI5V and SILV scripting engine interpreter](https://awesomerea.org/resources/project-anise-ai5v-case/index.md): Case study · Project ANISE is a C++ interpreter for Japanese adventure games built on the AI5V or SILV scripting engines. Its source includes script operations, graphics, sound and input components. The project was developed on Windows with SDL, and the author reports compiling and running it on Linux.
- [Project Carrot: rebuilding a Jazz Jackrabbit 2-style engine](https://awesomerea.org/resources/project-carrot-case/index.md): Case study · Project Carrot develops a C++ engine modeled on Jazz Jackrabbit 2 using converted resources from a user's copy. Its source includes game systems and JJ2 format handling; companion tools extract Anims.j2a assets and convert tilesets and levels. The author describes the project as progressing slowly.
- [Project Dollhouse: reconstructing The Sims Online in C#](https://awesomerea.org/resources/project-dollhouse-case/index.md): Case study · Project Dollhouse reconstructs The Sims Online in C# with client and server components that use an installed copy of the game. The codebase includes readers for original DBPF, FAR and IFF resources alongside game screens, entities and server code.
- [PvZ-Portable: a reimplementation of Plants vs. Zombies GOTY](https://awesomerea.org/resources/pvz-portable/index.md): Case study · Cross-platform reimplementation of Plants vs. Zombies: Game of the Year Edition. The README says the code is a manual reimplementation from community research, . It names Linux, Windows, macOS, Android, iOS, WebAssembly, and Switch, using OpenGL ES 2.0 and SDL, with a browser build that still needs the player's game data.
- [Pyskool: reimplementing Skool Daze and Back to Skool](https://awesomerea.org/resources/pyskool-case/index.md): Case study · Pyskool reimplements the ZX Spectrum games Skool Daze and Back to Skool in Python and Pygame. Its shared engine supports configuration-file and Python-code customization, and its setup generates the launchers, images, configuration and sounds used to play.
- [R.E.L.I.V.E.: replacing the engines for Abe’s Oddysee and Abe’s Exoddus](https://awesomerea.org/resources/relive-engine-case/index.md): Case study · R.E.L.I.V.E. develops a cross-platform engine intended to replace the original PC executables for Abe’s Oddysee and Abe’s Exoddus. It runs with the player's game files and provides controller support, display options, and a level editor. The project reports that both games are playable, with bugs and crashes still possible.
- [RA2 Engine: reconstructing Red Alert 2 and Yuri's Revenge](https://awesomerea.org/resources/ra2-engine-case/index.md): Case study · RA2 Engine rebuilds Command & Conquer: Red Alert 2 with Yuri's Revenge as a C++17 and SDL2 engine for Windows and Android. It reads the player's original MIX and CSF files, including rulesmd.ini, and implements combat, movement, AI and timing from observed game behavior. The author describes version 0.9 as a playable beta.
- [Rad-Therapy: recreating Half-Life in QuakeC](https://awesomerea.org/resources/rad-therapy/index.md): Case study · Rad-Therapy is a QuakeC game for the FTE engine that plays the 1998 Half-Life campaign and deathmatch. Menus, client, server, and the network sub-protocol run in QuakeC. The release file package_valve.pk3 goes in HL1/valve/. A source build clones the game into the Nuclide SDK and runs make game GAME=valve. Launch can pass -halflife, and mods use fteqw -halflife -game.
- [RAD: recreating the Radix: Beyond the Void engine](https://awesomerea.org/resources/rad-x-case/index.md): Case study · RAD recreates the engine of the 1995 DOS game Radix: Beyond the Void and loads radix.dat from the original v2 remix release. The replacement adds software and OpenGL rendering, dynamic lighting, audio format support and PascalScript scripting.
- [Rails: an OCaml reconstruction of Railroad Tycoon](https://awesomerea.org/resources/rails-railroad-tycoon-case/index.md): Case study · Rails rebuilds the 1990 Railroad Tycoon game in OCaml, implementing railroad construction, train management, AI rivals and economy systems. It loads the user's original DOS PIC, PAN and DTA data files and uses SDL2 for its interface and presentation.
- [RappelzCore & RappelzRust: reconstructing a Rappelz NoLimits client and server](https://awesomerea.org/resources/rappelzcore-rappelzrust-case/index.md): Case study · RappelzCore and RappelzRust reconstruct a Rappelz NoLimits server and game client in Rust from analysis of the customized SFrame.exe client. The author documents REA and Ghidra work on client functions, resource formats and packet layouts; both components are described as under development.
- [raw(gl): Another World engine reimplementation](https://awesomerea.org/resources/rawgl-another-world-case/index.md): Case study · raw(gl) reimplements the Another World engine while reading data from the original game. Its interpreter supports Amiga, Atari, DOS, Windows 3.1, 3DO and anniversary releases; accompanying notes describe virtual-machine bytecode and platform-specific resource formats.
- [rawpsx: an Another World engine reimplementation for PlayStation](https://awesomerea.org/resources/rawpsx-another-world-case/index.md): Case study · rawpsx rewrites the Another World engine in C for the original PlayStation, adapting the earlier rawgl implementation with PSn00bSDK. It reads BANKxx and MEMLIST.BIN from a player's DOS copy and builds a PlayStation ISO. The author reports that the software-rendering branch runs the full DOS version.
- [Re-Comprehend: rebuilding Penguin Software adventure engines](https://awesomerea.org/resources/re-comprehend-case/index.md): Case study · Re-Comprehend reimplements the Comprehend and Graphics Magician engines for Penguin Software adventures including Transylvania, Crimson Crown and OO-Topos. It reads the user's original DOS game files, preserves the original save format, and offers data dumps and runtime commands for inspecting objects, rooms and state.
- [re2ds: a native Nintendo DS engine for Resident Evil 2](https://awesomerea.org/resources/re2ds-nds-engine-case/index.md): Case study · Reimplements Resident Evil 2’s PS1 game rules in a native Nintendo DS engine, with converters that turn data from the user’s own disc into DS formats. A helper wraps the PS1 executable as an ELF for REA’s Ghidra lane, analysis notes name the PS1 functions and tables each part follows, and the Reddit post linking it credits REA and Claude Code. Leon’s disc 1 is reported playable, while Claire’s disc, most enemy types and some menus remain unfinished.
- [rea-doom-term: a text-only reconstruction of DOOM](https://awesomerea.org/resources/rea-doom-term-case/index.md): Case study · rea-doom-term rebuilds DOOM (1993) as a playable Rust terminal game with WAD parsing, fixed-point math, movement, combat, and text raycasting. Its evidence log links reconstructed subsystems to original source functions and tests; the terminal renderer uses a different visibility and texturing approach.
- [reB3: reconstructing Burnout 3 from Xbox code and disc data](https://awesomerea.org/resources/reb3-case/index.md): Case study · reB3 reconstructs Xbox Burnout 3: Takedown as a C runtime using equations and behavior recovered from default.xbe and formats read from the user's disc. Its notes cite executable addresses for physics, collision, scoring and AI, while extraction code loads track and vehicle material at runtime. The author reports a playable racing harness with career mode absent.
- [Rebellion 2: a Unity remake of Star Wars: Rebellion](https://awesomerea.org/resources/rebellion-2-case/index.md): Case study · Rebellion 2 recreates the 1998 strategy game Star Wars: Rebellion in Unity. The source includes campaign simulation, AI, interfaces and modding support; the author reports that the single-player campaign is playable while multiplayer and replacement 3D tactical combat remain unfinished. Installation requires ownership of a supported original game.
- [Reburn 3: reimplementation of Burnout 3 Takedown](https://awesomerea.org/resources/reburn3-case/index.md): Case study · Reburn 3 is a work-in-progress open-source reimplementation of Burnout 3: Takedown. The README calls it a rewrite and says it is currently playable on Windows and Wine through Cxbx-Reloaded.
- [ReChan: reimplementing Jackie Chan Stuntmaster for PC](https://awesomerea.org/resources/rechan-case/index.md): Case study · ReChan reimplements Jackie Chan Stuntmaster's PlayStation game logic and systems in C++ for x86_64 Windows and Linux. It rebuilds data structures and formats, extracts required assets locally from a user's NTSC-U disc image, and adds widescreen, higher-resolution and keyboard-and-mouse support.
- [ReFlood: reconstructing the Amiga game Flood in C and SDL2](https://awesomerea.org/resources/reflood-case/index.md): Case study · ReFlood reconstructs the Amiga game Flood as a C99 program with an SDL2 host, using assets extracted from the player's own disk image. Its reports map the game's custom disk layout and document behavior recovered from the original, while the build also offers a headless core and a level editor.
- [REGoth-bs: reimplementing the Gothic and Gothic II engine](https://awesomerea.org/resources/regoth-bs/index.md): Case study · REGoth-bs reimplements the zEngine used by Gothic and Gothic II. The reviewed README says there is no official release yet. Nightly Windows builds are on the Azure Pipelines page for definition 1. Building and running on Linux or Windows are documented at regoth-project.github.io/REGoth-bs.
- [REGoth: reimplementing the Gothic and Gothic II engine](https://awesomerea.org/resources/regoth/index.md): Case study · REGoth reimplements the zEngine used by Gothic and Gothic II. The reviewed README says the project restarted at REGoth-project/REGoth-bs. This tree's latest tagged Windows and Android builds are version 0.4. git clone --recursive, CMake 3.1 or newer, and a C++14 compiler are required, along with libsndfile. The tested compilers are GCC 6, MinGW, and Visual Studio 2015 or 2017. REGoth -g takes a Gothic I or II installation and -w takes a zen file such as newworld.zen. The binary is in build/bin.
- [REinforced: extending the Flashback engine reimplementation](https://awesomerea.org/resources/reinforced-flashback-case/index.md): Case study · REinforced extends the REminiscence reimplementation of the 1992 Flashback game engine. Its C++ engine reads original PC, Amiga or Macintosh files and offers widescreen display modes, graphics scaling, saves and audio playback.
- [ReksioEngine: reimplementing the Przygody Reksia game engines](https://awesomerea.org/resources/reksio-engine/index.md): Case study · ReksioEngine reimplements the BlooMoo and Piklib engines used by the Przygody Reksia games. It runs the original assets and scripts in a web browser.
- [REminiscence: a Flashback engine reimplementation](https://awesomerea.org/resources/reminiscence-flashback-case/index.md): Case study · REminiscence reimplements the engine of the 1992 game Flashback and runs on data files from the user's DOS, Amiga, Macintosh or PC-98 release. Its SDL-based code handles game logic, graphics, cutscenes, audio and saves, with command-line options for scaling, widescreen display and language.
- [reone: reconstructing the Knights of the Old Republic engine](https://awesomerea.org/resources/reone-kotor-engine-case/index.md): Case study · reone reconstructs an engine for Star Wars: Knights of the Old Republic and The Sith Lords in C++ using public file-format information and observations of the games and their resources. It loads files from a legally obtained copy, with SDL 2 and OpenGL 3.3 used by the custom engine.
- [reRBR: reimplementing Richard Burns Rally 1.02](https://awesomerea.org/resources/rerbr-case/index.md): Case study · reRBR reimplements Richard Burns Rally 1.02 for Linux, macOS and Windows, using the player's game files and NGP 7.4.778 physics. Its Rust code covers game formats, stages, cars, race flow, damage, saves and rendering; the author reports comparing gameplay behavior with recordings of the original. BTB stage support remains experimental.
- [Return To The Roots: rewriting The Settlers 2 for modern systems](https://awesomerea.org/resources/return-to-the-roots-case/index.md): Case study · Return To The Roots rewrites The Settlers 2 for modern operating systems while using graphics and sounds from the player's original Gold Edition copy. The C++ project aims to add internet multiplayer and other changes, and provides build instructions for Linux, macOS and Windows.
- [ReverseSanta: a reconstruction of Santa Claus in Trouble](https://awesomerea.org/resources/reversesanta-case/index.md): Case study · ReverseSanta is a C++ reimplementation of Joymania's Santa Claus in Trouble built from study of the original without disassembly tools. Its source includes game, level, graphics, and editor components using DirectX 9. The author describes the result as inaccurate to the original and has not tested it from start to finish.
- [reWoodpecker: a PSP reconstruction of Woody Woodpecker](https://awesomerea.org/resources/rewoodpecker-case/index.md): Case study · reWoodpecker rebuilds Woody Woodpecker: Escape from Buzz Buzzard Park for PSP with a C++ engine and a Qt converter for the user's PS2 disc. The runtime loads levels, handles collision and gameplay, executes EKO scripts and renders through the PSP GU.
- [Rigel Engine: a Duke Nukem II engine reimplementation](https://awesomerea.org/resources/rigel-engine-case/index.md): Case study · Rigel Engine reimplements Duke Nukem II in C++ using findings from disassembly of the original game binaries. It replaces the DOS executable while reading the user's original game data, and adds widescreen display, smooth scrolling, quick saves and controller support.
- [Riiablo: rebuilding Diablo II in Java](https://awesomerea.org/resources/riiablo-case/index.md): Case study · Riiablo rebuilds Diablo II in Java with LibGDX, OpenGL, FlatBuffers, and Netty, loading game assets from the user's own installation. The current build can load supported saves and let characters move through the game, while an MPQ viewer and map viewer aid development. The author states that it is not yet playable.
- [rlvm: a RealLive interpreter reimplementation](https://awesomerea.org/resources/rlvm-case/index.md): Case study · rlvm reimplements the RealLive interpreter so VisualArts games can run on Linux and macOS using their own SEEN.TXT game directories. It supports KOE, NWK and OVK voice archives and implements rlBabel line breaking for compatible English patches.
- [Robot War Engine: a Total Annihilation-compatible engine reconstruction](https://awesomerea.org/resources/robot-war-engine-case/index.md): Case study · Robot War Engine rebuilds a Total Annihilation-compatible strategy-game engine that runs on the player's original data files. Its C++ core parses HPI archives, GAF sprites, 3DO models and COB unit scripts, while a separate Electron launcher provides a multiplayer lobby.
- [roBrowser: a browser reconstruction of Ragnarok Online](https://awesomerea.org/resources/robrowser-case/index.md): Case study · roBrowser recreates a Ragnarok Online client for web browsers using JavaScript, HTML5 and WebGL. Its code includes game and login engines, resource viewers and loaders; deployment instructions use converted client data, a remote resource client and a WebSocket proxy to connect to a server.
- [Rockport Native: reconstructing Need for Speed: Most Wanted on macOS](https://awesomerea.org/resources/rockport-native-nfs-mw-case/index.md): Case study · Rockport Native reconstructs the PlayStation 2 release of Need for Speed: Most Wanted as a macOS game using a Swift and Metal engine and data converted from the player's ISO. The project documents disc formats, game systems and a Ghidra and REA disassembly workflow; the author reports a playable Mac release and remaining gameplay gaps.
- [RodLegacy: reimplementing Street Rod and Street Rod 2](https://awesomerea.org/resources/rodlegacy-case/index.md): Case study · RodLegacy reimplements Street Rod and Street Rod 2 in C++ for modern systems, reading game data from user-supplied Amiga disk images. Its game code covers cars, races, scenes, sound and save files, with optional car-set mixing and several soundtrack sources. The author describes both games as playable while development and bug fixing continue.
- [Rollerbot: a reconstructed Android and Linux runtime](https://awesomerea.org/resources/rollerbot-android-case/index.md): Case study · Rollerbot-Android reconstructs the 2000 game Rollerbot: A Time Journey for Android and Linux from its original scripts and user-supplied assets. It implements gameplay, scene, audio and platform components, with an Android disc importer and a Linux Flatpak. Supporting notes map Direct3D Retained Mode call sites in the original executable.
- [Rook: reconstructing the Roblox engine](https://awesomerea.org/resources/rook-roblox-engine-case/index.md): Case study · Rook reconstructs a Roblox-compatible engine in Rust so user-supplied places can run outside Roblox. It loads .rbxl, .rbxm, .rbxlx and .rbxmx files and implements Luau scripting, an instance model, physics and rendering; its behavior notes and conformance cases compare results with Roblox Studio.
- [rrt2-decomp: a Rust reimplementation of Railroad Tycoon II](https://awesomerea.org/resources/rrt2-decomp-case/index.md): Case study · rrt2-decomp reimplements Railroad Tycoon II in Rust after studying the Platinum executable, game data and simulation rules. Its crates parse PK2 archives, LAD sprites, maps and saves, while a differential harness runs original functions for comparison; the new game uses the player's installed assets and a wgpu renderer.
- [RTAGlass: a Windows reimplementation of Road Trip](https://awesomerea.org/resources/rtaglass-case/index.md): Case study · RTAGlass reimplements the PS2 game Road Trip as a C++ Windows port. Its build analyzes the user's own USA disc image, generates tables and VU1 microcode conversions from the executable, converts models, textures and sound, and assembles a playable Windows build.
- [Rugrats: Search for Reptar: a Rust reconstruction of the PlayStation game](https://awesomerea.org/resources/rugrats-search-for-reptar-case/index.md): Case study · rugrats reconstructs the North American PlayStation game Rugrats: Search for Reptar as a native Rust PC game using data read from the player's own disc. Separate readers decode models, rooms, animation, sound and cinematics, while a new runtime implements controls, physics, level rules and saving. The author reports start-to-finish playability and records reverse-engineering findings in a worklog and format reference.
- [rust-theft-auto: reimplementing the original Grand Theft Auto engine](https://awesomerea.org/resources/rust-theft-auto-case/index.md): Case study · rust-theft-auto reimplements the original Grand Theft Auto engine in Rust using map and style files from a player's installation. The source includes map structures, tile and style handling, and a renderer. Reimplementing gameplay and extending maps and missions are stated goals.
- [Rusty MCLA: rebuilding Midnight Club: Los Angeles in Rust](https://awesomerea.org/resources/rusty-mcla-midnight-club-los-angeles-case/index.md): Case study · Rusty MCLA rebuilds Midnight Club: Los Angeles Complete Edition as a Rust game engine for Windows using data prepared from the user's Xbox 360 disc image. Its format tools handle the disc, archives, resources, scripts and shaders, while a function registry tracks work against the original executable. The author reports about 17 percent of functions closed and lists online play and several hardware features as later work.
- [RustyWorld: a Rust reimplementation of the Another World engine](https://awesomerea.org/resources/rustyworld-case/index.md): Case study · RustyWorld reimplements the Another World game engine in Rust and runs on the user's original data. Its VM separates instruction decoding from execution and groups related opcodes, while minifb handles video and input and rodio handles audio.
- [sacengine: reimplementing the Sacrifice game engine](https://awesomerea.org/resources/sacengine/index.md): Case study · sacengine reimplements the engine of Sacrifice, the game by Shiny Entertainment. It is written in D. LDC 1.41.0 is a known working compiler.
- [San Andreas Unity: a GTA San Andreas engine reimplementation in Unity](https://awesomerea.org/resources/san-andreas-unity-engine-case/index.md): Case study · Reimplements the Grand Theft Auto: San Andreas engine in Unity (C#), loading the archives, RenderWare models and textures, collision, animations, audio, text and item definitions from the user’s own PC installation. README says it will not be a complete reimplementation; it focuses on gameplay features, multiplayer and a framework for extending and modding the game through C# plugins. Development has stalled: the newest commit on any branch dates from 2022-09-30.
- [Sarien: a portable reimplementation of Sierra's AGI interpreter](https://awesomerea.org/resources/sarien-agi-interpreter-case/index.md): Case study · Sarien reimplements Sierra On-Line's Adventure Game Interpreter (AGI) in C so that AGI games such as Leisure Suit Larry, King's Quest II and Mixed-Up Mother Goose run across many platforms. It executes the compiled Logic bytecode and handles AGI graphic, text and sound resources, including Amiga and Apple IIgs versions and AGDS games, and adds extras such as a debugger console, picture and dictionary viewers and three-channel PCM sound. The Hacker's Guide documents the interpreter's architecture, drivers, graphics and sound; the project later merged into ScummVM.
- [Scion: reimplementing the SimCity 4 Gonzo/Rizzo framework](https://awesomerea.org/resources/scion-maxis/index.md): Case study · Scion is a reference implementation of the Gonzo/Rizzo framework used by Maxis. It aims at the version in SimCity 4 Deluxe Edition. The README also names SimCity 3000, The Sims 2, and Spore as games that used the framework, and says identical machine code is a stretch goal.
- [Scooby-Doo Mystery: a reconstructed Sega Genesis engine](https://awesomerea.org/resources/scooby-doo-mystery-genesis-case/index.md): Case study · The Scooby-Doo Mystery port reimplements the Sega Genesis game's engine in C++ with SFML 3, porting routines from 68000 code and reading graphics, text and scripts from a user ROM. The repository includes engine notes, script VM findings, Ghidra exports and emulator comparison tools.
- [ScummVM: replacement executables for classic adventure games](https://awesomerea.org/resources/scummvm-engine-case/index.md): Case study · Replaces the executables of classic adventure games and RPGs with one program that runs the user's original data files. It began with LucasArts SCUMM games and now names many other titles.
- [SDLPAL: reimplementing Legend of Sword and Fairy with SDL](https://awesomerea.org/resources/sdlpal/index.md): Case study · SDLPAL is an SDL reimplementation of the Chinese RPG Legend of Sword and Fairy, also called PAL. It builds for Windows desktop and UWP, GNU/Linux, macOS, Android, iOS, and several consoles. Windows desktop opens win32/sdlpal.sln in Visual Studio 2017 or later. GNU/Linux runs cd unix && make and needs SDL 2.0. The original resource files are copied into the same directory as the executable. On case-sensitive filesystems those filenames are lower-case. Versions are selected in the first-launch window or in sdlpal.cfg.
- [SDLPoP2: rebuilding the Prince of Persia 2 DOS engine](https://awesomerea.org/resources/sdlpop2-prince-of-persia-2-case/index.md): Case study · SDLPoP2 rebuilds the engine of Prince of Persia 2: The Shadow and the Flame from its DOS program as C for Linux and Windows. It reads the user's original game data, and its findings document DOSBox-X traces, reconstructed routines and equivalence tests; a headless core supports tool-assisted runs.
- [Seedra: reimplementing Minecraft Legacy Console Edition world generation](https://awesomerea.org/resources/seedra-case/index.md): Case study · Seedra reimplements Minecraft Legacy Console Edition world generation in a C++ library. It generates chunks, maps biomes, locates structures and spawn points, and computes structure loot from seeds, with examples selecting console, game version, world size, and biome scale.
- [sekiro-rs: a Rust and Bevy reconstruction of Sekiro](https://awesomerea.org/resources/sekiro-rs-case/index.md): Case study · sekiro-rs rebuilds parts of Sekiro: Shadows Die Twice in Rust and Bevy using data extracted from a user's Steam installation. It interprets Havok Script and behavior graphs, TAE events and Lua AI scripts, reads game formats including FLVER and MSB, and rewrites engine combat rules identified through static analysis.
- [sena-rs: reimplementing SoftPAL for Koikake](https://awesomerea.org/resources/sena-rs-case/index.md): Case study · sena-rs reimplements the SoftPAL engine in Rust for Koikake, with a PAL virtual machine, asset handling, script disassembly and decompiler components. It runs from an external game installation and provides builds for desktop, mobile, WebAssembly and experimental console targets. The author states that console hardware execution has not been tested.
- [Settlers.ts: decoding Settlers 4 data for a browser remake](https://awesomerea.org/resources/settlers-ts-case/index.md): Case study · Settlers.ts builds a browser-based Settlers 4 remake in TypeScript using files from the user's game installation. Its readers decode LIB archives, graphics, maps and saves, while WebGL renders map landscapes. Object drawing, settlers, buildings and game logic are listed as future work.
- [sh23ds: a native 3DS reconstruction of Silent Hill 2](https://awesomerea.org/resources/sh23ds-case/index.md): Case study · sh23ds rebuilds Silent Hill 2: Director's Cut as a native C engine for Nintendo 3DS using the player's PC game data. Game logic, camera, lighting and events were reconstructed from the PC executable; the research notes report analysis with Ghidra and REA. The author reports a complete playthrough in Azahar, while real-console testing and some PC behaviors remain unfinished.
- [sh3redux: a Silent Hill 3 engine remake in C++](https://awesomerea.org/resources/sh3redux-case/index.md): Case study · sh3redux rebuilds the Silent Hill 3 engine in C++ with OpenGL rendering. Its source includes game engine, graphics and ARC archive structures, with a CMake build and a Code::Blocks project.
- [Shiloh: reimplementing The X-Files Game engine](https://awesomerea.org/resources/shiloh/index.md): Case study · Shiloh is a Rust engine for The X-Files Game (1998), with an SDL2 window and a WebAssembly browser build. Complete playthroughs are reported for the English DVD Edition, program build 2.05, the Russian 1.00 release, and the German 7-CD release, program build 1.00.19. The browser build is served at 127.0.0.1:8640. Tables such as the computer, phone, and notes are read from the player's copy at run time.
- [shin: reimplementing the engine of Entergram visual games](https://awesomerea.org/resources/shin-engine-case/index.md): Case study · shin reimplements a game engine used by Entergram visual games, initially targeting the Switch release of Umineko no Naku Koro ni Saku. It runs original game data and includes a core library and CLI for extracting .rom, .bup, .pic, .nxa and other resources; .snr scenarios have execution tracing rather than decompilation.
- [shock2quest: recreating the Dark engine for System Shock 2 VR](https://awesomerea.org/resources/shock2quest-case/index.md): Case study · shock2quest recreates the Dark engine for a virtual-reality version of System Shock 2 on Meta Quest. Its runtime reads KPF archives and cutscenes copied from the user's 25th Anniversary Remaster installation; the Rust workspace includes engine, game and VR runtime components.
- [si78c: reimplementing Space Invaders in C](https://awesomerea.org/resources/si78c/index.md): Case study · si78c is a C reimplementation of the 1978 arcade game Space Invaders. Running it matches the original memory state apart from the stack, and the frames match pixel for pixel. The ROM files go in inv1/. invaders.e is MD5 7d3b201f3e84af3b4fcb8ce8619ec9c6, invaders.f is 7709a2576adb6fedcdfe175759e5c17a, invaders.g is 9ec2dc89315a0d50c5e166f664f64a48, and invaders.h is e87815985f5208bfa25d567c3fb52418. make builds ./bin/si78c. It uses SDL2 and ucontext, and the documented builds use Ubuntu 18.04 and Mac OS X El Capitan on little-endian machines.
- [SiegeFX: a Dungeon Siege engine reimplementation in alpha](https://awesomerea.org/resources/siegefx-dungeon-siege-engine-case/index.md): Case study · A C#/.NET 10 engine loads Dungeon Siege's original archives, scripts and models, with published alpha builds and an audit/parity ledger. The project also provides SiegeSmith modding tools, while describing remaining fidelity and playthrough risks.
- [siglus_rs: reimplementing four visual game engines in Rust](https://awesomerea.org/resources/siglus-rs-case/index.md): Case study · siglus_rs reimplements the UK2, AVG32, RealLive and SiglusEngine game engines in Rust, with its main focus on SiglusEngine. Launchers identify engines from game-directory formats and import games on supported platforms; the web launcher runs SiglusEngine, RealLive and AVG32, while UK2 runs on desktop, iOS and Android.
- [Sims 3 in Bevy: a Rust reimplementation of The Sims 3](https://awesomerea.org/resources/sims-3-bevy-case/index.md): Case study · Sims 3 in Bevy reimplements The Sims 3 in Rust using Bevy and data from the player's installation. A separate baking step converts packages into a local cache of textures, meshes and world data; format notes document resource layouts and gameplay tuning used by the implementation.
- [SimUnity2: a partial Unity reconstruction of The Sims 2](https://awesomerea.org/resources/simunity2-case/index.md): Case study · SimUnity2 partially reconstructs The Sims 2 in Unity using files from a user's game installation. The author reports working neighborhood selection and neighborhood views; the C# source includes DBPF and other game-file readers.
- [Skate 3 Rust Engine: a Bevy rewrite built on Skate 3 reverse-engineering research](https://awesomerea.org/resources/skate-3-rust-engine-case/index.md): Case study · Reimplements Skate 3’s skating, tricks, grinds and offboard movement in a new Rust and Bevy engine that runs on assets converted from the user’s own Xbox 360 copy, adding difficulty settings and a .skate custom-map format. Physics notes cite functions and constants read from the original executable in IDA, and audio research reads traces from a research-hooks branch of a separate Skate 3 static recompilation. README says gameplay parity is still a work in progress, credits dumbad’s years of format research and states that AI coding tools were used to write the rewrite.
- [SkyRoads: a DOS game engine reconstructed in portable C11](https://awesomerea.org/resources/skyroads-port-case/index.md): Case study · skyroads-port reconstructs the DOS game SkyRoads as a portable C11 engine after disassembling SKYROADS.EXE and documenting its file formats and algorithms. It reads original data files supplied by the user, and the author reports that replaying DEMO.REC follows the original demo road tick for tick.
- [smw: a Super Mario World engine reimplementation](https://awesomerea.org/resources/smw-case/index.md): Case study · smw reimplements Super Mario World's game logic as a native program using levels and images extracted from the user's ROM. It also runs an emulated version in the background, compares RAM state every frame, and saves a snapshot when the states diverge.
- [Snowball War: a bounded REA-assisted minigame reconstruction](https://awesomerea.org/resources/snowball-war-rea-case/index.md): Case study · The author uses REA’s Ghidra workflow to investigate the DOS Ski or Die binary, document Snowball War rules and rebuild that one minigame in Rust with SDL2. The public notes distinguish recovered tables and mechanics from approximations and deliberate presentation changes.
- [Sourcehold: reimplementing the Stronghold game engine](https://awesomerea.org/resources/sourcehold/index.md): Case study · Sourcehold is an early open-source engine for Stronghold, the 2001 castle game by Firefly Studios. It uses SDL2, OpenAL, FFmpeg, zlib blast, and the EnTT, filesystem, and cxxopts submodules. git submodule update fetches those. Windows builds use vcpkg for sdl2, ffmpeg, and openal-soft, then cmake --build build. macOS runs apple/build.sh macos. The iOS path builds only the simulator. --path points at the game data, or the files go in a data directory with binks, fx, gfx, maps, and stronghold.mlb.
- [steins-gate: reimplementing the Steins;Gate visual novel](https://awesomerea.org/resources/steins-gate-case/index.md): Case study · steins-gate is a GPL-licensed reimplementation of the Steins;Gate visual novel. Building it requires libnpa and libnpengine.
- [Street Rod: a DOS game reconstructed in C for SDL3](https://awesomerea.org/resources/street-rod-sdl3-case/index.md): Case study · Street Rod SDL3 reconstructs the 1989 DOS game's behavior in C and runs it through SDL3 using the player's original files. The repository records function specifications and file formats for the game's picture libraries and data, and its port covers the VGA game, racing systems, saves, and PC speaker sound.
- [Subway Runner 3D: rebuilding Subway Surfers movement rules](https://awesomerea.org/resources/subway-runner-3d-case/index.md): Case study · Subway Runner 3D is a procedural Three.js endless runner modeled on Subway Surfers movement and presentation. The author reports using REA and frame-by-frame observation of the original to derive speed, acceleration, jump and gravity values, then implementing lane movement, obstacles and power-ups for browsers and an Android WebView build.
- [Super Mario Bros Remastered: Godot recreations of four Mario games](https://awesomerea.org/resources/super-mario-bros-remastered-case/index.md): Case study · Super Mario Bros Remastered recreates four Super Mario Bros. games in Godot, with revised physics, new levels and characters, and a custom level editor. Players supply an original SMB1 NES ROM; the project provides the Godot game source.
- [Surreal Engine: reimplementing Unreal Engine 1](https://awesomerea.org/resources/surrealengine/index.md): Case study · Surreal Engine reimplements Unreal Engine 1, currently for Unreal Gold and Unreal Tournament. The SurrealEngine executable adds game folders and launches a selected game. It runs on Windows 10 or newer, macOS 15 or newer, and a current Linux distribution, using Direct3D 11, OpenGL 3.2, Vulkan, or Metal 2. Build steps are in Docs/Building.md. SurrealEngine [--url=<mapname>] [--engineversion=X] takes a game-folder path.
- [SWBF2 Browser Reconstruction: rebuilding Battlefront II maps in a browser](https://awesomerea.org/resources/swbf2-browser-reconstruction-case/index.md): Case study · SWBF2 Browser Reconstruction rebuilds parts of Star Wars Battlefront II (2017) in a three.js browser runtime using data extracted from the user's installed game. The pipeline converts Frostbite meshes, textures, lighting, animations, audio and gameplay values; its reference scene is Death Star II with Blast and Free for All modes.
- [T.O.R.E-Fighters: rebuilding Jane's Fighters Anthology in Rust](https://awesomerea.org/resources/tore-fighters-case/index.md): Case study · T.O.R.E-Fighters rebuilds Jane's Fighters Anthology in Rust around observed player-visible behavior. It imports resources from the player's retail copy, implements flight and quick missions, and documents original formats, feature coverage and approximations where behavior remains uncertain.
- [TA3D: rebuilding Total Annihilation in a 3D engine](https://awesomerea.org/resources/ta3d-total-annihilation-case/index.md): Case study · TA3D rebuilds Total Annihilation gameplay in an OpenGL 3D engine that loads original game maps, units and animation scripts from separate resource files. It implements movement, construction, weapons and campaign play, with additional visual effects and a game console.
- [Tapir: reimplementing the RGSS game runtimes](https://awesomerea.org/resources/tapir-rgss-case/index.md): Case study · Tapir reimplements the RGSS, RGSS2 and RGSS3 runtimes used by RPG Maker XP, VX and VX Ace games. It provides a C runtime with graphics, audio and input components and documents Linux builds and RTP installation. A test suite is set up to exercise the original RGSS runtimes supplied by the user.
- [TempleRun-RL: reconstructing Temple Run mechanics for simulator training](https://awesomerea.org/resources/templerun-rl-case/index.md): Case study · TempleRun-RL reconstructs Temple Run's track generation, hazards, and runner physics in a headless training simulator. A Frida gadget reads live state and calls game methods on an arm64 Android phone so the project can measure behavior and evaluate a PPO policy against the original. The author reports a longest device run of 16,782 metres.
- [Test Drive II Enhanced: a C reimplementation of the EGA game](https://awesomerea.org/resources/test-drive-ii-enhanced-case/index.md): Case study · Test Drive II Enhanced reimplements the EGA Test Drive II: The Duel executable in C and runs it through SDL3 with the player's original game files. Its replacement road renderer draws at higher resolution and 60 frames per second with a longer draw distance, while a classic mode retains the earlier view. A stage viewer reads the game's scenery data for camera exploration.
- [Test Drive II: The Duel: an SDL3 reconstruction of the DOS EGA game](https://awesomerea.org/resources/test-drive-2-sdl3-case/index.md): Case study · Test Drive II: The Duel is reimplemented in C for SDL3 from analysis of the DOS EGA game. The port loads the user's original executable and data, while accompanying tools unpack EXEPACK files, disassemble x86 code and decode resource archives. Function indexes, porting specifications and file-format notes document the reconstruction.
- [th10: reconstructing Mountain of Faith 1.00a for the browser](https://awesomerea.org/resources/th10-mountain-of-faith-case/index.md): Case study · th10 reimplements Mountain of Faith 1.00a in C++ for a portable browser runtime. Its TH10-specific systems handle game rules, ANM and ECL data, numeric behavior and replay logic, while SDL and WebGL provide the platform layer.
- [The Crystal Scrolls: a Crystal Space engine for The Elder Scrolls III: Morrowind](https://awesomerea.org/resources/crystal-scrolls-case/index.md): Case study · Reimplements the engine of The Elder Scrolls III: Morrowind on the Crystal Space 3D engine, loading the BSA and ESM files of an installed Morrowind with Tribunal and Bloodmoon. Plugins cover a BSA virtual file system, NIF mesh loading through niflib, terrain, skybox and game logic. The docs describe how NIF scene trees and animations are converted, how plugin reference IDs are remapped when several master files load, and list original Morrowind bugs with their causes, fixes and status in the engine.
- [The Force Engine: rebuilding the Jedi Engine for Dark Forces](https://awesomerea.org/resources/the-force-engine-case/index.md): Case study · The Force Engine rebuilds the Jedi Engine to run Star Wars: Dark Forces on modern systems using the user's original game copy. Its source includes game and engine code derived from analysis of the original executables, alongside a software renderer, GPU renderer, mod loader, and level editor. Outlaws support is planned but is not yet playable.
- [The Hobbit: reconstructing its graphics engine](https://awesomerea.org/resources/hobbitgfx-case/index.md): Case study · hobbitgfx implements the graphics engine of Melbourne House's 1982 text adventure The Hobbit in JavaScript. The repository contains the engine script and HTML demo pages.
- [Thirdeye: reimplementing the AESOP engine for Eye of the Beholder 3 and Dungeon Hack](https://awesomerea.org/resources/thirdeye-aesop-engine-case/index.md): Case study · Thirdeye reimplements the AESOP/16 and AESOP/32 engine in C++ to run Eye of the Beholder 3 and Dungeon Hack from their original RES files and unchanged bytecode. It includes a SOP virtual machine, resource readers and a RES disassembler, alongside a modern runtime with SDL3 audio, input and display support.
- [Thyme: Command & Conquer Generals: Zero Hour reimplementation](https://awesomerea.org/resources/thyme/index.md): Case study · Thyme is an open source reimplementation of Command & Conquer Generals: Zero Hour. It rewrites the game from the ground up and uses the original binary for functions it has not yet replaced.
- [TM2020-Sim: extending Trackmania physics simulation](https://awesomerea.org/resources/tm2020-sim-trackmania-case/index.md): Case study · TM2020-Sim extends Gearbox's Trackmania physics and asset loading into a headless simulator with a native C++ and Rust SDK. It adds parallel environments, replay analysis, driving-controller research and validation tools for local game observations.
- [TOD Tools: reconstructing Total Overdose and Kapow Engine](https://awesomerea.org/resources/tod-tools-case/index.md): Case study · TOD Tools reconstructs Total Overdose game and Kapow Engine code in C++. It builds a dinput8.dll that can call functions in the original game, develops a replacement executable, and includes tools to read and extract selected assets from unpacked archives.
- [Torchlight Rekindled: a portable engine following the Xbox 360 game](https://awesomerea.org/resources/torchlight-rekindled-case/index.md): Case study · Torchlight Rekindled implements an engine for the 2009 game Torchlight, following the logic of its Xbox 360 release. It uses OGRE 14 and ParticleUniverse for rendering, runs on Switch, mobile and desktop platforms, and reads a user's PC or Xbox 360 game archive at runtime.
- [touhou-engine: a Python reimplementation of Touhou gameplay](https://awesomerea.org/resources/touhou-engine-case/index.md): Case study · touhou-engine reimplements Touhou danmaku gameplay in Python, with TH07: Perfect Cherry Blossom as its reference game. The author says its engine logic was ported frame by frame against a decompilation, while the new architecture supplies an event stream, replay handling, headless stepping, and a pygame renderer. It reads original game archives supplied by the user.
- [Tower Toppler: reimplementing Nebulus](https://awesomerea.org/resources/tower-toppler-case/index.md): Case study · Tower Toppler reimplements the rotating-tower puzzle platformer Nebulus with newly drawn graphics. The author reports behavior close to the original after comparison, and the current game uses SDL for graphics and sound. A level editor supports new towers and missions.
- [tower-together: reconstructing SimTower's simulation for multiplayer](https://awesomerea.org/resources/tower-together-case/index.md): Case study · tower-together reconstructs SimTower's simulation as a multiplayer browser game. A TypeScript simulation core runs in a Cloudflare Worker and clients, while documented behavior notes and captured traces from the original executable guide comparisons of state at each tick. The project supplies its own interface and assets.
- [TurokEX: rebuilding PC Turok on the Kex engine](https://awesomerea.org/resources/turokex-case/index.md): Case study · TurokEX reimplements the PC version of Turok on the Kex engine, with the game's actors, enemy AI, weapons, pickups, areas and HUD written as AngelScript classes. Its KPFGen converter reads the original CARTFILE.DAT and Turok.exe and packs their textures, fonts, sounds, models, levels and particle effects into a game.kpf archive. The engine side covers OpenGL rendering, collision and physics, OpenAL sound, a console, ENet networking and an SDL2 platform layer.
- [TwinEngine: a Little Big Adventure 1 engine rewrite](https://awesomerea.org/resources/twinengine-lba1-case/index.md): Case study · TwinEngine rewrites the Little Big Adventure 1 engine in C to run the original game from its installation files. Its source covers rendering, scenes, actors, scripts and HQR resources; the project describes the engine as beta-stage.
- [Twisted Metal: Rust reimplementation of the 2012 PS3 game](https://awesomerea.org/resources/twisted-metal-native-engine-case/index.md): Case study · Twisted Metal reimplements the 2012 PS3 game's engine in Rust for Linux and macOS. Its tools extract a user's disc image, convert models, textures, collision and handling data, and support scene viewing and an early driving simulation with placeholder physics.
- [UA_source: a reimplementation of the Urban Assault engine](https://awesomerea.org/resources/ua-source-case/index.md): Case study · UA_source reimplements the Urban Assault engine in C++ and plays using files from the user's original game copy. It documents Linux and Windows builds with SDL2, OpenGL, OpenAL and other media libraries, and exposes options for rendering and original game behavior.
- [UAlbion: a remake of the 1995 RPG Albion](https://awesomerea.org/resources/ualbion-case/index.md): Case study · UAlbion reimplements the 1995 RPG Albion in C# using data from an original game installation. Its implemented features include 2D and 3D rendering, movement and environmental interaction in 2D areas, menus, inventory, dialogue and saves. Commands extract and repack game resources.
- [Ultima V Redux: recreating Ultima V from original game data](https://awesomerea.org/resources/ultima-v-redux-case/index.md): Case study · Ultima V Redux recreates Ultima V: Warriors of Destiny in Go using files from the player's MS-DOS PC copy. The engine adds modern presentation and a Debug Workbench, while companion guides describe game mechanics, compatibility formats and differences from the original.
- [Un-Banished: reconstructing the Banished engine in Rust](https://awesomerea.org/resources/un-banished-case/index.md): Case study · Un-Banished rebuilds the Banished 1.0.7 engine in Rust for desktop and browser play using data from the user's own game copy. Its documented process uses Ghidra pseudocode, emulated original functions and comparisons of the new code with original behavior. The engine also reads existing saves and BanishedKit .pkm mods; the author reports a beta with known differences.
- [Unciv: a Civilization V gameplay remake](https://awesomerea.org/resources/unciv-civ-v-case/index.md): Case study · Unciv recreates Civilization V gameplay as a moddable Android and desktop game built with LibGDX. Its roadmap identifies Gods & Kings and Brave New World mechanics that remain to be added.
- [Underworld Adventures: recreating Ultima Underworld I](https://awesomerea.org/resources/underworld-adventures-case/index.md): Case study · Underworld Adventures recreates Ultima Underworld I as a C++ engine for modern systems, loading the user's original game files. It uses OpenGL for 3D graphics, SDL2 for platform services and Lua for scripting, and includes documentation of Ultima Underworld I and II file formats.
- [Underworld Revisited: reimplementing Ultima Underworld in Unity](https://awesomerea.org/resources/underworld-revisited/index.md): Case study · Underworld Revisited reimplements Ultima Underworld: The Stygian Abyss (1992) in Unity. It reads the GOG or Steam copy. The checked GOG executable UW.EXE is 547,248 bytes. Windows releases are UnderworldRevisited-<version>-win64.zip and start with UR.exe. Linux releases since 0.3.0 are UnderworldRevisited-<version>-linux64.tar.gz and start with UR.x86_64. Saves use the installation folders UNDEROM1\SAVE1 through SAVE4.
- [Untangle: a browser rebuild from REA and Ghidra evidence](https://awesomerea.org/resources/untangle-rea-evidence-rebuild-case/index.md): Case study · An author-documented REA/Ghidra investigation of the shipped Untangle Windows binary produces a single-page playable rebuild and a claim-by-claim grading receipt. The report separates frozen findings, a later source-code answer key and a prior-knowledge audit.
- [vakfu: reconstructing Wakfu map rendering](https://awesomerea.org/resources/vakfu-case/index.md): Case study · vakfu reconstructs Wakfu's isometric map rendering in a Rust application that loads assets from the user's game copy. Its engine reference describes map chunks, sprite definitions, element ordering, lighting and binary fields, alongside gaps in the current implementation.
- [Vange-rs: reimplementing Vangers in Rust](https://awesomerea.org/resources/vange-rs-vangers-case/index.md): Case study · vange-rs reimplements Vangers in Rust with wgpu graphics, aiming to reproduce its worlds, vehicles and single-player behavior using original game resources. The repository includes a playable road binary, model and level viewers, resource conversion tools and technical notes on rendering and data formats.
- [Vault Engine: rebuilding Fallout and Fallout 2 in Rust](https://awesomerea.org/resources/vault-engine-case/index.md): Case study · Vault Engine reimplements Fallout and Fallout 2 as a Rust engine that reads the user's retail DAT archives. Its modules cover DAT formats, the INT script VM, combat, AI, saves and rendering, with behavior built from written clean-room specifications and checked through state hashes and trace oracles.
- [Vault13: a Rust reimplementation of the Fallout 2 engine](https://awesomerea.org/resources/vault13-fallout-2-case/index.md): Case study · Vault13 reimplements the Fallout 2 engine in Rust using files from a local game directory. Its source covers DAT archives, maps, graphics, inventory, dialogue and script execution, while the documented demo offers limited movement and display controls.
- [VCMI: recreating the Heroes of Might & Magic III engine](https://awesomerea.org/resources/vcmi-case/index.md): Case study · VCMI recreates the Heroes of Might & Magic III engine in C++ for playing the original game with an open-source runtime. The repository includes game logic, battle AI, a client and documentation for mods and supported game file formats.
- [VERA20K: rebuilding Red Alert 2: Yuri's Revenge in Rust](https://awesomerea.org/resources/vera20k-case/index.md): Case study · VERA20K rebuilds the Red Alert 2: Yuri's Revenge engine in Rust while reading the user's original game files. The project says coding agents study the original engine with Ghidra, implement its behavior in a new simulation and rendering architecture, and compare results with the original through tools and playtests.
- [Wacki: porting Wacki: Kosmiczna rozgrywka from decompiled code](https://awesomerea.org/resources/wacki-case/index.md): Case study · Wacki is a cross-platform port of Wacki: Kosmiczna rozgrywka (1998), reconstructed from the decompiled WACKI.EXE. The English portion of the README says it runs on macOS, Linux, Windows, Android, Miyoo and other PortMaster handhelds, and PlayStation 2.
- [wage-engine: a World Builder adventure engine reimplementation](https://awesomerea.org/resources/wage-world-builder-engine-case/index.md): Case study · wage-engine reimplements the World Builder engine for classic Mac graphic text adventures in Java. It loads Mac resource data for scenes, characters, objects, sound, and scripts, and converts script bytes into readable commands.
- [Wanderer: reimplementing Project Nomads](https://awesomerea.org/resources/wanderer-project-nomads-case/index.md): Case study · Wanderer reimplements the 2002 game Project Nomads in Java with libGDX, using assets from the original game. Its documented asset formats include models converted from Nebula NVX, textures converted from NTX, and animations converted from NAX; a story guide maps the original TCL scripts to JavaScript. The project aims to retain the original gameplay while fixing flaws.
- [War1: a C reimplementation of Warcraft: Orcs & Humans](https://awesomerea.org/resources/war1-warcraft-remake-case/index.md): Case study · War1 reimplements Warcraft: Orcs & Humans in C as an RTS engine that reads the original game's DATA.WAR assets. It implements unit movement and training, building construction, resource gathering, fog of war, spells and basic enemy behavior; AI, cinematics and save/load are still listed as unfinished.
- [War1gus: a Stratagus reimplementation of Warcraft: Orcs & Humans](https://awesomerea.org/resources/war1gus-case/index.md): Case study · War1gus reimplements Warcraft: Orcs & Humans for the Stratagus engine using graphics and sounds extracted from the user’s original game. Its scripts and campaigns support modern mouse controls, larger unit selections, additional multiplayer factions and a map editor.
- [Warsmash: reimplementing Warcraft III on LibGDX](https://awesomerea.org/resources/warsmash-warcraft-iii-case/index.md): Case study · Warsmash reimplements Warcraft III gameplay on LibGDX using assets from the user's own game installation. A configurable virtual file system reads MPQ archives, extracted folders, or CASC sources according to the installed patch, while Java source implements simulation, rendering, interface, and scripting components.
- [WebFun: reimplementing the Desktop Adventures game engine](https://awesomerea.org/resources/webfun-desktop-adventures-case/index.md): Case study · WebFun recreates the engine behind Indiana Jones and His Desktop Adventures and Yoda Stories as a web application. The project shows game play, mobile controls, save inspection, asset editing, debug overlays, and script coverage views.
- [Weltall: rebuilding Xenogears in Unreal Engine 5](https://awesomerea.org/resources/weltall-xenogears-case/index.md): Case study · Weltall rebuilds the PlayStation game Xenogears as a native Unreal Engine 5 port that reads content from the user's disc images. Its source implements field and battle rendering, game systems, input, saves, and disc-data handling. The author reports checking gameplay behavior against the original code and completing a playthrough of both discs.
- [widebrim: reimplementing the Professor Layton and Pandora's Box engine](https://awesomerea.org/resources/widebrim-case/index.md): Case study · widebrim recreates the Nintendo DS Layton 2 engine in Python and pygame, informed by decompilation research on the European Professor Layton and Pandora's Box release. It reads a user-provided ROM and implements game modes, puzzles and saves while documenting behavior it approximates or omits.
- [WinTex: an Under a Killing Moon engine reimplementation](https://awesomerea.org/resources/wintex-under-a-killing-moon-case/index.md): Case study · WinTex reimplements a Windows-native engine for Under a Killing Moon using files from the original game. Its C++ source reads game data, extracts graphics from AP resources and renders them with a DirectX-based interface; support for The Pandora Directive is planned.
- [wipEout Rewrite: reimplementing the 1995 PlayStation game](https://awesomerea.org/resources/wipeout-rewrite-case/index.md): Case study · wipEout Rewrite reimplements the 1995 PlayStation racing game in C. It provides SDL2 and Sokol platform backends, OpenGL and software rendering options, and expects original game textures and models to be supplied separately.
- [Wizardry 6: reconstructing game formats and systems](https://awesomerea.org/resources/wizardry-6-reconstruction-case/index.md): Case study · Wizardry 6 investigates the data formats and systems of Bane of the Cosmic Forge, with parsers and viewers for graphics, maps, scenario records, text and sound. It includes portrait and character-roster editors and a developing Python game engine that reads original game data.
- [wkbre2: recreating the Warrior Kings engine](https://awesomerea.org/resources/wkbre2-case/index.md): Case study · wkbre2 is an engine reimplementation for Warrior Kings and Warrior Kings Battles. It uses a client-server architecture and original game assets, and aims to load unit definitions and interpret gameplay scripts from the games' data.bcp archive. It supports Direct3D and OpenGL rendering and is in early development; it is not completely playable.
- [wkbre: reconstructing the Warrior Kings engine](https://awesomerea.org/resources/wkbre-case/index.md): Case study · wkbre reimplements the Warrior Kings and Warrior Kings: Battles engine to open original game data, load levels and render the world. Its current editor can modify savegames and terrain and create skirmish maps for the original engine; gameplay in the replacement engine remains under development.
- [Wolfenshine: reimplementing Wolfenstein 3D](https://awesomerea.org/resources/wolfenshine-case/index.md): Case study · Wolfenshine is a cross-platform C# reimplementation of Wolfenstein 3D. It reads the maps, artwork, music, and sounds from the player's copy and renders them with a .NET engine, including a 320 by 200 software renderer and an enhanced lighting mode toggled with F2.
- [Wolfenstein (2009) SP: reconstructing the single-player engine](https://awesomerea.org/resources/wolfenstein-2009-sp-case/index.md): Case study · Wolfenstein (2009) SP rebuilds single-player engine behavior in C++ on idTech4A++, using game data from the user's PC copy. It implements SP PK4, SPK and MPK readers and native tests for player, MP40, actor and trainyard behavior; research notes record findings from the original executables.
- [WoodyRE: reimplementing the Woody Woodpecker game engine](https://awesomerea.org/resources/woodyre/index.md): Case study · WoodyRE reimplements the engine of Woody Woodpecker: Escape from Buzz Buzzard Park, the 2001 PC game. It checks the player's CD against the English 1.00 release and also accepts the Spanish CD and three February 2002 discs. Releases cover Windows, Linux, Android 7.0 or later on 64-bit devices, and an experimental Switch build.
- [X-Settlers: reconstructing Settlers 3/4 maps and rendering](https://awesomerea.org/resources/x-settlers-case/index.md): Case study · X-Settlers is an early C++17 reimplementation effort for The Settlers 3/4 that renders map terrain and documents Settlers 3 map partitions. Its format notes identify map information, player and team data, previews, areas, buildings and resources. Loading graphics and maps directly from an original installation remains planned.
- [xoreos: an open reimplementation of BioWare’s Aurora engine family](https://awesomerea.org/resources/xoreos-aurora-engine-case/index.md): Case study · Reimplements BioWare’s Aurora engine and its later derivatives as a portable C++ engine that runs on the user’s installed game data, targeting nine games from Neverwinter Nights to Dragon Age II. Resource management, many Aurora file formats, graphics and sound are in place, and every target shows partial in-game areas in a free-flying spectator mode. README states that normal gameplay is not implemented yet.
- [XU4: a reconstruction of Ultima IV](https://awesomerea.org/resources/xu4-ultima-iv-case/index.md): Case study · XU4 recreates Ultima IV for modern systems while loading the original DOS game's data at runtime. Its implementation supports original EGA and upgraded VGA graphics, and its documentation maps file structures such as SHAPES.EGA.
- [YodaStoriesNG: rebuilding Yoda Stories and Indiana Jones from their data files](https://awesomerea.org/resources/yodastoriesng-case/index.md): Case study · YodaStoriesNG reimplements Star Wars: Yoda Stories and Indiana Jones and His Desktop Adventures in C# and SDL2 using each game's original data file. It parses tiles, zones, puzzles and IACT scripts, reconstructs world generation, and provides script disassembly and other inspection windows. The author reports complete Yoda Stories play and remaining Indiana Jones puzzle gaps.
- [z2rs: an incremental Rust reconstruction of Zelda II checked against an emulator](https://awesomerea.org/resources/z2rs-zelda2-reconstruction-case/index.md): Case study · Rebuilds Zelda II: The Adventure of Link (NES) in Rust for desktop, browser and Android by replacing the game’s 6502 routines one at a time. A built-in interpreter still runs the user’s ROM and hands ported routines to Rust, while a verifier compares RAM, sprites, palette and frames with a reference emulator. It is a behavioral, clean-room-style reconstruction guided by a community disassembly, with a standalone engine still in progress.
- [Zelda3: a C reimplementation of A Link to the Past](https://awesomerea.org/resources/zelda3-case/index.md): Case study · Zelda3 reimplements The Legend of Zelda: A Link to the Past in C, extracting levels and images from the user's US SNES ROM. It can run the original machine code beside the replacement and compare RAM state after each frame; the author reports that the game is playable from start to end.
- [Zeliard: DOS engine analysis and an SDL2 source port](https://awesomerea.org/resources/zeliard-dos-reconstruction-case/index.md): Case study · Reconstructs Zeliard's DOS engine and resource handling as documented C code and an SDL2 port that reads the user's original game files. Its tools extract SAR archives, decode compressed payloads and regenerate disassembly; technical notes map the boot chain, overlays and driver interfaces.
- [ZGloom: reimplementing the Amiga game Gloom](https://awesomerea.org/resources/zgloom/index.md): Case study · ZGloom reimplements the Amiga first-person game Gloom, including Zombie Massacre. Windows builds need the Visual Studio 2013 runtime. Linux builds use SDL2, SDL2_mixer, and libXMP.
- [ZT1-Engine: reconstructing Zoo Tycoon 1 from zoo.exe](https://awesomerea.org/resources/zt1-engine-case/index.md): Case study · ZT1-Engine reimplements Zoo Tycoon 1 for modern Windows by recovering game rules from zoo.exe and comparing behavior with the original. It reads art, sound, and other files from the player's installation and includes a lab for examining original addresses and execution traces. The author describes base-game freeform play as available in alpha, while expansion features and save parity remain incomplete.
- [2ooM: decoding Master of Orion II's LBX data for a remake](https://awesomerea.org/resources/2oom-master-of-orion-ii-case/index.md): Case study · 2ooM works toward a remake of Master of Orion II that runs on the original game's data files. Its liblbx library and the lbxtool and lbximg tools list and extract LBX archives and decode the game's multi-frame 256-colour LBX images to PNG, applying base palettes from fonts.lbx and override palettes for player colours, with an md5-based regression test against the original archives. Notes record the music format and map stream.lbx and streamhd.lbx entries to named tracks, and the engine repository holds a plugin-based skeleton with a virtual file system and SDL and FFmpeg modules.
- [A Link to the Past: an annotated US disassembly for Asar](https://awesomerea.org/resources/asar-us-alttp-disassembly-case/index.md): Case study · AsarUSALTTPDisassembly reorganizes and annotates assembly for the US SNES release of The Legend of Zelda: A Link to the Past. It adapts earlier disassembly work for Asar, adds labels, RAM maps and notes based on the author's research, and aims for an exact ROM rebuild once its build is complete.
- [accd: reconstructing the Assetto Corsa Competizione dedicated server](https://awesomerea.org/resources/accd-assetto-corsa-competizione-server-case/index.md): Case study · accd reconstructs the Assetto Corsa Competizione dedicated server in C99 for Linux and BSD systems. It accepts unmodified game clients and implements the observed connection handshake, session scheduling, car updates, results and telemetry messages. The repository includes server source and protocol validation tools.
- [ACEmulator: Asheron's Call server emulator](https://awesomerea.org/resources/acemulator-case/index.md): Case study · ACEmulator rebuilds the Asheron's Call MMORPG server in C#, aiming to reproduce the game world as it was when the official servers closed in January 2017. The source implements the client network protocol (packets, game actions, events and messages), physics, world objects and a loader for the client's .dat files, backed by MySQL or MariaDB. Server options switch individual retail behaviours, such as door holding and fast buffing, on or off.
- [AFS Volume 2.00 specification: reconstructing Tenchu archives](https://awesomerea.org/resources/afs200tools-case/index.md): Case study · AFS200Tools documents the AFS Volume 2.00 archive format found in PlayStation Tenchu games. It records the big-endian header, 36-byte file entries, file table placement and a tentative filename scheme, alongside C# source for handling volumes.
- [Afterhours 2015: Need for Speed online-service reconstruction](https://awesomerea.org/resources/afterhours-2015-case/index.md): Case study · Afterhours 2015 reconstructs online services for Need for Speed (2015) as a Rust server and local launcher. The workspace implements stream framing, tagged fields, typed backend and world messages, and content preparation from the player's installation; the author reports live checks for selected gameplay and garage flows.
- [agario-client: reconstructing the earlier agar.io client protocol](https://awesomerea.org/resources/agario-client-case/index.md): Case study · agario-client is a Node.js implementation of an earlier agar.io client protocol. It connects over WebSockets, parses game packets, and provides API methods for movement, spawning and spectating alongside events for ball-state changes. The author stopped development after a later game update changed the client implementation.
- [Aion 2: reconstruction of the client-to-server network protocol](https://awesomerea.org/resources/aion2-protocol-research-case/index.md): Case study · Aion 2 Network Protocol Research reconstructs parts of the game's client-to-server network protocol from captures and client inspection. It documents unsigned-varint framing, LZ4 bundles, an RSA-OAEP-SHA1 world handshake and continuous RC4 over post-handshake client frame bodies. Python tools analyze captures, recover session material and implement client cryptographic primitives.
- [alive-serv: reconstructing the SIF2 MIRACLE LIVE! server](https://awesomerea.org/resources/alive-serv-case/index.md): Case study · alive-serv reconstructs part of the SIF2 MIRACLE LIVE! game server in C from the global client's server protocol. Its four endpoints return an asset hash, initiate login, return a startup token and log client errors; the client can reach the title screen and part of login.
- [Alley Cat: an annotated DOS executable disassembly](https://awesomerea.org/resources/alley-cat-disassembly-case/index.md): Case study · Alley Cat Disassembly is an in-progress effort to turn the DOS game's Ghidra disassembly into annotated NASM x86 assembly. Its source is divided into gameplay, graphics, input, sound and data modules, and progress notes document the MZ header, segment mapping and address translation. The build compares the assembled output with the original cat.exe.
- [Alleyway: a checksum-matched Game Boy disassembly](https://awesomerea.org/resources/alleyway-gb-case/index.md): Case study · Alleyway reconstructs the 1989 Game Boy game as assembly source organized by audio, display, input, physics, and stage code. Its build script emits a 32 KiB ROM with published CRC32 and SHA-1 hashes, and accompanying notes identify unused routines and behaviors.
- [Another Life: reconstructing The Witcher 3 save state](https://awesomerea.org/resources/another-life-w3-case/index.md): Case study · Another Life reconstructs parts of The Witcher 3 Remastered save format and quest state to generate new saves from a player's story choices. Its Rust crates read and write the save container, variable table and token tree, then patch game facts, journal entries and quest graphs into a user-provided template save. The author reports limited successful in-game checks on patch 5.01.
- [Arkanum: reconstructing Arcanum archives and map sectors](https://awesomerea.org/resources/arkanum-arcanum-formats-case/index.md): Case study · Arkanum reconstructs Arcanum game data formats as part of a Python engine recreation. Its code reads and extracts DAT archives and parses map-sector structures including tiles, roofs, scripts and blocked-tile arrays, with field layouts recorded beside the parsers.