Published on 2026/09/05

If you spend enough time in online developer circles, you’ll eventually run into a specific, recurring complaint: Software is being radicalized.

This whole argument usually goes something like: once upon a time, open source was a pure, objective meritocracy. Code was just a utility. Tools were neutral, like hammers or electricity. But now, the SJWs (there’s always venom in the way they say SJW lmao) are making software political and ruining the careful meritocracy by bringing in things like codes of conduct and bringing attention to problematic individuals within the projects.

To a certain subset of developers, this feels like an existential crisis. A sudden, trend-driven corruption of a sacred technical sanctuary.

Now, what if I told you that this nostalgia for a simpler time was never actually based in reality at all?

What people are calling the “radicalization” of software isn’t a new thing at all. I think what we’re seeing is that developers are rediscovering the foundational DNA of the software liberation movement and realizing that the “politically neutral” open source ecosystem they miss was a temporary corporate anomaly all along.

The Great Sanitization of 1998

I feel like a short history lesson is in order to fully appreciate how we got to where we are.

In the 1980s, when Richard Stallman launched the GNU Project and published the GNU Manifesto, the movement was explicitly moral, ethical, and anti-authoritarian.

Stallman built free software because he saw proprietary software as a direct threat to human freedom, individual autonomy, and social solidarity. In the FSF worldview, software freedom was a fundamental social right.

Then came 1998.

As Linux gained traction, a group of prominent figures in the community realized that enterprise corporations - the IBMs and Microsofts of the world - were terrified of Stallman’s rhetoric. Phrases like “moral duty” and “user liberation” sounded too much like an anti-capitalist crusade to corporate boardrooms.

So, they engineered a rebrand. On February 3, 1998, Christine Peterson coined the term “Open Source”, and weeks later, Bruce Perens and Eric S. Raymond launched the Open Source Initiative.

The goal of this rebrand was explicit: strip away the moral, ethical, and philosophical language of Free Software and replace it with a pragmatic, business-friendly narrative. It was a textbook example of capitalism absorbing a radical critique of itself, sanitizing the politics, and repackaging it as an efficiency metric. As the OSI’s own historical account notes, the strategic pivot was designed specifically to “distinguish it from the philosophically-and-politically-focused label ‘free software’” and pitch the pragmatic business advantages of open development. Software wasn’t about pesky things like “human rights” or “ethics” anymore; it was about “superior engineering models”, “faster bug fixes”, and “economic efficiency”.

For twenty years, this sanitized version of open source reigned supreme. It built the modern internet. It also tricked a whole generation of developers into believing that tech had always been apolitical.

The Double Standard of “Neutrality”

When you look closely at the modern nostalgia for “neutral software”, a striking double standard emerges.

When GitHub enforces U.S. export control laws and suddenly strips developers in sanctioned countries like Iran, Syria, or Crimea of access to their private repositories, the tech world generally shrugs. It’s treated as an unalterable reality of corporate existence: Welp, GitHub is a U.S. corporation bound by U.S. trade laws. Business is business.

But when a community-funded, non-profit forge like Codeberg sets transparent, democratically decided rules - such as their recent community membership vote banning predominantly AI-generated slop repositories to prevent severe server strain and maintain code safety - the reaction is drastically different. Suddenly, it’s labeled a “moral panic”, a “loss of software freedom”, or the “radicalization of tech”.

Why the discrepancy?

Because for twenty years, developers were conditioned to accept corporate and state governance as an invisible default. Corporate terms of service, venture capital incentives, and state sanction laws were treated as “neutral baseline reality”, while human and community governance was labeled “political interference”.

A platform that enforces zero community standards isn’t neutral. It simply chooses to prioritize the comfort of bad actors over the safety of everyone else. Total unmoderated “neutrality” on a platform just means forcing volunteer maintainers to absorb abuse, spam, and server costs for free.

The Return to First Principles

Regardless of what people tell you, what we are witnessing today isn’t the death of open source - it’s the collapse of the illusion that tech can exist in a vacuum separate from human labor and human consequences.

Software is built by people, maintained by people, and hosted on infrastructure funded by people. Much like art, it cannot and does not exist in a vacuum.

If a maintainer decides that they’re done spending their nights and weekends handing free labor to a company or user actively harming them, using “cancel culture” terms to label that is stupid. They’re exercising basic individual agency.

The same goes for platforms. A non-profit forge restricting automated slop repos isn’t “censorship”; it’s basic resource management so that their servers aren’t overwhelmed.

Funnily enough, back when Linux adopted the Contributor Covenant in 2018, it kicked off a discourse that was nearly identical to today’s LLM discourse with “apolitical” developers claiming that they’d be witch-hunted and driven out of developer spaces (which obviously never ended up happening, but reactionaries gonna reactionary, I guess).

In classical open source, freedom was always a two-way street. You have the absolute freedom to write and release whatever code you want, but everyone else has the exact same freedom to say “Nope, I don’t want this anywhere near me or my platform”.

Software Was Never Just Utility

The idea that software was once this pure, objective utility that has been ruined by modern social politics is a myth.

We are not watching the corruption of an apolitical ideal (which, let’s be honest, does not exist). We are watching a generation of developers realize that the corporate-friendly, business-sanitized era of open source mostly served to extract billions in free labor for massive corporations while leaving communities defenseless against burnout, abuse, and exploitation.

By re-establishing boundaries, demanding ethical accountability, and taking control of community spaces, developers (and users) are simply rediscovering open source’s first principles: that software freedom is, and always has been, deeply tied to human values.