A recent article from The Register, “The Price of Software Freedom Is Eternal Politics,” struck a nerve. It didn’t tell us something entirely new, but it articulated what many in the free and open source world have felt for years: that the software itself is only half the story. The rest is people. And wherever people gather, politics follows.
The article explored the strange birth and controversial tone of Xlibre, a fork of the aging X.org display server. On the surface, this is yet another technical divergence — a team of developers unhappy with the current direction decide to fork, build what they prefer, and release it under their own flag. We’ve seen this before: Emacs vs. vi, GNOME vs. KDE, systemd vs. everything else. But this fork wasn’t just technical. It came with an ideological edge: the project's lead loudly rejects diversity initiatives, intentionally removed any code of conduct, and leaned into a kind of cultural antagonism that made the politics of the fork as visible as its source code.
This isn’t new behavior, nor is it unique to the X11 space. In fact, it reminded me of what I explored in a previous piece titled Programming Language Switching Politics. In that post, I argued that even a seemingly mundane engineering decision — such as switching programming languages — often has more to do with social dynamics than syntax. Changing a language reshapes the power structure inside a dev team. It creates new centers of expertise. It redistributes influence. The old guard loses their edge, and the weekend hobbyist who’s been secretly learning the new language becomes a rising voice.
This shift in influence isn’t malicious. It’s human. People like to feel useful. They want to be respected for what they know. Language switches challenge that. They threaten existing roles, expose weaknesses, and create uncertainty — even if nobody says that out loud. These transitions are rarely blocked by technical incapability. They’re resisted because of pride, fear, and the inertia of established pecking orders.
Xlibre isn’t just a technical fork — it’s a political claim. It plants a flag not only in the architecture of windowing systems, but in the culture of software itself. Some are recoiling from this overt politicization of infrastructure. But the truth is, we’ve always been here. The FOSS world has long been an uneasy alliance of competing philosophies. On one side, there’s Free Software — driven by individual rights, user freedoms, and the moral imperative of source access. On the other side, Open Source — more pragmatic, more business-friendly, aimed at producing better software by inviting more eyes and more hands.
The term “FOSS” tries to blend these views into a coherent banner, but that unity is fragile. As this latest fork reminds us, these communities have never fully agreed on what freedom even means.
What Xlibre reveals — or rather, what it forces us to admit — is that politics in software isn’t an accident. It’s not a side effect. It’s foundational. And the more power a piece of software represents — in infrastructure, in influence, in ideology — the more that politics becomes unavoidable.
That applies whether we’re talking about display servers or compilers. No one switches from C++ to some new language without disrupting the team's internal structure. No one replaces X11 with Wayland without sparking debates about values, history, compatibility, and trust. These debates are not noise. They’re the real content of the work.
Some developers still try to live in a world of pure logic and engineering. They see code as neutral, apolitical, almost mathematical. That’s a comforting illusion, but it breaks down the moment a team has to make a hard choice — especially a choice that might cost someone their reputation or relevance.
That’s where ideology creeps in. Not in slogans or manifestos, but in the quiet fear of becoming obsolete. In the pressure to back the “right” toolset. In the way licenses get interpreted. In the decisions about who leads, who speaks, who gets heard.
The way forward isn’t to pretend these pressures don’t exist. It’s to acknowledge them honestly. The fact that Xlibre now exists is less about the technical flaws of Wayland or the purity of X11, and more about who gets to decide what software culture looks like. It’s about control. It’s about belonging. And yes, it’s about politics — even if no one wants to use that word.
My goal in writing this isn’t to pick sides. It’s to expose the battleground under the source tree. If you still believe you can “just write code,” you haven’t been paying attention. Every line you ship lives inside a web of values, power, ego, legacy, and control. One day, you'll push a commit and realize it’s not just code — it’s a signal, a stance, a challenge.
The sooner you learn that, the better. Ideology lives in infrastructure. Control lives in protocols. Your build system might be neutral, but your position in the org chart isn't. Every new language, every forked repo, every license clause — they aren’t just tools, they’re political levers, culture bombs, and boundary markers.
In the coming years, as code eats the world and AI models eat the code, this won’t get simpler. It’ll get more dangerous. More loaded. More vital. The last free spaces are the ones we take back ourselves — with keyboards, not keyboards-as-a-service.
So stop pretending you’re above it all. Embrace the mess. Understand the stakes. Learn how the layers stack — not just the tech stack, but the human one too.
Because out here, in this neon-lit wasteland of surveillance capitalism, protocol wars, and corporate capture, the developers who survive aren’t the ones who code the fastest.
They’re the ones who know which side they’re on.
