The Team Holding Up a Linux Distro Just Walked Out

The core team maintaining Nixpkgs is gone. Not reduced, not reorganized — dissolved. Nixpkgs is the package repository behind NixOS and the Nix package manager, and the group that made the hard calls about it no longer exists.

Nothing broke technically. That’s the part worth sitting with. The repository still builds, the CI still runs, the pull requests still land. What collapsed was human.

What Nixpkgs Actually Is

Scale first, because the number is the story.

Nixpkgs holds over 100,000 packages. That’s more than Debian. More than Arch. And it all lives in a single Git repository — one monorepo where updating Firefox and touching glibc happen in the same place, reviewed by the same people, gated by the same process.

That design has real advantages. It also means dependency graphs get vicious fast. Bump one low-level library and thousands of downstream packages rebuild. Someone has to decide whether that’s acceptable — whether the breakage is worth it, whether the timing works, whether the maintainer of package #47,000 gets a heads-up. That judgment was the core team’s job.

For anyone outside the weeds: imagine the team that maintains a city’s water main schematics quitting all at once. Water still comes out of the taps. It will for a while. But nobody’s left who knows which valve does what.

Dissolution Is the Result, Not the Fight

The NixOS community has been in conflict for years, and this ending was visible from a long way off.

In 2024, Eelco Dolstra — who created Nix — stepped back from project leadership under sustained community pressure. That same year, defense contractor Anduril signed on as a NixCon sponsor, and the community detonated. An open letter drew hundreds of signatures. A meaningful chunk of contributors left outright. The fallout produced forks: Lix, and later Aux.

What followed was an earnest attempt to rebuild governance from scratch. A draft constitution. An elected steering committee. Restructured teams. The intentions were good and the process was serious.

It was also a second full-time job. The people reviewing PRs and shepherding packages became, simultaneously, parties to an ongoing political fight about the project’s identity. Every technical contributor was now also a constituent, a negotiator, and — inevitably — a target.

Burnout doesn’t come from volume alone. It comes from work that stops having endings. Code review terminates: merge, or don’t. Governance doesn’t.

The Same Three Failure Modes, Every Time

This pattern repeats across open source with unnerving consistency.

Zero compensation, unlimited liability. Most maintainers are unpaid. But when the repo breaks, the blame is entirely theirs. For a project like Nixpkgs — which companies run in production, on their critical path, without paying anyone — that asymmetry gets grotesque.

Governance has no exit ramp. A bad PR gets closed and everyone moves on. But “should we accept this sponsor?” and “should this person be excluded?” have no terminal state. Whichever way you rule, half the community is furious, and that half starts the next argument. There is no version of the decision that ends the conversation.

The bus factor is brutally low. The number of people who genuinely understand the architecture and history behind 100,000 packages is measured in dozens. Lose ten of them and you haven’t created org-chart vacancies — you’ve created a knowledge void. The context that made those decisions fast and correct isn’t written down anywhere.

Remember the xz utils backdoor in 2024. The attack that nearly compromised Linux servers worldwide started with an exhausted solo maintainer being socially engineered by someone offering to help. The attacker didn’t break the code. They exploited the fatigue.

So Is NixOS Dead

No. And this is the genuinely interesting part about how open source fails.

The Nixpkgs repository is intact. People with commit access are still there. Hundreds of PRs still flow through every day. In a company, a whole team walking out stops the roadmap cold. Open source doesn’t work like that — the machinery keeps turning on momentum and distributed habit.

The loss is directional. Without a body empowered to make contested decisions, a project drifts. Controversial changes sit in limbo indefinitely. Architectural proposals — the ones that require someone to say “yes, we’re doing this, over the objections” — quietly die from lack of quorum. From the outside it looks busy. From the inside it calcifies.

So the real question isn’t whether NixOS survives. It’s who takes the chairs next. When the last occupants left because the role burned them out, recruiting replacements is a hard sell.

This Is Your Supply Chain

It’s tempting to file this under someone else’s drama. It isn’t.

Your company’s build pipeline contains dozens of packages maintained by one or two people. Most organizations have never asked what happens when those people quit. Free to use is not the same as free. The cost is being paid — in someone’s evenings, someone’s weekends, someone’s mental health.

What companies can actually do is unglamorous and immediate: fund maintainers directly, assign engineers to upstream work as part of their job, and file reproducible bug reports instead of drive-by complaints. That beats announcing a foundation.

The Nixpkgs core team’s dissolution isn’t a technical failure. It’s a structural one reaching its limit — a system that consumes people finally running out of people. Open source looks durable because the code is public, but what actually holds it up is a small number of humans deciding, again, to keep going. Go look at the library you shipped to production last week. Count how many names are behind it.