Reverse-engineering case studies.

BLACK PC port runs the Xbox release of BLACK on Windows by loading the user's default.xbe and executing its x86 game code. A native loader replaces Xbox kernel, graphics, audio and input services, while project notes record analysis of the executable.

Bloodborne PC Windows Port runs the PS4 game's x86-64 executable directly on a Windows PC. It adapts a Linux port with Win32 memory, threading, and file services, while a shadPS4-based core translates PS4 graphics to Vulkan; the user supplies the decrypted game files.

Boulder Dash reconstructs an annotated disassembly of the USA NES game and translates its routines into a native C11 and SDL2 port. A local ROM supplies game data and generated assembly; recording tools capture original RAM changes and hardware accesses for routine-by-routine comparison with the C implementation.

BrawlerPad adapts the BattleShip Super Smash Bros. 64 source port for Apple Silicon macOS, iPhone and iPad. Its patches add Metal app integration, user-ROM resource extraction, touch controls and controller lifecycle handling while compiling the decompiled game code ahead of time.

Compiles the decompiled code of Dragon Ball Z: Budokai Tenkaichi 3 (PS2, USA release SLUS-21678) for PC on a new renderer, sound, input and platform layer rather than an emulator. The game code comes from the separate BT3-Decompiled matching decompilation, and the game's data is read from the user's own disc image. The README reports the full game loop and experimental online play and says AI helped make the project; these results remain project-reported.

Burnout 3 for PlayStation 5 ports Takedawn's original Xbox static recompilation of Burnout 3: Takedown to PS5. Its console layer uses Vulkan on RADV, maps Xbox memory into PS5 memory and handles sound-register accesses through page-fault traps.

Caesar II ports recovered source from the 1995 game to Linux, Windows, macOS and browsers through SDL3. It replaces DOS and Windows platform calls while retaining the game's logic, and adds an XMIDI and OPL3 music stack, Smacker playback and an importer for data from the user's copy. The repository also carries tooling for comparing the original executable with a reconstruction.

Calico ports Atari Jaguar DOOM to PC while retaining the original game's behavior where possible. The author reverse engineered Jaguar-specific renderer assembly and cross-referenced gameplay assembly with related C sources; the port loads a user-supplied ROM or extracted jagdoom.wad.

CannonBall rewrites the OutRun arcade game's 68000 and Z80 assembly as a C++ engine. It reads graphics and audio from the user's original ROMs and supports higher frame rates, widescreen output and SDL2-based rendering.

Carmageddon Android Port adapts the Dethrace engine reimplementation to Android ARM64 with a launcher, touch and controller input, and OpenGL ES rendering changes. It imports the user's Carmageddon or Splat Pack PC data and keeps their saves separate. The author reports an unresolved intermittent exit during a race.

Carpocalypse 2 decompiles Carmageddon 2 and builds native Linux and Android versions using data from the player's original installation. Its build offers a period MSVC matching path and a modern toolchain path, with SDL3 graphics support and documented remaining work.

Castlevania: Belmont’s Curse native preserves a paused Apple Silicon port adaptation of the game. Its source supplies Horizon service replacements, IL2CPP and SDK startup integration, NVN-to-Metal rendering, input support and loader diagnostics. The author reports reaching a title loading screen on macOS; menu, gameplay and iPhone operation remain unconfirmed.

The Castlevania: Symphony of the Night Vita project loads a game shared library through a custom ELF loader. Its source implements relocation, symbol handling and ARM and Thumb hooks, while the build targets the Vita SDK.

Chrono Trigger Reimplemented ports the USA SNES game to handwritten C and compares ported routines frame by frame against the original ROM. Its development runtime combines native routines with generated C and a 65816 interpreter while the attract sequence, field, menu, event and battle systems are being ported.

Cinnamon ports the Butterscotch reimplementation of the GameMaker: Studio bytecode runner to Nintendo 3DS, Wii and Wii U. It supports bytecode versions 16 and 17 and includes a 3DS preprocessor that converts a user's data.win textures and audio for the console.

Cosmo ports the reconstructed source of Cosmo's Cosmic Adventure: Forbidden Planet to macOS, Linux and Windows. It retains the game's logic and supplies an emulated EGA adapter, timer, keyboard controller, PC speaker and AdLib layer for the original code. The build uses the user's game data files.

Crash Bandicoot PC ports the North American PlayStation game to native C11 on macOS and Linux from a matching decompilation. It keeps the game's PS1 memory layout, routes GPU packets through PsyZ and reads the player's CUE/BIN disc image; the author reports playable levels and focused disc-based tests.

Crash Team Racing: High Octane ports the ctr-native Crash Team Racing code to PlayStation Vita, Windows and web browsers. It adds widescreen rendering, higher frame rates, post-processing, replay controls and platform-specific multiplayer features while reading game data from the player's US PlayStation disc dump.

Crash Twinsanity for Windows adapts an existing C++ decompilation and Mac port of the PAL PlayStation 2 game to native 64-bit Windows. It adds Windows calling-convention and memory handling, frame pacing and game-specific crash fixes, while reading game data from the user's disc image. The author reports playing the release through to the credits.

CTR Native ports the 1999 PlayStation game Crash Team Racing to Windows and Linux using source from the CTR-ModSDK decompilation. Its own native layer supplies audio, input, memory-card, CD, rendering, and PS1 interface support, with statically linked SDL3 and UDP netplay. Game assets are extracted from the user's NTSC-U disc.

CTR Reload Edition extends the ctr-native Crash Team Racing port into a Windows edition with a Vulkan renderer and tools for custom tracks and characters. It runs the original game logic while a native engine draws selected races and reads game content from the user's NTSC-U disc image.

Extends the Crash Team Racing: High Octane sourceport, which derives from the CTR Native port of the CTR-ModSDK PlayStation decompilation, into Windows and Linux builds with a native 3D renderer, selectable aspect ratios and frame rates up to 240 FPS. The decompiled game code still assumes 32-bit pointers and loads assets from the player’s own NTSC-U disc image. Renderer, timing and option tests exist, but device coverage and fidelity remain project-reported.

CTR-NitroFueled-PC ports the PS4 release of Crash Team Racing: Nitro-Fueled to Windows 10 and 11 using the player's decrypted game files. It executes the original x86-64 game code on the CPU, supplies a replacement PS4 runtime and translates graphics through a shadPS4-derived Vulkan renderer; the fork adds the Windows loader and system layer.

d2mac-linux ports the Diablo II 1.14d Mac executable to 32-bit Linux by converting its i386 Mach-O container to ELF and reimplementing imported Darwin, Carbon and AGL interfaces in Zig. The shim translates graphics to GLX and adapts threading, files and sockets. The author reports that the game reaches its menu and character creation.

DARIUSBURST SP Vita runs the Android ARMv7 game executable on PS Vita by loading it into memory, resolving its imports with native functions and applying runtime patches. The author reports testing with version 1.2.0; users provide the Android APK and OBB files.

