Recompilation, Decompilation and Game Ownership
Why this topic keeps coming up
Every recompilation project sits on a line between two facts. The project's own code is original work by its maintainers. The game it runs is somebody else's copyrighted work. Projects stay on the right side of that line by shipping code and tools only, and by requiring players to bring their own copy of the game. Most of the confusion around recompilation comes from not separating those two halves.
This guide explains the separation in practical terms: what copyright covers, what a recompilation project actually distributes, why asset packs are a red flag, how dumping your own copy fits in, and what an index like Recompedia can and cannot link to. It is general information, not legal advice. Copyright exceptions differ by country, and none of this substitutes for advice from a lawyer in your jurisdiction.
What copyright covers in a game
A console game is not one work. It contains executable code, which is a literary work in most legal systems. It contains artwork, models, textures, music, voice recordings, video and level data, each protected as its own kind of work. It contains trademarks: the game's name, logos, character designs in some cases, and the console maker's marks. The packaging and manual carry further rights.
Those layers matter because they are not treated identically. A project that writes its own runtime and translates machine code into C is dealing with the executable. A project that reads textures and audio from the player's disc is not copying those assets into its repository; the player's copy supplies them at runtime. A project that bundles extracted textures in a release is distributing copyrighted artwork, regardless of how the code was produced.
The practical rule that follows is simple: original project code is fine to publish, game data is not. A repository containing only source, build scripts and documentation is in a different position from one containing an extracted asset folder. This is why almost every project README repeats the same sentence about not including game assets.
What recompilation legally is, and what it is not
Static recompilation translates the console's machine code into a higher-level language ahead of time. The output is a new program that performs the same operations on a different CPU. It is not a copy of the original executable in any literal sense, but it is derived from it. The translated code is usually generated locally from the player's own game file; the repository holds the translator, the runtime and the build system, not the generated output.
That distinction is why projects can publish a recompiler and a runtime without publishing the game. The generated C or C++ is produced on the player's machine, from the player's copy. When a project does publish generated code for a specific game, it is publishing a derivative of that game's executable, which is a much more exposed position. Most projects avoid it, and the ones that publish generated code usually do so only where they believe the risk is acceptable or where the game's rights holder has not objected.
Recompilation is also not emulation in the legal sense that matters here. An emulator is a general-purpose program that executes another program's instructions. A recompilation is game-specific and contains translated logic. The legal questions are similar in practice, but the technical artefact is different, and that difference affects what a project can distribute.
Decompilation and clean-room reconstruction
Decompilation is the slower route. Maintainers read the original machine code and rewrite it as readable C or C++, function by function, until the rebuilt source compiles into a byte-identical executable. Matching decompilation projects often measure progress as the percentage of functions that produce identical output.
A decompilation repository contains reconstructed source code. That source is derived from the original executable and is generally treated as a derivative work, which is why decompilation projects are careful about how the code is distributed and why many are hosted with the understanding that they are preservation and research efforts rather than licensed products. Some projects use a clean-room approach, separating the person who studies the original binary from the person who writes the new code, to reduce the risk that the reconstruction is treated as a copy.
A native port built on a decompilation adds another layer. The port takes the reconstructed source and adapts it to modern platforms. When that port is distributed as a playable program, the same asset question returns: the port may include the reconstructed code, but it cannot include the game's art, audio or level data. That is why ports ask for your ROM or disc image at first launch.
Why projects cannot ship game data
Game assets are the most visible and most easily enforced part of a game's copyright. A texture, a music track or a character model can be identified and compared directly. Distributing them in a project release is straightforward infringement in most jurisdictions, and it exposes the maintainer far more than distributing translated code does.
This is also why 'all-in-one' repacks are a warning sign. If a download promises a working game without requiring your own copy, it contains copyrighted assets or the original executable, or it is an emulator bundled with a ROM. Either way, it is not the project's official distribution, and using it puts you outside the boundary the project was built around.
The same logic applies to asset packs shared in community forums. A pack of extracted textures may feel like a convenience, but it is a distribution of the game's artwork. Projects that need assets at runtime expect them to come from the player's own copy, extracted locally.
Dumping your own copy
Dumping means copying the contents of a disc or cartridge you own into a file your computer can read. In many countries this is treated differently from downloading a copy from the internet, though the details vary: some jurisdictions recognise format-shifting for personal use, others do not, and anti-circumvention rules can apply even when the copy itself is permitted.
Practically, the important points are that the copy is yours, that you keep it private, and that you do not redistribute it. A dump made from your own disc is for your own use with a project that reads it. Uploading that dump to a file host, sharing it in a Discord server, or bundling it with a build turns a personal copy into a distribution.
Different projects need different dump formats. A disc image may need to be a specific format, a cartridge dump may need a specific byte order, and some projects accept only an untouched image. The project's README is the authority. Converting or renaming a file does not change its region or revision, and a hash check will reject it if it is wrong.
BIOS files and system software
Some consoles require system software to boot games. In an emulator context, that is often a BIOS file. Recompilation projects usually avoid this requirement because they replace the console's services with their own runtime, but some projects or tools may still ask for system files.
A BIOS is copyrighted software. Owning the console does not automatically give you the right to distribute its firmware, and downloading a BIOS from a ROM site is not the same as extracting it from hardware you own. If a project needs system files, the safe path is to obtain them from your own hardware where that is lawful in your jurisdiction, and never to redistribute them.
Recompedia does not host or link to BIOS files. If a project's documentation points to a third-party BIOS download, treat that as a warning about the project's practices rather than as permission.
DRM, anti-circumvention and region locks
Modern consoles add technical protection measures: encrypted discs, signed executables, online activation. Anti-circumvention law in many countries prohibits bypassing those measures even for personal use. A recompilation project that requires you to decrypt a disc or extract keys may be raising legal questions that go beyond copyright in the game's code.
This is one reason the catalogue excludes projects that depend on console jailbreaks. Those projects may be technically impressive, but they sit on the wrong side of anti-circumvention rules in several major markets, and listing them would misrepresent the risk to readers.
Region locks and revision checks are a separate matter. A project that accepts only one region is making a technical choice, not a legal statement. The legal question is whether your copy is legitimate, not whether the project accepts it.
Project licences and third-party code
Recompilation projects usually publish their own code under an open-source licence. That licence covers the project's original work: the runtime, the translator, the build scripts, the launcher. It does not cover the game, and it cannot grant you rights the maintainer does not hold. A GPL or MIT licence on a repository is not a licence to distribute the game's assets.
Projects also depend on third-party libraries: graphics backends, audio libraries, UI toolkits. Those dependencies carry their own licences, and a build that bundles them must comply with those terms. When a project distributes binaries, it is responsible for that compliance; when you build from source, your build is your responsibility.
If you fork a project or redistribute a modified build, read its licence first. Some licences require you to publish your changes, others do not. None of them permit you to add game assets to the distribution.
What Recompedia does and does not do
Recompedia is an information index. It records projects, their status, the platforms they support and links to their own repositories. It does not host game files, mirror project releases, or provide asset packs. It does not link to ROM, ISO or BIOS download sites.
The site does link to third-party repositories and to media hosted by IGDB and YouTube. Those services have their own terms, and the site credits them. Game titles, console names and company names are trademarks of their respective owners and are used here only to identify the games and platforms being discussed.
Because the catalogue depends on project documentation, it can be out of date. A status label reflects what the project said at the last check, not a guarantee about the current build. When the catalogue and the project disagree, the project wins.
Preservation, abandonware and the long view
Recompilation and decompilation are often described as preservation work, and there is a real preservation argument behind them. Consoles fail, optical drives stop reading discs, online stores close, and a game that cannot be purchased legally becomes difficult to experience without infringement. Projects that keep an executable runnable on modern hardware serve a purpose that goes beyond hobby tinkering.
Preservation does not create a general exception, though. Keeping a game playable for people who own it is different from distributing it to people who do not. The projects that survive longest tend to be the ones that respect that line: code in the repository, assets from the player, no shortcuts for people who cannot be bothered to own the game.
Rights holders have responded in different ways. Some ignore fan projects. Some tolerate them while they remain non-commercial and require an owned copy. Some send takedowns regardless. The absence of a takedown is not permission, and a project's survival is not a legal ruling. That uncertainty is part of why projects are careful about assets and why an index should be careful about what it links to.
For readers, the practical conclusion is modest: use projects the way their maintainers intended, keep your own copy legitimate, and do not treat a working build as a licence to redistribute anything. The technology is interesting precisely because it preserves games; the boundary is what keeps it defensible.
A practical checklist
Before installing anything: confirm that you own the game and that your copy matches the region and revision the project targets. Confirm that the project ships code and tools rather than game data. Read the README's asset requirements and its licence.
While setting up: keep your dump private, do not upload it, and do not download asset packs from third parties. If a project asks for a BIOS or system file, verify that the requirement is documented and that you can satisfy it lawfully. Keep a backup of your saves and of the build that works.
If something feels off: a download that includes the game, a build that runs without your copy, a request to disable antivirus software, or a repository that mirrors assets instead of code. In each case, the safe move is to stop and check the project's official documentation.
None of this is legal advice. It is a practical summary of the boundary that legitimate recompilation projects work within, and of the questions to ask before you install a build.
Recompedia does not host or link to ROMs, BIOS files or game assets. Every project listed requires a copy of the original game owned by the player.