AI Finished the Melee Decomp. The Emulators on Your Handheld Ban It.

2026-09-09 · News and analysis

Affiliate disclosure: This guide contains affiliate links. As an Amazon Associate, we earn from qualifying purchases at no extra cost to you. Learn more.

This week Super Smash Bros. Melee reached 100% decompilation, with OpenAI's GPT-6 Astra closing out the final stretch of a six year project. It was covered everywhere as a milestone, and it is one.

Here is the part that did not get covered. In the same window, the emulator projects that actually run on your handheld have been doing the opposite. mGBA's contributing guide says, in capital letters, that AI-generated pull requests will be closed on sight. SDL banned them in April. QEMU says it cannot accept the legal risk at all.

These are not fringe projects. SDL is underneath RetroArch, PPSSPP, Dolphin and PCSX2, and it ships inside the Steam Runtime, which means it is on every Steam Deck. mGBA is the Game Boy Advance core on almost every device we cover.

So the software that made the Melee news possible and the software that plays your games have landed in completely different places. Both of them are being sensible. Understanding why is genuinely useful if you follow this stuff.

The Short Version

• mGBA: "WE DO NOT ACCEPT AI-GENERATED CODE. IF YOUR CODE IS GENERATED BY AI, YOUR PULL REQUEST WILL BE SUMMARILY CLOSED."
• SDL: banned April 2026. AI may be used to find bugs, but a human must write the fix
• QEMU: declines AI-derived contributions because contributors cannot honestly sign the Developer Certificate of Origin
• The common reason: licensing provenance, not code quality
• The decomp scene went the other way because it has something emulators do not: a compiler that proves the answer is correct
• RetroArch and libretro have no published policy either way that we could find
• Not a retro-only trend: GCC, Zig, OpenJDK, Godot, Bevy, LÖVE, Servo and others have similar rules

What mGBA Actually Says

mGBA is the accuracy-focused Game Boy Advance emulator, available standalone and as a RetroArch core, and it is what we recommend in our mGBA setup guide. Its contributing document contains this, in capitals:

WE DO NOT ACCEPT AI-GENERATED CODE. IF YOUR CODE IS GENERATED BY AI, YOUR PULL REQUEST WILL BE SUMMARILY CLOSED.

No rationale is offered. It is stated as a rule and left there, which tells you something about how tired the maintainer is of the conversation.

That bluntness is worth sitting with. mGBA is a project whose entire value proposition is accuracy. It exists because "close enough" GBA emulation was not good enough for people who cared about save behaviour, the solar sensor in the Boktai games, and link cable features. A project built on precision has the least patience for code that is confidently almost right.

SDL's Version Is More Detailed, and More Revealing

SDL adopted its policy in April 2026, written by Ryan C. Gordon after a GitHub issue asked where the project stood. The core line:

AI may not be used to generate code for contributions to this project.

The definition of AI given is broad, naming large language models generally rather than any single product.

Three reasons are given, and only one of them is about quality:

1. Unknown training data origins, with licensing terms that may be incompatible with SDL's zlib license
2. Risk of pulling in code carrying conflicting license terms
3. AI systems producing hallucinated issues, incorrect information and invented problem descriptions

There is one carve-out, and it is a sensible one. AI tools may be used to identify existing issues, but a human has to independently verify the problem and author the solution. Pull requests require the submitter to confirm they wrote the change and are contributing it under the zlib license.

SDL matters more than any other project on this page for handheld owners. It is the layer that handles windows, input, audio and controllers for an enormous share of the emulation stack. If you use RetroArch, PPSSPP, Dolphin or PCSX2, you are running SDL. If you own a Steam Deck, it is part of the runtime your games sit on.

QEMU Makes the Legal Argument Explicit

QEMU is blunt about the mechanism rather than the vibe:

With AI content generators, the copyright and license status of the output is ill-defined with no generally accepted, settled legal foundation.

The concrete problem is the Developer Certificate of Origin. When you sign off on a patch to a project like QEMU, you are certifying where the code came from and that you have the right to contribute it. QEMU's position is that if part of your patch came out of a model trained on unknown material, you cannot honestly make that certification. The project says it is "not willing or able to accept the legal risks of non-compliance."

It leaves a door open. Exceptions can be discussed on the development mailing list, and would still require full sign-off.

Why Decomp Can Use AI and Emulators Cannot

This is the part worth understanding, because on the surface it looks inconsistent. Both communities write low-level C. Both care enormously about correctness. One just used AI to finish a landmark project and the other closes AI patches unread.

The difference is that matching decompilation has an oracle and emulator development does not.

In a matching decomp, the test is mechanical. You compile your C with the original compiler and settings, and you compare the output bytes against the original binary. Either it matches or it does not. There is no judgement call, no "looks right to me," no reviewer fatigue. A model can produce a hundred wrong answers and it costs nothing, because the compiler rejects all hundred without a human ever reading them. When something matches, it is correct by construction. We covered how that constraint works in our decomp and recomp explainer.

Emulator code has no such check. If a model writes a plausible-looking fix to a graphics blending path, nothing automatically proves it wrong. It compiles. It probably runs. The tests pass, because emulator test suites cover a fraction of real behaviour. A subtly incorrect patch gets merged, and two years later somebody files a bug that a specific game corrupts its save file on a specific device, and now a maintainer is bisecting through history to find a change that never should have landed.

