Modernizing the open source desktop: what changes for devs

X11 was born in 1987, and a good chunk of Linux desktops still run on decisions made back then. LWN published a piece called Ideas on modernizing the open-source desktop, and the title alone sums up a conversation that is heating up in the community: what needs to change so the open source desktop stops feeling like a project that is forever "almost ready". The original is worth reading. Here I want to talk about the part that matters to people who write code: how this modernization affects your daily work.

What does modernizing the open source desktop mean?

Modernizing is not about new icons or a new theme. It means touching the foundation. Today, when someone talks about a modern Linux desktop, they almost always mean three things:

• Wayland replacing X11 as the way windows get drawn on screen.
• Packaged, isolated apps, with Flatpak and the xdg-desktop-portal portals.
• An immutable base system that updates atomically and rolls back if something goes wrong.

None of these ideas is new. Wayland has been around since 2008. Fedora Silverblue has years on the road. What's new is that the conversation moved from "someday, maybe" to a plan with a deadline. GNOME and KDE have already announced the end of the X11 session. KDE has its own distro, KDE Linux, which has been immutable from day one. And GNOME OS is no longer just a test image.

Why this matters now

The reason is simple: the old model doesn't scale. On the traditional desktop, every app sees everything. Any program can read your ~/.ssh, and on X11 any window can capture the screen of the others. That was fine in the 90s. Today, with malicious browser extensions and compromised npm packages showing up every week, it's an open invitation.

The other reason is maintenance. A classic distro is a puzzle of thousands of packages updated one by one. An update that stalls halfway leaves the system in a state nobody ever tested. The immutable model replaces that with a whole image, tested as a single block. Updated and it broke? Reboot into the previous version.

Anyone who has lost an afternoon fixing their own system after an update understands the value of an undo button.

And there's an example that shows this works outside the lab: the Steam Deck. SteamOS is immutable, uses Flatpak for desktop apps, and millions of people use Linux without knowing they're using Linux. That's the clearest sign the approach works for regular people.

What changes in your development workflow

Now the painful part. The modern desktop and the traditional dev environment clash in a few places.

An immutable system won't let you install everything at the root. That sudo dnf install postgresql-devel you run without thinking doesn't work the same way. The ecosystem's answer is development containers, with toolbox or distrobox:

distrobox create --name dev --image fedora:latest
distrobox enter dev

# inside the container, business as usual
sudo dnf install nodejs postgresql
curl -fsSL https://bun.sh/install | bash

The container shares your home directory, so your project, your keys and your .gitconfig are all still there. In practice, after a week you forget you're inside a container. I actually think it's better than the old model: each project with its own dependencies, and a clean base system.

An editor in Flatpak sees very little. If you install VS Code from Flathub, it runs isolated. The integrated terminal can't see the Node you installed on the host, and the language servers disappear. You can open up permissions:

flatpak override --user --filesystem=home com.visualstudio.code

But then you're undoing part of the isolation that justified Flatpak in the first place. My take: heavy development tools (editor, IDE, Android Studio) work better installed inside the same container as your toolchain. Flatpak shines with end-user apps: browser, Slack, music player.

Wayland changes things you didn't even remember depended on X11. Screen capture, screen sharing on Meet, automation tools that simulate clicks, global shortcuts. On Wayland, none of that is free. Everything goes through a portal, with the user granting permission. If you build web apps, getDisplayMedia() in the browser already works through PipeWire and the portal without you changing a single line. If you build Electron apps or desktop tools, it's worth testing:

# forces Electron to run natively on Wayland in older versions
code --ozone-platform-hint=auto

Recent Electron versions already detect Wayland on their own. But if you maintain an old Electron app, this is the kind of thing that shows up as a "blurry window" or "I can't share my screen" bug in the issue tracker.

The most common objections, answered

"I'll lose control of my system." You lose a little, yes. You stop editing /usr by hand. In exchange, you get a system that doesn't rot. For people who like to tinker with everything, traditional distros still exist and will keep existing.

"Flatpak duplicates libraries and eats disk space." It takes more space than native packages, that's true. Shared runtimes and deduplication reduce the damage, but they don't eliminate it. In 2026, with 1 TB SSDs being cheap, I'll trade a few gigs for apps that don't break when the distro updates glibc.

"Wayland still can't do X." That list has shrunk a lot. Three years ago it was long. Today what's left is a niche: certain accessibility tools, some automation workflows and proprietary software that never gets updated. The niche is real, and people who depend on it have every right to complain. But it's no reason to hold everyone back on X11.

"This is Red Hat pushing an agenda." GNOME and Red Hat drove a lot of this, but KDE, Valve and the people behind Bazzite and openSUSE Aeon reached similar conclusions through different paths. When people with different interests converge, it's usually because the problem is real.

What I would do today, in practice

If you develop on Linux and want to get ahead without switching distros tomorrow:

1. Run your session on Wayland for a week. Write down what breaks. It's probably less than you think.
2. Put one project inside a distrobox. If it works, move the others over little by little.
3. If you maintain a desktop app, test it on native Wayland and as a Flatpak. Your users will get there before you do.
4. Keep isolation on for apps that don't need to see your whole home directory. Your ~/.aws/credentials will thank you.

None of this requires reinstalling your system. And if it goes wrong, you just leave the container. That's the best part of this modernization: mistakes get cheap.

My take

The open source desktop spent two decades trying to beat Windows at Windows' own game. It didn't win. What's changing now is different: instead of copying, it's building something the commercial desktop still doesn't fully have. A base system that doesn't break, apps isolated by default, rollback for free. The transition will be annoying, and people who depend on old tools will suffer first. But the destination makes sense, and for the first time in a long while it feels like the community is rowing in the same direction.

I've been working with a containerized dev environment for a while now and I'm not going back. If you want to see what comes out of that environment, take a look at the projects I've been building.

The Linux desktop still carries decisions made in 1987. And that is finally changing.

GNOME and KDE have already announced the end of the X11 session. Wayland, Flatpak and immutable systems are no longer "someday, maybe". They now have a plan and a deadline.

If you write code, this hits your daily routine. No more installing everything at the root. Your Flatpak editor can't find your Node. Screen capture now goes through a portal.

My answer was a containerized dev environment with distrobox. Each project gets its own dependencies, the base system stays clean, and if something goes wrong, you just leave the container.

The Steam Deck already proved this model works for regular people. Mistakes got cheap.

I wrote on the blog what I would do today, in practice, to get ahead without reinstalling anything. The link is in the comments.

#Linux #OpenSource #Wayland #DevExperience #SoftwareDevelopment