# Reverse-engineering case studies · Page 10

> Page 10 of 21, cases 1,801–2,000. 4,025 case studies from 5,191 curated resources, with documented reconstruction methods, scope, and original evidence.

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

## Games (200)

- [BLACK PC port: running Xbox game code on Windows](https://awesomerea.org/resources/black-pc-case/index.md): Case study · 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: a native Windows port of the PS4 executable](https://awesomerea.org/resources/bloodborne-pc-windows-port-case/index.md): Case study · 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: an NES disassembly and C/SDL2 port](https://awesomerea.org/resources/boulder-dash-nes-decomp-case/index.md): Case study · 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: an Apple-platform port of Super Smash Bros. 64](https://awesomerea.org/resources/brawlerpad-smash-64-apple-port-case/index.md): Case study · 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.
- [Budokai Tenkaichi 3: a native PC port built on a matching decompilation](https://awesomerea.org/resources/tenkaichi3-pc-port-case/index.md): Case study · 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: a port of Takedawn](https://awesomerea.org/resources/ps5-burnout-3-case/index.md): Case study · 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: a portable build of recovered game source](https://awesomerea.org/resources/caesar-ii-port-case/index.md): Case study · 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: Atari Jaguar DOOM port with renderer reverse engineering](https://awesomerea.org/resources/calico-doom-case/index.md): Case study · 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: rewriting the OutRun arcade engine in C++](https://awesomerea.org/resources/cannonball-outrun-case/index.md): Case study · 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: adapting Dethrace for ARM64 phones](https://awesomerea.org/resources/carmageddon-android-port-case/index.md): Case study · 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: a Carmageddon 2 decompilation and native port](https://awesomerea.org/resources/carpocalypse2-case/index.md): Case study · 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: a paused native Apple Silicon port](https://awesomerea.org/resources/castlevania-belmonts-curse-native-case/index.md): Case study · 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.
- [Castlevania: Symphony of the Night: a Vita shared-library port](https://awesomerea.org/resources/sotn-vita-library-port-case/index.md): Case study · 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: a frame-checked native C reimplementation](https://awesomerea.org/resources/chrono-trigger-reimplemented-case/index.md): Case study · 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: porting a GameMaker: Studio runner reconstruction to Nintendo consoles](https://awesomerea.org/resources/cinnamon-gamemaker-runner-case/index.md): Case study · 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: a native port of Cosmo's Cosmic Adventure](https://awesomerea.org/resources/cosmo-native-port-case/index.md): Case study · 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: a native port from matching decompiled source](https://awesomerea.org/resources/crash-bandicoot-pc-port-case/index.md): Case study · 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: a Vita, PC and browser source port](https://awesomerea.org/resources/crash-team-racing-high-octane-case/index.md): Case study · 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: adapting a PS2 decompilation to native Windows](https://awesomerea.org/resources/crash-twinsanity-windows-case/index.md): Case study · 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: a Crash Team Racing PC port from decompiled source](https://awesomerea.org/resources/ctr-native-port-case/index.md): Case study · 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: extending a native Crash Team Racing port](https://awesomerea.org/resources/ctr-reload-edition-case/index.md): Case study · 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.
- [CTR Turbocharged: a PC sourceport built on the Crash Team Racing decompilation](https://awesomerea.org/resources/ctr-turbocharged-port-case/index.md): Case study · 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: a Windows port of Crash Team Racing: Nitro-Fueled](https://awesomerea.org/resources/ctr-nitrofueled-pc-case/index.md): Case study · 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: porting the Diablo II Mac executable to 32-bit Linux](https://awesomerea.org/resources/d2mac-linux-case/index.md): Case study · 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: an Android executable port to PS Vita](https://awesomerea.org/resources/dariusburst-sp-vita-case/index.md): Case study · 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: a PlayStation 2 port of Dark Souls Remastered](https://awesomerea.org/resources/dark-souls-ps2-case/index.md): Case study · 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: porting the Android game to PS Vita](https://awesomerea.org/resources/death-road-to-canada-lite-case/index.md): Case study · 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: portable C port of the PlayStation game](https://awesomerea.org/resources/destruction-derby-2-port-case/index.md): Case study · 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: a Nintendo Switch port of reconstructed Diablo](https://awesomerea.org/resources/devilution-nx-case/index.md): Case study · 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.
- [DevilutionX: porting Diablo’s reconstructed engine](https://awesomerea.org/resources/devilutionx-case/index.md): Case study · 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.
- [DiabloWeb: a WebAssembly browser port built on Devilution](https://awesomerea.org/resources/diabloweb-devilution-wasm-port-case/index.md): Case study · 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.
- [Diddy Kong Racing on Xbox: a UWP port of Golden Balloon](https://awesomerea.org/resources/dkr-xbox-case/index.md): Case study · 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: translating arcade routines and modeling triple-Z80 hardware](https://awesomerea.org/resources/digdug-decomp-case/index.md): Case study · 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.
- [Digimon World 2 PC port: native Windows and Linux builds](https://awesomerea.org/resources/digimon-world-2-pc/index.md): Case study · 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: a handheld port of the matching decompilation](https://awesomerea.org/resources/dw3-handheld-port-case/index.md): Case study · 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: a native PC port from decompiled C](https://awesomerea.org/resources/dw3-native-port-case/index.md): Case study · 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: bringing Dinosaur Planet Recompiled to Apple devices](https://awesomerea.org/resources/dinopad-dinosaur-planet-case/index.md): Case study · 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: an Android port of The Dishwasher: Dead Samurai](https://awesomerea.org/resources/dishsoap-dishwasher-android-port-case/index.md): Case study · 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.
- [DK64: Recompiled — an Android port of Donkey Kong 64](https://awesomerea.org/resources/dk64-android/index.md): Case study · 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: a native GameCube port of Diddy Kong Racing](https://awesomerea.org/resources/dkr-gc-diddy-kong-racing-case/index.md): Case study · 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: porting Dead or Alive Xtreme 3 Fortune to Windows](https://awesomerea.org/resources/doax3-fortune-pc-case/index.md): Case study · 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: a native Death Rally port for Linux and BSD](https://awesomerea.org/resources/drally-case/index.md): Case study · 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: a Unity client and server from game analysis](https://awesomerea.org/resources/driftcity-unity-case/index.md): Case study · 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: porting Dead Space 2 to Nintendo Switch](https://awesomerea.org/resources/ds2-nx-case/index.md): Case study · 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: running the Durak Android game on Nintendo Switch](https://awesomerea.org/resources/durak-nx-case/index.md): Case study · 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: a native Twilight Princess port](https://awesomerea.org/resources/dusklight-ps4-case/index.md): Case study · 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.
- [Dusklight: a native Twilight Princess port built on the decompilation](https://awesomerea.org/resources/dusklight-twilight-princess-port-case/index.md): Case study · 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.
- [EA SPORTS UFC 3: a native PS4 game port for Linux and Windows](https://awesomerea.org/resources/ufc-3-ps4-port-case/index.md): Case study · 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: native EarthBound build](https://awesomerea.org/resources/earthbound-companion/index.md): Case study · 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: partial Project Eden reconstruction](https://awesomerea.org/resources/eden-project-eden-case/index.md): Case study · 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: a native Nintendo 3DS port of Pokémon Emerald](https://awesomerea.org/resources/emerald-3ds-case/index.md): Case study · 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: a modern port of the reconstructed DOS game](https://awesomerea.org/resources/f15-strike-eagle-2-source-port-case/index.md): Case study · 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: an Apple platform port of F-Zero X](https://awesomerea.org/resources/f0x-f-zero-x-case/index.md): Case study · 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: reconstructing the DOS loader, formats and game systems](https://awesomerea.org/resources/fifa-96-re-case/index.md): Case study · 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: running the Android game on PS Vita](https://awesomerea.org/resources/final-fantasy-4-vita-case/index.md): Case study · 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: rehosting the Android executable](https://awesomerea.org/resources/final-fantasy-after-years-vita-case/index.md): Case study · 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: rehosting the Android game on PS Vita](https://awesomerea.org/resources/final-fantasy-dimensions-vita-case/index.md): Case study · 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: an Animal Crossing GameCube PC port](https://awesomerea.org/resources/forest-animal-crossing-port-case/index.md): Case study · 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: a native Star Fox Adventures port](https://awesomerea.org/resources/foxhollow-star-fox-adventures-case/index.md): Case study · 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: porting The Settlers I remake to C#](https://awesomerea.org/resources/freeserf-net-settlers-case/index.md): Case study · 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: reconstructing the game's intro renderer and audio](https://awesomerea.org/resources/frontier-elite-ii-intro-player-case/index.md): Case study · 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: F-Zero X port for Nintendo 3DS](https://awesomerea.org/resources/gdx-3ds-case/index.md): Case study · 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: a PC port of F-Zero X and its 64DD Expansion Kit](https://awesomerea.org/resources/g-diffuser/index.md): Case study · 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: a LÖVE2D port of eleven Pokémon games](https://awesomerea.org/resources/g1r-deluxe-pokemon-port-case/index.md): Case study · 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: porting Super Mario Galaxy to iPhone and iPad](https://awesomerea.org/resources/galaxypad-super-mario-galaxy-case/index.md): Case study · 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: a PC port of Super Smash Bros. Melee's matching decompilation](https://awesomerea.org/resources/gds-melee-case/index.md): Case study · 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: a native Geometry Wars: Retro Evolved 2 port](https://awesomerea.org/resources/geow2-case/index.md): Case study · 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.
- [Ghostship: a libultraship native port of Super Mario 64](https://awesomerea.org/resources/ghostship-sm64-port-case/index.md): Case study · 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: a port of Mirror's Edge for iPad](https://awesomerea.org/resources/glassline-mirrors-edge-ipad-port-case/index.md): Case study · 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: a mobile port with game-code analysis](https://awesomerea.org/resources/goemon64-recompiled-android-case/index.md): Case study · 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: native and browser port of Diddy Kong Racing](https://awesomerea.org/resources/goldenballoon-case/index.md): Case study · 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: an on-device recompilation port](https://awesomerea.org/resources/golden-sun-recompiled-android-case/index.md): Case study · 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.
- [GoldenEye 007: a Nintendo 3DS port from decompiled source](https://awesomerea.org/resources/goldeneye-3ds-port-case/index.md): Case study · 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.
- [GoldenEye 007: an agent-assisted native port from a decompilation](https://awesomerea.org/resources/goldeneye-pc-port-case/index.md): Case study · 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: a native multiplatform port](https://awesomerea.org/resources/gran-turismo-2-pc-vr-browser-case/index.md): Case study · 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.
- [Gravity Rush 2: a PS4 runtime port for PC](https://awesomerea.org/resources/gravity-rush-2-pc-case/index.md): Case study · 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: a native PC port of the PS4 game](https://awesomerea.org/resources/gravity-rush-remastered-pc-case/index.md): Case study · 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: porting an Xbox 360 recompilation to PlayStation 5](https://awesomerea.org/resources/gta-iv-ps5-port-case/index.md): Case study · 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: a function-level C++ port of the DOS game](https://awesomerea.org/resources/gunboat-port-case/index.md): Case study · 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: a PC port of Kirby 64](https://awesomerea.org/resources/halberd-kirby-64-port-case/index.md): Case study · 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.
- [Halo 2: an Xbox gameplay reconstruction and native port](https://awesomerea.org/resources/halo-2-native-port-case/index.md): Case study · 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.
- [Halo CE Decomp Remix: VR, PC and Android port](https://awesomerea.org/resources/halo-ce-decomp-remix-vr-case/index.md): Case study · 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.
- [Halo CE on RG35XX H: porting Halo: Combat Evolved to H700 handhelds](https://awesomerea.org/resources/halo-ce-rg35xx/index.md): Case study · 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: Combat Evolved: a decompilation-based PS Vita port](https://awesomerea.org/resources/halo-ce-vita-case/index.md): Case study · 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: an iOS port of Ocarina of Time via Ship of Harkinian](https://awesomerea.org/resources/harkinianpad-case/index.md): Case study · 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: decompiling and porting Massive Encounter](https://awesomerea.org/resources/harvest-massive-encounter-case/index.md): Case study · 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: adapting reconstructed game code to Yamagi Quake II](https://awesomerea.org/resources/heretic2-yamagi-reconstruction-case/index.md): Case study · 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: an AYN Thor port of Hollow Knight](https://awesomerea.org/resources/dual-souls-case/index.md): Case study · 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: a dual-screen Metroid Prime Hunters Android port](https://awesomerea.org/resources/hunters-recomp-case/index.md): Case study · 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: an Android native-library port for Linux ARM handhelds](https://awesomerea.org/resources/ice-rage-arm-port-case/index.md): Case study · 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.
- [ico-pc: a native ICO port compiled from the PS2 decompilation](https://awesomerea.org/resources/ico-pc-port-case/index.md): Case study · 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: porting the 1997 racing game from executable analysis](https://awesomerea.org/resources/ignition-port-case/index.md): Case study · 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: rehosting the PS4 game on Windows](https://awesomerea.org/resources/infamous-first-light-pc-case/index.md): Case study · 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: reconstructing the CPC game's bytecode engine](https://awesomerea.org/resources/infernal-runner-js-case/index.md): Case study · 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: a disassembly-based UEFI port of the NES game](https://awesomerea.org/resources/jackal-uefi-port-case/index.md): Case study · 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: porting the Call of Duty 4 multiplayer client to Apple Silicon](https://awesomerea.org/resources/jgalbs-cod4-case/index.md): Case study · 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: porting Kingdom Hearts: Chain of Memories to PS Vita](https://awesomerea.org/resources/kh-com-vita-case/index.md): Case study · 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: a PS Vita port of Kingdom Hearts 358/2 Days](https://awesomerea.org/resources/khdays-vita-case/index.md): Case study · 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: a native Windows port with Vulkan graphics](https://awesomerea.org/resources/killzone-shadow-fall-pc-case/index.md): Case study · 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.
- [Kingdom Hearts 358/2 Days: native PC port built on a matching decompilation](https://awesomerea.org/resources/khdays-native-pc-port-case/index.md): Case study · 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: running the PS4 game with a replacement runtime](https://awesomerea.org/resources/knack-pc-case/index.md): Case study · 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: reconstructing the puzzle game's rules in 6502 assembly](https://awesomerea.org/resources/kye-c64-case/index.md): Case study · 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: a Bloodborne runtime for Windows and Linux](https://awesomerea.org/resources/lantern-engine-case/index.md): Case study · 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: a PS4-to-Windows native port](https://awesomerea.org/resources/lego-dimensions-pc-case/index.md): Case study · 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.
- [LEGO Island, portable: a multi-platform port of the decompiled source](https://awesomerea.org/resources/lego-island-portable-case/index.md): Case study · 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: porting the decompiled game across platforms](https://awesomerea.org/resources/lego-racers-portable-case/index.md): Case study · 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: a cross-platform port from matching decompiled source](https://awesomerea.org/resources/legoland-port-case/index.md): Case study · 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.
- [Lighthouse: a Banjo-Kazooie PC port built on the decompilation](https://awesomerea.org/resources/lighthouse-banjo-kazooie-port-case/index.md): Case study · 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.
- [LineWars II: a portable SDL3 reconstruction](https://awesomerea.org/resources/linewars-ii-sdl-case/index.md): Case study · 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.
- [Link: The Faces of Evil — a native PC port of the CD-i decompilation](https://awesomerea.org/resources/link-faces-of-evil-pc-case/index.md): Case study · 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: rehosting Dark Souls: Remastered on Apple devices](https://awesomerea.org/resources/lordran-native-case/index.md): Case study · 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: porting Super Mario Galaxy to Apple Silicon](https://awesomerea.org/resources/maciogalaxy-case/index.md): Case study · 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: a DOS game reconstruction and Windows port](https://awesomerea.org/resources/magic-carpet-native-port-case/index.md): Case study · 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: a differential TypeScript port of Marble Madness](https://awesomerea.org/resources/marble-love-case/index.md): Case study · 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: a Ghostship port](https://awesomerea.org/resources/ps5-ghostship-case/index.md): Case study · 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: porting Mario Kart 64 to Nintendo 3DS](https://awesomerea.org/resources/mario-kart-64-3ds-case/index.md): Case study · 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: porting the Nintendo 64 game to Dreamcast](https://awesomerea.org/resources/mk64-dc-case/index.md): Case study · 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: a native port built from the player's disc](https://awesomerea.org/resources/mkw-3ds-case/index.md): Case study · 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: an iPhone and iPad port of Majora's Mask](https://awesomerea.org/resources/maskpad-case/index.md): Case study · 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.
- [Max Payne Mobile: Android binary rehosting on Switch](https://awesomerea.org/resources/max-payne-mobile-switch-port-case/index.md): Case study · 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: porting Max Payne Mobile's Android binary to PS Vita](https://awesomerea.org/resources/max-vita-case/index.md): Case study · 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: reconstructing the 1997 game](https://awesomerea.org/resources/mdk-sdl-case/index.md): Case study · 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: a port from game data and executable analysis](https://awesomerea.org/resources/mdk-godot-case/index.md): Case study · 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: reconstructing the 1989 game in C17](https://awesomerea.org/resources/mechwarrior-sdl-port-case/index.md): Case study · 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: a Medal Of Honor PlayStation decompilation port](https://awesomerea.org/resources/medalofhonor-xport-case/index.md): Case study · 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: a native PC port of the 2019 PS4 game](https://awesomerea.org/resources/medievil-2019-pc-port-case/index.md): Case study · 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: an Android and iOS port of the recompilation](https://awesomerea.org/resources/mega-man-64-mobile-port-case/index.md): Case study · 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: seven Commander Keen games reconstructed in Godot](https://awesomerea.org/resources/megarocket-commander-keen-case/index.md): Case study · 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: a native original Xbox port of Super Smash Bros. Melee](https://awesomerea.org/resources/melee-x-case/index.md): Case study · 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: porting Super Smash Bros. Melee to Xbox 360](https://awesomerea.org/resources/melee360-case/index.md): Case study · 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.
- [Metaforce: a Metroid Prime engine reimplementation rebuilt on the decompilation](https://awesomerea.org/resources/metaforce-metroid-prime-case/index.md): Case study · 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.
- [Metroid Prime Port: an AI-assisted native port of the PrimeDecomp decompilation](https://awesomerea.org/resources/metroid-prime-port-case/index.md): Case study · 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: porting a PS2 game function by function](https://awesomerea.org/resources/metropolismania-pc-case/index.md): Case study · 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.
- [MikuPan: a native Fatal Frame PC port built on the Himuro decompilation](https://awesomerea.org/resources/mikupan-fatal-frame-port-case/index.md): Case study · 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: porting fifteen Nintendo 64 games to Miyoo Mini](https://awesomerea.org/resources/miyoo64/index.md): Case study · 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: translating the Mega Man 5 sound driver to C++](https://awesomerea.org/resources/mm5sound-case/index.md): Case study · 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: an Android port of The Legend of Zelda: A Link to the Past](https://awesomerea.org/resources/moonpearl/index.md): Case study · 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.
- [Naruto: The Broken Bond — an Android ARM64 port of the Xbox 360 recompilation](https://awesomerea.org/resources/naruto-the-broken-bond-android-port-case/index.md): Case study · 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: reverse-engineered ports of Build-engine games](https://awesomerea.org/resources/nblood-build-games-case/index.md): Case study · 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: bringing Super Mario Galaxy to Windows](https://awesomerea.org/resources/nebula-smg/index.md): Case study · 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.
- [Need for Speed: Most Wanted: rehosting the Android release on R36S](https://awesomerea.org/resources/nfsmw-r36s-case/index.md): Case study · 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: a Rust reconstruction checked against the original](https://awesomerea.org/resources/nes-tetris-rust-case/index.md): Case study · 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): a Unity rebuild from speed.exe analysis](https://awesomerea.org/resources/nfsmw-unity-case/index.md): Case study · 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: running NHL 24 on Windows through a game-specific PS4 runtime](https://awesomerea.org/resources/nhl24-pc-case/index.md): Case study · 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: PlayStation executable analysis and native PC port](https://awesomerea.org/resources/nightmare-creatures-pc-port-case/index.md): Case study · 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: running Xbox game code on a native Windows runtime](https://awesomerea.org/resources/ninja-gaiden-black-port-case/index.md): Case study · 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: a native Shinobi III reconstruction](https://awesomerea.org/resources/ninja-master-shinobi-iii-case/index.md): Case study · 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: a native CTR Nitro-Fueled PC port with online play](https://awesomerea.org/resources/octr-nitrofueled-pc-case/index.md): Case study · 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: running the PS4 game code on PC](https://awesomerea.org/resources/odin-sphere-leifthrasir-pc-case/index.md): Case study · 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: a native Battle Engine Aquila port](https://awesomerea.org/resources/onslaught-ce-case/index.md): Case study · 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: a PC source port of Ocarina of Time](https://awesomerea.org/resources/open-ocarina-master-port-case/index.md): Case study · 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: porting Halo: Combat Evolved to PlayStation 4](https://awesomerea.org/resources/opence-ps4-case/index.md): Case study · 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: porting Halo: Combat Evolved to Apple silicon](https://awesomerea.org/resources/opence-macos-case/index.md): Case study · 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: rewriting the original Civilization](https://awesomerea.org/resources/opencivone-case/index.md): Case study · 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: a Quest and PCVR port of Colin McRae Rally 2.0](https://awesomerea.org/resources/opencmr2-vr-case/index.md): Case study · 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: porting Animal Crossing to Anbernic handhelds](https://awesomerea.org/resources/opencrossing-anbernic-case/index.md): Case study · 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: an original Xbox port of Animal Crossing](https://awesomerea.org/resources/opencrossing-xbox-case/index.md): Case study · 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: a native Dragon's Crown Pro host for console dumps](https://awesomerea.org/resources/opencrown-pc-case/index.md): Case study · 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: porting Dragon Wars to a C game engine](https://awesomerea.org/resources/opendw-dragon-wars-case/index.md): Case study · 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: porting the original Mac Deepworld client to Windows](https://awesomerea.org/resources/opendw-case/index.md): Case study · 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: Mad TV decompiled and ported to modern systems](https://awesomerea.org/resources/openmtv-mad-tv-case/index.md): Case study · 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: porting the MX Unleashed simulation to Rust](https://awesomerea.org/resources/openmx-case/index.md): Case study · 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: a cross-platform reconstruction of the Nox engine](https://awesomerea.org/resources/opennox-engine-reconstruction-case/index.md): Case study · 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: rehosting OMORI's desktop runtime in the browser](https://awesomerea.org/resources/openomori-case/index.md): Case study · 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: a replacement engine for PREY (2006)](https://awesomerea.org/resources/openprey-prey-2006-case/index.md): Case study · 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: a Linux and Windows port of Solomon's Key](https://awesomerea.org/resources/open-solomons-key-case/index.md): Case study · 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: a native Spider-Man (2000) PC rebuild](https://awesomerea.org/resources/openspidey-spider-man-port-case/index.md): Case study · 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: porting Silkroad Online v1.150 to a browser game stack](https://awesomerea.org/resources/opensro-case/index.md): Case study · 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: porting Star Wars: Episode I Racer with runtime code replacement](https://awesomerea.org/resources/openswe1r-case/index.md): Case study · 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: rebuilding Sensible World of Soccer in C](https://awesomerea.org/resources/openswos-case/index.md): Case study · 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: porting the Titus the Fox and Moktar engine](https://awesomerea.org/resources/opentitus-case/index.md): Case study · 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: a C# port of Grand Theft Auto: Vice City](https://awesomerea.org/resources/openvice-case/index.md): Case study · 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: a Nintendo Switch port of the Oracle games](https://awesomerea.org/resources/oracles-nx-case/index.md): Case study · 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: an ARM64 port of Jak and Daxter](https://awesomerea.org/resources/ottsel-jak-port-case/index.md): Case study · 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: native ports built on an arcade game decompilation](https://awesomerea.org/resources/outrunners-port-case/index.md): Case study · 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: an OverBlood PlayStation decompilation port](https://awesomerea.org/resources/overblood-xport-case/index.md): Case study · 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: a native Paper Mario: The Thousand-Year Door port](https://awesomerea.org/resources/paper-cut-thousand-year-door-case/index.md): Case study · 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: a reconstructed Super Hexagon port for Linux and Playdate](https://awesomerea.org/resources/paper-hexagon-super-hexagon-case/index.md): Case study · 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.
- [PaperBoat: a native Paper Mario port built on the decompilation](https://awesomerea.org/resources/paperboat-paper-mario-port-case/index.md): Case study · 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: bringing Paper Mario to Apple devices](https://awesomerea.org/resources/paperpad-case/index.md): Case study · 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: a PC port of Paper Mario 64](https://awesomerea.org/resources/papership-paper-mario-port-case/index.md): Case study · 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: a multiplatform Mario Party 4 port](https://awesomerea.org/resources/party-board-case/index.md): Case study · 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: a native Parasite Eve II port from decompiled C](https://awesomerea.org/resources/pe2pc-parasite-eve-ii-port-case/index.md): Case study · 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.
- [Perfect Dark on Android: porting the decompilation-based game](https://awesomerea.org/resources/perfect-dark-android-case/index.md): Case study · 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: reconstructing the four .hack PS2 games in Rust](https://awesomerea.org/resources/piney-apples-case/index.md): Case study · 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: a native port from executable analysis](https://awesomerea.org/resources/playcard-cosmic-port-case/index.md): Case study · 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: an Android port of the FTL engine reimplementation](https://awesomerea.org/resources/pocket-wormhole-ftl-android-case/index.md): Case study · 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.
- [Pokémon Platinum 3DS: a native 3DS port of Pokémon Platinum](https://awesomerea.org/resources/pokeplatinum-3ds/index.md): Case study · 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.
- [Pokémon Platinum PC Port: a native port built on the pret decompilation](https://awesomerea.org/resources/pokemon-platinum-pc-port-case/index.md): Case study · 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: native C reconstruction of game logic and field data](https://awesomerea.org/resources/pokemon-x-reconstruction-case/index.md): Case study · 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: Android ARM64 port of the Jak and Daxter trilogy](https://awesomerea.org/resources/precursor-android-jak-case/index.md): Case study · 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: a first-level demo rewrite](https://awesomerea.org/resources/prehistorik-demo-rewrite-case/index.md): Case study · 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: an Android game rehosting port](https://awesomerea.org/resources/layton-vita-case/index.md): Case study · 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: an Android executable port](https://awesomerea.org/resources/layton-lost-future-hd-vita-case/index.md): Case study · 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.
- [Professor Layton: Pandora's Box HD: rehosting the Android game on Vita](https://awesomerea.org/resources/professor-layton-pandoras-box-hd-vita-case/index.md): Case study · 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: a native PC port of The Legend of Zelda: The Minish Cap](https://awesomerea.org/resources/project-picori-minish-cap-port-case/index.md): Case study · 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: rehosting the PS4 games on Windows](https://awesomerea.org/resources/prototype-pc-port-case/index.md): Case study · 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: a native PC port of PlayStation Doom and Final Doom](https://awesomerea.org/resources/psydoom-case/index.md): Case study · 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: recovering Xbox 360 controller behavior for PC](https://awesomerea.org/resources/quake4-definitive-case/index.md): Case study · 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.
- [Quest 3 Strikers: porting Super Mario Strikers to mixed reality](https://awesomerea.org/resources/strikers-quest-mr/index.md): Case study · 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.