Back when I took the plunge and tried my very first immutable operating system, I wasn’t sure what the fuss was about. My OS of choice was Fedora Silverblue, and on the surface, I didn’t really see the point of immutability. All I really saw was an inability to install things via the console, a layering system people told me not to use because it’d ‘defeat the purpose’ and that’s about it.
Well, that was six months ago, and I’ve since made my FOSS nest in Fedora Kinoite, the atomic, immutable version of Fedora KDE Plasma. And not only do I now ‘get’ the whole immutable system idea, but I honestly think people should give it a shot at least once during their distro hops.
Immutable systems don’t have the problem of ‘software rot’
No more having to reinstall your OS every few months
Before we hop into why I adore immutable systems so much, let’s check out what the term actually means. An immutable operating system is one where the OS puts all system files into a read-only state. There may be some exceptions (for instance, with non-atomic OSes—more on that later), but for the most part, nothing can edit them. Not you, not the apps you install, and not the system processes.
Sounds like a pain, right? Well, that’s where the strength of the immutable system comes in. Because nothing is allowed to touch your important system files, you prevent ‘software rot’. This is when an OS slowly loses performance and stability over time because all the changes made to the system files begin to add up to the point where they actually affect your PC.
Of course, immutable systems don’t have that problem. Because all the system files are protected from changes, they pretty much stay the same as they were when you first installed them. No more cursing and tinkering when a bad install corrupts one of your system files.
Not being able to install apps the ‘normal way’ isn’t a huge problem
You just need to shift your mentality on how things get installed
One of the biggest drawbacks to an immutable system is that you can’t install apps the traditional way. Yes, that means no more punching commands into the terminal and having it download and install everything. You can add what’s called a ‘layer’ to an immutable system that weaves an app in with the OS’s immutable quilt, but fortunately, you quickly discover you don’t usually need to do that.
Enter your new best friends: containerised apps and AppImages. For the former, you can use your app of choice; I’m personally partial to Flatpaks. These run in their own little container, so they don’t need to install anything in your system’s files, and they come with their own dependencies bundled in.
For the latter, an AppImage has everything it needs to run on its own; it’s kind of like a portable Windows EXE. While you can just set them as an executable and double-click them to run, I’m partial to downloading Gear Lever as a Flatpak and using that to set up AppImages on my PC. All Gear Lever does is grab the name and icon of the AppImage, move the file somewhere safe, and add shortcuts for it to your distro, but once it’s all set up, it looks and feels like you installed it via the console.
Out of all the apps I use on Fedora Kinoite, I’ve only had to layer a single app, and that was DistroBox. There are other ways to get it running, but I took the easy way. Everything else either lives on my PC as a Flatpak or an AppImage.
An immutable OS also lets you try out atomic system design
I love how atomic operating systems work
So, people often confuse the terms ‘immutable’ and ‘atomic.’ They’ll sometimes use one term when they actually mean both. However, it is entirely possible to have an operating system that is immutable and not atomic, but it’s not very common.
Atomic operating systems don’t update themselves the ‘traditional’ way. When they update, they don’t open up the system files and tweak them; instead, it constructs a new snapshot containing the updated system state. Once the download is done, the PC waits for you to restart, then swaps out the snapshot you were just using with the new one. I love atomic systems; not only do they have an ‘all or nothing’ stance to updates (which means no data corruption if something goes wrong), but the system will often save past snapshots that you can really easily boot back into if an update messes something up.
Because atomic systems don’t edit the system files directly, combining them with an immutable distro is a match made in heaven. If you grab a modern-day immutable OS, such as Fedora Silverblue or NixOS, there’s a huge chance that it will also be an atomic one. As such, by trying out one of the more popular immutable systems out there, you also get a taste for how an atomic one works. And trust me, once you get hooked on the atomic operating system design, it’s really hard to go back to the old ways.
Give an immutable system a try next time
Immutable systems sound like they’re more of a pain to use than they actually are. As long as you shift away from the idea of installing everything to the system root and instead move things into Flatpaks and AppImages, you can get the benefit of having no software rot. Plus, if you pick a modern-day OS, there’s a very good chance you’ll also get to check out an atomic system too.