The asymmetry is the whole story. Decomp gets a free, perfect, automated reviewer. Emulators get a volunteer with limited time reading a patch that was written to look convincing.

Then add the licensing problem, which cuts against emulators much harder. A decomp project is reconstructing code that already exists in a binary somebody owns, and the legal questions there are already well understood by the people doing it. An emulator is original work under a specific license, distributed to millions of people and shipped inside commercial products. Contaminating that codebase with code of unknown provenance is not a theoretical risk. It is the kind of thing that can force a rewrite.

This Is Not Just an Emulation Thing

The retro projects are part of a much wider shift through 2026:

Veloren's phrasing is the one that sticks. It classifies model output as tainted content, which frames the issue exactly the way these projects experience it. The worry is not that the code is bad. It is that once it is in, you cannot get the uncertainty back out.

There is a middle position too. The EFF published a policy in February 2026 that does not ban the tools outright, instead requiring that contributors genuinely understand the code they submit and that comments and documentation be written by a human. That is a reasonable place to land, and it puts the obligation on the contributor rather than on the tool.

Two notable absences. We could not find a published AI contribution policy for RetroArch or libretro, which is surprising given how central they are. And Dolphin has no explicit AI rule either, though it has long refused code from anyone with confidential knowledge of GameCube or Wii internals. That is already a provenance rule. Dolphin has been thinking in these terms for years, just about a different contamination risk.

What This Means If You Just Play Games

Practically, very little changes for you this week. Nothing here breaks an emulator or removes a feature.

Over a longer horizon it is worth watching for two reasons.

Emulator development is volunteer work and it is slow. These projects are maintained by small numbers of people doing unpaid, difficult work. A tool that could genuinely speed that up would matter. Ruling it out is a real cost, and the maintainers taking that cost are doing it deliberately because they judge the alternative worse.

Decomp and recomp are moving in the opposite direction, which means the two paths to playing old games on new hardware are now diverging in method. Emulation stays careful, slow and human. Native ports get a new accelerant. If that holds, the balance we describe in our decomp vs recomp explainer shifts over the next few years in a way nobody planned.

Our honest read: mGBA, SDL and QEMU are making the right call for their situation, and the decomp teams are making the right call for theirs. The interesting question is not who is correct. It is what happens to projects sitting between the two, like emulator cores that also maintain reverse-engineered documentation, where the same contributor might be welcome to use a model on one task and banned from using it on another.

Frequently Asked Questions

Does mGBA really ban AI-generated code?

Yes. Its contributing guide states in capital letters that AI-generated code is not accepted and that such pull requests will be summarily closed. No rationale is given alongside the rule.

Why did SDL ban AI-generated contributions?

SDL cited three reasons in its April 2026 policy: the unknown origins of model training data and possible incompatibility with SDL's zlib license, the risk of incorporating code carrying conflicting license terms, and AI tools generating hallucinated issues and incorrect problem descriptions. AI may still be used to identify bugs, but a human must verify and write the fix.

Why does this matter for my handheld?

SDL is the layer handling input, audio, controllers and windowing for a large share of emulation software, including RetroArch, PPSSPP, Dolphin and PCSX2, and it ships in the Steam Runtime on the Steam Deck. mGBA is the Game Boy Advance core on most retro handhelds. Decisions these projects make reach almost every device.

If the Melee decompilation used AI, why can emulators not?

Because matching decompilation can be verified automatically. The compiler either produces a byte-for-byte match with the original binary or it does not, so wrong answers are rejected without a human reading them. Emulator code has no equivalent check, so a plausible but subtly incorrect patch can pass review and cause bugs years later.

Is this about code quality or about law?

Mostly law. All three projects lead with licensing provenance rather than correctness. QEMU's objection is specifically that a contributor cannot honestly sign the Developer Certificate of Origin when part of the work came from a model trained on unknown material.

Do RetroArch and Dolphin ban AI code too?

We could not find a published policy for RetroArch or libretro either way. Dolphin has no explicit AI rule, though it has long declined code from contributors with confidential knowledge of GameCube or Wii internals, which is a provenance rule of the same kind.

Are other open source projects doing this?

Yes, widely. GCC, Zig, OpenJDK, Godot, Bevy, LÖVE, Servo, Veloren, Endless Sky and Cataclysm: Dark Days Ahead have all restricted or banned AI-generated contributions. Jellyfin permits them with disclosure, and Codeberg bans hosting projects that are primarily LLM-generated.

Will this slow emulator development down?

Possibly, and the maintainers know it. Emulator projects are volunteer-run and chronically short on people, so declining a tool that might speed things up is a real cost. They have judged the licensing and review risks to be the larger problem.

Related Reading

• Melee Is 100% Decompiled, and AI Finished the Last Stretch
• Decomp vs Recomp: How Old Games Become PC Ports
• mGBA Setup Guide
• Every Recompiled Game So Far
• AI Fan Translations Are Splitting the Romhacking Scene
• RetroArch Setup Guide
• Emulation Legal Status in 2026

Policy wording reflects each project's public documentation as of September 9, 2026. These policies are being revised across the open source ecosystem and will change.