What happens when open-source takes itself seriously?

Stick around to the end for more of my recent open-source articles.

For many years, “open-source” has been haunted by a dark shadow in the public space: Open-source meant powerful ideas but rough implementations. The reputation of “useful but woefully awkward” was (quite honestly) well earned. Even for many who could see its potential, the open-source ecosystem remained essentially “philosophically good, but unusable for serious work”, unless, of course, you were already deeply invested in the culture.

This reputation didn’t come out of nowhere.

The banality of good intentions

One of the reasons open-source has this reputation is that for a long time, we’ve simply lived by the practice that good intentions = good outcomes. “If we just make something that gets the job done, surely no one could fault it, right?” No doubt, there’ve been countless open-source tools packing incredible power buried behind awkward interfaces, obscure and often arcane installation methods, inconsistent packaging, or documentation written solely for experts (if at all).

What we’d so long failed to realize is that no matter how capable an application is, paving the road to using it with shards of broken glass only makes people remember how the glass cut their feet. We’d do the same if we’re being honest.

That’s why the current shift in perceptions of open-source matters. It’s not coming about because people are just tired of paying for subscription services or frustrated that they had to create an account by force just for one meagre download. Forced accounts, proprietary lock-in, data harvesting, and platforms that treat users like resources are still real reasons, but they’ve always existed in tech, long before any of these shifts gave us options to break free.

The real reason is something far more profound and meaningful: Open-source is starting to take itself seriously.

Tech Insight: Professionalism is not the enemy of freedom

Like someone investing in self love, F/OSS projects are improving governance through stronger, structured communities and real-world professional, logistical, and physical infrastructure. Developers are paying more attention to usability, design, distribution, sustainability, and trust. As a matter of fact, as a designer, it gives me great delight to see that all three of my main open-source tools, Inkscape, GIMP, and Pinta, have dedicated UX teams or discussion boards.

What’s even more encouraging is that the open-source community is embracing Continuous Integration (CI) pipelines and other professional development resources provided by the wider tech ecosystem to drive an evolution away from the old mindset and energy of “compile it yourself” and move towards software distribution models that put the user first and encourage community growth as a result.

It’s not about what you can do, but how easily you get to do it

I used creative software as my primary example because these tools need more than just raw capability. They need to be usable. The ultimate goal of any creative tool is to make it so you can dive in and create freely without wrestling with it the whole time. This has long been the primary complaint about open-source software, and not just creative/design tools either.

But we’re seeing a tidal shift towards centering user experience and adopting the same standards as proprietary and “professional” software. We’re finally asking not only “what can the software do?”, but we’re also asking, “what’s the experience doing with it”.

That’s the difference between a “powerful” tool and software people can actually live and thrive in.

It’s an entire platform shift

This sea change isn’t only happening at the app level. As a matter of fact, much of what’s driving this shift is that the major players in the Linux and open-source desktop world, which host and frame the end-user applications we use, are really doing their homework and acing it too. The main players in this space are GNOME and KDE, with others following their lead in many ways.

It shouldn’t come as a surprise that a company as large and robust as Valve chose to build the future of PC gaming on Linux and open-source software. What they’re seeing and affirming is the value and vision of the hard work put in by open-source projects and the coalescing of this value and vision into a stable platform. In Valve’s case, they’ve chosen Qt, KDE Frameworks, Kirigami and the like, but we can’t forget that underlying this work are systemd, PipeWire, portals, runtimes, and the other less glamorous pieces built through cross-community planning and collaboration. Plus, if you take a look through Flathub, the largest and most popular Linux “app store” equivalent, you’ll quickly see where GTK, libadwaita, and the GNOME philosophy are driving app development and innovation by giving developers a clear place to stand.

The open-source realm is finally turning from a land of scattered possibilities into a targetable ecosystem.

The end of an era, and the beginning of a revolution

“Fragmentation” has long been our “curse”, both in Linux and in open-source on a broader scale. Developers often complained about not even knowing where to begin. To be fair, we’ve long lacked any single desktop platform in the vein of Windows or macOS, like Win32 APIs, Cocoa, AppKit, and Foundation, to name a few.

But now, we can confidently point developers in a single direction and let them do their thing. Want to build for elementary OS? Sure, go ahead. GNOME? Got you covered. KDE? Start right here. COSMIC? Thought you’d never ask…

…and so on. Plus, love it or hate it, we’ve finally gotten past the packaging debate. Cross-platform, cross-distribution packaging has never been easier. CI handles the hard work for many projects now, and on Linux, you can literally take your pick of Flatpak, Snap, or AppImage if you don’t want to wrangle with individual distros. What’s more, our biggest “app stores” give a standard way (appstream) to provide screenshots, useful descriptions, clean (even one-click) installs, reliable updates, and straightforward discovery.

We can’t ask for anything better, really.


Practical Tip: Get involved

One of the things I’m most excited about in all we’ve discussed here is that it’s being driven by real, regular people, like you and me. Really, we’re all real and regular people, obviously, but sometimes we need this framing to stop seeing this work as somehow beyond us.

My encouragement to you, and something I’ve been practicing myself for many years now, is to get directly involved with the projects you know and love. That’s the beauty of open-source (when it sticks to its core principles). Anyone can get involved in the work, and anyone can help to make it better.

If your favourite project has a UX team, you don’t even need to be a UX expert to get involved. Opening a discussion about that little quirk you just can’t wrap your mind around might be the on-ramp to delivering a new feature or breaking a bad pattern that’s stuck around forever.

So my simple encouragement is to get out there and get involved. You may not think your voice matters, but the reality is it can leave a legacy that can’t be erased. You could even open doors for yourself (and others) as I’ve seen for myself through my work.


If you want to stay in this lane

I’ve written some related articles in this series that you might find interesting if you liked this one:


Working with us

At RolandiXor Media Inc., we blend design and open-source thinking for our clients.

rolandixor.pro/services


Elsewhere


Support this work

If this writing has been useful and you’d like to help sustain it:

https://ko-fi.com/rolandixor


Thanks for reading.
Catch you in the next Roll Out!