Last revised: 14:22 30.05.2026, you can see previous revision by clicking here.
"Free and bloatless software" means software that unconditionally respects both the user's liberty and the user's resources. The landscape of computing has fundamentally shifted since the original Free Software Definition was drafted. In the 20th century, the primary threat to user freedom was the hoarding of source code. Today, the threats are structural and architectural.
Having access to the source code is no longer enough if the software demands a constant connection to a corporate cloud, consumes gigabytes of memory to render simple text, spies on the user by default, or traps them in an infinitely complex web of dependencies. Today, software controls the user not just by denying them the source code, but by overwhelming their hardware, hijacking their attention, and holding their data hostage in remote servers.
Thus, "Free and Bloatless" is a matter of absolute autonomy. To understand the concept, you should think of “free” as in “free speech,” and “bloatless” as in “respect for human time and physical resources.”
When users do not control the software's architecture, its hardware footprint, and its network behavior, the software is "hostile" or "bloated." Hostile software treats the user as a product to be analyzed, and the user's hardware as an infinite dumping ground for unoptimized code.
A program is Free and Bloatless Software if the program's users have the five essential freedoms:
A program is free and bloatless if it adequately gives users all of these freedoms. If it falls short on any of these fronts—even if its source code is technically published on the internet—it is hostile, bloated, or unfree.
In the rest of this document, we explain more precisely how these freedoms apply to modern computing paradigms such as Cloud Computing, Telemetry, Software-as-a-Service (SaaS), and the Dependency Crisis.
The freedom to run the program means you must be able to run it yourself. In the modern era, many "open source" projects are merely clients for a proprietary cloud backend, or they require a sprawling, enterprise-grade cloud architecture (like AWS or GCP) to function. This is an illusion of freedom.
If a program's primary function does not inherently require the internet (e.g., text editing, image processing, local file management, or private team coordination), it must not demand an internet connection to operate. A user must be able to self-host the software entirely on their own equipment—whether that is a laptop or a cheap home server. If a developer remotely disables the software, locks an account, or shuts down their servers, a free and bloatless program running on your machine must continue to function exactly as it did the day before.
Freedom 1 requires access to the source code, but mere access is insufficient if the codebase is an unreadable monolith of microservices, hidden abstractions, and millions of lines of unstructured logic. We call this "obfuscation by architecture."
For Freedom 1 to be meaningful, the software must be designed with legibility in mind. What the software does with your data, how it stores it, and who it communicates with must be obvious to a competent engineer. If malicious behavior or aggressive telemetry is hidden deep within a convoluted architecture simply because the system is intentionally designed to exhaust the reviewer's attention through artificial abstractions, the software violates the spirit of transparency and is not free.
Modern software often relies on thousands of third-party packages to execute simple tasks (often referred to as "dependency hell"). This practice creates massive security vulnerabilities, introduces unaudited code into the user's machine, and forces the software to become bloated.
A free and bloatless program minimizes external dependencies. It relies on system libraries and foundational tools rather than downloading hundreds of megabytes of external frameworks. If a program requires a massive, complex, and fragile web of third-party dependencies just to compile or run, it violates Freedom 3.
Software must respect the physical constraints of the user's hardware. The modern proprietary industry relies on "planned obsolescence"—writing heavy, unoptimized software that forces users to constantly buy newer, faster computers. We consider this a form of environmental and economic abuse.
Freedom 3 dictates that the software's resource consumption must be strictly proportional to the utility it delivers to the user. Using a massive web rendering engine (like Electron) to display a simple chat interface or a text document is a violation of the user's hardware resources. Optimization is not a luxury; it is a fundamental ethical requirement of software engineering. Bloatware denies the user the freedom to use older hardware and gatekeeps technology away from those who cannot afford constant upgrades.
Proprietary software and many modern open-source projects continuously spy on their users, sending data about mouse clicks, usage time, and hardware configurations to remote analytics servers.
Free and bloatless software must not contain hidden telemetry. If telemetry exists for debugging purposes, it must be completely transparent, strictly anonymous, and, most importantly, opt-in by default. Software that assumes consent to harvest user data is an instrument of unjust power and is fundamentally hostile.
Users must never be trapped in a corporate ecosystem. Freedom 2 guarantees the "Right to Exit." The software must not use proprietary file formats or convoluted database structures designed to prevent the user from migrating to a different tool. Data must be exportable in standard, open, plain-text, or universally recognized formats (like JSON, Markdown, CSV, or standard SQL dumps).
Furthermore, the software should follow the philosophy of doing one thing well. It should not artificially absorb unrelated features to become an inescapable "super-app."
Free software can and should be commercial. Developers deserve to be paid for their labor, support, and hosting services. However, the business model must not dictate the architecture of the software.
We reject the manipulative "Open-Core" model, where the open-source version is intentionally crippled (e.g., lacking basic security features, backups, or single sign-on) to force users into a commercial tier.
Furthermore, the software interface must not employ "Dark Patterns." Hidden subscription checkboxes, artificially difficult cancellation processes, un-skippable advertisements, and manipulative push notifications designed to harvest human attention are unethical. The user interface must be honest, direct, and entirely under the user's control.
The Free and Bloatless Software Definition is a commitment to returning computing to the user. It is a rejection of the modern software industry's obsession with endless scale, surveillance capitalism, and forced obsolescence. By ensuring that software is autonomous, legible, modular, lightweight, and honest, we guarantee that the tools we use serve us, rather than exploit us.
For in markdown