# Reverse-engineering case studies · Page 11

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

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

## Games (200)

- [rac1-native: porting Ratchet & Clank to PC](https://awesomerea.org/resources/rac1-native-case/index.md): Case study · rac1-native ports the PS2 game Ratchet & Clank to Linux, Windows, and Apple Silicon macOS. Setup extracts assets from the user's disc and translates much of the MIPS and vector-unit code into C++; the port also contains handwritten C++ and functions combining generated and handwritten code. Host code replaces PS2 hardware. An R5900 interpreter compares ported functions with original execution.
- [Rage Racer PC: a native port of the PAL PlayStation game](https://awesomerea.org/resources/rage-racer-pc-case/index.md): Case study · Rage Racer PC runs the PAL PlayStation release of Rage Racer as a native Windows, Linux and macOS game. Its C runtime imports models, textures and sky data from a user-supplied disc image and provides both a PS1-style classic renderer and a modern geometry renderer.
- [Raptor: porting a reconstructed Call of the Shadows codebase](https://awesomerea.org/resources/raptor-source-port-case/index.md): Case study · Raptor ports a reverse-engineered Raptor: Call of the Shadows codebase to modern desktop systems and Android. Its build uses CMake and SDL2, while the game loads GLB assets supplied from the player's own shareware or full version.
- [RatchetPort: a PS4 Ratchet & Clank runtime for Windows](https://awesomerea.org/resources/ratchetport-case/index.md): Case study · RatchetPort runs the PS4 version of Ratchet & Clank (2016), CUSA01047 USA v1.00, through a native Windows runtime derived from SpartanPort with shadPS4 rendering components. Its game-specific research identifies executable sites for timing, motion blur and resolution work. The author reports 30 FPS gameplay on one RTX 5070 Laptop configuration, while compatibility and long-session stability remain unresolved.
- [Rayverse: porting Rayman 1 from its disassembly](https://awesomerea.org/resources/rayverse-rayman-1-case/index.md): Case study · Rayverse ports Rayman 1 PC version 1.21 into a modern executable based on a disassembly of the original. Its C source and platform code target Windows, Linux and macOS as a replacement for RAYMAN.EXE.
- [Recharged: native PC port of Mario Strikers Charged](https://awesomerea.org/resources/recharged-strikers-case/index.md): Case study · Recharged compiles reconstructed source for Mario Strikers Charged into a native program for Windows, Linux, macOS, and Steam Deck. The README says the game's own code runs unchanged while Recharged supplies graphics, sound, controllers, disc access, and saves.
- [recvx-enhanced-port: enhanced native Resident Evil Code: Veronica X port](https://awesomerea.org/resources/recvx-enhanced-port/index.md): Case study · This is a native Linux and Windows port of the PlayStation 2 game Resident Evil Code: Veronica X, built from the recvx-decomp decompilation. It compiles the game code for the PC and reads an NTSC-U disc image, product SLUS-20184, in place. The renderer can go to 8x internal resolution while the game logic stays at 30 FPS. Two-player online co-op uses a lobby, join codes, and a small rendezvous server. recvx.exe or ./recvx starts a release. The Linux source build is a 32-bit Ninja build with cmake/linux-i686.cmake and needs OpenGL 3.3.
- [ReKHCoM: native ports of Kingdom Hearts: Chain of Memories](https://awesomerea.org/resources/rekhcom-case/index.md): Case study · ReKHCoM ports the decompiled Game Boy Advance code of Kingdom Hearts: Chain of Memories to native and browser runtimes. It supplies rendering, audio, a launcher, widescreen options, and support for European, US, and Japanese cartridge dumps.
- [ReMech2: rebuilding MechWarrior 2 from decompiled code and original game data](https://awesomerea.org/resources/remech2-mechwarrior-2-case/index.md): Case study · ReMech2 rebuilds MechWarrior 2: 31st Century Combat for Windows and Linux using a Rust runtime and decompiled C/C++ game code from the related demech2 project. It loads data from the user's original disc or installation and adds modern input, audio, rendering and widescreen support.
- [ReNFS: rebuilding The Need for Speed Special Edition](https://awesomerea.org/resources/renfs-case/index.md): Case study · ReNFS rebuilds the 1996 DOS release of The Need for Speed Special Edition as a native C and SDL2 game for Linux, Windows and macOS. The author studied NFS_DOS.EXE with Ghidra, rewrote routines by hand and compared racing, physics, rendering and replay behavior with the original. The port reads game tables and assets from the user's own Special Edition CD.
- [ReRAC: porting Ratchet & Clank to PC](https://awesomerea.org/resources/rerac-case/index.md): Case study · ReRAC ports the 2002 PlayStation 2 Ratchet & Clank to a native PC application using data read from the player's original disc. Its launcher prepares the game and starts it. The project reports that its early alpha covers four planets, player movement, weapons, saving, travel, and cutscenes.
- [reUndr: a PS5 port of Need for Speed: Underground](https://awesomerea.org/resources/reundr-ps5-case/index.md): Case study · reUndr ports the original Xbox Need for Speed: Underground to homebrew-enabled PS5 consoles using an existing static recompilation and a PS5 replacement runtime for graphics, audio, input, and system services. It imports game data from the user's USA Xbox disc image.
- [Reuromancer: porting Neuromancer to 64-bit Windows](https://awesomerea.org/resources/reuromancer-case/index.md): Case study · Reuromancer ports the MS-DOS game Neuromancer to 64-bit Windows. Its engine uses reverse-engineered game routines and adapted disassembled code, while a separate resource browser examines and exports resources from the game's DAT files. Running the port requires the user's own DOS game data.
- [ROLLER: reconstructing Whiplash/Fatal Racing for modern PCs](https://awesomerea.org/resources/roller-whiplash-case/index.md): Case study · ROLLER aims to reimplement the functionality of the 1995 game Whiplash/Fatal Racing for modern PCs. Its C implementation substitutes DOS-specific functions with SDL and Windows or Unix equivalents, and its documentation records symbol and executable analysis used during reconstruction.
- [Rosebed: porting Minecraft Beta 1.7.3 to Zig](https://awesomerea.org/resources/rosebed-minecraft-beta-case/index.md): Case study · Rosebed ports decompiled Minecraft Beta 1.7.3 source to Zig as a client and dedicated server. The author reports matching game behavior, seeded worlds and multiplayer compatibility with the original. Builds are described for desktop, browser, Android and iOS, with original game assets fetched separately.
- [rr-pc-port: reconstructing a playable Ridge Racer race on PC](https://awesomerea.org/resources/rr-pc-port-case/index.md): Case study · rr-pc-port reconstructs a playable PC race slice of the 1994 PlayStation Ridge Racer by re-expressing game logic in portable C. It ports selected functions and fixed-point driving behavior, reads course and resource data from the user's local game files, and renders through an optional SDL2 host. Its roadmap separates confirmed behavior from documented approximations.
- [Salamander UEFI: a disassembly-based UEFI port of the NES game](https://awesomerea.org/resources/salamander-uefi-case/index.md): Case study · Salamander UEFI ports the NES game Salamander to a native UEFI Shell application by translating its 6502 disassembly into a platform-independent C core. The repository includes a 6502 disassembler, a user-ROM resource extractor, host tests and a fidelity checklist. UEFI GOP, input and timing services replace the original console environment.
- [Scooby-Doo! Mystery Mayhem: a Rust and Bevy PS2 game port](https://awesomerea.org/resources/scooby-doo-mystery-mayhem-pc-case/index.md): Case study · Scooby-Doo! Mystery Mayhem is a Rust and Bevy PC port of the PlayStation 2 game, built from reverse-engineered engine and game-logic modules. It loads levels, media and module data at runtime from the owner's ISO, with notes tracing MIPS module behavior and engine interfaces.
- [SF33RDSXBRecompo: an Xbox 3rd Strike native port](https://awesomerea.org/resources/sf33rdsxbrecompo-case/index.md): Case study · SF33RDSXBRecompo ports the Xbox version of Street Fighter III: 3rd Strike to Windows, Linux and Android using C game logic from 3s-decomp-ogxb. It replaces Xbox services with SDL3, Vulkan or OpenGL, OpenAL and SQLite, while importing game archives and sound banks from the player's disc.
- [Shadow of the Colossus — native Windows port of the PS4 game](https://awesomerea.org/resources/shadow-of-the-colossus-oussama-pc-case/index.md): Case study · Shadow of the Colossus runs the PS4 game's x86-64 code directly on Windows 10/11 while translating its graphics to Vulkan. This port supports the named EU 1.01 and US 1.00 releases, loads a user-provided game dump, and implements the system functions the game needs.
- [Shadow of the Colossus: running the PS4 game natively on Windows](https://awesomerea.org/resources/shadow-of-the-colossus-pc-case/index.md): Case study · Shadow of the Colossus-PC runs the PS4 version of Shadow of the Colossus on Windows 10 and 11 using the user's game dump. Its loader runs the game's x86-64 code on the host CPU, supplies needed PS4 system functions and translates graphics to Vulkan. The author reports playing from the last colossus through the ending and credits.
- [Shinobi Legions: Saturn code analysis and PC port](https://awesomerea.org/resources/shinobi-legions-saturn-pc-port-case/index.md): Case study · Reconstructs Shinobi Legions for PC from analysis of its Sega Saturn SH-2 code and disc formats. A C11 and SDL2 port rewrites game functions while retaining the original memory layout; the author reports that the title, 18 stages, bosses, and ending run using files extracted from the user's disc.
- [Ship of Harkinian: a native Ocarina of Time port built on the decompilation](https://awesomerea.org/resources/ship-of-harkinian-oot-port-case/index.md): Case study · Builds Ocarina of Time as a native PC application from the OoT decompilation’s source, with libultraship standing in for the N64 libultra SDK and DirectX 11, OpenGL or Metal rendering. No game assets are shipped: they are converted from the user’s supported ROM into an .o2r archive, and the port adds save states, alternate and custom assets and other enhancements.
- [Sightline: a native GoldenEye 007 engine port](https://awesomerea.org/resources/sightline-goldeneye-port-case/index.md): Case study · Sightline ports the GoldenEye 007 Nintendo 64 decompilation to a native Windows executable with a platform layer and OpenGL renderer. It reads game content from the user's USA ROM and retains a matching build and per-tick trace harness for checking changes to game logic.
- [Silent Engine: porting the original Silent Hill from decompiled code](https://awesomerea.org/resources/silent-engine-case/index.md): Case study · Silent Engine ports the original Silent Hill to a cross-platform C++ engine using logic migrated from a decompilation of the PlayStation game. It includes format loaders, asset streaming and a launcher that extracts original assets from the user's compatible ROM. Boot, video playback and some menus are partially functional.
- [Skate 3 Port: an Android ARM64 static recompilation port](https://awesomerea.org/resources/skate-3-port-android-case/index.md): Case study · Skate 3 Port adapts an Xbox 360 Skate 3 static recompilation to Android ARM64, linking the translated PowerPC game code against a Vulkan runtime. Its Android launcher validates and extracts a player's ISO, while the fork adds touch controls, graphics settings and runtime changes. The project is experimental, with visual bugs, missing effects and device-specific performance issues listed as expected limitations.
- [SkiFree SDL: an SDL2 port of decompiled SkiFree](https://awesomerea.org/resources/skifree-sdl-case/index.md): Case study · SkiFree SDL adapts an existing decompilation of the Microsoft Entertainment Pack game SkiFree into a cross-platform SDL2 source port. It contains the C source and CMake build files, while the player supplies original graphics and icon resources for the build.
- [skynet-godot: porting SkyNET and Future Shock to Godot](https://awesomerea.org/resources/skynet-godot-case/index.md): Case study · skynet-godot ports the 1996 XnGine shooters SkyNET and Future Shock to a rewritten Godot 4 engine. It decodes BSA archives, WLD heightmaps, textures, maps and audio from the player's installations, while DOS executable disassembly informs movers, weapons, AI and mission behavior. The author reports bounded campaign and deathmatch support.
- [Sly 2: Bevy of Thieves — a partial Rust and Bevy port](https://awesomerea.org/resources/sly-2-bevy-of-thieves-case/index.md): Case study · Sly 2: Bevy of Thieves ports Sly 2: Band of Thieves logic function by function into Rust and Bevy, replacing PS2 hardware services with native systems. It reads levels and media from the user's disc image; the archived build loads early episode hubs but cannot be played start to finish.
- [sm-3ds: a Nintendo 3DS port of Super Metroid](https://awesomerea.org/resources/sm-3ds-port-case/index.md): Case study · sm-3ds ports a Super Metroid PC reconstruction to Nintendo 3DS using native source, devkitARM, and SDL2. It builds against a user-supplied sm.smc ROM; the author reports about 50 FPS on hardware and unresolved hardware save support.
- [SM64 Scratch: rebuilding selected Super Mario 64 gameplay in Scratch](https://awesomerea.org/resources/sm64-scratch-case/index.md): Case study · SM64 Scratch builds a playable Scratch version of selected Super Mario 64 scenes from a user's USA ROM. Python decoders reconstruct textures, models, animations, collisions, and audio using recorded ROM offsets and conversion recipes; Scratch block patches implement gameplay based on the public decompilation. The initial beta includes the castle grounds, part of the castle interior, and Bob-omb Battlefield.
- [sm64-gba: Super Mario 64 movement and collision on GBA](https://awesomerea.org/resources/sm64-gba-physics-port-case/index.md): Case study · sm64-gba ports Super Mario 64 movement and collision code to Game Boy Advance and adds a software-rendered playable demo. Its harness compares Mario's state frame by frame with an unmodified decompilation; the author reports bit-for-bit matches in emulator tests.
- [sm64ex: an enhanced Super Mario 64 PC port from the decompilation](https://awesomerea.org/resources/sm64ex-pc-port-case/index.md): Case study · Builds native Super Mario 64 executables from decompiled source, extending the sm64-port fork of the n64decomp reconstruction with renderer, input, camera, save-format and external-data options. Game assets are extracted from the user’s own ROM at build time. It is an enhanced native port.
- [sm64synth: Rust port of the Super Mario 64 audio engine](https://awesomerea.org/resources/sm64synth-case/index.md): Case study · sm64synth ports the reconstructed Super Mario 64 audio engine to Rust as a reference implementation. Its music player and WAV renderer use sound assets extracted from a compatible game ROM; the implementation is based on the European version.
- [Smash 64 DS Port: bringing Super Smash Bros. 64 logic to Nintendo DS](https://awesomerea.org/resources/smash-64-ds-port-case/index.md): Case study · Smash 64 DS Port brings reconstructed Super Smash Bros. 64 game logic from BattleShip to a Nintendo DS backend. Its build checks a user-provided North American ROM, regenerates assets locally, and produces a DS game image; the author reports playable campaign and local four-fighter matches, with performance and feature gaps.
- [SMG-3DS: an unfinished Super Mario Galaxy port to New 3DS](https://awesomerea.org/resources/smg-new-3ds-native-port-case/index.md): Case study · SMG-3DS ports Super Mario Galaxy to New 3DS by compiling Petari's decompiled game code and implementing the Wii interfaces it calls. The port translates GX graphics to PICA200 and runs the Wii audio DSP in software. The author reports playable but slow hardware performance, and the project is archived.
- [SMW: a PS4 port of Super Mario Bros. Wonder](https://awesomerea.org/resources/smw-ps4-case/index.md): Case study · SMW brings BelmanteGu's static recompilation of Super Mario Bros. Wonder to jailbroken PS4 consoles. The game's ARM code was translated to C++ ahead of time and compiled for the PS4 CPU, and its NVN graphics run on Vulkan through Mesa's RADV driver.
- [Snipes: porting the 1982 DOS game from its executable](https://awesomerea.org/resources/snipes-dos-port-case/index.md): Case study · Snipes ports the 1982 DOS text-mode game from reverse-engineered executable code to modern C++ builds. It offers SDL and Windows console front ends and adds replay recording and playback. The author reports identical game logic to the original.
- [SOCOM Legacy: a browser reconstruction of SOCOM II](https://awesomerea.org/resources/socom-legacy-case/index.md): Case study · SOCOM Legacy rebuilds SOCOM II U.S. Navy SEALs in TypeScript and three.js for browser multiplayer, loading maps and other game data from the user's own disc. The project records values read from disc data and game code, and tracks parity for menus, online flow, maps, and matches while its multiplayer implementation continues to develop.
- [Sonic 1 C Port: reconstructing Mega Drive game code in C](https://awesomerea.org/resources/sonic-1-c-port-case/index.md): Case study · Sonic 1 C Port translates Sonic the Hedgehog revision 1 code from a Mega Drive ROM into C, then manually repairs generated control flow. A Rust runner and Speedshoes emulation framework compare C-side game state with the original and support instruction-level accuracy checks.
- [Sonic CD 2011: an RSDKv3 Dreamcast port](https://awesomerea.org/resources/sonic-cd-dreamcast-port-case/index.md): Case study · Sonic CD 2011 for SEGA Dreamcast ports the reconstructed RSDKv3 engine to Dreamcast with platform-specific graphics, audio, input, saving and video code. It converts selected audio assets from a user-provided mobile Data.rsdk while leaving other game data in the archive.
- [soniccdrespinned: a cross-platform Sonic CD port built on the decompiled code](https://awesomerea.org/resources/soniccdrespinned-case/index.md): Case study · soniccdrespinned is a cross-platform port of Sonic CD that runs the decompiled stage, special-stage, time-warp and title-screen code on a newly written platform layer. That layer decompresses the original SZDD-packed CMP sprite and tile bitmaps, streams ADX music from the US or Japanese AFS soundtrack, and renders through SDL 1.2 or SDL2, with PC and PSP input backends.
- [SoulCalibur Vita: running the Android game on PS Vita](https://awesomerea.org/resources/soulcalibur-vita-case/index.md): Case study · SoulCalibur Vita adapts the Android version of SoulCalibur to PS Vita by loading its ARMv7 executable into memory, resolving imports with native functions and patching behavior needed for the port. The repository contains the loader and Android compatibility implementations, while installation uses the player's APK and OBB files.
- [Space Rangers HD — Free Pascal Port: adapting recovered Delphi source](https://awesomerea.org/resources/space-rangers-hd-free-pascal-port-case/index.md): Case study · Space Rangers HD — Free Pascal Port adapts recovered Delphi source for Space Rangers HD: A War Apart to Free Pascal. It documents compatibility changes for Delphi arithmetic, floating-point and control-flow behavior and targets desktop, mobile, browser and Switch platforms using player-supplied game data.
- [SpaghettiKart: a native Mario Kart 64 port built on decompiled source](https://awesomerea.org/resources/spaghettikart-mk64-port-case/index.md): Case study · Builds a native Mario Kart 64 port for Windows, Linux, macOS and Switch from source that keeps the Mario Kart 64 decompilation’s file layout, running on libultraship’s reimplemented N64 SDK. Its bundled Torch extractor converts the user’s US ROM into an asset archive, and the port adds mods, custom tracks and an editor. The README does not name its upstream decompilation, and no matching or fidelity checks are published.
- [SpaghettiKart: an Android port of Mario Kart 64](https://awesomerea.org/resources/spaghettikart-android-case/index.md): Case study · SpaghettiKart's Android fork brings Mario Kart 64 to Android. Its app validates a user-provided US ROM and extracts an mk64.o2r archive on the device; the repository includes Android launcher, input and touch-control code.
- [SpaghettiPad: Mario Kart 64 iOS port integration](https://awesomerea.org/resources/spaghettipad-mario-kart-64-ios-case/index.md): Case study · SpaghettiPad adapts the decompilation-based SpaghettiKart port of Mario Kart 64 for iPhone and iPad. Its mobile integration adds Metal rendering, analog touch steering, Bluetooth controller routing, game-data import and optional texture-pack loading. Builds require the player's supported US 1.0 ROM.
- [SpartanPort: a native PC port of God of War III Remastered](https://awesomerea.org/resources/spartanport-case/index.md): Case study · SpartanPort ports the PS4 release of God of War III Remastered to Windows and Linux using the player's own game dump. It runs the game's x86-64 code through a native runtime, uses Vulkan graphics components and includes a loader that rewrites selected instructions for CPUs lacking MOVBE, BMI1 or LZCNT.
- [SpyroEngine: a native PC port of the PlayStation Spyro trilogy](https://awesomerea.org/resources/spyroengine-trilogy-case/index.md): Case study · SpyroEngine ports the original PlayStation Spyro trilogy to PC with title-specific native subsystems and psxport's Lightrec executor for remaining MIPS code. It authenticates each player's game executable before running it, and records per-title progress on presentation, terrain and gameplay paths.
- [SSB-X: a Super Smash Bros. port for the original Xbox](https://awesomerea.org/resources/ssb-x-super-smash-bros-xbox-port-case/index.md): Case study · SSB-X ports the N64 Super Smash Bros. to the original Xbox using an existing Dreamcast port's game code. It reimplements the Dreamcast port's PowerVR, AICA, controller, storage and threading services on Xbox hardware, while generating game content from the user's US ROM during the build.
- [ssb64-dc: porting Super Smash Bros. to Dreamcast](https://awesomerea.org/resources/ssb64-dc-dreamcast-port-case/index.md): Case study · ssb64-dc ports the N64 Super Smash Bros. decompilation to Sega Dreamcast. It replaces N64 graphics, audio, and memory paths with Dreamcast implementations, while build tools convert assets from the user's US ROM. The author describes the port as playable but still affected by minor visual issues.
- [Star Fox 64: Dreamcast port](https://awesomerea.org/resources/sf64-dc-case/index.md): Case study · This is a Sega Dreamcast port of Star Fox 64, based on sonicdcer/sf64. The player builds a CDI from their own Nintendo 64 ROM. The README says it is intended for real Dreamcast hardware, with VMU saving when a VMU is present.
- [Star Fox Enhanced: an SDL3 port of reconstructed Star Fox code](https://awesomerea.org/resources/star-fox-enhanced-case/index.md): Case study · Star Fox Enhanced ports UltraStarFox to a native C++ and SDL3 program for Star Fox and Star Fox EX. It separates fixed game simulation from presentation frame rate and reconstructs runtime assets locally from supported retail ROM revisions supplied by the player.
- [Star Haven: a native 3DS port of Paper Mario](https://awesomerea.org/resources/starhaven-case/index.md): Case study · Star Haven is a native Nintendo 3DS port of Paper Mario for the Nintendo 64, built from the pmret/papermario decompilation. The game's own C code runs on the 3DS.
- [Starship: a Star Fox 64 PC port built from the decompilation](https://awesomerea.org/resources/starship-sf64-pc-port-case/index.md): Case study · A native PC port of Star Fox 64 that compiles the game's decompiled C code against libultraship, an N64 porting library that reimplements libultra and renders through Fast3D. On first run it uses the Torch tool to turn the user's US ROM into an asset archive, and it ships for Windows, Linux, macOS and Switch. The README of the separate Starfox 64: Recompiled static recompilation calls this port its sibling, built with different technology.
- [StarshipPad: bringing the Star Fox 64 source port to iOS](https://awesomerea.org/resources/starshippad-case/index.md): Case study · StarshipPad adapts the decompilation-based Star Fox 64 source port Starship into an iPhone and iPad application. Its maintained patches and build scripts add Metal rendering, touch flight controls, controller handling and local ROM import through Files.
- [Starwing 3DS: a Nintendo 3DS adaptation of Star Fox](https://awesomerea.org/resources/starwing-3ds-case/index.md): Case study · Starwing 3DS ports the reconstructed Star Fox / Starwing engine to Nintendo 3DS with dual-screen presentation, console input, SPC audio and local processing of a user-supplied SNES ROM. It builds on Starfox Enhanced and related reconstruction work; the author describes the release as experimental.
- [Street Rod Enhanced: an SDL3 port with a new road view](https://awesomerea.org/resources/street-rod-enhanced-case/index.md): Case study · Street Rod Enhanced ports the reconstructed Street Rod engine to SDL3 and adds a road view drawn at the display refresh rate with higher resolution and antialiasing. The engine retains the original garage, opponents, physics and screens, while the new renderer covers races and drives through town.
- [Strikers: a native port of Super Mario Strikers](https://awesomerea.org/resources/strikers/index.md): Case study · Strikers is a native port of Super Mario Strikers built on Yannick Suter's decompilation. It runs on Windows, Linux, macOS, Steam Deck, and Nintendo Switch. One executable covers the US, European, and Japanese discs and loads ISO, GCM, CISO, GCZ, or an extracted folder. Graphics go through Metal, Vulkan, or Direct3D 12 via Aurora. Build steps are on the project wiki.
- [sundog: reconstructing SunDog's p-system runtime](https://awesomerea.org/resources/sundog-frozen-legacy-case/index.md): Case study · sundog ports the Atari ST game SunDog: Frozen Legacy to modern platforms by implementing its UCSD Pascal p-system interpreter in C. It runs the original p-code from the player's disk image, reimplements graphics assembly routines and uses SDL2 and OpenGL ES for host input and display.
- [Super Mario 64: a PlayStation port of reconstructed game source](https://awesomerea.org/resources/sm64-psx-port-case/index.md): Case study · sm64-psx ports reconstructed Super Mario 64 source to the original PlayStation. It replaces floating-point-heavy paths with fixed-point math, translates RSP display lists into a PSX-oriented format and converts textures, while extracting required assets from a user-provided US ROM.
- [Super Mario All-Stars: a ROM-based Windows and Android port](https://awesomerea.org/resources/super-mario-all-stars-pc-port-case/index.md): Case study · Super Mario All-Stars runs from the user's SNES ROM in a Windows and Android port with its own SNES runtime and game-specific extensions. The repository documents reverse-engineering findings for the included Mario games, including RAM fields, code banks and checks made with traces, memory watches and save states.
- [Super Mario Bros.: an Atari Lynx port from NES disassembly](https://awesomerea.org/resources/super-mario-bros-lynx-port-case/index.md): Case study · The Super Mario Bros. Atari Lynx port adapts the NES game's 6502 logic to the Lynx 65C02 using a complete disassembly. Adapter code maps NES tile rendering to Suzy sprites, APU output to Mikey audio, and controller input to the Lynx joypad; artwork and level data are extracted from the user's ROM at build time.
- [Super Mario Sunshine: a native PC port from an AI-assisted decompilation](https://awesomerea.org/resources/sms-pc-port-case/index.md): Case study · Builds a native PC port of Super Mario Sunshine’s North American release from a pinned matching-decompilation fork, adding a host platform layer for graphics, disc, audio, input and OS services. The fork’s README says AI was used extensively to reconstruct and match its code; the port documents scripted regression hashes and lockstep comparisons with retail captures. Functions that do not yet match can still behave differently from retail, and the game must come from the user’s own disc image.
- [Super Mario Sunshine: a PAL native PC port with Aurora rendering](https://awesomerea.org/resources/super-mario-sunshine-pal-aurora-port-case/index.md): Case study · Super Mario Sunshine PAL PC port compiles the GMSP01 decompilation for native Windows and replaces GameCube platform services with host implementations. Its Aurora bridge renders GX through WebGPU on Direct3D or Vulkan, and the project adds widescreen, 60 fps, configurable controls and optional mod support.
- [Super Mario Sunshine: a PS5 port of the decompiled game](https://awesomerea.org/resources/ps5-sunshine-case/index.md): Case study · PS5_Sunshine adapts the decompilation-based Super Mario Sunshine PC port to PlayStation 5 with platform code, SDL drivers and build patches. It compiles game code for the console and reads models, levels, sound and movies from the user's North American disc image.
- [Super Mario Sunshine: an Android port of the decompiled game](https://awesomerea.org/resources/sms-android-port-case/index.md): Case study · sms-android ports Super Mario Sunshine to native ARM64 Android using decompiled game source, OpenGL ES 3.0, and SDL2 input. It reads a user-provided USA GameCube GMSE01 ISO and adds on-screen touch controls alongside USB and Bluetooth gamepad support.
- [Super Metroid: a C# translation and playable port](https://awesomerea.org/resources/super-metroid-csharp-port-case/index.md): Case study · A C# translation of Super Metroid implements the game's movement, combat, rooms, menus, rendering and audio. The Windows application extracts required resources from the user's Japan/USA NTSC v1.0 ROM, while original addresses and regression tests guide behavioral comparison. The author reports that it is playable from beginning to end.
- [Super Monkey Ball 2 Sakura Edition Vita: an Android game port](https://awesomerea.org/resources/super-monkey-ball-2-sakura-edition-vita-case/index.md): Case study · Super Monkey Ball 2 Sakura Edition Vita runs the Android game on PS Vita by loading its ARMv7 executable, resolving imports with native functions and applying platform patches. The setup uses the player's APK and downloaded cache files from versions released before the game became free to play.
- [SwitchWaker: a native port of The Wind Waker from decompiled source](https://awesomerea.org/resources/switchwaker-case/index.md): Case study · SwitchWaker ports the GameCube game The Wind Waker to Mac, Linux and Switch by compiling imported decompiled source and running it through a new platform layer with Aurora rendering. Build scripts generate required asset headers from a user's GZLE01 or GZLP01 revision 0 disc.
- [SwitchWakerHD: a Nintendo Switch port of the Wind Waker HD recompilation](https://awesomerea.org/resources/switchwakerhd-switch-port-case/index.md): Case study · Ports the ZeldaWWHDRecomp static recompilation of The Wind Waker HD to the Nintendo Switch as homebrew, adding a libnx platform layer and a renderer that draws the game’s GX2 graphics with deko3d, with translated shaders compiled on the console by uam. Game code is recompiled locally from the user’s own Wii U dump, so no Switch binaries are released. README reports the game playable handheld and docked at stock clocks, at 26–30 fps in its own measurements, and states that nearly all of the Switch work was written by Claude Code under human direction and hardware testing.
- [Swordigo Vita: an Android executable port to PS Vita](https://awesomerea.org/resources/swordigo-vita-case/index.md): Case study · Swordigo Vita runs the Android ARMv7 build of Swordigo on PS Vita by loading its executable, resolving imports with native functions and applying patches. Users provide the Android APK and extract the required executable and assets.
- [swos-port: a DOS Sensible World of Soccer port with recorded behaviour checks](https://awesomerea.org/resources/swos-port-case/index.md): Case study · swos-port adapts the DOS Sensible World of Soccer 96/97 to C++ and SDL. It combines generated translations of original assembly routines with rewritten systems and compares port state frame by frame against recordings from the DOS game.
- [Tactical-Retreat: rebuilding Counter-Strike 1.5 gameplay in QuakeC](https://awesomerea.org/resources/tactical-retreat-case/index.md): Case study · Tactical-Retreat rebuilds Counter-Strike 1.5 game logic for the QuakeC-based Rad-Therapy and FTEQW stack. Its entity notes map hostage, bomb, buy-zone and other CS behaviors to source implementations, while original game data is supplied separately.
- [Test Drive Enhanced: an SDL3 port of the 1987 game](https://awesomerea.org/resources/test-drive-enhanced-case/index.md): Case study · Test Drive Enhanced ports the 1987 DOS game to SDL3 using the author's C reimplementation of its driving simulation and game flow. Its engine notes link that implementation to reverse-engineering specifications and disassembly of TDEGA.EXE; this version adds higher-resolution road rendering and optional elements from the Amiga release.
- [Test Drive III Enhanced: an SDL3 port of the reconstructed racing game](https://awesomerea.org/resources/test-drive-iii-enhanced-case/index.md): Case study · Test Drive III Enhanced ports a reconstructed Test Drive III: The Passion engine to a native SDL3 program. It keeps a faithful game core while adding smoother high-resolution rendering, longer draw distance, steering changes and a launcher. The program loads the player's original executable and data files.
- [Test Drive III: The Passion: a reverse-engineered SDL3 port](https://awesomerea.org/resources/test-drive-iii-sdl3-case/index.md): Case study · Test Drive III: The Passion is reconstructed in C as an SDL3 port that reads the player's original DOS game files. The project documents recovered functions and resource formats, including pictures, 3D objects, maps, and sound. Its VGA version covers the cars, courses, menus, traffic, replay, results, and scores; several original graphics and sound modes remain outside the port.
- [Test Drive SDL3: reconstructing the DOS and Amiga game ports](https://awesomerea.org/resources/test-drive-sdl3-case/index.md): Case study · Test Drive SDL3 ports the DOS EGA, CGA and Hercules versions and the Amiga version of the 1987 game to native SDL3 programs. Reverse-engineering specifications cover game flow, simulation, rendering and platform behavior, while a separate document covers file formats. The ports read user-supplied original game files.
- [th06-headless: deterministic Touhou 6 logic runtime](https://awesomerea.org/resources/th06-headless-case/index.md): Case study · th06-headless adapts reconstructed Touhou 6 game logic into a deterministic Linux runtime for replay and learning research. It removes window, audio and frame-pacing requirements, accepts seeded per-tick actions, exports JSONL state, and offers a lockstep observation/action interface. The fork builds on GensokyoClub/th06 and uses the user's original Japanese game data.
- [th06-sdl2: porting Touhou Koumakyou to SDL2](https://awesomerea.org/resources/th06-sdl2/index.md): Case study · th06-sdl2 is a cross-platform port of Touhou Koumakyou, the Embodiment of Scarlet Devil, version 1.02h, built on the happyhavoc/th06 reconstruction. Direct3D 8 and the Win32 window and audio stack are replaced with SDL2. Renderers are desktop OpenGL, OpenGL ES 2.0, and an optional Vulkan backend. The README says the project is archived.
- [TH08 Web: a WebAssembly port built from reconstructed source](https://awesomerea.org/resources/th08-web-wasm-port-case/index.md): Case study · Compiles the reconstructed C++ source of the Japanese Touhou 8 1.00d release to WebAssembly with Emscripten, adding WebGL 2 rendering, Web Audio, browser input and IndexedDB saves behind the game’s D3D8-, DirectSound- and DirectInput-shaped interfaces. Players select their own retail DAT files locally. The web build is a separate port from the curated TH08 reconstruction.
- [The Hobbit, native: a routine-by-routine C port of the ZX Spectrum game](https://awesomerea.org/resources/hobbit-1982-native-case/index.md): Case study · The Hobbit, native ports the 1982 ZX Spectrum game to C one Z80 routine at a time, guided by an annotated SkoolKit disassembly. It provides a faithful version preserving register and memory behavior plus a separate edition that fixes identified bugs, with a reference runner that compares routine effects and transcripts against the original.
- [The Last Guardian: a native PC port of the PS4 executable](https://awesomerea.org/resources/the-last-guardian-pc-port-case/index.md): Case study · The Last Guardian PC port runs the PS4 game's original executable as native CPU code while replacing PS4 system services and translating graphics to Vulkan. Its loader and runtime use a user-provided dump of the game and update 01.03; an optional library from the user's console firmware supplies audio. The author reports playable Linux sessions, while Windows gameplay remains untested.
- [The Last Guardian: a Windows port through PS4 compatibility layers](https://awesomerea.org/resources/tlg-port-case/index.md): Case study · TLG-Port runs The Last Guardian's PS4 executable on Windows through game-specific replacements for PS4 system libraries. It executes the game's x86-64 instructions on the host CPU and maps graphics commands to Vulkan while converting shaders to SPIR-V during play.
- [The Legend of Zelda: The Minish Cap — a native PC port](https://awesomerea.org/resources/tmc-pc/index.md): Case study · This is a native PC port of The Legend of Zelda: The Minish Cap for x86-64 Linux, Windows, and macOS. It uses SDL3, the ViruaPPU software renderer, and agbplay. The USA ROM baserom.gba has SHA-1 b4bd50e4131b027c334547b4524e2dbbd4227130. The EU ROM baserom_eu.gba has SHA-1 cff199b36ff173fb6faf152653d1bccf87c26fb7. Prebuilt archives are named tmc-usa-{linux,windows,macos}-<version>.tar.gz and are published from 999sian/tmc. A Switch build is in platforms/switch.
- [The Minish Cap: a native PC port of the GBA decompilation](https://awesomerea.org/resources/minish-cap-pc-port-case/index.md): Case study · The Minish Cap PC port compiles the GBA game's recovered C source for Linux, Windows and macOS. It replaces GBA hardware with SDL3, a software PPU renderer and agbplay audio, extracts assets from the user's ROM, and currently supports the USA and EU releases for native play.
- [The Order: 1886: a native PC runtime for the PS4 game](https://awesomerea.org/resources/the-order-1886-pc-port-case/index.md): Case study · The Order: 1886 PC port runs the user's PS4 game executable natively on a Windows x86-64 processor through replacement system libraries. It uses the shadPS4 video core to translate PS4 GPU commands and shaders to Vulkan; the author reports reaching a rendered prologue with CUSA00035 version 01.02.
- [The Simpsons Game — Android Evolved: an ARM64 recompilation port](https://awesomerea.org/resources/the-simpsons-game-android-recomp-case/index.md): Case study · The Simpsons Game — Android Evolved ports statically recompiled Xbox 360 game code to Android ARM64 using ReXGlue, SDL3 and Vulkan 1.1. It adds Android launcher and touch controls, renderer adjustments and diagnostic tools. The author reports reaching the title screen and animated introduction on a Galaxy S25 Ultra.
- [The Simpsons: Hit & Run: an Android port with native touch controls](https://awesomerea.org/resources/simpsons-hit-and-run-android-case/index.md): Case study · The Simpsons: Hit & Run Android adapts an earlier Switch and PS Vita port of the game for Android. It adds native touch controls and an in-game control-layout editor, supports external controllers, and loads assets supplied from the player's PC copy.
- [The Witcher 3: bounded native function recovery for ARM64](https://awesomerea.org/resources/witcher-3-native-research-case/index.md): Case study · The Witcher 3 native research recovers selected vector, VM, and decoder functions from The Witcher 3: Wild Hunt for ARM64 port experiments. Ghidra helpers extract references, while C models and harnesses compare x64 and ARM64 behavior; the author reports checks of 21 small function bodies and no complete engine or playable port.
- [Thimbleweed Park Vita: an Android executable port to PS Vita](https://awesomerea.org/resources/thimbleweed-park-vita-case/index.md): Case study · Thimbleweed Park Vita runs the Android ARMv7 build of Thimbleweed Park on PS Vita by loading its executable, resolving Android imports to native functions and applying runtime patches. Users provide the game's APK and OBB files.
- [TMNF Android native port: reconstructing TrackMania Nations Forever for Android](https://awesomerea.org/resources/tmnationsdecomp-case/index.md): Case study · TMNF reconstructs parts of TrackMania Nations Forever 2.11.11 as a native Android 15 game using behavior and data recovered from the Windows executable. Its C++ core reads GBX and NadeoPak files, rebuilds campaign tracks and collision scenes, and drives vehicle simulation and a recovered camera from user-supplied game data.
- [tmnt-recomp: porting the NES Teenage Mutant Ninja Turtles game to C](https://awesomerea.org/resources/tmnt-recomp-case/index.md): Case study · tmnt-recomp ports the 1989 NES Teenage Mutant Ninja Turtles game to C from analysis of its 6502 code. It loads a user-provided European or American ROM at runtime, implements game logic and needed NES hardware behavior, and compares recorded runs with emulator traces.
- [Tomodachi Native: running Tomodachi Life on Apple Silicon](https://awesomerea.org/resources/tomodachi-native-case/index.md): Case study · Tomodachi Native adapts nxnative to run the Switch game Tomodachi Life: Living the Dream on Apple Silicon Macs and iPads. It rewrites selected ARM64 instructions, supplies Switch system services and translates NVN graphics to Metal 4 using a game-specific profile. The author reports that early island and Mii creation scenes work on Mac.
- [TonyWasAProSkater: a THPS1 native port forked from a matching decompilation](https://awesomerea.org/resources/thps1-decomp-native-port-case/index.md): Case study · Ports Tony Hawk’s Pro Skater (PlayStation, USA) to native Windows and Linux builds from a fork of an in-progress matching decompilation of the retail executable. The decompilation recompiles reconstructed functions with a Psy-Q toolchain and compares them byte for byte with the user’s retail executable, while the port replaces PlayStation hardware and libraries with SDL2 and OpenGL services. Play needs the user’s own disc image; matching and gameplay results remain project-reported.
- [Touhou 11: a C++ and WebAssembly reconstruction of Subterranean Animism](https://awesomerea.org/resources/touhou-11-web-reimplementation-case/index.md): Case study · th11 reconstructs the Japanese 1.00a release of Touhou 11: Subterranean Animism in named C++ and runs it in browsers through WebAssembly, SDL3, and WebGL2. Its documentation reports comparing gameplay state and original replays across fixed samples; players assemble a runnable package locally from game files they may use.
- [Touhou Reiiden: a C# port built around original PC-98 game data](https://awesomerea.org/resources/touhou-reiiden-port-case/index.md): Case study · Touhou Reiiden is a C# and .NET 8 port of the 1997 PC-98 game that loads assets from the user's own disk image or game folder. It rebuilds stages, bosses, menus, scoring, and audio, using ReC98 as a behavioral and file-format reference and measurements of the original for selected boss sequences.
- [tp-vita: porting Twilight Princess to PS Vita](https://awesomerea.org/resources/tp-vita-case/index.md): Case study · tp-vita ports Dusklight's GameCube Twilight Princess code to PS Vita by compiling the game and JSystem sources for ARM. It retains Aurora's GX command processor and adds a vitaGL GLES2 renderer. The author reports a VPK that boots and renders in Vita3K; audio is disabled, and a memory-card prompt blocks progress past file select.
- [Twilight Princess PC Port: an early port of the GameCube decompilation](https://awesomerea.org/resources/twilight-princess-pc-port-mbayonal-case/index.md): Case study · Twilight Princess PC Port adapts the zeldaret Twilight Princess decompilation to PC and is developing a bridge from GameCube GX graphics to Aurora. Its source initializes heap, video, controller and process systems, while asset loading, scene creation and gameplay rendering remain unfinished.
- [Twilight Princess VR: porting the game to Apple Vision Pro](https://awesomerea.org/resources/tpvr-visionos-case/index.md): Case study · Twilight Princess VR ports The Legend of Zelda: Twilight Princess to Apple Vision Pro using Dusklight's decompilation-based PC version and the TPVR mod. Its visionOS app runs the game framework with immersive, portal and window views, and loads a disc image supplied by the user.
- [UGH!: a C++ port of the 1992 DOS game](https://awesomerea.org/resources/ugh-port-case/index.md): Case study · UGH! ports the 1992 DOS game routine by routine from analysis of UGH.EXE into C++23 and SDL 3. It reads graphics, levels and sound from the user's executable, models VGA Mode X behavior and ports the AdLib driver. Project guidance records use of a REA plugin with Ghidra during analysis.
- [Ultima IV: a matching Master System rebuild and PC port](https://awesomerea.org/resources/ultima-iv-sms-recompiled-case/index.md): Case study · Rebuilds the Sega Master System version of Ultima IV: Quest of the Avatar from a disassembly and ports its routines to native C for PC. The ROM build is checked byte for byte against a user-supplied release, while shadow execution compares C rewrites with the original code's state and can also compare timing.
- [Uncharted Collection PC: running the PS4 trilogy on Windows](https://awesomerea.org/resources/uncharted-collection-zorde23-case/index.md): Case study · Uncharted Collection PC runs the PS4 Uncharted trilogy on Windows by executing the original x86-64 game code over replacement PS4 system libraries and a Vulkan graphics layer. The fork adapts a pre-existing runtime to the collection and documents game-specific fixes, controls and remaining performance issues.
- [Uncharted: The Nathan Drake Collection — a native Windows port of the PS4 games](https://awesomerea.org/resources/uncharted-nathan-drake-collection-supermedo-case/index.md): Case study · This Windows port runs the original PS4 code of Uncharted: The Nathan Drake Collection on a PC and translates its graphics to Vulkan. A launcher selects among the three games, using a user-provided decrypted collection dump; the port builds on bbport and a shadPS4-derived renderer.
- [unturned-godot: porting Unturned maps and gameplay to Godot](https://awesomerea.org/resources/unturned-godot-case/index.md): Case study · unturned-godot ports Unturned map content and selected gameplay to Godot 4.7 with C# readers for the game's serialized data. It loads terrain, objects, foliage, roads, audio and characters from a Steam installation, with movement, zombies and multiplayer at an experimental stage.
- [Vagrant Story Native: a Windows source port of the PlayStation game](https://awesomerea.org/resources/vagrant-story-native-case/index.md): Case study · Vagrant Story Native ports the PlayStation release of Vagrant Story to Windows x64 in C++. It adapts prior decompilation work into native game systems, converts data from the user's disc, and documents remaining engine and content gaps.
- [Valiant Hearts Vita: rehosting the Android game on PS Vita](https://awesomerea.org/resources/valiant-hearts-vita-case/index.md): Case study · Valiant Hearts Vita runs the Android release of Valiant Hearts: The Great War on PS Vita by loading its ARMv7 executable into memory. The loader resolves imports with native functions and patches the program for the Vita environment. Users provide the executable extracted from their own APK and the game's OBB file.
- [Vandal Hearts: native PC port built on matching decompilations](https://awesomerea.org/resources/vandal-hearts-pc-port-case/index.md): Case study · Builds on shao113’s matching decompilation of PlayStation Vandal Hearts, adds a Japanese matching tree, and carries both through to a native Windows and Linux port. SDL2, OpenGL or Metal and OpenAL backends replace the console’s GPU, GTE, CD-ROM/XA, SPU, MDEC and pad interfaces, and one executable runs the USA, Asia and Japan discs. The matching builds are still checked on every change; PC-only features such as Tactical Mode and HD packs are opt-in.
- [Verdite1: porting the Japanese King's Field to PC and Android](https://awesomerea.org/resources/verdite1-case/index.md): Case study · Verdite1 ports the Japanese PlayStation release of King's Field to Windows, Linux, and Android as native C/C++ built from an existing decompilation and King's Field Enhanced. It reads a user-provided SLPS-00017 disc image and adds widescreen display, keyboard and mouse controls, rendering changes, and mod support.
- [Vigilante8-xport: a PlayStation decompilation port](https://awesomerea.org/resources/vigilante-8-xport-case/index.md): Case study · Vigilante8-xport reconstructs routines from the PlayStation game Vigilante 8 in C for a native port. Its startup code loads the original SLUS_005.10 boot image and BIOS, mounts a disc image, and connects game routines to PlayStation runtime services.
- [WHITE ALBUM 2: an Apple port of a reconstructed game engine](https://awesomerea.org/resources/white-album-2-apple-port-case/index.md): Case study · The WHITE ALBUM 2 Apple port adapts a Godot 4 .NET reimplementation of the game's engine for iPhone, iPad, Vision Pro, Apple TV, and Apple silicon Macs. It adds platform input and performance work, reads scripts and media from the user's PC copy, and includes an ASF/WMV playback extension.
- [Wind Waker HD for PlayStation 5: a port of ZeldaWWHDRecomp](https://awesomerea.org/resources/ps5-wind-waker-hd-case/index.md): Case study · Wind Waker HD for PlayStation 5 ports ZeldaWWHDRecomp to a homebrew-enabled PS5, compiling Wii U PowerPC code from the user's dump and drawing GX2 graphics through the recompilation's Vulkan renderer on RADV. The author reports reaching the first island after the prologue on one console; later areas remain unmeasured.
- [WindowWaker: a Windows port of The Wind Waker from decompiled code](https://awesomerea.org/resources/windowwaker-port-case/index.md): Case study · WindowWaker builds a native Windows port of The Legend of Zelda: The Wind Waker from a community decompilation of the USA GameCube release. The fork adds a Windows build and presentation interpolation for 60 and 120 FPS while game simulation remains at 30 Hz; the build generates asset headers from the user's disc image.
- [WinWar: rewriting Warcraft: Orcs & Humans with original game data](https://awesomerea.org/resources/winwar-case/index.md): Case study · WinWar rewrites Warcraft: Orcs & Humans as a C# and MonoGame desktop port for Windows, Linux and macOS. It loads the original game's WAR art and level files from a user-supplied retail or demo copy. The project is archived.
- [WipEout Omega Collection: a native PS4 game port for PC](https://awesomerea.org/resources/wipeout-omega-collection-pc-case/index.md): Case study · wipeout_pc runs WipEout Omega Collection's original PS4 x86-64 code on PC with a replacement system runtime and shadPS4-derived Vulkan graphics core. It documents executable preparation, import mapping and game profiles by title ID; one executable runs WipEout HD, Fury and 2048 using files from the user's own PS4 dump.
- [World of Goo Vita: rehosting the Android game on PS Vita](https://awesomerea.org/resources/world-of-goo-vita-case/index.md): Case study · World of Goo Vita runs the Android version of World of Goo on PS Vita by loading its ARMv7 library into memory, replacing Android imports with native functions and applying runtime patches. The loader uses the user's own paid Android game files, including libworldofgoo.so and asset folders.
- [World of Kartcraft: porting Crash Team Racing physics into WoW](https://awesomerea.org/resources/world-of-kartcraft-case/index.md): Case study · World of Kartcraft ports Crash Team Racing's driving model, read from a decompilation, into a Rust World of Warcraft 1.12.1 client. It recreates kart handling, powerslides and boosts in Azeroth while setup extracts kart data from the user's CTR disc and reads a separate WoW installation. The project documents the physics port and the resulting multiplayer kart systems.
- [Zelda: The Wand of Gamelon: a Windows port of decompiled CD-i code](https://awesomerea.org/resources/zelda-wand-of-gamelon-pc-case/index.md): Case study · The Zelda: The Wand of Gamelon PC port runs the CD-i game's decompiled C code natively on Windows. An SDL3-based layer replaces video, audio, disc and input hardware behavior while loading game data from the user's own disc image. The port supports five regional releases.
- [Zombies Ate My Neighbors: a ROM-checked C port](https://awesomerea.org/resources/zombies-ate-my-neighbors-pc-port-case/index.md): Case study · The Zombies Ate My Neighbors PC Port rewrites the SNES game's logic in C and checks it against execution of the user's original ROM. An in-tree tracer produces code/data logs and memory maps, while a co-simulation harness compares port behavior with the reference core; the port also adds widescreen display and controller options.
- [ZumaTAS: a JavaScript port of Zuma Deluxe and search-generated TAS](https://awesomerea.org/resources/zuma-deluxe-tas-case/index.md): Case study · ZumaTAS ports Zuma Deluxe game logic from the CircleShootApp decompilation into a deterministic JavaScript simulation for browser and Node.js use. It includes asset extraction from a user's game installation, a replay viewer, search programs, and recorded tool-assisted play through all 76 Adventure levels. The author reports an 8:12 total for the published run.
- [1oom: Master of Orion engine recreation](https://awesomerea.org/resources/1oom-case/index.md): Case study · 1oom recreates the Master of Orion (1993) game engine using LBX files from version 1.3 of the original game. It includes a classic interface, a command-line interface, LBX viewing and editing utilities, and converters for graphics and saved games.
- [Abyss Engine: clean-room Diablo 2 engine](https://awesomerea.org/resources/abyss-engine/index.md): Case study · Abyss Engine is a clean-room reimplementation of the Diablo 2 engine in C, aimed at a portable base that can be modded. The README says it uses no original game code and will not be compatible with the original save files or multiplayer systems.
- [Abyssal: a Godot engine for DEEP using the player's JAR](https://awesomerea.org/resources/abyssal-deep-case/index.md): Case study · Abyssal reimplements the mobile game DEEP in a Godot engine for desktop, browser and Android. It converts a player-provided MIDlet JAR locally, decoding resources and evaluating selected class-file data tables to supply the engine. The implementation covers submarine piloting, stations, trading, missions and combat.
- [AgainROM: a new engine for Rage of Mages](https://awesomerea.org/resources/againrom-rage-of-mages-case/index.md): Case study · AgainROM reimplements the Rage of Mages engine in Go to run the original campaign on Windows, macOS and Linux. It loads the user's RES archives, graphics, audio, movies and saves, and includes a map editor; research notes document recovered resource formats and known behavior differences.
- [Age of Empires Free Software Remake: a re-implementation on the original data](https://awesomerea.org/resources/aoe-free-software-remake-case/index.md): Case study · Re-implements Microsoft’s Age of Empires and its Rise of Rome expansion as a cross-platform C++17 engine on SDL2 and OpenGL that loads the original game’s DRS archives and language.dll resources. README says it mimics the Windows API and the Genie engine for compatibility and reconstructs some code from the disassembly; the repository adds format notes and Python tools for inspecting the original data files. Only very basic gameplay through a multiplayer session exists so far, so it is an early engine case rather than a playable replacement.
- [Angelica Wardrobe: rebuilding Perfect World's fashion window](https://awesomerea.org/resources/angelica-wardrobe-case/index.md): Case study · Rebuilds the Vietnamese Perfect World client's fashion collection window as a standalone 3D app. Python readers decode package, mesh, skeleton, animation and UI formats; the project also recreates face morphing, body-shape rules and shaders identified in the client's x86 code. It generates assets locally from the user's game client.
- [Angry Birds PC engine: reimplementing the game engine from executable analysis](https://awesomerea.org/resources/angry-birds-pc-engine-case/index.md): Case study · Angry Birds PC engine reimplements the game's native engine in C++ from analysis of the 1.6.2 executable. It hosts the user's original Lua scripts and data with SDL2, OpenGL, Lua 5.1 and Box2D, covering menus, levels, physics, rendering and audio across several Angry Birds PC releases.
- [Another World Suite: a WebAssembly engine and debugger](https://awesomerea.org/resources/another-world-suite-case/index.md): Case study · Another World Suite implements the Another World game engine in Rust and compiles it to WebAssembly for browser use. Its frontend includes a debugger with thread and register views, plus resource views for scripts, bitmaps, palettes and sounds.
- [Arcanum: a Unity engine reimplementation on the original game data](https://awesomerea.org/resources/arcanum-unity-reimplementation-case/index.md): Case study · Arcanum — Unity Reimplementation rebuilds the engine of Arcanum: Of Steamworks and Magick Obscura in Unity 6 while reading data from the user's game installation. Its C# readers cover archives, art, dialog and other formats, and its notes describe the original engine's systems and behavior. The playable systems remain partial.
- [ash: reimplementing a Dark Souls slice for PSP](https://awesomerea.org/resources/ash-dark-souls-case/index.md): Case study · ash reimplements a limited Dark Souls: Remastered experience in a C99 engine for Sony PSP hardware. Local converters prepare models, animations and parameters from the user's game copy; the engine provides combat, rendering and AI bytecode execution. The author reports playing from the Northern Undead Asylum to Firelink Shrine on a PSP Street E1000.
- [Azel: reverse engineering Panzer Dragoon Saga into native C++](https://awesomerea.org/resources/azel-panzer-dragoon-saga-reimplementation-case/index.md): Case study · Reconstructs the Sega Saturn RPG Panzer Dragoon Saga as native C++, rewriting the game’s SH-2 routines for its kernel, field, town, battle, menu and audio systems. The rewritten code loads the user’s original disc files and reads their tables by Saturn address, rendering through bgfx and SDL with ImGui debugging views. README calls the project very early: the opening is semi-playable, with bugs, up to the Arachnoth battle, and no byte-matching rebuild is attempted.
- [BaK GL: rebuilding Betrayal at Krondor mechanics](https://awesomerea.org/resources/bakgl-case/index.md): Case study · BaKGL reimplements Betrayal at Krondor in a C++ and OpenGL engine built around original game data. It reconstructs exploration, quests, shops, inventory and other mechanics, includes resource explorers and an image extractor, and allows replacement textures. Combat remains in progress.
- [BaK-Again: reconstructing Betrayal at Krondor](https://awesomerea.org/resources/bak-again-case/index.md): Case study · BaK-Again rebuilds Betrayal at Krondor in Unity, loading story, world, rules and art from the player's installed game. It includes .NET data libraries, Kaitai specifications for game formats and tests; the author reports that every chapter can be played to its end.
- [Ballanced: reimplementing the Ballance runtime](https://awesomerea.org/resources/ballanced/index.md): Case study · Ballanced is a source-level reimplementation of the Ballance runtime. It rebuilds the player, engine libraries, building blocks, and plugins into a Ballance-compatible directory layout. The documented runtime is the cross-platform SDL3 build on the sdl branch.
- [Battalion Wars 2: a Rust and Bevy engine reconstruction](https://awesomerea.org/resources/battalion-wars-2-rust-decomp-case/index.md): Case study · Battalion Wars 2 is reconstructed as a native Rust and Bevy engine that loads archives, models, terrain, audio and Lua 5.0 mission bytecode from a user-supplied Wii disc image. The project documents PowerPC main.dol analysis used to implement native Lua bindings. The author reports playable campaign and multiplayer maps while listing remaining physics, AI and shader parity work.
- [Bayshore: a Wangan Midnight Maximum Tune 6 server reimplementation](https://awesomerea.org/resources/bayshore/index.md): Case study · Bayshore is a TypeScript server reimplementation of Wangan Midnight Maximum Tune 6. The README says it is part of Project Asakura.
- [BelthasarProject: reimplementing the Chrono Trigger engine](https://awesomerea.org/resources/belthasar/index.md): Case study · BelthasarProject reimplements Chrono Trigger for the SNES, USA 1995, as a portable C engine. The dump is a headerless 4,194,304-byte ROM, SHA-1 de5822f4f2f7a55acb8926d4c0eaa63d5d989312. The README says the title, a new game, the field, battles, menus, the overworld, and the music run on the C engine. A full playthrough remains unverified. Optional mods add widescreen and frame rates above 60.
- [Benilla-Wotlk: reconstructing the World of Warcraft 3.3.5a client](https://awesomerea.org/resources/benilla-wotlk-case/index.md): Case study · Benilla-Wotlk reconstructs the World of Warcraft 3.3.5a client in Rust and Bevy, using the original client as a behavioral reference and loading assets from the user's installation. It implements MPQ, BLP and world-format readers, FrameXML and Lua interfaces, and the game's authentication and world-session communication.
- [benilla: reconstructing the World of Warcraft 1.12.1 client](https://awesomerea.org/resources/benilla-wow-client-case/index.md): Case study · benilla reconstructs the World of Warcraft 1.12.1 client in Rust and Bevy, drawing on reverse-engineering findings from benilla-re. It reads MPQ archives and game assets from the user's installation, implements the original server protocol, and runs the stock FrameXML and Lua interface with addons.
- [Benno4j: reconstructing a game world from GAM saves and BSH graphics](https://awesomerea.org/resources/benno4j-game-world-case/index.md): Case study · Benno4j reconstructs a game world in Java from original save and graphics files for the NINA and History Edition versions. Its readers parse GAM save chunks for islands and ships and BSH image files for rendering; the interface includes ship movement and pathfinding.
- [Bermuda Syndrome: an engine rebuilt from the Windows executable](https://awesomerea.org/resources/bermuda-syndrome-engine-case/index.md): Case study · bermuda reimplements the Bermuda Syndrome game engine in C++ from analysis of the original Windows executable. It loads the player's retail or demo data files and provides SDL-based play, saves, optional soundtrack playback and display controls.
- [Blues Brothers: rewritten engines for three Titus games](https://awesomerea.org/resources/blues-brothers-engine-case/index.md): Case study · blues rewrites the engines of Blues Brothers and Blues Brothers: Jukebox Adventure in C, with support for Prehistorik 2. It loads original Amiga or DOS data files and adds horizontal scrolling and configurable screen size.
- [Bravo: a reverse-engineered Minecraft server](https://awesomerea.org/resources/bravo-minecraft-server-case/index.md): Case study · Reimplements the server side of Minecraft’s Alpha- and Beta-era multiplayer in Python on Twisted; its documentation calls it a reverse-engineered implementation written from scratch, credits network traffic dumps and says general Minecraft data went to a community wiki. The final 2.0 release speaks the 1.4.x client protocol for login, chunk transfer, entities, server-side inventories, lighting, physics and Anvil saves, while deliberately changing behaviour such as chunk loading and item stacking. A pluggable architecture adds terrain generation, seasons and commands, and small scripts inspect packets, NBT and region files.
- [BreadFlowerDos: reimplementing the Refractor 2 game engine](https://awesomerea.org/resources/breadflowerdos/index.md): Case study · BreadFlowerDos is a modern C++ recreation of the Refractor 2 engine, focused on Battlefield 2 and Battlefield 2142. The README says it reimplements functionality rather than matching the original binaries.
- [Brickwork: a DX-Ball-inspired browser game from REA and Ghidra findings](https://awesomerea.org/resources/brickwork-case/index.md): Case study · Brickwork is a browser brick-breaker reconstructed from the author's REA and Ghidra study of DX-Ball's Windows executable and asset formats. Its TypeScript engine uses HTML5 Canvas and WebAudio for gameplay, procedural graphics and sound, with a board editor and mobile mode.
- [BrightEyes: recreating Realms of Arkania games](https://awesomerea.org/resources/brighteyes-case/index.md): Case study · BrightEyes reverse engineers MS-DOS-era games and aims to recreate them for modern platforms. It began with Realms of Arkania: Blade of Destiny, and the repository contains C, C++, assembly and build files.
- [Bully Decompiled: an Unreal reconstruction of Bully: Scholarship Edition](https://awesomerea.org/resources/rea-bully-case/index.md): Case study · Rea Bully studies Bully: Scholarship Edition's executable, Lua 5.0 scripts, and asset formats with REA, Ghidra, and local recovery tools, then builds an Unreal Engine 5.8 exploration runtime from those findings. The author reports a Windows developer preview with 85 assembled zones across 47 areas, sampled traversal checks, and selected characters and interactions.
- [bully-re: reconstructing the Bully: Scholarship Edition engine](https://awesomerea.org/resources/bully-re-case/index.md): Case study · bully-re reimplements the PC engine of Bully: Scholarship Edition from analysis of its executable. The C++ code and technical notes cover RTTI-derived classes, Lua API bindings, action-tree AI and loaders for original game files, with host tests comparing parsed values against the user's copy.
- [Butterscotch: rebuilding the GameMaker: Studio runner](https://awesomerea.org/resources/butterscotch-case/index.md): Case study · Butterscotch reimplements the GameMaker: Studio runner in C so exported games can execute on additional platforms. It interprets GameMaker bytecode and documents support for WAD versions 8 through 17, with desktop, web, and console targets. Bytecode support remains in progress, and native-code YYC and GMRT games are outside its stated scope.
- [Cadence: reimplementing Geometry Dash 2.2091 in Rust](https://awesomerea.org/resources/cadence-geometry-dash-case/index.md): Case study · Cadence reimplements Geometry Dash 2.2091 in Rust for desktop and browser play using the user's game resources. Its notes record binary analysis, level-data study and runtime traces; comparison tools check physics and camera behavior against the original. The author reports step-by-step position and velocity matches on 135 recorded runs, while the project remains in early development.
- [Carnage3D: open-source remake of Grand Theft Auto 1](https://awesomerea.org/resources/carnage3d/index.md): Case study · Carnage3D is an open-source remake of Grand Theft Auto 1. The README describes the project as an early stage and links a WebAssembly build tested in Chrome 85 and Firefox 81, both 64-bit. The Linux build instructions use clang and name GLEW, GLM, Mesa, X11, and OpenAL development packages.
- [Castlekeep: a Stronghold 1 engine reimplementation](https://awesomerea.org/resources/castlekeep-stronghold-case/index.md): Case study · Castlekeep reimplements Stronghold 1 as a C++ game engine. Its code initializes a world, loads assets, generates terrain and renders it through an SDL2 platform layer and OpenGL renderer.
- [Chariot: Age of Empires engine reimplementation](https://awesomerea.org/resources/chariot/index.md): Case study · Chariot is an open-source effort to reimplement the engine of the original Age of Empires (1997). It aims to support ports and enhancements; the README describes it as a work in progress with asset-loading demonstrations, not a playable game.
- [Chicken Invaders 1: rebuilding the 1999 game](https://awesomerea.org/resources/chicken-invaders-1-case/index.md): Case study · Chicken Invaders 1 rebuilds the original 1999 game in C++ with a separate UveDX engine layer. Its reverse-engineering notes cover game classes, scoring and file formats, while the author reports that the current build is playable despite remaining bugs and decompiled variable names.
- [Chocolate Strife: reconstructing Strife from its DOS executable](https://awesomerea.org/resources/chocolate-strife-case/index.md): Case study · Chocolate Strife recreates Strife: Quest for the Sigil within Chocolate Doom from analysis of the original DOS executable. Its authors disassembled and decompiled the executable, compared findings with released Doom and Heretic source, and implemented compatible behavior in the port.
- [Chronon: reimplementing Anachronox on Quake 2](https://awesomerea.org/resources/chronon-case/index.md): Case study · Chronon is an open-source reimplementation of Anachronox on the Quake 2 engine. The README says the work follows public documentation and observation, and that nothing is playable yet.
- [Chronoshift: incrementally rebuilding Command & Conquer: Red Alert](https://awesomerea.org/resources/chronoshift-red-alert-case/index.md): Case study · Chronoshift incrementally reimplements Command & Conquer: Red Alert in C++. Its launcher and DLL supply rewritten game functions while the original executable supplies functions still pending, so the current build targets the English 3.03 beta patch.
- [ChronoStorm: reimplementing the Red Alert 2 and Yuri’s Revenge engines](https://awesomerea.org/resources/chronostorm/index.md): Case study · ChronoStorm reimplements the engines of Command & Conquer: Red Alert 2 and Yuri's Revenge in Python and Pygame. It extracts MIX archives and renders SHP sprites and VXL voxels. Map parsing and the isometric grid are still open.
- [Chuckie Egg: a BBC game logic reconstruction](https://awesomerea.org/resources/chuckie-egg-bbc-recreation-case/index.md): Case study · Chuckie Egg is recreated in C with level loading, player movement, ducks, lifts, scoring, and rendering backends. A companion offset map records original game-state fields such as player coordinates, level timers, and duck state.
- [ClassiCube: a clean-room reconstruction of Minecraft Classic](https://awesomerea.org/resources/classicube-case/index.md): Case study · ClassiCube recreates the 2009 Minecraft Classic client in C through a documented clean-room reverse-engineering approach. It supports single-player and compatible multiplayer play across desktop, mobile, browser and several console platforms, with optional custom blocks, models and environment colors.
- [Clone Dash: rebuilding Muse Dash gameplay](https://awesomerea.org/resources/clone-dash-case/index.md): Case study · Clone Dash rebuilds Muse Dash's rhythm gameplay in a cross-platform C# game engine and loads levels from the player's Steam installation. It provides the core play loop and supports custom albums in the .mdm format, while the author describes the project as a beta vertical slice.
- [CoD4 Rewrite: Rust/Bevy reconstruction](https://awesomerea.org/resources/cod4-rewrite-reconstruction-case/index.md): Case study · A Rust/Bevy reconstruction of Call of Duty 4 multiplayer systems, using assets from a local game installation. Source covers menus, local bots, movement and combat, and connects custom relay-based netplay to the game.
- [Command Series engine: playing Atari strategy games from disk images](https://awesomerea.org/resources/command-series-engine-case/index.md): Case study · Command Series engine recreates play for MicroProse's Crusade in Europe, Decision in the Desert and Conflict in Vietnam using the user's Atari ATR disk image. Its Go code includes game rules and interface modules, plus tools for disk reading, map and image extraction and disassembly. Music, sound, intros, endings and some visual effects are listed as missing.
- [Commander Genius: Commander Keen game interpreter](https://awesomerea.org/resources/commander-genius-case/index.md): Case study · Commander Genius reimplements an interpreter for Commander Keen 1–6 and Keen Dreams in C++, using the original games' data files to run their gameplay on modern systems. It also includes partial support for Cosmo's Cosmic Adventure, alongside SDL 2.0, Lua mod support, and multiplayer features.
- [Coney: reimplementing The Warriors](https://awesomerea.org/resources/coney/index.md): Case study · Coney reimplements The Warriors (2005) in C++ for Windows, Linux, and macOS. The PlayStation 2 version is the reference for how the game plays, and the Xbox port is a second source for rendering and assets. With a disc it plays the startup movies and the front end, and runs levels as far as the missions page records.
- [CorsixTH: an open reimplementation of Theme Hospital](https://awesomerea.org/resources/corsixth-engine-case/index.md): Case study · Reimplements the engine of Bullfrog’s 1997 Theme Hospital, with game logic in Lua and C++ for graphics, sound, movies and pathfinding, on top of the original game’s data files. The README reports that the full campaign can be completed, lists features that are still missing, and adds extensions such as high resolutions and a map editor. It recreates the game’s behaviour on original content.
- [Cosmo-Engine: a replacement engine for Cosmo's Cosmic Adventure](https://awesomerea.org/resources/cosmo-engine-cosmic-adventure-case/index.md): Case study · Cosmo-Engine supplies a C engine for playing Cosmo's Cosmic Adventure using a copy of the original game. Its source includes game, actor, map, file, video and audio components, with CMake builds using SDL2 and SDL_mixer.
- [CR1:U: a reconstructed Chaos Rings engine for original game data](https://awesomerea.org/resources/cr1-u-chaos-rings-case/index.md): Case study · CR1:U reimplements Chaos Rings as a native C++ engine using behavior and format findings from the iPad HD release. It loads original iOS, Android or Vita data from the user's copy and includes parsers for archives, events, models, textures, audio and saves.
- [Cranked: reconstructing the Playdate runtime](https://awesomerea.org/resources/cranked-playdate-case/index.md): Case study · Cranked reconstructs a runtime for Playdate console games by emulating its ARM processor with Unicorn and implementing the Playdate API across native, Lua and C++ calls. Development compares program execution with the official simulator, and the emulator accepts .pdx directories or .pdx.zip archives. The author reports compatibility mainly with SDK demos so far.
- [CroftEngine: reimplementing the first Tomb Raider engine](https://awesomerea.org/resources/croftengine/index.md): Case study · CroftEngine is an open-source engine for the first Tomb Raider. It reads data from an original installation, and the README points soundtrack files at opentomb.earvillage.net. Releases include a Windows installer, and openSUSE packages it in the Games repository. A setup assistant starts from Beta 15 when files are missing. Windows builds use vcpkg and CMake. The listed packages include boost, glfw3, libpng, openal-soft, OpenGL, freetype, ffmpeg, utfcpp, gettext tools, libarchive, and libjpeg-turbo. git submodule update --init --recursive is required first.
- [CrossCraft: a Zig reconstruction of Minecraft Classic 0.30](https://awesomerea.org/resources/crosscraft-case/index.md): Case study · CrossCraft reconstructs Minecraft Classic 0.30 as a Zig client and server on the Aether engine. Shared code covers world generation, physics, saves and networking, and the project documents independent reverse engineering behind its compatible network protocol. It uses original or third-party licensed assets.
- [Crusader: No Remorse — a C++ engine reimplementation](https://awesomerea.org/resources/crusader-no-remorse-decomp-case/index.md): Case study · Crusader: No Remorse — DECOMP reimplements the 1995 game's engine in C++20 and SDL2 for Windows and Linux. It reads data from supported French, US, and English editions and includes shape and map viewers, script probes, and a tool for comparison with the original.
- [Cryogenic: reimplementing the 1992 Dune game](https://awesomerea.org/resources/cryogenic-dune/index.md): Case study · Cryogenic is a C# reimplementation of Cryo's Dune, the 1992 CD version, running on Spice86. Builds target Linux, macOS, and Windows on .NET 10.
- [CSVM: a Crimson Skies engine built from game-data and executable analysis](https://awesomerea.org/resources/csvm-case/index.md): Case study · CSVM reimplements the Crimson Skies (2000) engine in Godot and reads game data from the player's own install or disc. Its C# readers handle original formats, while format and behavior notes draw on data inspection, comparison with the game, and static analysis of crimson.exe. The build covers campaign, Instant Action and multiplayer modes.
- [Cursed Lands: a Godot engine for Evil Islands and Lost in Astral](https://awesomerea.org/resources/cursed-lands-case/index.md): Case study · Cursed Lands reimplements the engine for Evil Islands and Lost in Astral in Godot, reading maps, models, audio, scripts and tables from the player's own game copy. Its native rendering, combat, AI, scripting and interface systems follow the original game's rules, with releases for desktop, Android and browsers.
- [cyrus: rebuilding The Elder Scrolls Adventures: Redguard in Rust and Bevy](https://awesomerea.org/resources/cyrus-redguard-case/index.md): Case study · cyrus rebuilds The Elder Scrolls Adventures: Redguard in Rust and Bevy using files from a local GOG installation. It loads game worlds and formats for native and browser viewing, while its fidelity mode aims to reproduce visuals, audio, controls, timing, and outcomes.
- [D2Decomp: rebuilding the Diablo II: Lord of Destruction engine](https://awesomerea.org/resources/d2decomp-diablo-ii-case/index.md): Case study · D2Decomp reimplements the Diablo II: Lord of Destruction 1.14d engine for Linux, Windows and macOS using the user's game data. Ghidra analysis informs the code, while Unicorn runs original functions for behavior comparisons. The author reports that all five acts play through; multiplayer hosting and a dedicated server remain unfinished.
- [D2MOO: reimplementation of Diablo II](https://awesomerea.org/resources/d2moo-case/index.md): Case study · D2MOO is a reimplementation of Diablo II with patching facilities for modders. The README says the project aims to stay close to the original game and does not yet provide bug fixes.
- [Daggerfall Unity: recreating Daggerfall in Unity](https://awesomerea.org/resources/daggerfall-unity-case/index.md): Case study · Daggerfall Unity recreates Daggerfall in the Unity engine for Windows, Linux and macOS. It reads textures, models and sounds from a separate DOS Daggerfall copy and adds widescreen support, updated lighting, controls and mod support.
- [Dangerous Dave 2: Modification Edition: a configurable remake](https://awesomerea.org/resources/dangerous-dave-2-modification-edition-case/index.md): Case study · Dangerous Dave 2: Modification Edition recreates Dangerous Dave 2 as a configurable engine that loads external mod packs. It supports resizable levels, animated tiles, resource packs and a Tiled-based editor; its new level format needs a converter for original levels.
- [DarkFO: a browser engine reimplementation of Fallout 2](https://awesomerea.org/resources/darkfo-fallout-2-case/index.md): Case study · DarkFO rebuilds the Fallout 2 engine in TypeScript and Python for a web browser. Its setup script extracts and converts data from the user's installed game, including archives and FRM images. The author lists map loading, movement, dialog and barter among working areas, while combat and saving remain limited.
- [Dejavu: reimplementing classic Game Maker](https://awesomerea.org/resources/dejavu-game-maker-case/index.md): Case study · Dejavu reimplements classic Game Maker in Rust to run existing projects and games on modern platforms. Its source includes GML parsing, compilation and interpretation, project reading, and a game runtime; the CLI accepts GMK projects, EXE games, and GML scripts. The implementation is early-stage, with GML and drag-and-drop code running while more APIs remain to be added.
- [Desktop Adventures: a ScummVM engine for Indiana Jones and Yoda Stories](https://awesomerea.org/resources/scummvm-deskadv-case/index.md): Case study · Desktop Adventures reconstructs a ScummVM engine for Indiana Jones Desktop Adventures and Yoda Stories. It detects original and demo releases by file hashes, reads DAW and DTA resources, loads cursors from the original executables, and provides graphics and sound components.
- [Desktop Games Nostalgia: a macOS and browser port](https://awesomerea.org/resources/desktop-games-nostalgia-rea-port-case/index.md): Case study · A Swift/macOS and JavaScript/browser port recreates the Desktop Games screen-smashing toy from a captured image. The author documents Claude and REA/Ghidra work on the Peter interpreter, a decompiled program tree and extracted assets, with explicit visual differences and no project license.
- [DesktopAdventures: reconstructing the Desktop Adventures engine](https://awesomerea.org/resources/desktopadventures-engine-case/index.md): Case study · DesktopAdventures recreates the engine used by Indiana Jones and His Desktop Adventures and Yoda Stories in C. It parses named DAT sections and documents IACT script layout using observed data and disassembly of script routines. Linux and 3DS are the documented working platforms.
- [Dig Dug – native PC port: reconstructing the arcade board](https://awesomerea.org/resources/dig-dug-native-case/index.md): Case study · Dig Dug – native PC port re-creates the arcade board's three Z80 processors, shared memory, Namco I/O, video and wavetable sound in C# so user-supplied game ROM code runs on Windows and Linux. Its developer switches disassemble the Z80 programs and trace I/O, code coverage and memory writes.
- [DirkSimple: reconstructing Dragon's Lair and Cliff Hanger game logic](https://awesomerea.org/resources/dirksimple-laserdisc-games-case/index.md): Case study · DirkSimple reconstructs Dragon's Lair and Cliff Hanger laserdisc game logic in Lua, playing user-supplied original footage through a C FMV runtime. It accepts Ogg Theora video with matching timing and can be built as a standalone SDL player or a libretro core.
- [Domino-Chain: recreating Pushover](https://awesomerea.org/resources/domino-chain-case/index.md): Case study · Domino-Chain recreates the 1992 puzzle game Pushover, in which players arrange dominoes to trigger a chain reaction. It adds levels, domino types, graphics and music, and can load original Pushover levels from a player's copy.
- [Donkey Kong: reconstructing arcade gameplay from descriptions and video](https://awesomerea.org/resources/donkey-kong-arcade-remake-case/index.md): Case study · The Donkey Kong arcade remake recreates the 1981 game's four stages in C++ with Allegro5, using published descriptions of original mechanics and observations from play videos. The author reports that rolling barrels are close to the original while other behaviors and movement timing differ; the repository contains the game logic without its assets.
- [donut: reimplementing The Simpsons: Hit & Run](https://awesomerea.org/resources/donut/index.md): Case study · donut is a C++ and OpenGL reimplementation of The Simpsons: Hit & Run. It needs the original game assets. git clone --recursive fetches the tree. Dependencies are SDL2, Bullet3, OpenAL Soft, and fmt, installed through vcpkg or found by CMake. Windows uses Visual Studio 2019. The Linux command is cmake -S . -B build with the vcpkg toolchain, then cmake --build build.
- [Doom 64 EX+: a continuation of the Doom 64 recreation](https://awesomerea.org/resources/doom64ex-plus-case/index.md): Case study · Doom 64 EX+ continues the Doom 64 engine recreation with support for the 2020 remaster's IWAD, Lost Levels and KPF content. Its C source uses SDL3 and adds PWAD loading and other modding features, running on assets from the user's remaster copy.
- [Doom64EX: a reverse-engineered recreation of Doom 64](https://awesomerea.org/resources/doom64ex-case/index.md): Case study · Doom64EX recreates Doom 64 as a buildable engine with added modding features. Its data generator produces the required WAD and soundfont files from a user-supplied Doom 64 ROM.
- [doukutsu-rs: a Rust reimplementation of the Cave Story engine](https://awesomerea.org/resources/doukutsu-rs-case/index.md): Case study · doukutsu-rs reimplements the Cave Story engine in Rust and runs on separately supplied game data. It supports the original freeware release, Cave Story+ and Nintendo Switch data, with additional controls and platform ports.
- [dreamREfactory: rebuilding CyberFlix's DreamFactory engine](https://awesomerea.org/resources/dreamrefactory-case/index.md): Case study · dreamREfactory rebuilds CyberFlix's DreamFactory game engine in TypeScript for browser play using the owner's game data. It decodes container formats, interprets scripts and supports titles including Titanic: Adventure Out of Time, Dust, Timelapse and RedJack; executable disassembly supplies logic for Skull Cracker, Lunicus and Jump Raven.
- [Dreerally: a Death Rally engine reimplementation](https://awesomerea.org/resources/dreerally-case/index.md): Case study · Dreerally recreates the Windows version of Death Rally as a replacement executable that reads files from an original game copy. Its C source covers game systems and rendering, and accompanying scripts extract or decrypt BPA, BPK, music, and save data.
- [DRIG: a Race Driver: GRID engine reconstruction](https://awesomerea.org/resources/drig-race-driver-grid-case/index.md): Case study · DRIG reimplements Race Driver: GRID in Rust and Bevy, loading tracks, cars, textures, sounds, and other data from the user's PC installation. Its research uses Ghidra on grid.exe and compares reconstructed driving, AI, audio, and selected routines against original behavior. The author describes the playable engine as early and experimental.
- [DSDS: Dark Souls 1 map viewer and engine reimplementation](https://awesomerea.org/resources/dsds-dark-souls-1-map-viewer-case/index.md): Case study · DSDS reimplements parts of the Dark Souls 1 engine to display game maps from a Steam installation of Prepare to Die Edition. Its notes list open questions about MSB map parts and how material definitions lead to compiled shaders; map objects, MSB events and regions, and collision are unimplemented.
- [Dungeon Keeper Remake: a C++ engine for the original game data](https://awesomerea.org/resources/dungeon-keeper-remake-case/index.md): Case study · Dungeon Keeper Remake is a C++ remake of Dungeon Keeper being developed with DirectX 11 and XAudio2 for use with the original game installation. The project uses RNC decompression for compressed assets and a Smacker decoder for game videos.
- [DuperHex: reimplementing the Super Hexagon engine from extracted game logic](https://awesomerea.org/resources/duperhex-case/index.md): Case study · DuperHex reimplements the Super Hexagon engine in Rust with SDL3 and wgpu. Its extractor uses angr and Unicorn to recover game logic encoded in executable conditional branches and convert it to JSON, alongside assets from the Steam-on-Linux release.
- [DW3 Remake: reimplementing Digimon World 2003](https://awesomerea.org/resources/dw3-remake-case/index.md): Case study · DW3 Remake reimplements the PlayStation game Digimon World 2003 in Godot 4 and C#. Its extractor decodes a user-supplied European BIN/CUE disc into a private SQLite and image data pack, which the new game runtime reads. Exploration and dialogue are playable; combat remains in progress.