How to Play Recompiled Console Games on PC

What playing a recomp actually means

A recompiled game is not an emulated game. The project translates the console's original machine code into C or C++ ahead of time, compiles that code into an ordinary program, and runs the result natively on your computer. There is no emulator window, no per-frame instruction translation, and no virtual console. The game's logic executes as code written for your CPU.

That difference explains both the appeal and the friction. Recompiled ports often support higher frame rates, widescreen, higher internal resolution and modern controllers because the game is no longer tied to the console's original timing or memory layout. They also tend to be stricter about input files, because the program still needs the original game's assets. A recomp ships code and tools; it does not ship the game.

This guide covers the practical path from a listed project to a running game. It applies to static recompilations, source ports built on decompilations, and projects that call themselves ports. The details differ per project, but the sequence is usually the same: confirm the target version, obtain the build, prepare your own game data, launch, then troubleshoot.

Choosing the right project for a game

Many games have more than one project. A game can have a static recompilation, a port built on a decompilation, and a separate Android project, each with its own status and requirements. The catalogue groups them on one game page so you can compare without hunting across repositories.

When several projects exist, start with the one whose documentation is clearest about the version it accepts and the platforms it supports. A Playable project with a narrow target is often a better first choice than an In Progress project that claims broad compatibility. If one project is a decompilation that only builds a console ROM and another is a native port, they solve different problems: the first preserves the original build, the second aims at a modern desktop.

Read the most recent release notes, not only the README. A README can lag months behind the code, while release notes describe what changed in the build you are about to install. If the two disagree about supported platforms, trust the release notes for that release and the README for the project's overall intent.

Finally, check the issue tracker for the specific game version you own. A project can be healthy and still have an open bug for your region or revision. Knowing that in advance turns a confusing failure into an expected limitation.

What you need before you start

First, a legally owned copy of the game. Depending on the platform, that means a disc, a cartridge, or a legitimate digital purchase that the project's documentation supports. Recompedia does not host or link to ROMs, ISOs, BIOS files or game assets, and no project on this site does either. If a guide or video offers to supply the game files, stop reading it.

Second, the exact version the project targets. Console games shipped in multiple regions and revisions, and a recompilation is usually built around one executable. A North American 1.1 cartridge, a European disc and a later budget re-release can contain different code. Many projects check a hash and refuse anything else; others load the wrong version and fail in confusing ways later. The project README is the authority here, not a forum post.

Third, the project's current build or source tree. Some projects publish ready-made binaries for Windows, Linux and macOS. Others expect you to compile from source with a specific toolchain. A few provide Android packages. The release page and README tell you which case applies; do not assume a GitHub repository with source code also publishes a convenient executable.

Fourth, the runtime dependencies the README lists. A GPU with a specific API level, a particular Visual C++ runtime, SDL, .NET, Java, or a platform-specific package. Most failures at first launch come from a missing dependency rather than a broken game.

Step 1: confirm the project's status and target version

Before downloading anything, read the project's README and its most recent release notes. Look for three things: the exact game version or region it accepts, the platforms it currently supports, and whether the maintainer describes the game as playable, in progress, or experimental. A tagged release is evidence of activity, not proof that every level works.

The catalogue entry on this site records the same facts, but the project's own repository wins when the two disagree. Status labels are conservative: Playable generally means the project itself states the game can be played through. In Progress means work continues and the project does not claim completion. Announced means support has been stated but not released. Unknown means the current state could not be confirmed.

If the README does not name a version, check the project's issues and release notes. A project that accepts multiple regions usually lists a hash or filename for each. Write down the required filename and hash before you touch your game files; this saves an hour of guessing later.

Step 2: obtain the project build

Prefer the project's own release page. Download the archive for your operating system, check the release notes for the version you are installing, and keep the archive until the game runs. If the project publishes only source, follow its build instructions exactly: the compiler version, the submodules, and the build directory all matter. A build that succeeds with a different toolchain may still produce a binary that fails at runtime.

Be careful with third-party repacks. Recompilation projects are small and their releases are usually a few archives on GitHub. A repack that bundles 'everything you need' often includes game data, which is precisely what the project is not allowed to distribute. It may also be stale. If a repack is the only download you can find, treat that as a warning sign about the project's maintenance.

On Windows, extract to a folder you control rather than Program Files; several launchers write settings next to the executable. On Linux, check whether the project expects a distribution package, an AppImage, or a source build. On macOS, unsigned builds may need the standard Gatekeeper bypass, and Apple Silicon support is often separate from Intel support. On Android, an APK is not automatically compatible with every phone; the README usually states the minimum Android version and GPU requirement.

Step 3: prepare your own game data

