Mostly Harmless: A Hitchhiker's Guide to Nintendo Emulation and the Linux Hackers Who Won't Let It Die

At 15:04:49 on Monday the 12th of May 2025, a volunteer named Peder Bergebakken Sundt deleted a package called torzu from nixpkgs. Torzu was a fork of a fork of yuzu, the Nintendo Switch emulator. It had been in the repository for four and a half months. The commit message is two words: torzu: drop.

Eighteen seconds later, at 15:05:07, he committed this:

aliases: re-add entries for yuzu and citra

Not add. Re-add.

Fourteen months earlier, yuzu and Citra had been erased from the internet in a legal settlement. When nixpkgs removed them, it left behind small markers — one line each, saying where the packages went and why. Sometime in the intervening year, a routine cleanup had swept those markers away. And while he was down there burying torzu, Peder noticed the older graves had been levelled.

So he carved them again. All eight of them, character for character, including the inconsistent capitalisation in the originals.

I want to tell you about the two years of legal machinery that made that commit necessary. But mostly I want to tell you about the eighteen seconds — because in those eighteen seconds is the entire argument for free software, and I don't think I've ever seen it stated more plainly by anyone, in any manifesto, anywhere.

Mostly harmless#

In The Hitchhiker's Guide to the Galaxy, the Guide's entry for the planet Earth — the whole planet, four billion years of it, everyone who ever lived — reads, in its entirety:

Mostly harmless.

That joke has stayed with me for twenty years because of how it works: the horror isn't that the entry is wrong. It's that it's accurate, and it's two words, and that's all the room the universe allocated.

Nixpkgs has an entry like that for every piece of software it has ever buried.

Here's the mechanic, because everything below depends on it. When a package leaves nixpkgs, the maintainers can't simply delete the files. Thousands of people have yuzu written in a config file somewhere, and Nix is an evaluated language — if the name just vanished, they'd get a bare "attribute 'yuzu' missing" and nothing else. So nixpkgs keeps a file, pkgs/top-level/aliases.nix, which is somewhere between a redirect table and a cemetery. An entry can point at a new name:

citra = citra-nightly; # added 2022-05-17

Or, when there's nothing left to point at, it becomes a throw — an attribute whose only remaining purpose is to fail loudly and explain itself:

notepadqq = throw "'notepadqq' has been removed due to upstream stopping maintenance in 2023."; # Added 2026-02-10

That's it. A throw in aliases.nix is a headstone. The software is gone, but the name persists, carrying one sentence about what happened to it, written by whoever buried it, addressed to a stranger in the future whose config finally breaks.

I counted. As of today that file is 3,016 lines long and contains 1,980 of these epitaphs. It is, almost certainly by accident, one of the largest machine-readable memorials to dead software that exists anywhere.

And when you read them in bulk, you notice they nearly all say the same handful of things:

norouter = throw "norouter has been removed because it has been marked as broken since at least November 2024.";
notary = throw "'notary' has been removed due to being archived upstream. Consider using 'notation' instead.";
notes-up = throw "'notes-up' has been removed as it was unmaintained and depends on deprecated webkitgtk_4_0";
nufraw = throw "'nufraw' has been removed as the UI depended on the deprecated GTK2 engine.";

Unmaintained. Broken. Archived. Abandoned. Depends on something deprecated.

These are software's natural causes of death — entropy, boredom, the slow retirement of a dependency, a maintainer who got a new job or a kid or simply stopped caring. Nineteen hundred and eighty gravestones, and the overwhelming majority died the way everything dies: because eventually nobody was left to hold it up.

Which is why the ones in this story stand out so violently. In a cemetery where almost everyone died of old age, a small cluster of stones say something else entirely.

They say that something came and took them.

The quiet decade#

Before any of that, there were years and years of nothing happening, which is the part everyone forgets and the part that matters most.

2014-09-02  73439c605320  add dolphinEmu and dolphinEmuMaster

Cray Elliott adds Dolphin — the GameCube and Wii emulator — in September 2014. Remember this commit. It's going to be the most important one in the piece, and you won't see why until the end.

2017-07-27  bc52bf2cfe3d  citra: init at 2017-07-26

Nikolay Amiantov adds Citra, the 3DS emulator. The project didn't cut releases, so the "version" is just the date somebody checked it out.

