Free Software that you can't customise is not truly Free Software

One of the most widely touted advantages of FOSS (free and open-source software) is that you have the freedom to modify and customise it to your needs… theoretically. How well does this work in practice? I’m convinced that most FOSS actually does a pretty poor job at satisfying this goal - often worse than well-known proprietary software!

The Free Software Foundation has a list of the “four essential freedoms” that they consider paramount to free software; this is the second.

The freedom to study how the program works, and change it so it does your computing as you wish (freedom 1). Access to the source code is a precondition for this.

In theory, this sounds incredible. You mean I can just take a piece of software that does 95% of what I want and then add the other 5% myself? Sign me the FUCK up.

I just wish it was that simple. ¯\_(ツ)_/¯

In the 2000s, there was a lot of talk about "Tivoisation" — the practice of releasing devices that ran FOSS but which you couldn't actually upload modified code to. This led to the release of the GNU GPL version 3 in 2007, which added clauses prohibiting this practice. I think there's a more insidious issue today, wherein software has grown so complex that we can't easily do it on our own machines, even if we run a completely libre environment.

A Hypothetical Scenario

Let's put it to the test. I’m one of those weird people who enjoys using vim keybindings to edit text. I’d love to have that ability across all text fields on my desktop. That should be easy if I’m running a FOSS desktop environment, right?

… Right?

I’m generally a KDE enjoyer, so I guess I should begin by grabbing the source code for Qt. Let’s pretend that I’ve made some nice changes to teach the magic of hjkl to QLineEdit and friends. Now I’d like to get it running.

I’ll figure out how my distro builds packages and I’ll try and use the same tooling to build something compatible, and install it, replacing the supplied version. So far so good! Except for the apps that ship their own version of Qt, so I guess I’ve got to track down the source code for the same version, apply my patches, build it using the same options, and shove the .so files into the right place.

Finally, thanks to the magic of FOSS, I’ve got the experience I’ve always wanted. Until a week later, when I install updates, and now half of my applications won’t run because the new versions are linked against a newer version of Qt.



I should note that this article isn’t meant to be a dig at free software — there are excellent examples of FOSS that offer rich, user-friendly customisation, like Firefox extensions.

Rather, I want to highlight that the ability to edit the source code doesn't always correlate 1:1 with the ability to adapt a program for your needs. That might have been the case on Unix boxes in the 1980s, but today’s software is just too complex to make the same approach viable without investing lots of time into maintenance. Even if you successfully build and install a program you've edited, you still need to worry about keeping it in sync with any dependencies/dependents, pulling in updates from upstream, protocol changes and so forth.

This leads to the paradoxical situation where proprietary software sometimes ends up giving users more freedom about how they compute than they would get from a FOSS alternative. But… how?? Here's a few examples I'm aware of.

Built-In Customisation

I’m using this term to describe software where the authors designed and included ways for users to modify their experience.

mIRC Scripting

This is an excellent example — mIRC is a Windows-only shareware IRC client that has been maintained for almost 29 years (an impressive run!).

It includes a scripting language that is somewhat idiosyncratic but has a ton of power. With a couple of lines, you can write a script that automatically identifies you to NickServ. More advanced scripts could customise the UI (or even create custom windows), restyle built-in messages like channel joins, and automate all sorts of behaviour.


Commercial reverse-engineering tools like IDA and Binary Ninja are also great examples here. They both offer scripting support that lets you hook into the application at myriad points and inject custom behaviour, even though you don’t get the source.

On the other hand, in the FOSS world, we’ve got Ghidra. It has a plugin system and a scripting system, and it’s fully open-source, so by all rights you’d expect it to leapfrog IDA and Binary Ninja here!

Well, sort of. The decompiler is a wad of C++ (whereas the rest of Ghidra is Java), and there’s no way to hook into it via scripts. If you want to improve it in any way — perhaps to detect and transform a weird code pattern that you see in one project — you’ve got to recompile the entirety of Ghidra, and then deal with merges if you want to update. I’ve done it, and it sucked.


Finally, I would be remiss if I didn’t mention Apple’s Shortcuts. This began as a third-party app called Workflow, which they acquired and later integrated into iOS and macOS.