Recompiled projects read assets from your copy of the game. The usual forms are a disc image, a cartridge dump, or a folder of extracted files. Dumping your own disc or cartridge is a separate skill; the project README normally explains what format it expects and sometimes links to a dumping guide for the relevant hardware.

Place the files exactly where the project expects them. Many projects ask for a specific filename, such as a region-coded ROM name or an ISO named after the game's serial. Some accept a folder of extracted assets; others require the untouched image. Do not rename a PAL dump to look like an NTSC file in the hope that it works. Hashes are checked for a reason: the code and asset layout differ.

If the project includes an extraction step, run it once and keep the output. Re-running extraction is usually harmless but slow. If the tool reports a hash mismatch, stop and confirm the region and revision rather than trying another file. A mismatched dump is the single most common cause of a black screen or an immediate exit.

Keep your game files outside the project folder when possible. Project updates frequently replace the program directory, and some launchers delete files they do not recognise. A separate folder also makes it obvious which data belongs to you and which belongs to the project.

Step 4: first launch and configuration

Launch the game through the project's own launcher or executable. On first run, many ports ask you to locate the game data; point them at the file or folder you prepared. If the launcher offers a graphics backend, start with the default and change one setting at a time. A crash after changing three settings tells you nothing about which one caused it.

Expect the first launch to be slower than later ones. Shader compilation, asset conversion and cache building can take minutes on some projects. A window that appears frozen during a first run may be working; check the project's documentation before killing it.

Controllers are usually handled by the project rather than the operating system. If a controller is not detected, confirm that the project supports it and that no other software is capturing it. Keyboard and mouse support varies; some ports expose it only in a settings menu, and some do not support it at all.

Save files and settings normally live in the project folder, in your user profile, or in a platform-specific application data directory. The README usually states which. Back up saves before updating the project, because save formats can change between releases.

Troubleshooting the common failures

An immediate exit with no window is usually a missing dependency or a rejected game file. Run the program from a terminal if the project supports it; the error message is often more specific than anything the window shows. Check the README's requirements list before reinstalling anything.

A black screen after the logo can be a graphics backend problem. Try the other backend the project documents, update the GPU driver, and confirm that the game data passed its hash check. On laptops with two GPUs, make sure the game is using the discrete GPU rather than an integrated one that lacks the required API.

Audio problems are often sample-rate or channel-layout issues. Check the project's settings and your system output configuration. Crashes during a specific cutscene or level are usually project bugs rather than user error; search the project's issue tracker for the level name before spending time on local fixes.

If the game runs but performance is poor, do not assume the project is broken. Some ports are CPU-bound, some are GPU-bound, and some are limited by the original game's logic. The project's README and release notes often describe known performance ceilings. Compare against the documented behaviour rather than against a different project on different hardware.

When a project is not ready

Not every listed project is ready for a full playthrough. A project can boot, render menus and even reach gameplay while still failing at a late level, a specific boss, or a save-related feature. The catalogue notes known issues where the project documents them, but the repository is always more current.

If a project is In Progress, treat it as a work in progress: expect bugs, keep backups, and avoid relying on it for a first playthrough if you have another option. If a project is Announced, there is nothing to install yet. A release tag does not change that; check what the release actually contains.

It is also reasonable to wait. Recompilation projects improve quickly, and a build that fails today may work in a month. Following the project's releases is more useful than repeatedly rebuilding the same broken commit.

The legal and ethical line

Recompilation does not change copyright. The project is a third-party program that reads assets from a game you own; it does not grant you a licence to the game. Keep your copy legitimate, do not redistribute extracted assets, and do not upload game files to help someone else get a build running.

Recompedia does not host or link to ROMs, ISOs, BIOS files or game assets, and the projects listed here do not either. If a build asks you to download a pre-extracted asset pack, that is not a normal recompilation workflow. The legality guide on this site covers ownership, extraction and the difference between a clean-room project and a distribution of copyrighted data.

Keeping a build working over time

Recompilation projects move quickly. A build that works today can be replaced next week by a release that changes save format, configuration files or the required game data layout. Keep the archive of the version that works, and read release notes before updating. If a new build changes something you depend on, you can return to the previous archive.

Back up saves separately from the project folder. Some projects store saves next to the executable, others in the user profile. Copy the save directory before any update, and note the game version that produced the save. Save compatibility across project updates is not guaranteed, and a save from a different game revision may be rejected even when the project itself is unchanged.

Keep your game data in a stable location. Moving or renaming a disc image after setup can break a project that stores an absolute path. If you reorganise your files, expect to point the launcher at the data again.

None of this replaces reading the project's documentation. The steps above describe the common path, but every project has its own installation contract. When the README is specific, follow it exactly; when it is vague, prefer the release notes and the issue tracker over guesswork.