Dark Souls PS2 ports parts of Dark Souls Remastered to PlayStation 2 with a new C engine and hand-written VU1 programs. Python exporters convert maps, characters, animations, collision, scripts, and menus from the user's PC copy; executable findings document constants and rules used to reproduce behavior. The author describes it as an early prototype covering only the first few areas.

Death Road to Canada Lite runs the Android game on PS Vita through a native loader that resolves imports and patches its ARMv7 executable in memory. Setup uses libmain.so and assets extracted from the player's APK, together with a bundled mod that simplifies maps for Vita play.

Destruction Derby 2 is ported from its USA PlayStation executable and overlays into portable C11 using SDL3. The source replaces the game's PSX SDK calls for graphics, sound, disc access, controls and memory cards, and builds its asset directory from the user's own disc image.

devilution-nx ports the DevilutionX reconstruction of Diablo to Nintendo Switch. It provides Joy-Con and touch controls, Switch homebrew builds and instructions for loading DIABDAT.MPQ from the player's original Diablo disc or GOG copy. Its documentation traces the underlying reconstruction to IDA analysis and recovered C code.

Builds a modern Diablo and Hellfire port on the Devilution reconstruction, with platform support, bug fixes and optional quality-of-life features. The project documents the original symbol-assisted reconstruction and includes selected dungeon-generation and saved-game regression checks.

Runs Diablo in web browsers by compiling a stripped-down fork of Devilution, the community reconstruction of the game’s original source, to WebAssembly behind a React front end. The fork removes the Storm, DiabloUI, DirectX and Windows dependencies and reworks event handling for the browser. It is a port built on a reconstruction and reports no matching or behavior-equivalence checks of its own.

Ports Golden Balloon's Diddy Kong Racing source port to an Xbox Series X UWP package. The repository adds a WinRT entry point, compatibility patches, build translation and packaging tools for a user's own Golden Balloon checkout and ROM. The author reports completing the game's modes on Series X and matching 900 of 900 simulation hashes against a PC run.

Dig Dug translates routines from the 1982 arcade game's Rev 2 ROMs into Rust and models its three Z80 processors and Namco I/O, video and audio hardware. It includes a disassembler, memory-map report, native windowed port and differential checks against a separate Z80 interpreter. The author states that translation coverage and full hardware equivalence remain incomplete.

This runs Digimon World 2 for the PlayStation natively on Windows and Linux, built from the game's decompiled C. The disc is the USA release SLUS-01193, checked file by file. Game logic stays at 30 fps. The picture can be drawn at the monitor's refresh rate, and the 3D view can widen to 16:9.

Digimon World 2003 adapts an upstream matching decompilation and PC port for RK3326 Linux handhelds including the R36S and XF35H. The fork adds direct framebuffer output, a Mali GLES renderer, Cortex-A35 and NEON performance work, a gamepad menu and PortMaster packaging. The decompilation and PC port originate with gascarcella/dw2003recomp.

Digimon World 2003 is ported from decompiled C code for the European PlayStation release into a native Windows program. The port replaces console graphics, audio, files, controls and memory card services with PC implementations using OpenGL and SDL, and reads game content from the user's disc image.

DinoPad adapts Dinosaur Planet: Recompiled into native macOS, iPhone and iPad applications. Its Apple layer adds ROM import, touch controls, Metal and mobile runtime changes, save handling and lifecycle support around the existing static recompilation; the public base edition includes Prototype Mode.

DishSoap ports the Xbox 360 game The Dishwasher: Dead Samurai to Android using managed code decompiled locally from the owner's game copy. Repository code provides MonoGame platform shims, an on-device content importer, audio decoding, controls and save support; building from source also requires manual XNA-to-MonoGame edits.

This ports Donkey Kong 64: Recompiled to native Android with the NDK, N64ModernRuntime, RT64 on Vulkan, RmlUi, and SDL2. The USA NTSC-U 1.0 ROM has SHA-1 cf806ff2603640a748fca5026ded28802f1f4a50. The app accepts .z64, .n64, or .v64 and byteswaps as needed. It requires Android 8.0 or newer on arm64-v8a and Vulkan 1.1 or newer. GitHub Actions publishes app-debug.apk as dk64recomp-android-debug.

DKR-GC ports the Diddy Kong Racing N64 decompilation to native GameCube PowerPC code. It maps N64 scheduling, storage, graphics and audio services onto libogc2 and GX, and reads game data from a user-supplied ROM.

DOAX3 Fortune PC adapts Dead or Alive Xtreme 3 Fortune version 01.19 for Windows x64. Its inherited native runtime executes the game's x86-64 guest code, while a shadPS4-derived graphics core translates GPU commands and shaders to Vulkan. The author reports tested routes through the title, casino and several activities, with partial coverage of volleyball and Pool Hopping.

dRally is a C and SDL2 project to port Death Rally (1996) to Linux and BSD. Its installation instructions use asset archives extracted from the original game.

Drift City Rebuild rebuilds the online racing game as a Unity client that reads data from the user's installed copy, with a new Node.js server for offline or hosted play. Its reverse-engineering notes document REA/Ghidra analysis of DriftCity.exe and record format readers for NayaPack, NIF, DDS and other game data. The author reports roughly 94% code conversion.

ds2-nx adapts a ReXGlue static recompilation of Dead Space 2 for Nintendo Switch as a homebrew NRO. Switch-specific code handles disc swapping and rendering through deko3d, while a separate toolchain translates dumped Xbox 360 Xenos shaders into a library and, optionally, a DKSH cache.

Durak NX runs the Android ARM64 Unity game Durak 25.0 on Nintendo Switch through a target-specific compatibility layer for graphics, audio, files and input. The project documents ELF and IL2CPP analysis of the game's libraries and loads locally extracted files from the user's own Android package; the author reports menus, gameplay and sound working on Switch hardware.

Dusklight for PS4 adapts the decompilation-based Twilight Princess port into a native PS4 program. Its patches target the game and platform dependencies, while Setup Studio packages the user's GameCube or Wii disc data on a computer for installation on a GoldHEN PS4.

Reimplements Twilight Princess as a native application for desktop and mobile platforms, building on the zeldaret/tp decompilation and the Aurora GameCube/Wii compatibility layer. It runs from the user’s own disc image with no bundled assets and aims to stay accurate to the original while adding options, enhancements and mods.

The EA SPORTS UFC 3 port runs the PS4 game's original x86-64 code on Linux and Windows. A game-specific runtime supplies PS4 system services, while a renderer derived from shadPS4 translates GPU work to Vulkan; the user supplies the game's CUSA06534 dump and update 1.14.

EarthBound Companion is a native EarthBound build. Windows x64 release 1.0.18 is the supported package. Linux, macOS, and Android builds are community previews. It includes a pinned MaternalBound Redux adaptation, widescreen scenery, 1080p to 4K output, MSU music, and Story Shuffle. The game code is compiled C with SDL2.

