Reverse-engineering case studies.

Souls of the Reaper ports the Xbox 360 release of Diablo III to Windows by translating its PowerPC executable to native x64 C++ with ReXGlue. The project supplies a manifest, kernel overrides, generated-code patches, and a launcher that uses files from the user's disc.

South Park: Tenorman's Revenge is ported to Windows and Linux by translating its Xbox 360 executable to native PC code with ReXGlue. The project includes a package importer, launcher, and game-specific function analysis; the author reports that levels play on Windows while a full playthrough remains unconfirmed.

This translates the USA Dreamcast release of Space Channel 5 ahead of time into native modules. Preview v0.1.0-preview.2 runs SpaceChannel5.exe on Windows x64, SpaceChannel5 on Linux x64 and ARM64, and SpaceChannel5.app on Apple silicon and Intel macOS. The launcher checks a USA GDI and its track files. Gameplay does not use an SH4 interpreter. Flycast supplies device, rendering, and audio components. OpenGL 3.3 is required. Original 4:3 framing is the default.

Space Invaders 8080 Static Recompiler translates the 1978 arcade game's Intel 8080 ROM into generated C++ before execution. Its lifter uses a linear sweep and branch-target discovery, while an SDL3 runner models I/O ports, a shift register, video output and timed interrupts. The four original ROM files are supplied by the user.

Space Station Silicon Valley: Recompiled turns the N64 game's code into a native port with N64Recomp. RT64 renders the game, including S2DEX sprite and background display lists through a project fork, while runtime patches add widescreen and other host features.

SpaceRanger statically recompiles the USA Nintendo 64 release of Toy Story 2: Buzz Lightyear to the Rescue into a Windows port rendered by RT64. Its configuration and runtime adapters handle the game's overlays and generate translated code from the user's ROM during the build.

Sparta builds a native port of the PSP God of War: Ghost of Sparta by translating its MIPS program to C++ ahead of time. It links game-specific configuration with PortableKit's PSP services and a GE-to-Vulkan renderer. The author reports the opening level running on Windows, Apple Silicon macOS and Android.

Spartan, formerly OpenH3M, statically recompiles the Halo 3 Mythic multiplayer disc from Halo 3: ODST to Windows x64 with ReXGlue. Beta 0.8 has the 3D menu, Custom Games, local split screen for one to four players, and Forge. Theater can be opened. Recording and saved-film playback are not fully validated. The frame cap is the original 30 fps. The release archive is OpenH3M-beta-0.8-win-x64.zip and the program is OpenH3M.exe.

SpeedBreaker: Carbon is a static recompilation of the Xbox 360 version of Need for Speed: Carbon (2006). The only supported disc is the USA Collector's Edition. Packages cover SteamOS, Linux, Mac, and a Windows beta. An experimental iPhone and iPad build is also described.

Translates the Xbox 360 executable of Need for Speed: Most Wanted (2005) into native C++ with a patched XenonRecomp and runs it on a project runtime that stands in for the console’s kernel, Xenos GPU, XMA audio and controllers. Releases target SteamOS, Linux and Apple silicon Macs, with an experimental iPhone and iPad build, while all game data comes from the player’s own US disc. Rendering and frame-pacing improvements are project-reported.

The Spider-Man (2002) PC port uses xboxrecomp to translate the original Xbox game's code to C for a native Windows executable. A user-supplied default.xbe and data directory feed the build; the repository adds game-specific rendering, controls, settings and optional enhancements generated from that copy.

Spider-Man 2 PS2 Recomp applies static recompilation to the USA PlayStation 2 release SLUS-20776 for native PC execution. It combines a game-specific Ghidra function map with PS2Recomp source, runtime fixes and hardware comparison tests. The author reports that a native Windows build reaches the legal splash; the port is not playable.

The Spider-Man 2: Enter Electro kit configures psxrecomp to generate and compile the USA PlayStation game from the user's disc and BIOS during first-run setup. It includes title-specific symbols and function seeds, a recomp-ui launcher and a diagnostic build path.

Splatoon 1 PC Port builds a Windows and Linux port of the Wii U game Splatoon by statically recompiling its RPX code to C++. Continuing RebrewU, it adds game-version manifests, a Cafe OS runtime, GX2-to-Vulkan rendering and a builder that uses the player's Wii U dump. The author describes the port as work in progress.

This is a native Windows port of the original Xbox game Splinter Cell: Double Agent, made with Xbox XBE Recomp. The x86 game code is translated to C++ ahead of time and drawn with Direct3D 12 and XAudio2. An ISO or extracted files go in assets for play. A source build needs extracted files: default.xbe, sc4_adv.xbe, and the Default, Media, and adv folders. build.bat compiles it to out/build/release/SCDA.exe. The minimum system is Windows 10 64-bit, a CPU with SSE4.2 and POPCNT, and a Direct3D 12 GPU.

split2-recomp rebuilds TimeSplitters 2 for the original Xbox as a native program for Windows, macOS, and Linux, including SteamOS and Steam Deck. The build is made on the player's computer from their own copy.

Translates Super Smash Bros. Ultimate 13.0.4 AArch64 code ahead of time and supplies a Windows runtime with Vulkan/OpenGL rendering. It also reconstructs selected fighter scripts as editable C++ and compares translated/source behavior through differential and deterministic tests.

ssrecomp statically translates Pokémon SoulSilver's ARM9 code to C++ and runs it with a patched melonDS core supplying Nintendo DS hardware. Its frontend combines play on one screen and adds widescreen presentation and controller support. Builds generate game-specific code locally from the user's US ROM or decompilation output; the author states development has moved to another project.

This is a native Rust port of SSX 3 for PlayStation 2, USA SLUS_207.72. The game code was statically recompiled to Rust and is being replaced function by function. Rendering, movies, sound, files, controllers, and the memory card are native. The README says every race, freestyle event, and Conquer the Mountain are playable, on macOS, Windows, and Linux, with an experimental browser build.

SSX On Tour translates the PSP game's Allegrex MIPS executable into C++ ahead of time for Linux and Windows. Its project-specific tools load PRX data, discover functions and generate code locally; the PC runtime supplies PSP kernel services, GE rendering through OpenGL and SDL audio.

SSX Tricky Recomp generates native code from a user-supplied US retail Xbox copy of SSX Tricky and builds a Linux runtime around it. The source includes an analysis pipeline, Xbox recompilation toolkit patches and graphics, controller and audio integration; the author reports tested races and saves, with progression coverage still incomplete.

SSX Tricky: PC Port translates the Xbox game's code to C with xboxrecomp and runs it as a native Windows program using Direct3D 11, XAudio2 and XInput. The repository contains game-specific port code and notes on gameplay systems and asset formats. Its regeneration script translates code from the user's USA disc, while additional fixes and recovered functions are needed to reproduce the tested build.

This statically recompiles Star Fox for the Super Nintendo into native C with snesrecomp. The required ROM is an unheadered 1 MiB dump of Star Fox (USA) version 1.2, SHA-256 82E39DFBB3E4FE5C28044E80878392070C618B298DD5A267E5EA53C8F72CC548. The README says the game boots and that attract mode, menus, route selection, training, and gameplay have passed basic testing. An optional widescreen renderer is included.

Racer statically recompiles the N64 release of Star Wars Episode I: Racer with N64Recomp, N64ModernRuntime and RT64. Its ROM-analysis and symbol tools support game-specific fixes for libultra calls, split functions, asset loading and controller input; the author reports driving into a tournament race.

Star Wars Trilogy Arcade is ported to PC by statically translating its PowerPC game code to C++ and supplying new graphics, sound and control systems. The project documents Sega Model 3 Step 2.1 hardware and uses a Vulkan renderer; its build requires the player’s own Rev. A arcade ROM.