Shortcuts lets you create miniature scripts using a drag-and-drop interface, which can be executed from icons, Siri commands, the Share sheet, or triggered automatically by the OS when certain actions occur.

It’s not perfect, but in principle it feels similar to the scripting capabilities that you get from mIRC. You can use it for really simple tasks with minimal effort, and you can learn more and write more complex code if you need it.

Adversarial Customisation

This is a term I’ve just made up to describe customisation ecosystems that have sprung up around software that wasn’t built to support it.

Minecraft (Java Edition)

Minecraft is one of the most popular games of all time, and I'd wager that client modifications and custom servers have played a decent role in its longevity. It was published as an obfuscated Java application, but modifying .class files is still fairly straightforward — this led to the community putting together deobfuscation maps for the game and building all sorts of stuff.

There's mods that improve the game's rendering performance and graphics, like OptiFine. You can get new game modes, countless new blocks, and probably a lot that I'm unfamiliar with because I haven't played Minecraft in like a decade.

None of this was intended by Mojang, but enough people were interested in modding Minecraft that a large, user-friendly ecosystem sprung up around the game. There's mod loaders that make it easy for players to grab whatever they want.

Cydia on iOS

The iOS jailbreaking scene is another fine example of ‘adversarial customisation’ — I clung to it fondly for years, and even wrote a couple of my own tweaks. People often dismissed jailbreaking as just being used for app piracy, but this does a disservice to what was an incredibly creative community… hell, it still exists, although it’s losing steam as iOS exploitation gets harder.

Some of the things you could get through jailbreaking, years before Apple offered them (if they ever did):

This was all based around an ecosystem of tools. Cydia Substrate allowed developers to inject code modifications into apps and OS libraries. Cydia (and alternatives like Zebra) offered repositories for tweaks and themes, and even a marketplace for paid packages.

The most impressive example though, in my opinion, is Flex — a tweak which allowed users to create simple patches right from their device. You could select an app or a framework, and it would display a list of all the Objective-C classes and methods in it. You could then make small changes to them, like replacing specific arguments, or forcing a method to return a certain value.

This, to me, perfectly embodies the freedom to modify that you’re supposed to get from Free Software™.

Browser Extensions

Also, I know this is quite long already, but I feel like I should mention website customisations that are applied via browser extensions. There's userscripts and userCSS (applied using TamperMonkey and Stylus respectively), and there's also specialised site-specific extensions — the two that come to mind are Better TweetDeck and Missing E (for Tumblr) but that's definitely not an exhaustive list.

These are a pretty good way to let users have freedom over the web apps they interact with — even if obfuscated JavaScript blobs and React try their best to dissuade it.

Why does most FOSS suck at this anyway?

Implementing built-in customisation in a way that’s useful is difficult, and it takes up time that resource-constrained FOSS projects would probably prefer to spend on other tasks!

I suspect that it’s also really easy to dismiss with the argument of “you have the source code, you can just modify it”, which is quite fair… but as I’ve shown here, this is increasingly impractical.

Android might just be the most damning example. The core OS is open-source, but good luck doing anything interesting with it if you’re not a hardware vendor. You find a phone with an unlocked bootloader, flash your modified OS, and then half your apps stop working because they demand a Google-approved system. For all intents and purposes, Android may as well be closed source.

How do we fix it?

I’m not sure. I don’t expect FOSS maintainers to invest a ton of effort into making their projects more amenable to customisation, as much as I’d like to see that.

I’d love to see more tooling for adversarial customisation on non-web platforms, but modern platforms are growing evermore hostile to it for security reasons — which is understandable but still disappoints me as a tinkerer. The iPhone is well known for being one of the most closed general-purpose computing platforms… but when I had a jailbroken iPhone, it felt like the complete opposite. If I didn’t like something in an app, I could write my own tweak, or just install one that somebody else had made.

Anyway, thanks for reading my silly little rant. I want to reiterate that this isn’t meant to be a dig at FOSS or at the people who maintain it! I think the ability to adapt your software to your needs is really important. If this post encourages anybody to add some customisation to their FOSS projects, then it's been worth it.

Previous Post: Splash Golf Revival, Part 3: The Final Splash