Eden begins a Windows reconstruction of the 2001 game Project Eden, targeting a DirectX 9 build. Its C++ source covers a game window, error codes, an optional CD check, and partial DirectX and input initialization. The stated goal is to reach the game's main menu.

Emerald 3DS ports Pokémon Emerald's decompiled game code to native Nintendo 3DS execution. A C bridge supplies GBA register, video, audio and input behavior on ARM11, while a builder derives game data from the user's supported ROM; the port adds a touch interface and an optional voxel overworld.

F-15 Strike Eagle 2 source port brings reconstructed source for the 1991 DOS game to modern architectures with SDL3 input and presentation, OpenGL rendering and AdLib emulation. Its asset tools decode original PIC, SPR, 3D3 and WLD files into inspectable formats. The author reports that the game is playable while further fixes and features remain in progress.

F0X ports F-Zero X to Apple Silicon macOS, iPhone and iPad using G-Diffuser's decompiled game logic. Maintained patches connect the game to libultraship/Fast3D's Metal backend, while Torch extracts a local game archive from the player's US revision 0 ROM.

FIFA 96 reconstructs the DOS game's real-mode loader, appended protected-mode image behavior and formats including QFS, POG, TGV, VIV and EACS. A C11 port implements file readers, codecs, audio and match systems, while an SDL3 engine runs from the user's CD image. The author reports complete implementation of its counted native dispatch bodies but identifies remaining runtime wiring.

Final Fantasy 4 Vita ports the Android release of Final Fantasy 4 to PS Vita by loading its ARMv7 executable into memory, resolving Android imports with native functions and applying runtime patches. It uses libff4.so extracted from the player's APK and an OBB file, with display and input adaptations.

Final Fantasy 4: The After Years Vita runs the Android game's executable on PS Vita through a native loader. The loader maps the executable into memory, resolves Android imports to Vita functions and patches behavior needed for the port.

Final Fantasy Dimensions Vita runs the Android release of Final Fantasy Dimensions on PS Vita by loading its ARMv6 executable into memory. The loader resolves Android imports with native functions and applies patches; the player supplies the game's APK and OBB data.

Forest ports the GameCube release of Animal Crossing to PC from a matching decompilation. Its source tree contains game code and build configuration, while the build reads assets and original data from a user-provided GAFE01_00 disc image.

Foxhollow builds a native Star Fox Adventures port from the SFA decompilation and Aurora compatibility layer. It reads the user’s game disc, and the author reports the Mac, Windows and Linux builds are fully playable.

Freeserf.net ports and extends the freeserf remake of The Settlers I in C#. It loads the player's original DOS or Amiga data, adds AI logic and provides desktop and Android builds with experimental local multiplayer.

Frontier Elite II Intro Player recreates the Frontier: Elite II intro renderer and audio playback in C for Amiga and SDL platforms. It reads models and music from an original game executable, implements the game's 16-bit 3D model bytecode, and includes a model compiler and decompiler. The author reports that most of the original graphics code is covered, while 2D and navigation rendering remain incomplete.

G-Diffuser 3DS is a native port of the F-Zero X decompilation to Old and New Nintendo 3DS, built on the G-Diffuser PC port. It has stereoscopic 3D and full audio. Optional Expansion Kit builds stream 64DD content from the SD card.

G-Diffuser is a PC port of F-Zero X with the 64DD Expansion Kit. It requires a big-endian US revision 0 ROM, a .z64 file. Setup looks for baserom.us.rev0.z64 beside the executable. It also requires the Expansion Kit disk baserom.translated.ek.ndd or baserom.jp.ek.ndd, and a 64DD IPL ROM named N64DDIPLROM.n64 or 64DD_IPL_US_MJR.n64. F1 opens the enhancement menu. The release includes gdiffuser.o2r, which holds the Fast3D shaders used to start the renderer.

G1R Deluxe ports eleven Pokémon games, from Red and Blue through Emerald, into a Lua engine running on LÖVE2D. It draws engine and map behavior from pret disassemblies and C, then decodes graphics, game data and audio programs from each player's ROM during import.

GalaxyPad ports Super Mario Galaxy to iPhone and iPad using MacioGalaxy and Petari-derived native game code. Its current engine compiles for Apple silicon, renders with Metal and adds touch, controller and gyro controls; players import their own supported Wii image.

GD's Melee builds a native Windows and Linux port of Super Smash Bros. Melee NTSC 1.02 from the game's matching decompilation. It adds native rendering, rollback online play, m-ex mod support and Lua scripting while loading game data from the user's disc.

geow2 rebuilds Geometry Wars: Retro Evolved 2 as a native Windows, macOS, and Linux game based on analysis of the Xbox 360 executable. It implements the six original modes and local multiplayer, while a bundled extractor prepares data from the player's own XBLA release.

Builds Super Mario 64 as a native PC, Switch and Android program by compiling decompilation-style game source against the libultraship platform library. A bundled extractor converts the user’s US or Japanese ROM into an O2R archive at first launch or build time. The project ships modern renderers, configuration menus and mod-archive loading.

Glassline ports the 2010 iPad release of Mirror's Edge to Linux, Windows, Steam Deck, Android and browsers. Its code was reconstructed from the iPad executable, with SDL2, OpenGL ES, OpenAL and FFmpeg replacing iOS services; it loads assets from the user's game copy and adds a launcher, network play and replacement online services.

Goemon 64 Recompiled — Android ports the Mystical Ninja Starring Goemon recompilation to Android with RT64 Vulkan rendering, touch controls and ROM selection. Its game-specific analysis notes trace indirect calls through N64 overlays and correct earlier camera-function conclusions.

Golden Balloon is a native and browser port of the 1997 Nintendo 64 kart racer, built on the Diddy Kong Racing decompilation. The README says the game is compiled for the machine and runs from a ROM you already own.

Golden Sun Recompiled for Android ports the Golden Sun recompilation workflow to Android and builds game code from the player's ROMs on the device. It supports Golden Sun and The Lost Age, with touch controls, renderer options and save transfer between the games.

The GoldenEye 007 3DS port adapts the existing Nintendo 64 decompilation to Nintendo 3DS with rendering, input, audio, storage and timing interfaces. The author reports that the Dam level runs with movement, collision, guards, weapons and mission state while the port remains unfinished.

Builds a native PC port on the existing GoldenEye 007 decompilation, with a host platform layer and assets extracted from the user’s ROM. The project documents agent collaboration, rendering comparisons, playtest scope and unresolved platform support.

Gran Turismo 2 PC, VR & Browser ports Arcade and Simulation modes to desktop, Quest, PCVR and browser targets through shared C++ game code, with WebAssembly and WebGL2 for browser play. Players supply supported BIN/CUE disc images, and the project provides importers, build scripts and native rendering and input code. Optional tools decode selected Gran Turismo 4 car data from a separate player-owned disc.