Star Wars: Knights of the Old Republic is statically recompiled from a user-owned Steam swkotor.exe 1.03 into native C using pcrecomp. The repository supplies the lift driver, a 32-bit Windows host, and conformance scripts; the author reports an alpha build that reaches gameplay on the Endar Spire.

This is a native port of StarCraft 64, NTSC-U. N64Recomp translates the MIPS code to C, and a software renderer draws the game's display lists. The ROM must match SHA-1 a36d91b5aac7bb95df0d7de5f9814f5270e25c2b after byte-order normalization. The README says the single-player campaign, menus, Encyclopedia, saves, and sound work. macOS on Apple Silicon and Android arm64 from Android 9 are the accepted platforms. Windows x86_64 and Linux x86_64 packages are cross-built.

The StarCraft: Ghost Xbox recompilation translates the game's x86 executable into C with XboxRecomp and links it to a Windows runtime. Game-specific patches adjust generated code; the author reports tested mission loading, gameplay and transitions, with further coverage still pending.

Uses N64: Recompiled to statically recompile the US 1.1 (Rev A) Nintendo 64 release of Star Fox 64 into a native port for Windows, Linux and macOS, rendered with RT64. Its patches and enhancements draw on headers and some functions from the separate sf64 decompilation; the port is built through static recompilation. The README reports high-frame-rate, widescreen and mod support, with assets loaded from the user's own ROM.

Starlit Party is a native Windows, Android, and browser port of Mario Party 6, USA, built on recovered game code, Aurora, SDL3, and Dawn/WebGPU. Release 0.5.0 runs all six Party Mode boards, Solo Mode, Mini-Game Mode, Mic Mode, the Star Bank, and the opening, ending, and credits. 49 of 81 minigames are playable. The Windows program is build\release\mp6native.exe. Rendering can be uncapped while game logic stays at 60 Hz.

strahlender-xnu builds native apps for Pokémon Brilliant Diamond by translating the game’s ARM64 code ahead of time from a user-supplied dump. Its runtime replaces Switch operating-system services and its graphics interface, rendering through Metal on Apple devices and Vulkan on Linux and Windows.

Street Fighter II Recompiled translates the CPS1 arcade game's Motorola 68000 code into C using ROM analysis, Capstone disassembly and a project-specific generator. Its native build links to a sibling CPS1 runtime for video, audio and input; the author reports reaching the character-select screen.

This is a recompilation of Streets of Rage for the Mega Drive, released as Streets of Rage on the Sega Genesis. The README says desktop builds cover Windows, macOS, and Linux, and that a PlayStation 5 build is documented. The player supplies the ROM.

Strider 2 Recompiled uses psxrecomp to generate C from the US PlayStation release of Strider 2 and compiles a playable build locally from the user's disc. Its title-specific work includes symbol mapping and framework fixes for simulation pacing, line drawing on the stage briefing screen and interlaced menu text. The development notes describe comparisons with PlayStation reference implementations.

This recompiles Stuntman: Ignition for the Xbox 360, 2007, to Windows with ReXGlue. The README says menus, career, and races play. The installer extracts the player's ISO and compiles the game. A hand build uses ReXGlue v0.10.0 and places default.xex in game/.

Stunts HD recompiles Stunts 1.1, the 1990 DOS game also released as 4D Sports Driving. The player's GAME.EXE is translated to JavaScript and drawn in HD at the display resolution, with widescreen and the original physics. It runs in Chrome, Edge, or Firefox, and as a desktop app on macOS, Windows, and Linux.

Suikoden II Recomp configures psxrecomp to generate and compile the US PlayStation game from the player's SLUS-00958 disc image and SCPH-1001 BIOS. A recomp-ui setup host collects those inputs and builds normal and diagnostic executables locally.

Suikoden Recompiled provides a PSXRecomp setup recipe for generating and compiling the PlayStation game from a user's SLUS-00292 disc and specified BIOS. It combines title configuration, function seeds and a recomp-ui setup wizard; package setup and gameplay acceptance remain pending.

SunPad runs Super Mario Sunshine on iPhone, iPad, Apple silicon Mac, and experimental Apple TV through ahead-of-time recompilation, with Metal rendering, touch controls, controller support, and local game-image import.

This statically recompiles Super Mario Advance 2: Super Mario World for Windows. Release v0.0.3 runs SuperMarioWorldRecomp.exe. The launcher asks for the USA/Australia ROM and a retail GBA BIOS. The game boots through the opening and attract sequence. Adaptive Widescreen is optional and can expand supported scenes up to 9:5. Shift with F1 through F9 saves a state, and F1 through F9 loads one.

Super Mario Advance 4 Recomp builds a native Windows version of the GBA game through gbarecomp using a locally supplied ROM and BIOS. The project provides game configuration, a launcher, controls and save-state support. The author reports that the experimental build boots to the title screen and runs Super Mario Bros. 3 gameplay.

Builds a native Super Mario All-Stars port from the player's specified SNES ROM using snesrecomp and game-specific bank analysis inputs. Super Mario Bros. and The Lost Levels are mostly translated ahead of time; Super Mario Bros. 2 and 3 use a built-in interpreter. The port provides desktop and Android builds with a launcher and controller support.

Version 1.1.0 statically recompiles Super Mario Galaxy for the Wii, USA RMGE01 revision 0, into a PlayStation 5 homebrew title, PPSA99315, at 4K and 60 fps. Nebula translates that one disc. The Mac builder is SuperMarioGalaxy-PS5-Builder-1.1.0-mac.zip. The Windows builder is SuperMarioGalaxy-PS5-Builder-1.1.0-windows.zip. The result is a folder named PPSA99315, about 4.5 GB. A build takes about 4 minutes on an Apple silicon Mac and about 10 minutes on a fast PC, and needs about 12 GB free.

Super Mario Land 2: 6 Golden Coins — Recompiled builds native versions of the Game Boy V1.0 game and a DX color variant from one user ROM. It uses gbrecompiled for static recompilation and adds an optional widescreen view whose margins are constructed from live level data.

This brings a static recompilation of Super Smash Bros. Ultimate version 13.0.2 to the PlayStation 4. The game's AArch64 code is translated to C ahead of time, and the runtime draws with Direct3D 11 through DXVK. The README says matches are playable with up to four controllers, and that the player builds the package from their own dump. Build steps are in docs/BUILDING.md.

This port translates the Xbox 360 code of Super Street Fighter II Turbo HD Remix into native PC code with the ReXGlue SDK. It supports the base release and Title Update #1, with a launcher for local package import, graphics settings and online play.

SuperMarioRPGSNESRecomp applies snesrecomp to Super Mario RPG: Legend of the Seven Stars, compiling qualified 65816 code paths to C while other paths run through an interpreter. The shared snesrecomp runner emulates the game's SA-1 coprocessor, and coverage tools collect dispatch misses to guide later regeneration. The author reports a working attract loop and early-game replay, with two qualified ahead-of-time variants.

This recompiles Super Mario World for the SNES into C with snesrecomp. The 65816 code becomes functions in src/gen. PPU, APU, DMA, and registers stay in a C reimplementation of the SNES hardware. SuperMarioWorldSNESRecomp.exe or the Linux AppImage asks for a USA ROM in sfc or smc form and remembers the path in rom.cfg. The README says Yoshi's Island and Donut Plains were played through, and Vanilla Dome was in progress. Worlds 4 through 7 were not hand-verified.

SuperMetroidSNESRecomp translates selected Super Metroid 65816 functions into native C with snesrecomp and executes other paths from the user's ROM through an interpreter. Its game-specific runtime adds optional rendering and gameplay features plus replay capture for diagnosing divergences. The author reports boot, demo, door traversal, pause and ship-save checks while broader progression testing continues.