2020-04-02  c36ab0c67853  yuzu: init at 482
2020-07-31  2e2f87db13e0  ryujinx: init at 1.0.5160

Four months apart in 2020, both Switch emulators arrive, added by the same person — a maintainer signing as "Ivar" and "IvarWithoutBones," who appears to have simply been the one who cared about this corner of the world.

And then, for years: maintenance. Hundreds of commits of the most profoundly boring kind.

2022-03-21  yuzu-{ea,mainline}: {2557,953} -> {2690,992}
2022-05-12  yuzu-{ea,mainline}: {2690,992} -> {2725,1014}
2023-07-16  yuzu-ea: 3702 -> 3783, yuzu-mainline: 1475 -> 1513

Version bumps. Hash updates. Somebody fixing the Wayland build. Somebody adding udev rules so controllers work. Somebody noticing the package pulled in a copy of ffmpeg it didn't need.

In April 2023, K900 — by then yuzu's de facto caretaker in nixpkgs — writes this:

2023-04-28  f08af5a3d41e  yuzu: reanimate, clean up, switch to qt6

Reanimate. The package had gone stale and somebody brought it back. It's a throwaway verb in a routine commit, and it is the only time in this entire history that anyone uses that word about something that actually returned.

This is what a healthy free software ecosystem looks like from the inside. It isn't dramatic. Nobody is manning barricades. It's a handful of people, scattered across several countries, who have quietly taken on a small permanent obligation to strangers: this will keep working. Not because anyone pays them. Because they said they would, in the only way that counts, which is by continuing to do it every couple of weeks for years.

The last normal days#

Nintendo of America filed suit against Tropic Haze LLC, the developers of yuzu, on Monday the 26th of February 2024.

Here is what nixpkgs did on Tuesday:

2024-02-27 16:06:27  6b24129a4f67  yuzuPackages.compat-list: unstable-2024-02-14 -> unstable-2024-02-26
2024-02-27 16:21:46  db7b9caf4914  yuzuPackages.early-access: 4141 -> 4174
2024-02-27 17:48:21  efc44c29ab49  yuzuPackages.mainline: 1715 -> 1727
2024-02-27 22:37:40  b5c956262d95  Merge pull request #291878 from K900/fresh-fruit

Three routine version bumps and a merge, on a branch K900 had named fresh-fruit, the day after the lawsuit. Nothing acknowledges anything. It's a Tuesday, there were new builds, he packaged them.

The next day, somebody else shows up to do careful work:

2024-02-28  46fbd894a87c  Yuzu: Only compile with -msse4.1 if on x64

Rowan Goemans, fixing a compiler flag that was breaking the build on ARM. It's part of a larger effort to make yuzu work on aarch64 — people wanted to run it on handhelds and single-board machines. Meticulous, unglamorous portability work, the kind that benefits a minority of users and takes a disproportionate amount of care.

K900 merged it on the 1st of March.

The package had seventy-two hours left.

I keep returning to those three days, and I've decided the reason is this: they are the last moments in this story when the people involved were still simply building something. Not defending it. Not mirroring it. Not arguing about it. Just making a Switch emulator compile correctly on a processor architecture most of its users didn't own, because a good patch had arrived and that's what you do with a good patch.

Nobody wrote "this may be moot now." The commit log had no idea what was coming. It almost never does.

Two removals, and one word#

On Monday the 4th of March 2024, yuzu's developers settled for $2.4 million, agreed never to work on Nintendo emulation again, and pulled everything offline.

2024-03-04 20:39:38  ef72e8b3a9b9  yuzuPackages: remove

Soner Sayakci, on a branch called remove-yuzu. Eight package files deleted, 343 lines gone: mainline, early-access, the compatibility list, the timezone database helper, both update scripts. And in aliases.nix, four living redirects become five headstones:

-  yuzu-ea = yuzuPackages.early-access; # Added 2022-08-18
-  yuzu-early-access = yuzuPackages.early-access; # Added 2023-12-29
-  yuzu = yuzuPackages.mainline; # Added 2021-01-25
-  yuzu-mainline = yuzuPackages.mainline; # Added 2023-12-29
+  yuzu-ea = throw "yuzu-ea has been removed from nixpkgs, as it has been deleted upstream"; # Added 2024-03-04
+  yuzu-early-access = throw "yuzu-early-access has been removed from nixpkgs, as it has been deleted upstream"; # Added 2024-03-04
+  yuzu = throw "yuzu has been removed from nixpkgs, as it has been deleted upstream"; # Added 2024-03-04
+  yuzu-mainline = throw "yuzu-mainline has been removed from nixpkgs, as it has been deleted upstream"; # Added 2024-03-04
+  yuzuPackages = throw "yuzuPackages has been removed from nixpkgs, as it has been deleted upstream"; # Added 2024-03-04