The Gravity Rush 2 PC port runs the PS4 game's original x86-64 code on a host CPU while replacing PS4 services and translating GPU work to Vulkan. It adapts a shared runtime for Gravity Rush 2 and reads the user's own CUSA03694 game and update files.

Gravity Rush Remastered's PC port runs the PS4 game's original x86-64 executable on Windows with replacement PS4 system libraries. It uses shadPS4's video core to translate graphics commands and shaders to Vulkan and reads an unpacked copy supplied by the player; the author reports a full story play-through.

GTA IV for PS5 ports the existing Xbox 360 static recompilation of Grand Theft Auto IV and its two episodes to a jailbroken PlayStation 5. Its added code supplies PS5 startup, a game-selection hub, trophy integration, controls, build steps, and packaging around the inherited recompilation and renderer.

Gunboat reconstructs the 1990 DOS game Gunboat: River Combat Simulation in C++ and SDL3, porting functions from GB.EXE and reading the player's original data at runtime. It includes an executable map, subsystem specifications and differential tests against original code; the author reports native gameplay across the original video modes.

HALBERD ports the Kirby 64: The Crystal Shards decompilation to PC with libultraship for rendering and input, and Torch for extracting resources from the user's N64 ROM. Its own platform code supplies libultra shims and runtime bridges; the author reports working menus and level loading.

A C++20 native port of Halo 2 targets original Xbox TU1.5 gameplay and visuals through executable research, source comparisons and local asset imports. It uses SDL2 and Vulkan, imports Halo 2 Classic content from the user's MCC installation, and validated builds expose menus and an interim native Lockout test.

Adapts the Halo: Combat Evolved Xbox decompilation into builds for standalone VR headsets, Windows PC and Android. The port adds VR interaction and controller handling, PC and mobile launch paths, game-data import and campaign networking. It draws on the OpenCE port and requires the player's Halo game data.

This is a native ARM64 port of the Halo: Combat Evolved decompilation OpenCE to the Anbernic RG35XX H and other Allwinner H700 handhelds with a Mali-G31 GPU. The game build is Xbox 01.01.14.2342. The README reports 60 frames per second in menus and about 40 to 55 in campaign at the default scale, under Knulli.

Halo CE Vita compiles reconstructed Halo: Combat Evolved Xbox game code for the PS Vita's ARM processor. It adapts Direct3D rendering to the Vita GPU and includes extensive object-matching notes, platform code, campaign support and multiplayer features.

HarkinianPad adapts the Ship of Harkinian Ocarina of Time source port for iPhone and iPad. It adds Metal rendering, touch controls, controller support and local ROM import; the app creates its game archive from the user's ROM.

Harvest reconstructs C++ for the Linux amd64 1.18 release of Harvest: Massive Encounter and ports the recovered game and engine code to desktop and web platforms. Matching tools compare compiled objects with the original executable; the port replaces the platform layer with Zig, SDL3 and related components and reads separately supplied game data.

Heretic2 adapts Heretic 2 game code from an earlier reconstruction project to a customized Yamagi Quake II Remaster engine. Its source and progress notes cover differences in effects, movement, rendering and save handling while targeting single-player play from Heretic 2 game data.

HK: Dual Souls ports Hollow Knight v1.5.12620 to the AYN Thor Android handheld through a same-version Unity rebuild from the user's GOG or Steam copy. Its runtime adds a second-screen HUD, map, inventory and charms, while patch tooling prepares game data on the device. Some shaders are reconstructed approximations.

Hunters Recomp adapts a static recompilation of Metroid Prime Hunters for the AYN Thor's dual-screen Android hardware. Its app shell adds touch mapping, twin-stick controls and a GLES 3.2 renderer; game code is generated from the user's cartridge dump.

Ice Rage runs on Linux ARM handhelds through a bionic ELF loader that maps the game's Android armeabi-v7a library and supplies required Android interfaces. The author reports successful loading, audio, rendering and menus on an R36S; a full match remains unplayed.

Compiles the decompiled C of the PlayStation 2 game ICO natively for Windows, Linux, Android, iPhone and Apple-silicon Macs, with host code standing in for the PS2 hardware and Sony libraries. No PS2 code is interpreted or recompiled, and the program reads the player's PAL disc image on first start. It is a native port of a separately byte-matched decompilation, with documented divergences and optional enhancements.

Ignition ports the 1997 racing game by reading routines in its Windows executable with IDA and rewriting their behaviour in portable C99. The port loads data from the user's disc image and provides races, championships, audio and multiple platform hosts. Source files, executable-analysis notes and per-routine progress records document the reconstruction.

inFAMOUS First Light is rehosted on Windows by running the PlayStation 4 game's x86-64 code directly on the PC processor. A replacement PS4 runtime supplies system-library functions, and a Vulkan renderer handles graphics; the player supplies the original game dump.

Infernal Runner JS ports the Amstrad CPC game Infernal Runner to JavaScript from analysis of its disk image and Z80 code. It reimplements a cooperative-threaded interpreter for the game's 28 bytecode opcodes, loads the original disk image for graphics and scripts, and includes a bytecode disassembler and Z80 disassembly.

Jackal UEFI ports the NES game Jackal to a native UEFI Shell application by translating its 6502 disassembly line by line into a C core. UEFI GOP handles graphics while UEFI services handle input and timing; a ROM extractor generates tiles, palettes, and layouts from the user's copy. Audio calls retain state and timing behavior without sound output.

jgalbs cod4 ports the KisakCOD Call of Duty 4 multiplayer client to Apple Silicon macOS. Its native Metal renderer and platform work support menus, maps, input, audio, hosting and multiplayer gameplay while loading assets from a user's compatible game installation. The source documents ongoing development and tested feature boundaries.

KH_COM_VITA ports the GBA Kingdom Hearts: Chain of Memories decompilation to PS Vita by compiling the game's C for Vita ARM and replacing GBA video, DMA, interrupts, audio, BIOS and save services. Its source includes a Vita platform layer and patch; the author reports working early gameplay and a completed first battle, with later areas still under test.

khdays-vita compiles the Kingdom Hearts 358/2 Days decompilation into a native PS Vita program. Its platform layer replaces Nintendo DS graphics, audio, card and touch-screen behavior using VitaSDK and vitaGL, while loading game data from the user's European cartridge dump.

Killzone Shadow Fall for PC runs the PS4 game's code directly on a Windows CPU and translates its graphics to Vulkan at runtime. Its launcher points to a user-supplied version 01.81 game dump containing eboot.bin; the author reports campaign playability in a public beta.

Compiles the C of the khdays-decomp matching decompilation for Windows x64 and supplies a native platform layer for the Nintendo DS hardware, SDK services and sound driver. README reports the whole game running without an ARM interpreter; its rendering, controls, mod support and network multiplayer are the port’s own additions. This decompilation-based port builds on the byte-matching DS reconstruction.