Translates the Xbox 360 executable of WWE SmackDown vs. Raw 2011 to C++ ahead of time with ReXGlue and builds it as a Windows program on a Vulkan runtime derived from Xenia. A hand-maintained manifest adds function entry points the automatic pass misses, and project patches address frame pacing, a music-player delay and pipeline stalls. Exhibition play is author-tested on one AMD GPU; career mode and online remain untested.

Statically recompiles the North American PlayStation release of Castlevania: Symphony of the Night into C# with BlackLabelHQ’s RecompOne, whose runtime simulates the BIOS, memory-mapped I/O, GPU and CD-ROM so the game runs natively without a console BIOS. Per-overlay function maps and patches add widescreen, quality-of-life, randomizer and cheat features. References from the SOTN decompilation help name functions in this recompilation.

Syphon Filter 2 Recompiled is an experimental Windows static recompilation of the two-disc USA release, bootstrapped from SCUS-94451 and built with PSXRecomp. Release v0.1.3-alpha runs the retail game logic as a native x64 program. The launcher can add 16:9, PGXP-assisted geometry, and mouse camera control.

Takedawn translates the original Xbox game Burnout 3: Takedown ahead of time into native x86-64 and arm64 code. One download covers the North American disc, the European disc for France, Germany, and Italy, and the Europe and Australia disc. The release is 0.3.1, with a macOS 13 arm64 dmg, a Windows x64 setup, a Linux x86-64 AppImage, and an experimental Android arm64 apk. The first start checks the disc files and copies the data. Releases include SHA256SUMS.

Teenage Mutant Ninja Turtles: Turtles in Time Re-Shelled Recompiled translates the Xbox 360 game's PowerPC code into C++ and builds a native PC port with the ReXGlue SDK. Its launcher extracts an exact Xbox Live Arcade package supplied by the user; the port adds PC display options and an online multiplayer service.

Tekken 3 Recomp statically recompiles the US PlayStation release of Tekken 3 by extracting its MIPS executable and overlays from a user-supplied disc. Ghidra exports instructions and p-code to CSV sheets, a generator translates them into Rust, and a custom PlayStation runtime hosts the result inside a Bevy app.

Tekken 5 Recomp statically translates the PlayStation 2 game's Emotion Engine programs, IOP modules, and VU microcode into native Rust. Its pipeline extracts a user's disc image, analyzes programs with Ghidra, generates instruction sheets and Rust code, and runs the result in a Bevy app with a project-specific PS2 runtime.

Tekken 5 × Tekken 3 Merge adds five Tekken 3 characters to a statically recompiled Tekken 5. Its tools extract programs from the user’s discs, analyse them with Ghidra, generate Rust code from instruction sheets, and convert models, movesets, animations, and portraits for the expanded roster. The project documents patches and character-specific findings in its merge plan.

Tekken 6 Native Online builds a PC port from the user's Xbox 360 Tekken 6 disc by translating Default.xex to C++ with ReXGlue. Its game-side code adds rollback snapshots, input handling and determinism work, while a Qt launcher manages builds and matchmaking.

Tekken 6 Recomp generates native code from the Xbox 360 release of Tekken 6 using a patched ReXGlue SDK. It provides a game manifest, host code and runtime compatibility patches, with build paths for Windows and macOS. Its builders extract the user's own game image before code generation.

This is a native Windows port of Tekken Tag Tournament 2 for Xbox 360, built with XenonRecomp. ttt2_setup.exe takes a USA or Europe disc image and Title Update 3, checks them, and builds the PC version. It runs on Windows 10 or 11 with a DirectX 11 GPU, up to 4K at 60 fps, with all 59 fighters available. Online matches use rollback over Steam. Ranked Match, leaderboards, teams, and replay search need a community server. The server is written in Go.

The Tekken Tag Tournament 2 port translates the European Wii U v16 PowerPC executable to C++ ahead of time and builds it for Linux x86-64. Its runtime implements Cafe OS services and converts GX2 graphics work to Vulkan; game-specific hooks add display, input and practice features.

Alpha 0.1.4 statically recompiles Tenchu Z for the Xbox 360, the USA and Europe release, to Windows with ReXGlue. The archive is TenchuZ-HoloCattRecomp-0.1.4-alpha-windows.zip. Setup Tenchu Z.cmd checks the ISO and extracts it beside tenchuz.exe. Direct3D 12 and Vulkan are both available. Render scale runs from 1x to 7x. The hub and the first missions have been played. The rest of the game is untested. F6 opens the added menu.

TenchuRFDRecomp builds a native Windows port of the original Xbox game Tenchu: Return from Darkness by recompiling code from the user's disc image. The repository supplies game-specific startup hooks, graphics and audio adapters, controls and mod support; the author describes the release as an alpha.

Version 0.1.0 recompiles Tenchu: Stealth Assassins for the PlayStation, USA SLUS-00706, into C# with a fork of RecompOne. The launcher checks the disc boot executable and refuses any other disc. The disc stays required at runtime. Release 0.1.0 boots, plays, and saves. The controller stays inactive for about the first 20 seconds of the intro. Auto-save is off until Options enables it. A PlayStation BIOS is optional because the engine services BIOS calls itself.

TetrisGBRecomp statically translates the Game Boy Tetris version 1.0 ROM into C for native PC execution. Its configuration identifies the ROM and entry points, while a dispatch manifest supplies harvested function seeds; the gb-recompiled runtime models Game Boy graphics, audio and memory. The author reports all game modes playable.

The Bigs 2 Recompiled converts the Xbox 360 game's executable to C++ with ReXGlue for native Linux and Windows builds. Its game-specific hooks and renderer changes add resolution scaling, an experimental 60 fps mode and a first-run disc import screen.

Builds a native Windows x64 port of The Darkness by translating its Xbox 360 executable to C++ ahead of time with a patched XenonRecomp. A D3D11 renderer draws from the engine’s original geometry, shader sources and device state instead of interpreting console GPU packets. Gameplay coverage and Linux results are project-reported, and the author discloses OpenAI Codex assistance.

This recompiles The Legend of Zelda: The Minish Cap for the Game Boy Advance with gbarecomp. The USA ROM SHA-1 is b4bd50e4131b027c334547b4524e2dbbd4227130, and the runtime refuses any other checksum. The GBA BIOS is recompiled and executed. The save chip is EEPROM. The Windows release archive is MinishCapRecomp-windows-x64. Debug port 19842.

pc-theneedforspeed documents a native PC run of the 1994 3DO The Need for Speed through 3dokit static recompilation of ARM60 programs. It records disc structure, Portfolio boot behavior, replay inputs and runtime additions; the author reports reaching the race and driving in a window from a user-supplied disc.

The Phantom Menace project runs a static recompilation of the USA Rev 1 PlayStation game natively on desktop and M5Stack Tab5. Its recompiler translates MIPS code into C at build time and runs it with a PlayStation hardware runtime. A matching decompilation aims to replace the generated code function by function; the author reports native gameplay, while the initial handwritten C functions remain nonmatching.

The Simpsons Arcade Game PS3 project recompiles the PSN release's PowerPC EBOOT into a native PC program with ps3recomp. It lifts captured SPU jobs and documents how the EBOOT emulates the original arcade hardware while interpreting the 6809 game ROM. The author reports playable Stage 1 gameplay, saving and two-instance online co-op.

The Simpsons Arcade port translates the Xbox 360 game's PowerPC executable into C++ with XenonRecomp and runs it through ReXGlue's native runtime. Its repository records XEX analysis, switch-table work, game-specific stubs and fixes for frame pacing and guest timebase scaling.

The Simpsons Game port translates the US Xbox 360 game's PowerPC code into C++ ahead of time for a native Windows x64 build. It provides handwritten platform services, audio, input, and a Direct3D 11 renderer with an optional Vulkan path; the author reports that all levels load.