Look at the removed lines. # Added 2021-01-25. That alias had been pointing at a real, living package for three years and two months. That's how long the name meant something.

The reason given is "deleted upstream."

The following evening the same person came back to bury Citra, which died in the same settlement because it shared a team and a codebase:

2024-03-05 20:18:05  9b90f685e58c  citra: remove package

And tucked into that commit, alongside the three new Citra epitaphs, is this:

-  yuzu = throw "yuzu has been removed from nixpkgs, as it has been deleted upstream"; # Added 2024-03-04
+  yuzu = throw "yuzu has been removed from nixpkgs, as it has been taken down upstream"; # Added 2024-03-04

He went back and changed the wording on all five. Nothing else moved — same names, same dates, same trailing comments. One phrase:

deleted → taken down.

I've thought about this diff more than is reasonable. I don't know what was in his head and I'm not going to pretend I do. But those two phrases are not synonyms, and the difference between them is precisely what everybody was arguing about that week.

Deleted upstream is intransitive and blameless. It's the same register as the other nineteen hundred stones in that file — a project that stopped, a repo that went quiet, software dying of natural causes. It puts yuzu in the same category as nufraw, which died because nobody wanted to maintain a GTK2 interface.

Taken down has an agent. Something was done to it, by someone.

Twenty-four hours after writing the gentler version, with a second emulator to bury and presumably a day to think about it, a volunteer sysadmin went back into a 3,000-line file and corrected the historical record — so that the error message some stranger sees in 2031 will be true.

Nobody asked him to do that. Nobody would ever have noticed if he hadn't. There is no metric anywhere that rewards it. He did it because the record was slightly wrong and he was the one who knew.

What actually killed them#

Here's the part that changed how I think about this whole story, and I need to be precise about it, because the precision is the point.

Not one of these projects was ever found liable of anything by any court.

Not one. yuzu settled before any judge ruled on anything. Ryujinx never even got a lawsuit — in October 2024 its developer received a private offer and accepted it, and no one outside that conversation knows what was in it. The thirteen repositories that vanished in February 2026 came down on filed forms. In the entire two-year demolition of open-source Nintendo emulation, there was no verdict, no finding of fact, no adversarial hearing, no precedent set.

There was no law here in the sense most people mean the word. There was leverage.

And the leverage isn't copyright, which is the thing everyone assumes. Copying a game is infringement, obviously — but writing an emulator isn't, and that was settled decades ago in Sega v. Accolade and Sony v. Connectix. Clean-room reverse engineering is legal. It has been legal my entire adult life. Nintendo has never once argued otherwise in front of a judge, because they would lose.

The lever is §1201 of the Digital Millennium Copyright Act — the anti-circumvention provision. And §1201 doesn't regulate copying. It regulates tools. It makes it unlawful to distribute technology that circumvents an access control, and — this is the part that should worry you regardless of how you feel about Nintendo — you can be liable under it whether or not any infringement ever occurs. The act it punishes is publication. The thing it removes from the world is not a copy. It's a piece of source code.

If that sounds familiar, it should. This is the same statute, and very nearly the same fight, as Universal v. Corley — the first circuit-level test of §1201 — in which a federal court ordered 2600 magazine to stop publishing DeCSS, a few hundred lines of C that let you play a DVD you owned on a Linux machine. Not to stop pirating anything. To stop publishing the source code. The injunction barred Corley from posting it and from knowingly linking to anyone who had.

The response is one of the founding legends of the culture this post is about. People printed DeCSS on t-shirts. Somebody set it to music. Seth Schoen wrote the algorithm out as a 465-stanza haiku — explicitly to make the argument that source code is speech, and to force a court that wanted to ban it to explain why banning a poem was different. Phil Carmody found a prime number whose digits encoded the gzipped source, so that a prime number became contraband. Jon Lech Johansen, the Norwegian teenager who co-wrote the thing, was prosecuted at home and acquitted — twice. Within weeks there were mirrors on every continent, and the code has never been unavailable for a single day since.