Knack for PC ports the PlayStation 4 game Knack to Windows and Linux by running its original x86-64 code with replacement PS4 system libraries and a Vulkan graphics core. The Knack-specific work covers imported system functions, fixed-address memory, NGS2 audio layouts, and graphics translation. The author reports that the first chapters play from start to end; later chapters remain untested.

Kye for C64 ports the 1992 puzzle game to Commodore 64 in 6502 assembly. Its author inferred object-processing and magnet rules by testing the original, then implemented them alongside a parser for original Kye level files; the port documents its behavioral differences.

Lantern Engine runs Bloodborne CUSA03173 update 1.09 from the player's own PS4 dump on Windows and Linux. Built on bbport and shadPS4, its game-specific runtime supplies PS4 system services while the game's code executes on the CPU and graphics are translated to Vulkan. The source documents additional launcher, rendering, control, and performance work.

LEGO Dimensions PC ports PS4 LEGO Dimensions version 01.24 to Windows x64 by adapting its executable and rewriting PS4 system-library behavior. It translates GCN graphics to Vulkan; preparation from a user-supplied game dump converts the executable and translates the game's shaders before play.

Adapts the LEGO Island decompilation into a portable build for desktop, mobile, console, DOS and Web targets. Windows-only subsystems are replaced with SDL3, miniaudio, iniparser and a custom Direct3D Retained Mode re-implementation, while core gameplay is meant to stay unchanged. It ports reconstructed source rather than checking byte-identical binaries, so it is distinct from the exact-rebuild decompilation case.

LEGO Racers, portable adapts the 1999 game's decompiled source for Windows, macOS and Linux. It replaces Windows windowing, input, audio and rendering paths with SDL3 and miniaudio, and handles original AVI movies with an in-tree demuxer and Indeo 5 decoder.

LEGOLAND, portable turns a matching decompilation of the 1999 game into builds for Windows, Linux, Android and browsers. It adds program startup code, replaces the game's assembly routines with C, and substitutes Windows graphics, input, audio and other APIs with SDL3 and supporting libraries. Installation reads game data from the user's CD or disc image.

A native Windows, Linux and macOS port of Banjo-Kazooie that compiles game C sources, many tagged with their Banjo-Kazooie decompilation file paths, against libultraship, a reimplementation of the N64 SDK. Torch extracts the user’s ROM into an asset archive, and the port adds Anchor multiplayer, romhack and language-pack support and a randomizer. Unlike Banjo: Recompiled, it builds from decompiled source rather than statically recompiling the ROM’s code.

Provides an SDL3 backend for a portable-C reconstruction of the 1994 DOS game. Its build configuration links the reconstructed engine to video, input and audio adapters; the upstream documents differential gates against original machine code.

A native Windows port of Link: The Faces of Evil runs C code from the Philips CD-i game decompilation and replaces CD-i video, audio, disc and input services with an SDL3 host. It reads the player's own raw disc image and includes a small 68000 interpreter for enemy graphics stored on the disc.

Lordran Native ports the Nintendo Switch release of Dark Souls: Remastered to Apple devices by running its ARM64 code directly. A rewriter adapts kernel-dependent instructions, a host supplies Horizon services, and a Metal layer implements NVN graphics. The project packages locally supplied NSP files and keys into macOS or unsigned iOS builds.

MacioGalaxy ports the Petari Super Mario Galaxy decompilation to Apple Silicon Macs. It compiles reconstructed game code for arm64, renders GX graphics through Aurora and Metal, and adds native input, audio, and menus. Game resources come from the user's extracted USA revision 0 disc data.

Magic Carpet reconstructs Bullfrog's 1994 DOS game as a Windows x64 C++17 and SDL2 port from analysis of carpet.exe. The repository includes Ghidra naming data, format documentation and a DOSBox reference harness; the author reports matching simulation ticks and rendered frames in recorded comparisons.

Marble Love ports Marble Madness arcade routines from 68010 disassembly into a TypeScript engine and browser frontend. MAME traces and focused Musashi execution provide comparison data for gameplay, rendering and audio behavior; the project also documents a Slapstic prefetch finding.

Mario 64 for PlayStation 5 ports Ghostship's decompilation-based Super Mario 64 application to PS5. It adds console-specific SDL drivers, Vulkan and RADV integration, and patches to the Ghostship stack; the user's ROM is converted into game data on first launch.

Mario Kart 64 3DS is a native Nintendo 3DS port of Mario Kart 64, based on SpaghettiKart. It adds a dual-screen interface, touch menus, and customizable controls and display options.

Mario Kart 64 for Dreamcast is a Sega Dreamcast port of the n64decomp/mk64 decompilation. The README says the 2026 update adds hardware-mixed audio, a raw PowerVR Fast3D backend, and 30 fps four-player play with music, and that it was tested on physical hardware.

Mario Kart Wii 3DS continues a native Nintendo 3DS port of Mario Kart Wii, building an installable CIA from the player's USA disc image. The builder converts courses, characters, vehicles, menus, movies and sound; the runtime uses recreated kart physics and 3DS-specific rendering, audio and menus.

MaskPad adapts the 2 Ship 2 Harkinian Majora's Mask source port into a native iPhone and iPad app. It supplies iOS patches, Metal rendering, touch controls and local extraction from a user-provided ROM, with scripts to build an unsigned IPA.

Rehosts the Android release of Max Payne Mobile on Nintendo Switch by loading and patching its original AArch64 shared library. The wrapper supplies a minimal Android-like environment and Switch-specific hooks for game, audio and graphics behavior. It adapts an earlier Vita port and uses files supplied by the player.

max_vita ports the Android release of Max Payne Mobile to PS Vita by loading and patching the user's original game binary. Its wrapper supplies a small Android-like environment and compatibility hooks for graphics, audio and game behavior.

MDK in C# and SDL3 ports the 1997 game using reconstructed data formats and behavior from MDKD3D.EXE. It reads levels, textures, models, sound and scripts from the user's installed copy and implements the original's BSP collision and script-driven gameplay on SDL3.

MDK in Godot ports the 1997 game MDK to Godot 4.7 using analysis of its data files and MDKD3D.EXE. It loads levels, media and scripts from the player's installed game and documents file formats, engine behavior and the script virtual machine. The author reports that all six levels run, while playtesting and bug fixing continue.

MechWarrior SDL port reconstructs the 1989 game's campaign and combat systems in C17 and SDL3 for Windows x64. It reads resources and executable-authored tables from the player's installation; the author reports an experimental build reaching briefing, movement, firing and combat return.

MedalOfHonor-xport ports reconstructed routines from the PlayStation game Medal Of Honor. Its Windows C runtime loads the original SLUS_009.74 executable, rebuilds startup state and handles selected PSX interrupt, DMA and memory operations.

MediEvil for PC runs the 2019 PS4 game's own x86-64 executable on Windows through replacement PS4 system libraries and a shadPS4-based Vulkan graphics core. The launcher accepts the user's unpacked game folder or fake PKG and supplies patches, resolution controls and input support.

