Free LLM Search Continues: None of the Proposed Models Meet Four Essential Freedoms Requirements


Free LLM Search Continues: None of the Proposed Models Meet Four Essential Freedoms Requirements

Last updated: 2026-08-14

This information has been compiled from discussions on the Emacs Devel and Emacs Tangents mailing lists.

What makes an LLM free?

A program is free software if users have these four essential freedoms:

  1. The freedom to run the program as you wish, for any purpose.
  2. The freedom to study how the program works, and change it so it does your computing as you wish. Access to the source code is a precondition.
  3. The freedom to redistribute copies so you can help others.
  4. The freedom to distribute copies of your modified versions to others. Access to the source code is a precondition.

For an LLM, this means more than just having “open weights” or a public API. The training data is the source code; the weights are the result. A free LLM must be trained only on data that itself is free, with licenses that allow use, study, redistribution, and modification, and that do not impose attribution requirements the model cannot satisfy.

See also: What is free software?

Richard Stallman on Emacs packages and LLMs

On 2026-08-14, Richard Stallman wrote to emacs-devel about an Emacs package (Hermes) that requires an LLM at runtime:

Are there free, local LLMs we can recommend people use with Hermes? … But that does not mean we can recommend its use with those that are SaaSS, or those with nonfree programs or a merely binary (“open weights”, ha!) model. So hermes should not have anything in it that leads people to those. It should only talk about freedom-respecting LLMs.
If there are no LLMs for use with Hermes that we can recommend, we should not recommend Hermes either.

This means Emacs packages that depend on or promote LLM agents which in turn promote nonfree Service as a Software Substitute (SaaSS) or nonfree APIs must not be recommended. Only freedom-respecting local LLMs are acceptable.

See also: Who does that server really serve?

Apertus: a case study in non-freedom

During the same discussion, Richard Stallman stated plainly: Apertus isn’t free at all.

Apertus (Swiss AI) claims to use “openly available data,” but as Jean Louis pointed out, they never defined “openly.” Their logic is that if a website does not block bots via robots.txt, its data is considered open — which is the default for nearly the entire internet. That means Apertus used copyrighted material without explicit permission.

Jean Louis wrote to the Apertus team explaining that “publicly available” is not the same as “public domain” or “freely licensed.” He applied the four freedoms:

Björn A. Lindqvist noted that Apertus’s data collection procedure is specified in their paper: most data comes from FineWeb-2, which is licensed under ODC-By 1.0 but is also subject to CommonCrawl’s Terms of Use.

Jean Louis reviewed those terms and found them incompatible with the four freedoms:

Apertus’s practice of treating any website that does not explicitly deny access via robots.txt as “openly available” means it ingests proprietary and copyrighted works, making the model unsafe for users because it can reproduce those works verbatim or generate infringing derivatives without permission.

Thus Apertus is not free, and any LLM trained on FineWeb-2 or Common Crawl data cannot meet the GNU definition of free software.

Jean Louis’s proposed verification list

On 2026-08-14, Jean Louis proposed verifying several LLMs that claim to be truly free:

Jean Louis noted that more efforts toward truly free LLMs are a good sign, but that organizations need to be taught what “truly free” means.

Ellie’s verification results

Ellie (el at the domain horse64.org) checked each candidate in the same thread. The conclusion: none of these models can be considered free, because their training data includes non-free or attribution-encumbered material.

Moxin

Problem: Moxin uses The Stack, a dataset of source code with many licenses, including licenses that require attribution. An LLM cannot reliably provide attribution for generated code, so using The Stack without filtering for attribution-free licenses violates the FOSS licenses of the original projects. No evidence is given that Moxin filtered out attribution-required code.

OLMo

Problem: The Stack v2 states: “Any use of all or part of the code gathered in The Stack v2 must abide by the terms of the original licenses, including attribution clauses when relevant.” Since an LLM cannot consistently attribute output to original projects, training on this data violates the licenses of those projects.

Marin

Problem: starcoderdata is an older version of The Stack. It carries the same requirement: original licenses must be respected, including attribution clauses. Marin provides no evidence that it filtered out code with such requirements.

DaVinci

Problem: There is no indication that public GitHub repositories were filtered for licensing. GitHub repositories commonly use FOSS licenses with attribution requirements. MegaMath is derived from Common Crawl, which is a dump of web pages with arbitrary and often proprietary licenses. Using such data without license filtering means the model output can reproduce copyrighted material without permission or attribution.

SmolLM

Problem: FineMath is filtered from Common Crawl, which contains web pages under all sorts of licenses, including proprietary. There is no indication of FOSS license filtering, and no way for the model to provide attribution. This makes the output legally questionable.

OpenCoder

Problem: OpenCoder’s page mentions The Stack near the top. The paper does not contain the words “license” or “licensing” anywhere. No evidence is given that The Stack data was filtered to exclude code with attribution requirements. Therefore, OpenCoder inherits the same license violations.

Why training data is the source code

Björn A. Lindqvist put it clearly: if we think in terms of programs, the dataset is the source code of an LLM, the weights are its machine code, and training is compiling. You cannot reconstruct the weights without the dataset. A free LLM therefore requires a free training dataset, just as a free program requires free source code.

This analogy also explains why “open weights” are not enough: without the data and the training code, users cannot study or modify the model in the way the four freedoms require.

Conclusion

All six LLMs proposed by Jean Louis and verfied by Ellie fail to meet the four freedoms because their training data includes non-free or attribution-encumbered material. The search for a truly free LLM continues.

Until a genuinely free LLM exists — one trained only on freely licensed data with no SaaSS dependency — Emacs packages that require or promote nonfree LLM services should not be recommended. The GNU Project’s standards remain clear: software must respect the user’s freedom, and that includes the model and its training data.

Note: Ellie’s reviews are not legal advice; they are based on the documentation and licensing statements available at the time.

Jean Louis’s Conclusion

While LLMs may be under fully free licenses and are legal to download, share, and train, their data is not free — and no fully free LLM was found in this brief check of those claiming to be free as in freedom. The user is ultimately responsible for LLM-generated output and cannot freely deal with the LLM because its training data was not free as in freedom as defined by the GNU Project.

Not greping on one’s own computer rather this way:

Copyright responsibility when using an LLM

Without the LLM

If a user uses someone else’s copyrighted text to generate new work, and the result is clearly plagiarized or infringes copyright (there are many different ways this can happen), the user is ultimately responsible for any copyright issues.

With the LLM

The user should assume that some output may be copyrighted, and should therefore be creative enough when using the LLM:

If the user avoids those risky activities and gives enough context, the randomness of LLM generation will generally produce original, copyright-safe output. The user can also check the internet to see whether generated text resembles existing works. In any case, the user alone remains ultimately responsible for copyright infringements.

With a fully free LLM

Even with an ideologically fully free LLM, the user would have little chance to verify all the training data — what if the preparers made errors? So even in that case, the user could still be held responsible for copyright infringement. The user could also be falsely accused. In court, it would not be a strong defense to say that “other people prepared the LLM with fully free datasets,” because the user did not verify this and cannot shift responsibility to others.

No matter the LLM’s license or training data, the user who creates work with LLM assistance is ultimately the one responsible for copyright issues.