Translates the PlayStation game’s MIPS code to C with a pinned psxrecomp fork and builds Windows and Linux programs on its hardware-modelling runtime, with a launcher and a game-specific plugin. Without patching game code, the plugin adds 16:9 matches, 60 FPS by raising the emulated CPU clock and rescaling movement, intro skipping and unlocks. The user’s own NTSC-U disc image is required, and the measurements are author-reported.

This recompiles the original Xbox release of The Sims 2, USA, with Xbox XBE Recomp. The supported default.xbe is 3,399,680 bytes, SHA-1 16f9e41ce26c315a758f25d43ba1fa9d3809d1ad. The README says Windows reaches live gameplay on a lot, and the native Linux build reaches the title screen and a 3D neighbourhood. Windows uses Direct3D 12. Linux uses Vulkan.

Statically recompiles the x86 code of The Lord of the Rings: The Two Towers (Xbox, USA, 2002) into C with the bundled xboxrecomp toolkit, producing native Windows, Linux and experimental macOS builds. The recompiled sources are generated locally from the player's own default.xbe, and game data comes from their disc image or extracted folder. README reports the game as fully playable, with visual, frame-rate and mod issues listed.

This static recompilation of the original Xbox game The Urbz: Sims in the City, North America, builds Urbz.exe for Windows with Direct3D 12 and XAudio2, and Urbz for Linux with Vulkan and SDL3. default.xbe is 3,035,136 bytes, SHA-1 5712b6a3e2eaaacfcae228cf6154ade499a0033c, title ID 0x45410060, linked 2004-10-07 against XDK 1.0.5849. xiso_extract.py extracts the disc, xbe_info.py checks that SHA-1, and build.bat or build.sh recompiles 15,942 functions.

Theme Park statically recompiles Bullfrog's 1994 DOS game into a native Windows and Linux program using pcrecomp to translate its 32-bit code to C. The project adds a DOS/4GW host, display and sound layers, TCP support for the game's network mode, save states, and scripted conformance runs. The author reports lifting 6,517 functions and passing six conformance milestones.

Tiberian Sun and Firestorm recompiles the games' Win32 Game.exe into native C with pcrecomp and a game-specific host. The author reports playable menus, skirmishes and early campaign missions, with high-resolution display and a native Linux build. Lifted C is generated locally from the owner's game copy.

Tiger Woods PGA Tour 2004 - XBE Recomp ports the original Xbox game to Windows by statically recompiling its XBE with Xbox XBE Recomp and building the game code from the user's copy on first launch. The port adds widescreen display, graphics settings, and PC controls, alongside an emulated Xbox audio DSP.

TimeSplitters recompiles the USA PlayStation 2 game's MIPS program and VU microcode into C++ with PS2Recomp for native Windows, Linux and original Xbox builds. Its runtime models PS2 graphics, sound and IOP services. The Windows and Linux builds extract data from the player's disc dump on first launch; Xbox game files are prepared on a Windows PC.

tkdr-recomp runs the PSP release of Tekken: Dark Resurrection by translating its MIPS executable ahead of time to C for native builds or WebAssembly in the browser. A custom runtime supplies PSP library calls, scheduling, graphics, audio, and input. The author reports working boot, menus, movies, saves, and full matches, with Quick Battle explored from boot.

TLKRecomp translates the US SNES release of The Lion King's 65816 program into C with snesrecomp and builds a native program for Linux, Windows and Apple Silicon macOS. Its host uses emulated PPU and SPC components. The author reports matching frames and RAM against interpreter runs, and matching game RAM against BizHawk runs.

Tokyo Jungle Recompiled translates the PS3 game's PowerPC executable into native PC code with ps3recomp and supplies game-specific loading, import and runtime glue. Its investigation documents PPU functions, SPU workloads, asset loading and a main-loop wait that currently blocks geometry rendering.

This statically recompiles Tomba! 2: The Evil Swine Return with psxrecomp. Windows and Linux previews accept the USA disc SCUS-94454 and the Italian PAL disc SCES-02686. Native code is prepared from all 22 original area files plus shared overlays before gameplay. Release builds include the MIT OpenBIOS from PCSX-Redux. Adaptive widescreen and 1080p internal rendering are on by default. SDL3 is the default host backend.

Tony Hawk's Pro Skater Recompiled supplies a PSXRecomp configuration and recomp-ui flow for generating a native build from the user's PlayStation disc. The project contains title symbols, function seeds and build scripts. Its Windows, Linux and macOS setup packages are described as candidates pending package checks.

Top Spin 4 Recomp ports the Xbox 360 game Top Spin 4 to Windows through ahead-of-time translation of its PowerPC code with ReXGlue. A game-specific renderer maps its Direct3D 9 calls to Vulkan, and a launcher prepares files from the user’s disc image and Title Update 1. The author reports working exhibition, career, academy, and local multiplayer modes.

TotK Recomp statically recompiles The Legend of Zelda: Tears of the Kingdom into a native x86-64 program for Windows and Linux, with a Vulkan renderer. It accepts the base game plus update 1.1.0, 1.2.1, or 1.4.3 as NSP, XCI, NSZ, or XCZ. Windows setup needs Windows 10 or later, SSE4.2, and Vulkan 1.3. Linux needs Linux 6.7 or later and glibc 2.34 or later. The toolchain steps are in docs/building.md.

TriAevum, Echoes of Time, is an ahead-of-time recompilation of The Legend of Zelda: Ocarina of Time 3D for Windows and Linux x64, with an NRI/Vulkan renderer. The documented release is v0.8.0-beta.1.2. TriAevumForge.exe accepts a decrypted EUR or USA ROM, original or revision 1, as .3ds or .cci. Japanese, Korean, and Taiwanese releases are not supported. The Windows zip contains TriAevumForge.exe, and setup writes TriAevum.exe beside it.

This statically recompiles Trials HD for the Xbox 360, title ID 5841095A, to Linux x86-64 and macOS with ReXGlue. Physics stay at 60 Hz while rendering can run at a higher refresh rate. The GPU backend is WebGPU or Vulkan. ./build.sh --game takes the game directory or the STFS package and reads default.xex from it. Later builds omit --game.

TribesPad translates the x86 code of Tribes 2 and Starsiege: Tribes ahead of time into native ARM64 for iPhone, iPad and Mac. Its runtime supplies Windows services, a Metal graphics path, audio, input and networking; mobile builds add touch and controller controls. Game-specific translation and runtime configurations accompany investigation records.

Trouble Makers turns Mischief Makers' N64 MIPS code into a native PC port with N64Recomp, N64ModernRuntime and RT64. The repository includes a US 1.1 symbol map, compatibility patches and a technical reference covering the ROM and engine; optional widescreen and frame interpolation are experimental.

TsumuLightRecomp configures PSXRecomp to translate the Japanese PlayStation game's MIPS code into native C and compile a PC executable. It supplies title-specific function seeds, build settings and a runtime English text layer; the author reports puzzle-stage play and memory-card save/load.

Twilight Princess HD: Recompiled translates the Wii U game's Zelda.rpx PowerPC code to C and runs it as a native Apple Silicon macOS app. It adapts a Wind Waker HD recompilation runtime with Cafe OS services and Metal graphics to Twilight Princess HD; the author reports title-screen and early Ordon Village play.

Twin Snakes Native Port analyzes the GameCube executables of Metal Gear Solid: The Twin Snakes for a planned native recompilation. Its workflow uses Ghidra, decomp-toolkit, signature matching, and DolRecomp to recover function boundaries and symbols and translate PowerPC code to C. The repository also contains runtime code for GameCube SDK services; current work centers on symbol recovery.