They did not win in court. Corley lost, and lost the appeal; the Second Circuit affirmed that §1201 was constitutional even applied to publishing source. What they won was the only victory that was ever actually on offer: they made the code impossible to erase.

That is the tradition these commits belong to. Not a legal tradition — a practical one. When the law can remove something from the world by filing a form, the only durable answer is to make the something exist in too many places, held by too many unaffiliated people, to be worth the forms.

Which brings us to a man with an archive.org link and an apology.

Ryujinx dies slowly#

yuzu died in a single commit. Ryujinx took twenty-one months to finish dying, and the manner of it is completely different — and, I think, more moving.

On the 1st of October 2024, Nintendo contacted gdkchan, Ryujinx's developer, and offered him an agreement. He took it. Within a day the GitHub organisation and every asset in it was gone. No filing, no figure, no terms, no court. A phone call, and six years of work left the internet.

This created an immediate and mundane problem for nixpkgs, of the kind that lawsuits don't usually cause: the package's src pointed at a repository that no longer existed. Ryujinx no longer built. Not for anyone wanting to pirate anything — for anyone on NixOS who already had it in their configuration and ran an update.

Four days later:

2024-10-05 17:53:29  59a5a09b670a  ryujinx: archive.org tarball mirror

The body of that commit is my favourite artifact in this entire history:

Should fix source builds by relying on our beloved archive.org to host a SHA256-matching tarball generated from a mirror of the repo.

I have only nix repl'd the fetchTarball expression for its consistency check, as I do not currently have the time nor storage to build the package locally, sorry about that.

