Reverse-engineering case studies.

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 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 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 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 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 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.

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 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 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 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 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 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 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 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 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 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 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 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 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 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-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.

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.

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 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 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 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 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 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 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 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 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 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.

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 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 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 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 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 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 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 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 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 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 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 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.

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'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 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 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 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 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 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.

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 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 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.

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 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 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 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 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 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.

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 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.

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.

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 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.

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.

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.

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 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 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.

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 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 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 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 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 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 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 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 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 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.

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 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 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.

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.

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 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 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 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 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 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 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 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 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 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.

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.

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 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 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 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 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! 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.

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 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.

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 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 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 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.

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 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 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.

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 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 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 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_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 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 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.

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.

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 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 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 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 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 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.

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.

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 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 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 — 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 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.

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.

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 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 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 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 is a TypeScript server reimplementation of Wangan Midnight Maximum Tune 6. The README says it is part of Project Asakura.

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 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 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 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 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 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.

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 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 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 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.

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 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 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 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 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 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 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 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 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 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 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 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 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 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 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.

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 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 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 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.

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 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 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 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 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 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 — 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 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 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 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 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 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 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 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 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 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 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 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.

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 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 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 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 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.

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 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+ 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 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 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 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 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 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 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 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 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 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.