Software Liberalism

Non-interference

I publish my stuff under my own licence. It is not uncommon for people to allow others to use their works for reasons they deem acceptable and forbid those they deem not to be. This is, generally speaking, a widely accepted use of intellectual property, particularly in the arts. It is often said these works are free use.

However, there is a very specific definition of what "free use" is, as set out by the Free Software Foundation. A work is only considered to be free by the FSF and more broadly open-source advocacy if it grants what is dubbed as the Four Freedoms:

Under these definitions, I do not produce free works. My licence forbids cramming my software with spyware, for example. This restricts the freedom to freely change it. The FSF is primarily concerned with negative liberties, the absence of restrictions. The justification used by the FSF and many open-source advocates is that should a work turn out to be unfavourable for the user, it should be forked into a better version of itself.

This in many regards is similar to the liberal concept of freedom. Classical liberalism in particular rejects interference from the state and promotes the idea of freedom as non-interference: the individual should be left alone to act, contract, build, and trade such as they see fit insofar they do not infringe upon the rights of others. It does not prescribe what it sees as morality, it merely prevents coercion.

But can something be free if it lets itself do harm?

My criticism of this definition of freedom is it does little to ensure good; only to ensure that there is no overt harm. And it doesn't even do that well. Forking a program is much akin to quitting a job. Theoretically, the option is available, but it ignores the material constraints in which people are bound to by exploitative means. Quitting a job does not magically give you a better source of income, nor does forking a program instantly bring you the developer base.

The FSF's definition of freedom is liberal in structure and does not make consideration to the ways such freedoms can be exploited. And it has been made apparent that non-interference is not a system by which society can manage itself, both in and out of software.

The problem

Redis is a fast database system designed to operate quickly. It is commonly used for temporarily storing data, messaging, and other tasks that need high performance. For most of its history, it was released under the open-source BSD 3-Clause licence.

Cloud providers such as Amazon's AWS and Microsoft's Azure took note of Redis' utility and began offering Redis as a paid service. They did not need to alter Redis very much, rather, they packaged Redis with their own services and captured most of the monetary value that went into Redis, while the developers themselves who did all the programming did not bear many fruits of their labour.

This behaviour was entirely compliant with the BSD 3-Clause licence. It permits anyone to use the software for any purpose, including providing it as a commercial service. This forced Redis to eventually adopt its own non-free licence and require large hosting services to either give back or to pay for a commercial licence.

The ownership of capital, not code, was what was important. Open-source was acting exactly as intended.

This is not an isolated case in the world of open-source. There are countless other examples, like MongoDB, HashiCorp, and Elastic NV, all suffering from the same fate: tech giants went up and took their code for free and made all the profits, while the developers did not see much of the value of the program returned back to them.

There is clearly a common mechanism behind this. Microsoft no longer makes most of their profits from Windows - they haven't done so since the 2010s. Only a third of Amazon's revenue in 2025 was from actually selling goods. Today they make most of their money selling their infrastructure, what is essentially digital land, to other companies and individuals and paying them, and making them pay even more to run services on this land.

In this sense the relationship between the platform and the user has become landlordism. Power comes not from the production of a good product or service, but the ability to extract rent from those operating within one's domain. Open-source code therefore becomes part of this system as a resource captured by these giants; as land owners extract and exploit natural resources that they exclusively can access. The rights protected by open-source licensing guarantees the absence of the restriction of this system. Platforms nominally are on equal terms while exercising materially rather unequal power.

Open-source has no mechanism against this exploitation of code. In fact, it is what enables it. By granting the universal rights to run, modify, and distribute, it ensures those who already possess vast amounts of resources and capital do not face any barriers extracting the value of the work and the rent generated from users. The freedom to use a program for any purpose include the freedom to use it for exploitation.

This more broadly is in line with the liberal concept of freedom. Non-interference is the highest good. Insofar nobody is coerced and no agreement has been breached, the result of an action is considered to be legitemate. The landlord is theoretically as free as the tenant, yet they are vastly more powerful. Open source sits atop an increasingly privatised landscape.

The modes of production

In Marxist theory, a mode of production is a combination of the productive forces of a society, labour, with its relations of production, such as social relations and the classes. Each mode expands the productive capacity of a society while introducing contradictions that grow over time. Eventually these contradictions grow so great the current system of relations cannot sustain itself and is overthrown to enable the development of new relations of production.

This is a useful way to think of the evolution of software. Software history itself has also followed several distinct relations between the groups of the digital world and the means by which value is extracted.

The earliest mode was perhaps the academic commons of the 60s and 70s. Here the first ecosystems were created within universities, enthusiast groups, institutions, and other public organisations. Computers themselves were scarce, expensive, and bulky. Code, however, was freely shared as a matter of necessity. Software had not yet been treated as a commodity to be bought and sold,