This statically recompiles Twisted Metal: Black for the PlayStation 2, USA SCUS-97101, to Linux and Windows with BozoEngine. The executable SCUS_971.01 has SHA-1 3ff17f4897552e355d0bb8c3abfa5125fe3ff2ef. Release v0.4.0 plays one-player, story, and four-player split-screen matches at the NTSC rate of 60 updates per second. The Windows launcher is TMB Launcher.exe, from TMB_Recomp-<version>-bozo.zip.

Twisted Metal lifts the 2012 PS3 game's PowerPC EBOOT.BIN into C++ and links it with ps3recomp for a native Windows build. Its analysis notes cover imports, function boundaries, SPU images and boot behavior; the author reports reaching a match and drawing its HUD while the 3D world remains blocked.

TwistedMetal1234Recomp builds native Windows programs for the first four PlayStation Twisted Metal games through psxrecomp, with a unified launcher. Game-specific hooks adjust frame pacing, widescreen terrain drawing and HUD placement, while framework patches expose related display settings. The generated C is produced locally from each user's disc image.

UltraCombo ports the arcade games Killer Instinct and Killer Instinct 2 to Windows and Linux using users' ROM and disk files. It boots each game on an interpreter, snapshots loaded code, translates the game and sound DSP programs to C, and compiles native modules while emulating the surrounding arcade hardware.

UltraTears builds a native version of The Legend of Zelda: Tears of the Kingdom 1.4.3 for Windows, Linux, and Steam Deck from plain exefs and romfs folders. The romfs tree is about 304,000 files and 16 GB. Windows 10 or 11, or Linux with kernel 6.7 or newer and glibc 2.34 or newer, plus Vulkan 1.3, are required. python tools/setup.py --dump takes the dump directory and writes the game folder under build/. About 40 GB free is listed for setup.

Uncharted Waters: New Horizons is statically recompiled into a native Windows 10/11 application that uses the player's own USA/Canada NTSC ROM. The source includes generated native code, a target core and an SDL frontend, with an optional headless connector. Widescreen support remains experimental.

This is an Android port of Unleashed Recompiled for the Xbox 360 version of Sonic Unleashed. It runs the statically recompiled game on ARM64 Android 10 or newer, with touch controls, gamepad support, a mod manager, and a bundled Turnip Vulkan driver. The launcher installs a zip or folder, or separate base-game, title-update, and DLC packages. The main tested GPUs are Adreno 710, 725, 732, and 750. Adreno 830 is selected automatically. Recent Mali GPUs with Vulkan 1.3 are experimental. A Windows host with Visual Studio 2022, CMake, Ninja, Android NDK r29, JDK 17, and vcpkg builds the port.

Builds an unofficial Sonic Unleashed PC port by statically recompiling Xbox 360 PowerPC code with XenonRecomp and Xenos shaders with XenosRecomp. The port adds modern display and modding options while documenting original-engine limits and remaining compatibility issues.

Unreal Championship 2 is statically recompiled from an ISO image of the user's original Xbox game into a native Windows program with xboxrecomp. The project translates game code to C and adds game-specific runtime code, D3D11 graphics support and toolkit patches.

Urban Reign PC Port translates the USA PlayStation 2 game's code into C++ for native Windows and Linux builds. It uses the PCSX2 renderer through DirectX 11 or Vulkan and adds higher internal resolutions, widescreen display and multiplayer controls. Code generation reads the user's own SLUS-21209 disc image.

Vagrant Story Recompiled builds a native PC version of the USA PlayStation game through psxrecomp. It reads the user's disc for game code and supplies title-specific widescreen, input, menu and frame-rate plugins, plus patches to the recompiler runtime.

ValkyrieRecomp configures PSXRecomp to generate a native PC build of the USA PlayStation release of Valkyrie Profile from a user-supplied disc. It adds a launcher for selecting the two discs, rendering options and controller support; compatibility testing remains in progress.

Verdite2 ports the North American PlayStation release of King's Field, SLUS-00158, to PC with RecompOne static recompilation. It contains function maps, runtime patches and documentation for the game's executable and disc handling. The project adds widescreen display, modern controls and rendering changes, and reports playability from start to finish.

Verdite3 ports the North American PlayStation release of King's Field II, numbered King's Field III in Japan, to PC through RecompOne static recompilation. Its game-specific maps and patches cover the main executables and area modules, with changes to rendering, controls, pacing, and saves.

VeronicaRecomp uses ReXGlue SDK to statically recompile Resident Evil CODE:Veronica for native PC. Its CMake project includes a code generation target and builds an executable; users extract the required assets from their own game copy. The author describes the current build as playable but unfinished.

vig8 statically recompiles Vigilante 8 Arcade's Xbox 360 PowerPC executable into native Windows C++ with ReXGlue. Its manifest records game-specific function boundaries, while runtime glue handles application and networking behavior; the author reports that menus, Quest, and single-player battles run in an alpha build.

Virtua Cop statically recompiles the Sega Model 2 arcade game's i960 program ROM into C for a native Windows build. A ROM loader prepares flat images from the user's ROM set, and the generated C links with model2recomp to model the board and render the game. The author reports that the game boots and plays a stage; sound is unimplemented.

Virtua Fighter 3 Recomp runs the arcade game's PowerPC program as native ARM64 or x86-64 code translated from the user's ROM at startup. Its own runtime models the Sega Model 3 board, tile generator, and Real3D graphics, with native rendering and input on desktop systems.

Virtual Pro Wrestling 2: Recompiled translates the Japanese Nintendo 64 game into native PC code with N64Recomp, N64ModernRuntime and RT64. Its own disassembly metadata and runtime additions support widescreen display, controls, saves and experimental lighting effects.

Viva Piñata Recomp translates the original Xbox 360 game's code into C++ with ReXGlue and builds a native Windows program. It includes a launcher, game-version checks and Direct3D 12 or Vulkan rendering modes; the author reports menu, garden and save functionality on the documented disc version.

Voldorium is a native Windows and Linux port of SoulCalibur for the Dreamcast, USA release T-1401N V1.000. The README says the game's SH-4 code is statically recompiled to C and linked with a native runtime, adding 16:9 widescreen, arbitrary resolution, and an online versus mode with GGPO rollback. Only that USA release is supported.

VP2S_Recomp builds a native Windows port of Valkyrie Profile 2: Silmeria by translating its PlayStation 2 MIPS code to C++ with PS2Recomp. Game-specific tools unpack encrypted and compressed modules, Ghidra maps functions, and the port draws models and interface elements through a native renderer with a native audio mixer.

This statically recompiles War of the Monsters for the PlayStation 2 to Windows, and has a Linux x86-64 path. The Windows program is wotm.exe. PS2Recomp translates the executable, including VU0, into C++ that is generated locally. A decompilation build ends with build/SCUS_971.97.rom: OK. The Linux target needs AVX2, BMI2, POPCNT, and LZCNT. Mods go in mods next to wotm.exe.

WarioRecomp builds a native PC port of the US Wii release of Wario Land: Shake It! by statically recompiling its PowerPC code to C++ with WiiCompiled. Native libraries replace Wii video, audio, controller, disc and save services, while the launcher imports the user's disc and builds the port locally.

This static recompilation of WarioWare: Twisted! runs on Windows x64 and Android arm64, using the phone gyroscope or a controller motion sensor for the cartridge gyro. The USA ROM and a retail GBA BIOS are selected in the launcher. Their identities are recorded in variants/warioware_twisted/game.toml. Windows builds use CMake, Ninja, MSYS2 MinGW64, and SDL2. pwsh tools/regen.ps1 regenerates the translation, and cmake --build build --target WarioWareTwistedRecomp builds the program.

Wave Race 64: Recompiled applies N64Recomp and RT64 to a native PC port of Wave Race 64. Its build requires the player's USA Rev A ROM; the author reports that the current result boots only to two boxes of noise.