Mega Man 64 Recompiled Mobile adapts the MegaMan64Recompiled game port to Android and iOS with N64ModernRuntime and RT64. It adds ROM import, editable touch controls, controller input and persistent saves; a separate Quest preview displays the game on an OpenXR virtual screen.

Megarocket ports Commander Keen 1–6 and Keen Dreams into one Godot 4 program using function-level reconstructions of the DOS games. It reads art, levels and sound from the user's copies and documents regression comparisons of pictures and frame timing against recorded DOS play.

Melee-X ports the Super Smash Bros. Melee decompilation to the original Xbox, compiling game code for its Pentium III and mapping GameCube graphics calls to the NV2A GPU. It implements platform services for input, audio, disc access and saves, and reads game data from the player's NTSC-U 1.02 disc image. The author reports four-player play and notes occasional crashes.

MELEE360 ports reconstructed Super Smash Bros. Melee code to a native Xbox 360 XEX. It adapts the game to PowerPC, D3D9/Xenos and XInput while reading original resources from a user-supplied NTSC-U 1.02 disc image. The author reports bounded Xenia tests, with campaign content and physical-console operation still incomplete.

Started in 2015 as a reverse-engineered reimplementation of the Metroid Prime engine, Metaforce has been rewritten on top of the PrimeDecomp matching decompilation. Its native app compiles that game code as non-matching C++ for desktop and mobile through the Aurora GameCube compatibility layer and loads a user-selected disc image. The README says builds are unavailable while the rewrite stabilizes.

Compiles the PrimeDecomp decompilation of Metroid Prime’s game and engine code as native C++20 for Linux, Windows and Android, with an experimental macOS build. Aurora supplies the GameCube SDK compatibility layer and rendering, and the port reads a user-supplied disc image at run time. The author states that parts were written with AI coding assistants under their oversight.

Metropolismania PC rebuilds the PS2 game as readable C++ while using PS2Recomp output from the user's disc as a running scaffold. Functions are replaced individually and compared with recorded original calls; the author reports all 1,481 game functions rewritten, with 1,432 passing differential checks, while playthrough remains unfinished.

Ports the PS2 game Fatal Frame to native PC builds without emulation; its repository description names the Himuro decompilation as its basis. Stubs replace PS2 kernel calls and a new SDL3-based layer handles rendering, audio and UI, while game data comes from the user’s own disc. The README calls the port very early work and publishes no matching or fidelity checks.

Miyoo64 runs fifteen Nintendo 64 games natively on the Miyoo Mini, Mini Plus, and Mini Flip, built from their decompilation projects. Each game reads a ROM the player owns and builds what it needs on the device. The listed USA ROMs include Perfect Dark revision 1, Mario Kart 64, Ocarina of Time 1.0, and Super Mario 64.

mm5sound translates Mega Man 5's 6502 assembly sound driver into C++ while retaining ROM addresses near related code. Its comparison workflow builds register-write logs from the user's ROM and checks them against logs from NSFPlay.

Moon Pearl is an Android port of the zelda3 C reimplementation of The Legend of Zelda: A Link to the Past. The player picks an .sfc or .smc ROM and the app builds the game data on the device. It adds widescreen, nine save-state slots, rewind, and controller support.

An experimental Android ARM64 port adapts the existing static recompilation of the Xbox 360 game Naruto: The Broken Bond, compiling translated PowerPC code with ReXGlue and bringing its runtime, Vulkan renderer and touch input to Android. The author reports that the original intro, menus and a training fight render on an OPPO A58 at about 1 FPS.

NBlood provides reverse-engineered ports of Build-engine games using EDuke32 technology. Its NBlood, PCExhumed and Rednukem programs cover Blood, Exhumed or PowerSlave, and several Duke Nukem 3D-derived games; users supply the relevant game data.

Nebula runs Super Mario Galaxy on 64-bit Windows. Release 1.0.2 plays the North American disc RMGE01 from start to finish. Setup translates that disc's PowerPC code to C++ and compiles it locally. The current branch, Nebula 2, is unreleased and builds the game from the Petari decompilation, adding the European disc RMGP01 and the Japanese disc RMGJ01. Windows 10 version 1803 or Windows 11, a Direct3D 12 GPU, and 8 GB of RAM are required. Source steps are in docs/BUILDING.md.

The R36S port runs the 2012 Android release of Need for Speed: Most Wanted on ArkOS using the owner's game files. An ARMv7 loader maps the original libraries, while Bionic, JNI and soft-float bridges connect them to Linux graphics, controls and audio; the author reports playable races in the public alpha.

NES Tetris rebuilds the 1989 NES game in Rust for desktop and browser play, reading graphics, music and data from a user-provided ROM. Its documented workflow translates disassembled routines into Rust and compares their calls with the original through a shadow oracle.

NFS Most Wanted (2005) rebuilds the PC game's systems in Unity from function-by-function study of speed.exe and reads cars, world, audio and other content from the user's installation. Its analysis notes report using REA with Ghidra, and its code includes game-data readers, runtime systems and standalone .NET probes. The author reports a playable offline career and 98% code-port coverage.

NHL24 PC runs the PS4 version of NHL 24 on Windows through a game-specific shadPS4 fork. It executes the game's x86-64 code directly, replaces PS4 system-library calls with native implementations, translates GCN shaders to SPIR-V for Vulkan, and extracts the user's own base and update PKGs through its launcher.

Nightmare Creatures ports the USA PlayStation game to macOS, Windows, and Linux using a user-supplied CHD image. Its runtime interprets the original processor code while native components handle graphics, sound, input, and saves; separate tools analyse the game's executables and progressively translate code into C.

Ninja Gaiden Black native PC port runs the original Xbox game's x86 code inside a 32-bit Windows process. Its C runtime supplies an XBE loader, replacement Xbox kernel, NV2A-to-OpenGL renderer and APU audio engine; Python tools and notes document game formats and executable behaviour. The launcher imports files from the user's disc.

Ninja Master reconstructs Shinobi III: Return of the Ninja Master's gameplay as a native desktop program. It loads graphics, sound and stage data from a compatible user-supplied Mega Drive ROM, with widescreen presentation, configurable controls and save slots.

OCTR adapts Crash Team Racing: Nitro-Fueled's PS4 executable to Windows and Linux while running its x86-64 code directly on the host CPU. A replacement PS4 runtime and shadPS4-derived Vulkan renderer support the game, and this fork adds community-server races, private rooms, friends, and the Pit Stop.

Odin Sphere Leifthrasir - PC Port runs the PS4 game's original x86-64 code on a native PC runtime that replaces PS4 system libraries and uses a shadPS4-derived Vulkan renderer. Its installer accepts user-provided packages for specified USA, Japanese, European and Hong Kong builds, and scans selected eboot.bin builds for executable sites.

