When Free Software Isn't Free Enough

Published on 2026/11/13

If you’ve previously read my blog, it should come as no surprise that I’ve been a champion of free software for a very long time. The idea that you should be able to run, study, change, and share the programs that run your life is something I truly believe in, maybe even to an annoying degree. This past week though, a mailing list thread made me wonder whether the movement built around that idea is aiming high enough.

What happened

The thread is called “Human Emacs”, and it ran on the emacs-devel mailing list. It asks a question many projects are facing: should GNU Emacs accept LLM-generated contributions?

Brian Cully, who argued against, posed a hypothetical to find out where the maintainers draw their line:

if I live in a territory that permits slavery, and by law i am granted sole ownership of the products of that forced labor, and then i use that to create contributions to gnu emacs, complete with copyright assignment, and it is technically correct, and, above all, you, the emacs maintainers are aware of how this was produced, would it be ethical to accept those contributions?

As part of their response, Eli Zaretskii said: “Our answer must be YES.”

Their reasoning was that weighing contributors’ politics, ethics, or origins would split the community along ideological lines, and that the Free Software movement addresses only problems that directly affect software freedoms. They also rejected the idea that GNU pursues liberty for all humanity, saying its goals are narrower than that.

The internet did what it did, and the story became “GNU supports slavery”, which is not a fair summary, and I want to say so plainly. Eli later clarified that they personally don’t tolerate slavery. Their argument was that in the context of Emacs development, the only thing that matters is the quality of the code being contributed, and that bringing personal values into those decisions would hurt the project. Another maintainer pointed to GNU’s stated position: the project endorses only two political positions, that users should control their own computing and that basic human rights in computing should be supported. Everything else, they said, is off-topic.

Now, I don’t think anyone in that thread is a villain. I think their answers were consistent with the question they were asked, but that consistency is exactly what bothers me.

The case for their answer

Let’s consider the strongest version of the maintainers’ position, because I don’t think it’s foolish.

A project that tries to enforce a moral purity test on every contribution has to decide whose morality counts. Once “is this code ethically sourced?” becomes a gate, maintainers become the judges of every contributor’s life, labor, and country. That is unworkable, and it invites exactly the kind of factional fights that kill volunteer projects. There is also a fair point that rejecting the patch frees no one. The people in the hypothetical are no better off if Emacs says no.

I take that seriously, but I don’t think that it settles the question.

Where it falls short

Someone on the thread put the problem better than I can:

there is no such thing as justice for only one group of people

They went on to say that narrowly focusing on one arena is fine, as long as the work exists in the context of a larger, universal struggle. Otherwise it’s hollow.

That’s really the heart of this whole thing for me. The free software movement has a rich vocabulary of freedom and liberty, and almost all of it is about one relationship: that of the person running the software and the code they run.

To be fair, free software has never been neutral about ethics. Its founding claim is that proprietary software is an ethical wrong, and the FSF campaigns on issues like surveillance and DRM. So my complaint isn’t that the movement has no ethics. It’s where those ethics stop. They stop at one relationship: that between a person and the software on their own computer. Anything outside of that line, such as how the code was made, who was paid what, or what the finished software does to other people, gets declared off-topic. That’s the edge this thread ran into.

When “the only thing that matters is the code” is the rule, the movement has decided pre-emptively that it cannot see the labor behind the code, the data behind the models, the people who are surveilled, scored, or sorted by software they never chose and can’t inspect, or the people who can’t use any of it because they lack a computer, a language, an accessible interface, or time. A freedom that only reaches people who already have the privilege of reading source code is a narrow freedom.

I’ll note that GNU’s own stated principles include supporting basic human rights in computing. That is a real commitment, and it suggests the door is open further than the thread made it look. But a commitment that appears only when it’s convenient, and disappears when someone asks it to carry weight, doesn’t amount to much.

About the LLM question

The full case against LLMs — how they’re built on unconsented labor, sold through hype, and coercively pushed onto workers — deserves its own post, which I’ll link here once I publish it.