We could also generate archives to address [issue #345410] and the 24.05 branch.

Nabile Rahmani. Our beloved archive.org. And then, instantly, the apology — he couldn't build it locally, he didn't have the disk space, he's sorry, and here is exactly what he verified and exactly what he didn't.

I find that almost unbearably decent. A corporation had just deleted a project from the internet, and this man's response was to go find a copy, wire it back up, and apologise for the limitations of his hard drive.

The diff is a small monument:

-  src = fetchFromGitHub {
-    owner = "Ryujinx";
-    repo = "Ryujinx";
-    rev = "5dbba07e33e83c9047dcbb701c9655edbbe89086";
+  src = fetchzip {
+    url = "https://archive.org/download/ryujinx-5dbba-07e-33e-83c-9047dcbb-701c-9655edbbe-89086.tar/Ryujinx-5dbba07e33e83c9047dcbb701c9655edbbe89086.tar.gz";
     hash = "sha256-UeJ3KE5e5H9crqroAxjmxYTf/Z4cbj41a6/1HW2nLcA=";
   };

The hash didn't change.

Sit with that for a second, because it's the most quietly radical thing in this post. Nix builds are content-addressed: the definition doesn't say where the source lives, it says what the source is, as a cryptographic fingerprint. The project was erased from the internet, and the build recipe barely noticed, because nixpkgs already knew exactly what it was looking for and any bit-identical copy from anywhere on Earth would satisfy it.

You cannot take something down from a system like that. You can only make it slightly harder to find. The architecture itself — designed for reproducibility, for boring engineering reasons, years before any of this — turns out to be censorship-resistant as a side effect of being honest about what it wants.

Three hours later he backported the same fix to the stable branch, so people on release-24.05 wouldn't be stranded either. Nobody was going to thank him for that either.

Then the long tail, which is somehow sadder than the removal:

2024-10-14  3b0e6194fb38  ryujinx: remove absolute path in desktop entry

Two weeks after the project ceased to exist, somebody tidied up its .desktop file. The little menu entry with the icon. For a program whose upstream had been gone a fortnight.

2024-11-05  a321e2707588  ryujinx-greemdev: init at 1.2.76

A fork appears — a developer called greemdev had picked up the code — and gets packaged five weeks after the death.

2024-12-16  f1c84c20f7f3  ryujinx: drop update script

That one is the actual funeral. The update script is the machinery that periodically checks upstream for a new release. Deleting it is the moment somebody concluded, in writing, that there would never be another version. The package still built fine. It just stopped waiting for news.

The fork got a real name in January —

2025-01-20  255128254232  ryujinx-greemdev: rename to ryubing

— and only in the summer, twenty-one months after the phone call, did anyone finally remove the original:

2025-07-30  1c1083100bd2  ryujinx: remove

ryujinx = throw "'ryujinx' has been replaced by 'ryubing' as the new upstream"; # Added 2025-07-30

Read that against yuzu's headstone. No takedown. No deletion. No blame. Replaced by, as the new upstream. Even in the epitaph, it's a handoff — one set of hands to another.

The sweep#

After yuzu's settlement the codebase forked in every direction at once, and the names are their own form of testimony: Suyu — say it aloud, sue-you — and Sudachi, Torzu, Nuzu, Uzuy, Sumi, Citron. People were angry, and the anger came out as puns, which is the most reliable indicator of a healthy subculture I know.

nixpkgs picked up two of them, both over Christmas:

2024-12-25  f8289f040130  suyu: init at 0.0.4
2024-12-26  f0a75c8509dc  torzu: init at unstable 12.15.24

Somebody packaged a Nintendo Switch emulator on Christmas Day.

Torzu then got months of genuine care — a maintainer went through it properly, switching it from vendored libraries to system ones, unbreaking aarch64, cleaning up the ffmpeg handling. Four separate commits on a single day in January 2025, all of them tidying. This is a fork of a fork of a dead emulator, and somebody was still doing the boring, correct, invisible thing with it.

And then the 12th of May:

2025-05-12 15:04:49  6b4920b3da9a  torzu: drop
2025-05-12 15:05:07  e0828b8ecd96  aliases: re-add entries for yuzu and citra
2025-05-12 19:10:58  41e4ba4b5582  suyu: drop

Two different maintainers, four hours apart, burying both forks. And the epitaphs have changed again:

torzu = throw "torzu has been removed from nixpkgs, as it is subject to a DMCA takedown"; # Added 2025-05-12
suyu = throw "suyu has been removed from nixpkgs, as it is subject to a DMCA takedown"; # Added 2025-05-12

Written independently, hours apart, by two people who as far as I can tell never coordinated — and they arrived at the same sentence. By the second round of deaths, nixpkgs had stopped reaching for euphemisms altogether and started naming the instrument.

But the commit I care about is still the middle one. The eighteen-second one.

+  citra = throw "citra has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
+  citra-nightly = throw "citra-nightly has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
+  citra-canary = throw "citra-canary has been removed from nixpkgs, as it has been taken down upstream"; # added 2024-03-04
...
+  yuzu-ea = throw "yuzu-ea has been removed from nixpkgs, as it has been taken down upstream"; # Added 2024-03-04
+  yuzu-early-access = throw "yuzu-early-access has been removed from nixpkgs, as it has been taken down upstream"; # Added 2024-03-04
+  yuzu = throw "yuzu has been removed from nixpkgs, as it has been taken down upstream"; # Added 2024-03-04
+  yuzu-mainline = throw "yuzu-mainline has been removed from nixpkgs, as it has been taken down upstream"; # Added 2024-03-04
+  yuzuPackages = throw "yuzuPackages has been removed from nixpkgs, as it has been taken down upstream"; # Added 2024-03-04

Eight headstones, restored exactly — the original # Added 2024-03-04 comments preserved, the lowercase # added on the Citra lines preserved, the whole thing put back the way it had been rather than tidied into consistency. He didn't rewrite history. He restored it.

Mechanically it's housekeeping. A refactor dropped entries it shouldn't have, and he put them back so old configurations would keep producing useful errors. Five minutes of work.

But consider what it actually is.

A corporation spent $2.4 million and two years making a piece of software cease to exist. And fourteen months after it stopped existing, an unpaid volunteer in Norway, working on something else entirely, noticed that the record of its death had been accidentally erased — and stopped what he was doing to write it back.

Not the software. The software was gone. The memory of it. The eight lines whose only function in the universe is to tell some future stranger there was something here, and this is what happened to it.

That's not nostalgia. That's not even really about emulators. That is a person deciding, unprompted and unpaid, that erasure is a thing worth resisting on principle, at whatever scale you happen to have access to — and then doing the five minutes of work available to him.

Most political convictions never get closer to reality than an opinion. This one took eighteen seconds and shipped.

The one clean handoff#

While all this was happening, the 3DS branch of the family did something nobody else in the story managed: it reorganised, deliberately, and survived.

Citra died in March 2024 alongside yuzu. Two months later, a fork was packaged:

2024-05-22  60c881713318  lime3ds: init at 2114

Lime3DS got a normal year — version bumps, a boost compatibility fix, a build repair. Then upstream, Lime3DS and a separate long-running Citra fork looked at each other, decided that two half-staffed forks were worse than one properly staffed project, and merged. And nixpkgs recorded the whole transition in a single commit:

2025-03-22  fd2881f93fac  lime3ds: remove; azahar: init at 2120.1

One package out, its successor in, same commit, same author. No throw about takedowns — because nothing was taken. Just a community deciding to consolidate, and the packaging walking across with it.

Azahar is still there. It got a version bump last month.

It's the only death in this history that was actually a graduation, and it happened because the people involved were free to merge their work — which they were, because it was all under a licence that let them.

Citron: fourteen days#

On the 5th of February 2026, a new contributor added another descendant:

2026-02-05  0422085da960  citron-emu: init at version 0.12.25

Emre Cebi. A 197-line package expression — the full careful treatment, every system library wired up by hand, fetchFromGitea because Citron had already fled GitHub.

On the 13th of February 2026, Nintendo filed DMCA takedowns against thirteen Switch emulator repositories on GitHub in a single day. Active projects, dead projects, archived projects. One company, one afternoon, one form each.

On the 19th of February 2026:

2026-02-19  d4e880822a10  citron-emu: remove

Emre Cebi. The same person. Fourteen days. He wrote the package and he was the one who deleted it, and there were nine working days in between.

The epitaph:

citron-emu = throw "citron-emu was discontinued in february 2026"; # added 2026-02-19

Lowercase february. Typed by somebody who wasn't composing anything for posterity — just closing out a package he'd spent a couple of evenings on, two weeks earlier, when it still had a future.

Thirteen repositories in one day, and no court was involved in any of it. That's the part I can't get past. Not a hearing, not a judgment, not a finding. A sufficiently large company can now file a stack of forms on a Friday and remove thirteen pieces of software from the world's largest code host before the weekend, and the only thing standing between that and permanence is whether enough unaffiliated strangers happened to keep copies.

What's still standing#

It would be a tidy ending if that were the end. It isn't, and the ways it isn't are the whole reason I wrote this.

Three weeks before Citron arrived, someone had packaged another one:

2026-01-29  8c40c044b6b6  eden: init at 0.1.1

Eden went through the exact same February sweep that killed Citron. Its maintainers filed counter-notices, moved their infrastructure, and kept shipping. It is in nixpkgs right now. The most recent commit touching it is four days old:

2026-08-11  12c5a31da8d2  eden: pin httplib input

Somebody pinning a dependency to keep a build reproducible. The single most ordinary commit imaginable — which is exactly the point. The correct response to "they will try to erase this" turns out not to be a manifesto. It's a version pin, filed on a Tuesday, by someone who intends to still be here next month.

Ryubing is still standing too, and in May it did something that made me put my coffee down:

2026-05-08  5b511c170c0d  ryubing: migrate to forgejo

-  src = fetchFromGitLab {
+  src = fetchFromForgejo {
     domain = "git.ryujinx.app";
-    owner = "Ryubing";
-    repo = "Ryujinx";
+    owner = "projects";
+    repo = "Ryubing";

There is an entire diaspora encoded in which fetcher function these packages call.

They all started on fetchFromGitHub. Ryujinx fell back to fetchzip against archive.org when GitHub stopped being an option. Citron used fetchFromGitea. Ryubing went to fetchFromGitLab on a self-hosted box and then to fetchFromForgejo when that box changed software. Eden fetches from git.eden-emu.dev — its own machine, its own domain, its own terms.

Read the fetcher calls in chronological order and you get a map of where everyone fled, and what they fled to: off the centralised platform, onto their own hardware, running software they control.

That migration is not a defeat. That is the free software movement's oldest argument being proven in real time, at cost, by people who would much rather have been left alone. A single DMCA to a single American company removed thirteen projects in an afternoon — because thirteen projects were all standing on the same floor. The answer, the one people have been making since before most of these maintainers were born, is federation: your own server, your own domain, software you can fork, licences nobody can revoke. It's more work. It's less convenient. It is the only arrangement that cannot be undone by a form.

And nixpkgs followed every single one of them to their new address. That's what a distribution is, when you strip away everything else: a standing promise to keep knowing where the source lives, no matter how many times it has to move.

Now — the control group.

Dolphin, added in 2014 in the very first commit of this post, has never been removed. Never aliased, never mirrored, never threatened into silence. It got a version bump in June. So did cemu, the Wii U emulator. melonds has had nine version bumps this year alone. mgba, ares, snes9x, desmume, mupen64plus — all present, all boring, all completely fine. Nintendo's lawyers have been extraordinarily busy for two years and not one commit has touched any of them.

Because it was never about emulation. Every project that died in this story required the user to supply cryptographic keys extracted from a physical console, and that — §1201, the tool, the circumvention — is the entire hook. The projects that don't need keys have sat in the same repository, undisturbed, for over a decade.

You can read that distinction directly off the commit log. It is much, much clearer there than in any reporting I found, and it is the strongest possible evidence that what happened here was not the enforcement of copyright. It was the selective removal of software that a company found inconvenient, using a statute that never required it to prove harm.

The name in the licence field#

One last commit. If you open Eden's package expression today — the living one, the one updated four days ago — and scroll down to the licence list, you'll find this:

  # Primary
  gpl3Plus

  # Build system
  lgpl3Plus

  # Dynarmic and Yuzu code
  gpl2Plus
  bsd0

Dynarmic and Yuzu code.

Nintendo got the repositories. They got the domains, the Patreon accounts, the Discord servers, the developers' signatures on an agreement never to do this again, and $2.4 million.

And the name is still sitting there, in the licence field of a package that somebody updated on Tuesday, because the code was GPL and attribution is not optional under the GPL. It's not sentiment. It's not defiance. It is a legal requirement, and it runs in the opposite direction from every other legal requirement in this story.

That's the thing I want you to take away, and it took me a week of reading commit logs to see it.

Copyright was the weapon. Section 1201 was the weapon. The same body of law that let a company delete six years of work with a phone call is the law that makes it mandatory to keep saying yuzu's name — in every fork, in every downstream package, in every distribution that carries any descendant of that code, forever, as a condition of the licence.

Richard Stallman's insight in 1989 was that you could take copyright — an instrument designed to let owners restrict — and invert it, so that the same enforcement machinery guaranteed freedom instead. Copyleft. It has been called a hack, and it is one, and this is what it looks like when it works forty years later on a battlefield nobody anticipated:

They bought silence, and copyleft made silence illegal.

Coda#

None of the people in this story are activists. I don't think any of them would use that word about themselves, and I suspect several would be embarrassed by this post.

They're people who took on a small, permanent, unglamorous obligation to strangers — this will keep working — and then kept discharging it under conditions nobody signed up for. Bumping a version the day after a lawsuit. Fixing an ARM compiler flag on a package with seventy-two hours to live. Tidying the desktop entry of a project that no longer existed. Hunting a tarball across archive.org and apologising for not having the disk space to test it. Backporting the fix to stable three hours later so the people on the slow channel wouldn't be stranded either. Packaging an emulator on Christmas Day. Going back the next evening to change one word, so the record would be true.

And, fourteen months after a death, noticing that the gravestones had gone missing, and putting them back.

That's the whole movement, really. Not the licences, though the licences are what make it enforceable. Not the manifestos, though somebody had to write them. Underneath all of it, free software is just an enormous number of people, most of whom will never meet, each doing the small amount of work in front of them on the shared understanding that things worth having are worth keeping, and keeping is a thing you do repeatedly, forever, or not at all.

You can take down a repository. You can buy a settlement, or make a phone call that ends a project in an afternoon, or file thirteen forms before the weekend and remove thirteen years of work from the largest code host on Earth. All of that has been done, and it worked, and there is no court anywhere that has said otherwise.

But you cannot serve a takedown on everyone who kept a copy, because nobody knows who they are, and that is the entire design. You cannot DMCA a hash that already describes the thing you deleted. You cannot revoke a licence that requires your victim's name to be spoken by everyone who inherits their work.

And you cannot stop a volunteer, on a Monday afternoon in May, from spending eighteen seconds making sure the dead are still named.

2025-05-12 15:05:07  aliases: re-add entries for yuzu and citra

Don't panic. Keep a copy.

Every commit hash, date, and quotation in this post was read out of a local nixpkgs clone with git log and git show. Nothing here came from a press release. If you want to walk it yourself, git log --all -i --grep=yuzu is a good place to start — and git log -p -- pkgs/top-level/aliases.nix is a genuinely underrated way to spend an evening among the headstones.