Wave Race 64: Recompiled builds a native Windows, Linux and macOS port from the player's USA Rev A ROM using N64Recomp. Its code adds widescreen, draw-distance options and an optional water renderer, while technical documents record game internals and rendering investigations.

Weeping of the Empire builds a native Windows port of The Legend of Zelda: Tears of the Kingdom from the user's Switch game dump. It recompiles ARM64 code ahead of time to x86-64, supplies Switch services through a host runtime and renders through Vulkan. The engine documentation credits totk-recomp as the starting point and identifies the added Windows port, renderer, controls and menus.

WET is a PC port of the Xbox 360 game built with ReXGlue from the user's disc image. Its setup script applies input patches and generates game code, while the project supplies host code, ultrawide display changes and Windows and Linux build paths.

The WHITE ALBUM2 port shares game logic between Windows x64 and Android ARM64 while migrating from a hybrid static recompilation to a native C++ compatibility engine. Current native components handle save flags, script behavior and resource processing; the delivered shared-aot build still uses recompiled functions. Original PAK files remain external.

This recompiles White Knight Chronicles II for the PlayStation 3. The disc also includes White Knight Chronicles I, and the current Windows build reaches that game's starting town and can load one local save. Vulkan is the primary renderer. DirectX 12 is experimental. The documented disc is the USA release BLUS30784. The 30 fps limit is the baseline.

This statically recompiles Wii Party to Windows and experimental Linux. The DOL and all 115 REL modules translate. 4,152 tests check every instruction kind the game uses. Graphics go from GX to Direct3D 11. The frame rate is locked at 60 fps PAL60, at up to 6 times the console resolution, using about 600 MB of RAM. Every one of the 79 Free Play minigames and a full 17-round Board Game Island session have been played. The offline Windows archive is wiipartyrecomp-offline-windows.zip, about 185 MB.

WiiCompiled's Xbox UWP port builds the static recompilation of Mario Kart Wii as a packaged application for Xbox Series consoles. It adds fixes for MSVC compilation and AppContainer startup, Direct3D 12 rendering through aurora and Dawn, memory use, and controller mapping; the author reports play on an Xbox Series S in Developer Mode.

WiiCompiled turns a user-supplied Mario Kart Wii disc image into a native PC application through PowerPC static recompilation. Its translator parses Wii DOL files, lifts instructions through IR and SSA, emits C++, and compiles the output with a runtime; project manifests select game revisions and input layouts.

Statically recompiles The Wind Waker HD’s Wii U PowerPC code to C ahead of time, reimplements the Cafe OS libraries the game uses and implements GX2 graphics on Metal or Vulkan, producing native macOS, Linux, Windows and Android builds without a Cemu runtime. All game code and data are generated locally from the user’s own dump; an experimental macOS-only build can instead run functions from the separate ZeldaWWHDDecomp/wwhd decompilation.

Wind Waker HD Recompiled for Android — Plus runs The Legend of Zelda: The Wind Waker HD on ARM64 Android through static recompilation of Wii U PowerPC code and Vulkan rendering. This fork adds Brazilian Portuguese translation, a HUD editor, .wua archive input and controller improvements; the app extracts and builds from a user-provided game dump.

pure-recomp turns Wipeout Pure’s US Greatest Hits v2.00 PSP executable into a native Apple Silicon macOS or Windows program through ahead-of-time translation. It supplies host implementations of PSP services and Metal or Vulkan graphics, generating translated game code from the user’s disc image. Its checks compare frames with PPSSPP captures.

Wipeout XL Recompiled supplies a PSXRecomp recipe and recomp-ui setup host that generates and builds the PlayStation game from the user's own disc and BIOS. The repository includes title-specific identity and seed files; package setup and gameplay acceptance remain pending.

Wipeout XL Recompiled is an unofficial PSXRecomp project for Wipeout XL (USA), SCUS-94351. Setup kits for Windows 10/11 x64, Linux x64, and macOS 15 on Intel and Apple Silicon generate the game code on the user's machine from a Redump-style CUE and all 12 BIN tracks. The runtime uses OpenBIOS and SDL3.

Witch Time is a static recompilation of Bayonetta 3 for Nintendo Switch. It translates the AArch64 code to C from a personal dump and runs it on a reimplemented system layer, with NVN on Vulkan. The dump folder contains exefs and romfs. On Linux, cargo builds tools/wtbuild and wtbuild setup --dump takes that folder. A Windows release zip runs witch-time.exe and needs a Vulkan driver. Gameplay is 60 FPS in the tested Tokyo and Shibuya sections. The default resolution is 1600x900. The Old Picture Book uses update program 1, title ID 01004A4010FEA001, update 1.2.0, placed in program1.

World Driver Championship: Recompiled builds an experimental native Windows port from the user's USA Nintendo 64 ROM. N64Recomp and RSPRecomp translate CPU code and BOSS graphics microcode, while RT64 renders low-level RDP commands. The author reports testing through menus and Hawaii practice driving.

Wreckless uses xboxrecomp to translate the original Xbox game's x86 code into C and compile a native Windows executable. Its analysis documents XBE sections, kernel imports, function recovery and ABI work. The author reports that initialization runs but rendering and gameplay are still blocked by an indirect call into a function body.

WWE '12 PC ports the Xbox 360 version of WWE '12 to Windows through ReXGlue static recompilation and a native Vulkan renderer. Its build uses the player's game files and includes code-generation patches, native hooks, and a script for finding function pointers omitted by the recompiler.

WWE '13 Recomp translates the Xbox 360 game's PowerPC code to C++ with ReXGlue for native Windows and Linux builds. A launcher imports the user's game files and required title update, while game-specific patches address graphics, input, saves and content handling.

WWE 2K14 PC Recomp builds a Windows port of the Xbox 360 game through the ReXGlue static recompilation SDK. It reads the user's ISO or extracted game folder and includes game-specific patches and a launcher for graphics, controls, languages, DLC, and mods.

WWE 2K14 Recomp builds a native Windows x64 port by translating the Xbox 360 game's PowerPC code into C++ ahead of time with ReXGlue. Its game-specific work maps functions in title update 2.0.1.0 and repairs startup, cloth, texture and timing behavior. The author reports working menus, exhibition matches and saves, while several modes remain incompletely tested.

WWE 2K16 PC Recomp statically recompiles the Xbox 360 game for a PC build using the ReXGlue SDK. Its launcher accepts a user-supplied ISO or extracted folder and adds graphics settings, input mapping, DLC support and mods.

WWE SmackDown vs. Raw 2007 recompiles the Xbox 360 game's code with ReXGlue and renders it through game-specific native graphics code on PC. The release targets Windows directly and runs on Linux or Steam Deck through Proton. The author reports 60 FPS in entrances and matches, with resolution and controller settings exposed in game.

This recompiles the Xbox 360 version of WWE SmackDown vs. Raw 2008. The game code is recompiled and drawn by a native renderer: Direct3D 12 on Windows, and Vulkan on Linux and the Steam Deck. The README says it runs at 60 fps, with resolution choices from 480p to 8K. Windows runs the release directly. The Linux and Steam Deck steps run that Windows release through Proton.

This recompiles the Xbox 360 version of WWE SmackDown vs. Raw 2009. Direct3D 12 draws on Windows, and Vulkan draws on Linux and the Steam Deck. The README says it runs at 60 fps, with resolution choices from 480p to 8K. Windows runs the release directly. Linux and Steam Deck run that Windows release through Proton.

This recompiles the Xbox 360 version of WWE SmackDown vs. Raw 2010. The game code is recompiled and drawn by a native renderer: Direct3D 12 on Windows, and Vulkan on Linux and the Steam Deck. The README says it runs at 60 fps, with resolution choices from 480p to 8K. Windows runs the release directly. The Linux and Steam Deck steps run that Windows release through Proton.