For now, the short version is simple: a movement built around user freedom has to ask what those freedoms are for when the tools being pushed into its codebase rely on mass extraction and coercion.

To be clear, I don’t judge people who are forced to use them at work. Most people have no say over the tools their job requires, and if the choice is between using the tool and keeping your livelihood, I don’t blame anyone for choosing their livelihood.

A volunteer contributing on their own time, or a maintainer setting a project’s rules, has a choice that an employee under a mandate doesn’t. That’s why I hold FOSS projects and their leadership to a higher standard here. My criticism is for how projects use that choice, not for people who don’t have one.

What I’d like to see

I’m not suggesting that we throw out the four freedoms. They’re foundational, and I’m not interested in burning everything to the ground to replace it with something more vague. I want to start from them and add something. Here’s where I’d start, with the small and concrete.

• Projects should decide how they treat LLM contributions, in the open, instead of defaulting to “only the code matters.” That could mean a policy that rejects them, or one that allows them with disclosure. Either way, it should be written down, argued over in public, and owned by the maintainers. Not deciding is also a decision, and it’s the one that favors whoever is pushing the hardest.

• Judge the process, not the person. I’m not asking maintainers to audit a contributor’s politics or country. That’s the unworkable version, and I think Eli is correct to fear it. A contribution policy that asks whether the code was written by a consenting human who understands and stands behind the change — rather than extracted from coerced labor or generated by a model trained on unconsented work — sets an ethical boundary without putting anyone’s personal beliefs on trial.

From there, the larger principles follow:

• Freedom for users, not just programmers. Source code access means little if you can’t read it. Real software freedom has to include usability, accessibility, documentation, and support in the languages people actually speak.
• Software has a supply chain, and it’s made up of people. Who wrote this, under what conditions, and who profits? These questions belong in the conversation, even when the answers are inconvenient.
• Software has effects beyond the machine. Systems that decide who gets a loan, a job, or bail are freedom issues, whether or not the license is permissive.
• Neutrality has costs. Declining to take a position is itself a position, and it tends to favor whoever already has power.
• Solidarity over purity. The goal isn’t a perfect test for every patch. It’s a movement that sees itself as part of a larger struggle, and shows that in how it conducts itself.

None of these are particularly new ideas. People have been arguing for a long time that struggles for justice are linked. I’m only asking that the people who build the tools of the future treat that as part of the job.

The obvious objections

• “Who decides whose morality counts?” The maintainers do, the same way they already decide everything else about a project: openly, and accountably. Setting a contribution policy isn’t a moral purity test. Every project already has standards for what it will accept.

• “Doesn’t this violate freedom zero?” I don’t think so, and I want to be careful here. Freedom zero is about what you can do with the software once you have it. A project declining a patch doesn’t stop anyone from running, changing, or sharing the code. If the policy is unpopular, anyone can fork, and that’s the system working as designed. I’m not proposing licenses that restrict who can use the software or for what. That’s a whole other thing.

  At the same time, we shouldn’t pretend “just fork it” solves anything. Legally, anyone can fork any free software project. Practically though, that’s only true up to a certain point. You might be able to fork a smaller tool, but nobody is going to feasibly fork something like the Linux kernel, for example — not when it’s backed by billions of dollars in corporate hardware support and engineering resources. When foundational projects refuse to draw ethical lines, the rest of us don’t actually have a realistic exit option.

• “Rejecting the patch frees no one.” Yes, but I’d rather say so than pretend otherwise. Also, accepting a contribution isn’t neutral either. It rewards how the work was done and signals to everyone watching what the project will take. A project can’t be indifferent to its inputs and also claim to care about freedom.

Where I’m landing

I’ll be honest, it’s hard not to feel a little disillusioned with the free software movement at the moment. I’m not angry at the maintainers and I’m still going to use and appreciate the software they’ve built, but I can’t keep treating “freedom” as a word that means so much to some people and so little to everyone else.

If you feel the same way, I’d like to hear from you. What would a movement like this look like to you? What should it commit to, and what should it refuse?

And remember, nobody is free until we’re all free. That includes people who write the code, and the people who live with what it does.