Onslaught CE ports Battle Engine Aquila to native 32-bit Linux and Windows builds using the game's public source and a separate matching decompilation. Its SDL3 platform layer supplies window, input and audio support, with Direct3D 9 through dxvk-native on Linux and the system implementation on Windows; retail data comes from the user's installation.

Open Ocarina ports the Ocarina of Time decompilation to a Windows build using assets extracted from the player's ROM. It adds adjustable frame rates, free camera control, keyboard and gamepad mappings, and support for GLideN64 texture packs.

OpenCE PS4 ports OpenCE's reconstructed Halo: Combat Evolved code to a jailbroken PlayStation 4. It builds the game as x32 code inside a PS4 host, maps platform services and DualShock 4 input, and routes OpenGL ES rendering through Mesa Zink and RADV; game maps come from the user's own Xbox copy.

OpenCE-macOS ports OpenCE's Halo: Combat Evolved decompilation to Apple silicon Macs. It builds a native macOS app, maps the game's 32-bit code into a 4 GB address window, and renders through ANGLE on Metal. At first launch, the app imports maps from the user's Xbox disc image.

OpenCivOne rewrites the 1991 DOS Civilization game for desktop systems with .NET 8 and Avalonia. A virtual CPU runs assembly code still awaiting replacement, while rewritten portions use C#. The game currently needs the owner's original text, picture, and palette files.

OpenCMR2 VR ports Colin McRae Rally 2.0 to Meta Quest 3 and Windows PCVR using the OpenCMR2 codebase built from CMR2Decomp. It adds OpenXR rendering and controller support and imports data from a player's installed PC copy. The Quest build runs on the headset; the Windows build uses a connected OpenXR headset.

OpenCrossing Anbernic runs Animal Crossing for the GameCube on Anbernic handhelds. The game's decompiled C code runs on the handheld CPU, and a translation layer turns GameCube graphics calls into OpenGL ES. It is built from ACreTeam/ac-decomp.

OpenCrossing-Xbox compiles the decompiled GameCube code of Animal Crossing for the original Xbox and reads data from the user's USA Rev 0 disc image. Its Xbox-specific layer adapts video, audio, input, memory and file paths, including a renderer path to the NV2A GPU.

OpenCrown PC runs Dragon's Crown Pro from a user-supplied decrypted PS4 or PS5 dump on Windows and Linux. Its native loader executes the game's code while replacing PS4 libraries, rendering, input, saves and online services; the repository includes format readers and a separate Linux host.

OpenDW ports Dragon Wars from its 16-bit DOS implementation toward a C game engine for modern environments. It builds an SDL2 frontend and uses the player's original DRAGON.COM, DATA1 and DATA2 files; the repository also includes resource extraction tools.

OpenDW reverse engineers and ports the original Mac Deepworld client to Windows in C++ with Axmol. The source implements game entities, world rendering, inventory and interface components; builds require user-provided assets, and play requires a compatible server.

OpenMTV ports the 1991 DOS game Mad TV to Windows, macOS, and Linux using readable C reconstructed from its executable. A static recompiler supplies machine-level C for remaining code, while a DOS and hardware runtime supports the game and comparisons with original behavior.

openmx ports the PlayStation 2 game MX Unleashed's riding simulation to Rust and supplies new desktop and browser presentation. It reads tracks, vehicles, art and sound from the user's disc dump; the author reports comparing simulation functions, PCSX2 captures and frame-by-frame replay state hashes with the original.

OpenNox ports and extends the Nox game engine with Go and C code for cross-platform play, preservation and modding. Its contributor documentation describes analyzing an incompletely understood codebase with a C parser and refactoring it while replacing platform dependencies with Go, SDL2 and OpenAL. The project reports campaign and online play support.

OpenOMORI rehosts the user's OMORI copy in a browser by replacing the game's NW.js and Node desktop APIs with browser-facing shims. It adds in-memory data decryption, a mod loader, map and event compiler, checkpoints and research-based story-route tools. The author reports coverage of early game flows on one Steam build in Windows Chrome, with later gameplay still unexplored.

OpenPREY adapts a Quake4Doom-derived engine to run PREY (2006) from the player's original installation on Windows, Linux and macOS. It checks the game's PK4 asset layout, supports its game-module loading model, and adds SDL3 windowing, modern display modes and diagnostic tooling.

OpenSolomonsKey ports the 1986 arcade game Solomon's Key to Linux and Windows in C++. Its source includes gameplay, graphics, audio, level handling and platform entry points, with build scripts for the supported systems.

OpenSpidey rebuilds the PC version of Spider-Man (2000) as a native SDL3 and OpenGL application using an attributed earlier decompilation and the player's own game data. Its setup imports files from a disc ISO or installed folder, and a comparison tool places original game functions beside rebuilt DLL functions. The author describes the game restoration and matching decompilation as unfinished.

OpenSRO ports Silkroad Online v1.150 into a TypeScript and WebGPU browser client with a Go game server. Function-address evidence accompanies ported behavior, and an asset pipeline turns the user's own v1.150 client installation into data for the browser and server.

OpenSWE1R ports the Windows x86 release of Star Wars: Episode I Racer by patching replacement open-source code into the game at runtime. It combines x86 CPU emulation with implementations of the Windows functions the game uses. Unreplaced functions still execute from the original game binary, and game art comes from the user's copy.

OpenSWOS rebuilds Sensible World of Soccer in C from reverse engineering of the Amiga game and runs it across desktop, mobile and Amiga platforms. Its setup creates the required graphics, music and team data from the user's own game copy, and the port adds online multiplayer and widescreen display.

OpenTitus ports the DOS game engine used by Titus the Fox and Moktar into a C program for Linux and Windows. It parses files from the user's original games, including SQZ levels, sprites and images, and uses titus.conf to select their paths and game-specific settings.

OpenVice ports Grand Theft Auto: Vice City to a C# engine that uses the original game's files. It parses RenderWare data, renders through OpenTK, uses BEPU Physics and decodes ADF radio audio alongside MP3 playback.

Oracles NX ports the C reimplementation of Oracle of Ages and Oracle of Seasons to Nintendo Switch homebrew. It builds the native game code into an .nro and adds Switch-specific ROM installation, SDL3 and OpenGL ES rendering, controls and fiber stacks.

Ottsel ports OpenGOAL's decompiled Jak and Daxter: The Precursor Legacy source to iPad, iPhone and Apple Silicon Macs. It adds an ARM64 compiler backend, ahead-of-time signed modules and an Apple-platform app with touch and controller input, while extracting art and data from the user's PS2 disc. The author reports physical-iPad and Mac runs; physical-iPhone testing remains pending.

OutRunners ports Sega's arcade game to native computer and handheld builds using the game's C decompilation. Its own runtime provides arcade and home versions, while extraction tools obtain graphics, sound and other data from a user-provided World ROM set.