HCTP Recompiled is a static recompilation of WWE SmackDown! Here Comes the Pain for PlayStation 2, NTSC-U SLUS-20787, into a native Windows program. PS2Recomp translates the MIPS code to C++. A Direct3D 11 renderer draws the graphics, and the IOP runs the game's IRX modules.

This recompiles X-Men Destiny for the Xbox 360 to Windows with ReXGlue. The entry executable is game/default.xex. setup.ps1 clones ReXGlue v0.10.0. The port targets Direct3D 12.

xwa statically recompiles Star Wars: X-Wing Alliance by lifting its x86 code to C and linking it with a Win32/DirectX compatibility layer and Direct3D 11 renderer. The workflow uses the user's Steam installation and a locally obtained decrypted executable. The author reports an alpha build that reaches campaign flight and completes the first mission under autoplay; audio and much game logic remain untested.

This repository ships Linux and Windows launchers that statically recompile Xbox 360 titles to x86-64 and draw them with Vulkan. rexmenu imports an ISO, an archive, an STFS package, an XEX, or an extracted folder, then checks the tree against content/content.sha256. The title table lists Burnout Revenge, Ridge Racer Unbounded, Midnight Club: Los Angeles Complete Edition, Split/Second, Banjo-Kazooie, Banjo-Tooie, Geometry Wars: Retro Evolved, Geometry Wars: Retro Evolved 2, Rez HD, Soulcalibur II HD Online, After Burner Climax, Hydro Thunder Hurricane, Space Giraffe, OutRun Online Arcade, Daytona USA, and Geometry Wars 3: Dimensions. Linux needs gamescope and Python 3. Windows 10 or 11 runs Launcher.bat. Saves stay in user-data.

Xbox 360 Quake 4 decomp builds a Windows port by translating a user-supplied Xbox 360 Quake 4 executable with ReXGlue and attaching game-specific hooks. Its alternate q4hle build routes the game's Direct3D calls through a native D3D11 renderer; the author reports testing the opening levels and documents remaining crashes and limited audio testing.

XC2 Recomp statically translates the Nintendo Switch game Xenoblade Chronicles 2 into a native x86-64 application for Windows and Linux. Its setup extracts the user's game and update files, lifts ARM64 code, and builds a runtime with Vulkan rendering. The author reports that the early build reaches the title screen and runs through the opening battle into Goldmouth.

XCX Recomp statically recompiles Xenoblade Chronicles X: Definitive Edition for Nintendo Switch into a Windows x86-64 executable with a Vulkan renderer. It is a fork of TotK Recomp. The project page says a new game, cutscenes, and gameplay run at 60 FPS by default, with a settings range of 30 to 360. XCX-Setup.exe builds the game from the owner's base-game files, the 2.0.0 update, and a key file. Add-on content is optional. Play starts xcx.exe. F1 opens settings and F10 opens the performance overlay.

Xena: Warrior Princess Recompiled configures PSXRecomp and recomp-ui to generate a native build of the USA PlayStation game from a user's disc and BIOS. Its repository contains game configuration, symbol seeds and setup-host build files; the project report identifies gameplay, input, audio and save checks as outstanding.

Xena: Warrior Princess combines a matching decompilation of the PlayStation release SLUS-00977 with a playable Windows port. The decompilation rebuilds the game executable from C and assembly, while a separate static recompiler translates its MIPS functions to C. A project runtime supplies GPU, GTE, SPU, CD-ROM, controller, and BIOS behavior through SDL2 and other host code.

XenogearsRecomp is a static recompilation of Xenogears (USA) for the PlayStation. It uses PSXRecomp to turn MIPS R3000A code into C and then native x64, and it recompiles an OpenBIOS or retail SCPH1001.BIN backend with the game executable.

Xerenge recompiles the Xbox 360 retail releases of Burnout Revenge to C++ ahead of time. Europe hashes to SHA-256 34c1bd4d549c2c53f29d814fa5e5d1c04c533c5ca0c39e57b6c2538f44ff59b4. The USA release, supported since 0.4.7, hashes to 7abf689f52b70666ba92052bd157cfcae9ed6290dae298fbf639baa1d169f92b. Each build uses its own default.xex. ./scripts/bootstrap.sh takes the ISO, then rexglue/run.sh starts the game. A Vulkan machine is required. Apple silicon Macs are supported. Intel Macs are not. The renderer is the project's plume plugin.

XI on Anything recompiles FINAL FANTASY XI's 32-bit x86 FFXiMain.dll and FFXi.dll to C from the user's installation and runs them through a native game host. Its platform layer supplies graphics, audio, input and sockets across desktop and selected mobile or console targets. A LandSandBoat server provides sign-in and gameplay services.

Yakuza: Dead Souls Recompiled translates the PlayStation 3 game's PowerPC PPU code and Cell SPU programs into a native Windows executable. It boots without PS3 firmware, plays the intro movies, reaches the title screen, and enters gameplay. Indoor scenes such as the gun tutorial were reported at the game's 30 frame cap. The crowded outdoor opening was reported at about 20 frames per second.

YW4 Recomp translates the ARM64 code of Yo-kai Watch 4++ update 2.2.0 into a native Windows program. Its project runtime and Vulkan renderer support portions of the game from boot through early play and selected later scenes, with graphics changes including ultrawide output and revised shadows.

Uses N64Recomp to translate Majora’s Mask into a native application and RT64 for rendering. The project separates static recompilation from source decompilation while reusing decompilation headers and selected functions for patches and enhancements.

Zelda ALttP SNES Recomp statically translates the 65816 CPU code of The Legend of Zelda: A Link to the Past into C with snesrecomp. PPU rendering, APU and SPC700 audio, DMA, and hardware registers run through an embedded snes9x core. The README says boot, the overworld, and dungeon sword combat have been checked, across those areas.

ZOE-Recompiled is a native Windows port of Zone of the Enders for the PlayStation 2, USA SLUS-201.48. PS2Recomp statically recompiles the MIPS code to C++. The runtime uses an OpenGL renderer, compiled vector-unit programs, and IOP and sound emulation.

2 Ship 2 Harkinian for PS4 adapts the decompilation-based Majora's Mask port to jailbroken PlayStation 4 consoles. It uses the OpenOrbis toolchain and Piglet rendering, with patches and technical notes covering PS4 platform integration and hardware-specific audio, memory and graphics issues.

Builds native Windows, Linux and macOS versions of The Legend of Zelda: Majora’s Mask from an adapted copy of the zeldaret/mm decompilation, with libultraship reimplementing N64 SDK functions. Game data comes from a user-supplied ROM and is packed into an archive that custom asset packs can override. It targets a playable PC port with enhancements.

358/2 Days for Android ports Kingdom Hearts 358/2 Days to Android using the upstream khdays-port and its decompiled C game code. It adds an Android app, ROM import, touch controls and a two-screen layout for the AYN Thor; on one-screen devices, both game screens share the display.

This ports the Space Cadet pinball decompilation to the PlayStation 2. It is built with the PS2SDK. Game data from 3D Pinball Space Cadet or the Full Tilt! Pinball Cadet table goes in mass:/APPS/3DPINBALL on USB storage. The README says the Full Tilt table works on PCSX2 and not on real hardware.

3dpinball-nds adapts the Space Cadet Pinball decompilation into a Nintendo DS port built with BlocksDS. Its ARM7 and ARM9 source implements the handheld platform layer, while game data comes from the user's Windows release.

Builds Street Fighter III: 3rd Strike as native C for Windows, macOS and Linux, continuing the 3s-decomp PS2 decompilation, with SDL3 for video, input and audio and GekkoNet for rollback netplay. README stresses that it is neither a recompilation nor emulation. The port needs the player’s own PS2 game files and works toward arcade-accurate balance, which an optional Statcheck build tests against CPS3 RAM states recorded from Fightcade replays.

9mm Vita ports 9mm HD Android to PS Vita by loading the user's ARMv7 game executable into memory. Its native compatibility layer resolves imports, patches a checked game build and maps Vita controls, while the user's APK and downloaded game data supply the original program and assets.

A Link to the Past 3DS adapts the reverse-engineered Zelda3 engine for Nintendo 3DS with gameplay on the upper screen and maps, inventory and settings on the lower screen. It extracts assets locally from the user's USA ROM and adds 3DS rendering, controls and per-ROM settings.

AceCombat3-xport ports reconstructed code from the Project Nemo edition of the PlayStation game Ace Combat 3: Electrosphere. Its startup code loads ACE3.BIN from DATA, while an extraction script processes the game's resource archives and XA sectors.

Airborne Ranger ports the 1987 DOS game to C by lifting AR.EXE and its TANDYSND.EXE overlay with a masm2c-style translator, then hand-checking the output against the reference binaries. An SDL2 frontend runs with the player's original files, and the repository includes lifted code, generation scripts and tests.

ALTTP-DX rebuilds The Legend of Zelda: A Link to the Past as a native PC game that extracts its assets from a user-supplied US ROM. Its Zig source adds widescreen display, menus and graphics options. A development mode runs the original machine code alongside the game and compares RAM each frame.

Amplitude reconstructs source for the 2003 PlayStation 2 rhythm game and builds its main executable and IOP modules with ps2dev tools. A user-provided North American or European disc supplies assets for a rebuilt image. The author reports playable builds of both releases; the European DNAS2 online library remains unrecovered.

Angry Birds ARM64 rebuilds the native runtime of Angry Birds 1.4.2 for AArch64 Android devices so the game's Lua logic can run with locally supplied game data. The work uses ARMv7 runtime analysis and behavioral comparisons to reconstruct rendering, input, physics bridges, audio, persistence and Android lifecycle services.

Animal Crossing gcNX ports the decompiled GameCube game to Nintendo Switch by compiling its code for ARM and translating GX graphics to OpenGL ES. It reads game resources from the user's USA disc image; the repository also documents an Android port built on the same decompilation.

Runs Animal Crossing’s decompiled GameCube C code natively on 32-bit x86, replacing the GX graphics API with an OpenGL 3.3 translation layer and console services with SDL2-based platform code. Game assets are read at startup from the user’s own disc image instead of being shipped. It is a port built on ACreTeam’s ac-decomp.

Animal Crossing Android Port runs decompiled GameCube game code natively on Android, building on an existing PC port. It translates GX graphics to OpenGL ES 3 and adds touch controls, a launcher that imports the user’s disc image, and on-device texture conversion.

Animal Crossing: Wild World, native compiles decompiled code from the USA Rev 1 Nintendo DS game into a PC program. A host layer supplies DS hardware services, SDL input, and CPU or WebGPU renderers; this branch changes the source for portability. The byte-matching ROM build is retained at the matching tag.

Another World JS ports Another World to an HTML5 browser runtime by implementing its 26 game bytecode opcodes in JavaScript. Extraction scripts convert original DOS and 15th anniversary data files into JavaScript input; the port adds palette switching, alternate resolutions and rewind.

Another World is ported to Commander X16 in 65C02 assembly, using data files from the user's MS-DOS game copy. The implementation adapts the original virtual-machine architecture for the X16 and builds with CC65. The author reports performance and audio limits, including missing music.

Ape Escape translates functions from the US PlayStation game's MIPS code into structured C and compares them against the original instructions on shared RAM images. A native SDL3 and OpenGL viewer runs selected game logic; the author reports about 1,500 functions differentially checked.

Apocalypse-xport ports reconstructed code from the PlayStation game Apocalypse. Its C++ source initializes game systems and handles CD data by resolving DATA paths, reading CD.WAD resources and mounting APOC.XA streams.

Arcanum Community Edition rebuilds Arcanum as a replacement executable for modern operating systems while using data from the player's game installation. Its C source covers game and engine modules, with named APIs and annotations in some areas and unresolved names in others.

The project ports the game to iOS and macOS with a C++ and Metal renderer that loads tile .art files extracted from the user's original game into an Arcanum Revitalized folder. Its current build renders the crash-sector terrain and a moving player character on physical iOS devices.

Atlantis Native ports the reverse-engineered CryOmni3D Atlantis engine to Rust for Atlantis: The Lost Tales and Atlantis II. It reads files from the user's own game copies and runs their scripts, panoramas, cinematics and puzzles on desktop systems and in browsers, with optional display and bug fixes.

axis-web ports the Korean action game AXIS to browsers by reconstructing client formats and simulation layers in C and compiling them to WebAssembly. WebGL renders original maps from user-supplied files, while documented packet codecs and a WebSocket relay support multiplayer state exchange.

BackstabRecomp runs the user-supplied Android ARMv7 library from BackStab HD 1.2.8d in a Windows x64 host through AndroidRecomp. It implements the game's needed Android, JNI, graphics, audio, filesystem, input, and lifecycle behavior, with widescreen rendering changes.

BallPad ports Super Mario Strikers to iOS and iPadOS by compiling a community decompilation-based source port as native ARM64 code. It adds Metal presentation, touch and physical-controller input, and an importer for the user's USA revision 0 disc image.

BananaPad adapts the Donkey Kong 64 static-recompilation port for Apple Silicon macOS, iPhone and iPad. Its scripts generate game and RSP code from a user-supplied ROM, then combine that code with a native Apple shell, Metal rendering, touch controls and game-specific patches. The author reports playable macOS and Simulator builds and a physical iPad build that renders the game.

Baroque translates the USA PlayStation 2 game's routines into a native Windows C++ port. It reads models, game data, audio and movies from the user's disc image through its own loaders, and adds widescreen presentation, higher display frame rates and keyboard and mouse controls.

BarrelPad adapts Golden Balloon's decompilation-based Diddy Kong Racing port for Mac, iPhone, and iPad. It adds Apple lifecycle integration, game-specific touch and controller input, and local loading of the user's ROM while the reconstructed game logic runs as native host code.

Ports the existing Super Smash Bros. N64 decompilation using libultraship and Torch. The author’s earlier README describes agent-built graphics/audio comparison tools and differential debugging against emulator behavior, rather than claiming AI recovered the game from a cartridge without prior community work.

bbport runs the original Bloodborne 1.09 x86-64 game code on Linux and Windows by preparing its executable as a memory image and replacing PS4 system libraries with a game-specific runtime. Its renderer translates PS4 GPU commands and shaders to Vulkan; the author reports playable areas, sound, saving and gamepad support.

BearBirdPad ports the BanjoRecomp version of Banjo-Kazooie to iPhone and iPad. Its iOS integration adds Metal rendering, movable touch controls, controller handling, local ROM import and save storage. Build scripts generate the game module from a player's supported NTSC-U 1.0 ROM.

Beat Hazard 2 Vita runs the game's Android ARMv7 executable on PS Vita by loading it into memory, resolving imports with native functions and applying runtime patches. The port also adds custom-song support for WAV, MP3, FLAC and OGG files.

Bejeweled LIVE + decomp ports decompiled C# source from the Windows Phone 7 release of Bejeweled Classic to MonoGame. Its solution contains game, graphics, audio and interface code and builds after the user supplies the original XAP assets.

BellPad ports the original US GameCube Animal Crossing to Apple Silicon macOS, iPhone and iPad using a decompiled game core. It adds Apple platform integration, Metal-backed rendering, local disc import, input handling and save support through tracked compatibility patches.

Birdman64 ports Pilotwings 64 to native PC play by compiling decompiled game source against a user-supplied US ROM during first-time setup. Its runtime adds widescreen rendering, modern controls and two-player split-screen; the project also describes experimental Android support and iOS test builds.