OverBlood-xport ports reconstructed code from the PlayStation game OverBlood. Its C startup code loads the original SLUS_004.64 executable, mounts extracted resources from DATA and loads KROM15.BIN before entering the game.

Paper Cut ports Paper Mario: The Thousand-Year Door to Windows, macOS, Linux, iOS and Android using C code from a decompilation. Aurora replaces the GameCube graphics, audio, input, disc and memory card layers with WebGPU/Dawn and SDL3. The port reads the user's disc image and supports the Japanese, US and European releases.

Paper Hexagon ports reconstructed Super Hexagon game code from the GOG Linux build to modern Linux and Playdate. Its Playdate shim replaces openFrameworks rendering, audio, input and persistence interfaces while retaining the game logic. The research documents byte-matching functions and behavioral trace comparisons; users supply their own music and sound assets.

Compiles Paper Mario decompilation sources, credited to the pmret and Paper Mario DX projects, into a native US-version application on libultraship. Torch converts the user’s own ROM into a local asset archive, and the port adds rendering backends, enhancements and archive-based mods. Desktop releases are published, while Android, iOS and web builds are documented on the development branch.

PaperPad builds Paper Mario for Apple devices from the game's decompilation sources, adding native touch controls, settings and local ROM import to PaperBoat. The repository also retains an earlier Apple port that combines the decompilation with a statically recompiled runtime.

PaperShip ports Paper Mario 64 decompilation source to PC with a custom platform layer on libultraship. It maps Nintendo 64 graphics, audio, input, and ROM access to desktop backends while reading game assets from the user's US ROM. The author reports playtesting through Chapter 2.

Party Board is a work-in-progress port of Mario Party 4 for Windows, Linux, macOS, Android and iOS that requires the user's own game copy. The repository includes C/C++ source, configuration for the two USA revisions GMPE01_00 and GMPE01_01, and platform build instructions.

PE2PC compiles decompiled C code from the US PlayStation release of Parasite Eve II as a native PC game. A Rust runtime replaces console graphics, sound, disc, controller and memory-card services, while game data is read at runtime from the user's two original disc images.

Ports the decompilation-based Perfect Dark game to Android through a platform layer, on-screen controls and a Gradle build. It builds on an existing desktop port and requires the player's own Perfect Dark ROM. The Android guide describes touch input, landscape orientation and a launcher that imports mod folders.

piney_apples rebuilds the engines of .hack//Infection, Mutation, Outbreak and Quarantine as a native Rust program. It replaces game loops, scripts, battles, rendering and audio, generates tables from users' North American PS2 discs, and compares selected Rust functions with original code run in a project interpreter. The project reports that players reached the endings of all four games.

Playcard Cosmic recreates the 2000 Windows shoot-'em-up in C++20 and SDL3 for Windows, Linux and macOS. Its analysis maps original executable functions and Win32 resources; the port reads graphics and sound from the user's COSMIC.EXE and replaces DirectX subsystems.

Pocket Wormhole brings the Project Wormhole reimplementation of FTL: Faster Than Light to Android using the player's ftl.dat. Its port replaces desktop OpenGL, OpenAL, GLFW and Slick2D interfaces with Android graphics, audio and touch input layers, and adds save export and import for compatible game runs.

This is a native Nintendo 3DS port of Pokémon Platinum, built from the pret/pokeplatinum decompilation. The remastered display targets a New 3DS, New 3DS XL, or New 2DS XL. The ROM is Pokémon Platinum, USA, revision 0 or revision 1. A browser builder makes the SD card files locally. A source build uses devkitPro's 3ds-dev group, Python 3.10 or newer, and Git.

Builds native 64-bit Windows and Linux executables of Pokémon Platinum from a fork of pret’s decompilation, replacing NitroSDK with the author’s libntr libraries; the same tree keeps the DS ROM build and an experimental Switch target. README says the game should be playable from start to finish but may crash or show graphical bugs. Prebuilt binaries require the player’s own US ROM, and the fork’s default build no longer runs pret’s checksum tests.

Pokémon X reconstruction rebuilds selected Nintendo 3DS game logic and asset handling in portable C, with an SDL2 field slice for walking, dialogue and wild battles. Its native tools decode local game data, and the analysis notes document a live REA MCP workflow for move-resource investigation. The author reports extensive checks of reconstructed subsystems; the field slice remains incomplete.

Precursor ports the Jak and Daxter trilogy to Android ARM64 using OpenGOAL's recovered GOAL code and tools. It adds an AArch64 compiler backend, C++–GOAL call bridges, an OpenGL ES 3.2 renderer, and a phone launcher that extracts and compiles game data from the user's PS2 ISO. The author reports that all three games boot on a phone, with different portions playable.

Prehistorik_js rewrites the first level of a specified Prehistorik playable demo in C. Its source includes game, cave, object, and level code alongside scripts for unpacking and converting DOS resources.

Professor Layton: Curious Village HD Vita runs the Android game on PS Vita by loading its ARMv7 executable, resolving Android imports with native functions and patching platform behavior. The loader uses the player's APK and OBB data; the author notes occasional video problems and slow animation after puzzle solutions.

Professor Layton: Lost Future HD Vita runs the Android ARMv7 game executables on PS Vita by loading them into memory, resolving imports with native functions and applying patches. The user supplies the Android APK and OBB files.

This Vita port runs Professor Layton: Pandora's Box HD by loading its Android ARMv7 executable, resolving imports with native functions, and applying compatibility patches. The loader uses game files supplied from an Android APK and OBB, with version 1.0.1 documented as tested.

Project Picori ports The Legend of Zelda: The Minish Cap to native Linux, Windows and macOS builds using SDL3, a software PPU renderer and agbplay audio. It validates a user-provided USA, EU or JP ROM by SHA-1 and extracts the runtime assets needed by the port.

PROTOTYPE — native PC port runs the PS4 bundle's x86-64 game code directly on Windows, replacing PS4 system libraries and translating GPU commands to Vulkan through a shadPS4 video core. Game-specific fixes address timing, saves and rendering; PROTOTYPE 2 support is experimental.

PsyDoom ports PlayStation Doom and Final Doom to modern PCs from code derived from the PlayStation machine code. The author describes a gradual conversion from emulated MIPS instructions to C++, emulates the original GPU and SPU behavior, and adds an optional Vulkan renderer. The author reports matching four recorded playthroughs when given the same player inputs.

Quake 4 Definitive Edition ports selected Xbox 360 controller behavior into openQ4 patches for the PC game. The project documents analysis of default.xex to recover stick dead zones, a square gate, look curves and turn speeds, then adds controller settings and aim-assist behavior to the engine.

This runs Super Mario Strikers for the GameCube on a Meta Quest 3 as a mixed-reality app. It is a fork of the Android port, compiled for the headset and drawn through OpenXR. The README describes a floating screen, a life-size stadium, and a tabletop pitch. The player installs the APK from Releases and supplies their own copy of the game.