It didn't take me long to fall in love with atomic systems. I gave them a try on a whim, and I ended up loving how they work and what they do within a week. In fact, being an ex-Windows user, it's really hard for me to go back to using Microsoft's operating system, partly because atomic Linux distros exist.

The thing is, I don't think Windows will ever adopt the atomic structure. It'd take a ton of work and architectural redesigning for it to come to life. And because of that, Linux will always have an edge over Microsoft's OS.

But first, let's check out what an atomic operating system is

And why I love it

Before we check out why Linux's atomic distros have a permanent edge over Windows, let's explore what an atomic distro even is. The idea behind atomic distros is that an update either fully completes or it doesn't complete it at all. There are no 'half-measures' with atomic, and no updates that stall at 99%; it's all or nothing.

While that's already a lot more convenient than failed Windows updates, atomic operating systems usually keep two versions of themselves available at the same time. Some systems will keep more (for example, NixOS can let you store as many as you like), but at the very least, you'll get both a current and a previous version.

When you download an update, the OS downloads the new files to a different location. When you reboot, the OS simply points to the new files instead of the old ones; nothing gets deleted right away. It's kind of like a switch on a train track; if you're going down Track A, an atomic OS update will set up all the new stuff you need on Track B. Then, when you restart your PC, the signal switches from A to B, and now you're using the new files while the old ones still "live" on Track A.

Keeping the current and last versions of an OS is fantastic

And really easy to use

While we're still on the topic of that changing train track, let's explore why that's so powerful. Let's say your OS downloads its update to Track B. You restart, get swapped over to Track B, and...it's awful. Your stuff keeps crashing, your OS is unstable, and everything's a mess. Great.

But wait a minute! Remember, the OS didn't erase Track A: it simply pointed away from it. As such, it's totally possible to restart your PC, tell your computer to go down Track A instead, and voila, your system files are back to how they were, bit for bit. Now you can coast on Track A until an update fixes Track B.

I actually encountered this once using Fedora. I downloaded an update and booted into it, but no matter what I did, the Plasma Shell (think Windows shell) went into a crash-reboot loop. On Windows, I'd have to roll back or delete the update; for my atomic Fedora distro, I restarted my PC, selected the previous image during boot, and I was fine. Then I just waited for the Plasma Shell to get an update, and I was back on track. What would have been a 10-20 minute time sink on Windows was fixed with a reboot on Linux.

Let's say you're using an OS that only stores two of these tracks, like Fedora Silverblue. If you're on Track B, and another update comes out, then the OS will download it on Track A and erase everything there. However, some distros will let you favorite specific updates so it doesn't get automatically cleaned.

The "all-or-nothing" update mantra makes my system rock solid

Don't settle for 99%

The problem with non-atomic systems is that they have to edit the current files when performing an update. Atomic systems don't do this; they leave the current files untouched and simply make brand-new updated files that live on another track. As such, if something goes wrong during an update, an atomic system handles it a lot better than a non-atomic one.

Let's say you're applying a Windows update and it fails at 80%. The good news is, Windows can roll back updates, but it has to, quite literally, roll back the update. It's kind of like realising you're painting a room wrong when it's 80% done; you can just take the paint off and go back to how things were, but it's messy, and it might not be the exact same as it was before.

Because atomic prepares the files in a separate location and simply points to them, nothing bad happens if the update fails. Your current system files are untouched, and the OS can simply scrap the track it was working on. You barely notice anything bad happened.

The worst part is, Windows can't reach true atomic design

And that's why Linux has the edge

So why am I claiming that Windows can't be atomic? Why couldn't a Microsoft engineer who's reading my article right now slap their forehead, go "Of course!" and rattle out this feature within a month? Well, the bad news is, Windows is built on some old tech that stops things from going atomic.

For one, you have the Registry. This stores all the settings on Windows. If you want to do an atomic update on Windows, you have to take a copy of the Registry and update it. However, while the update is running, Windows still allows system files and apps to make edits to the Registry, so the clone is already out of date before it's even finished.. And because the Registry also has user settings mingled in with the system settings, you have a real mess on your hands if you try to make a mirror version. Everything's all bunched up into one 'monolith'.

On the other hand, Linux is modular. It naturally separates the system files from the user's own files. In fact, if you set up Linux right, you can have an entire partition dedicated to user files. With Windows, that line's a lot blurrier, and it's hard to separate the system from the user's files. In fact, this is why atomic systems are also usually 'immutable,' which means the system files are read-only and off-limits to the user. It helps keep the two separate and prevents apps or tools from altering the system files.

To make Windows atomic, Microsoft would need to rewind three decades' worth of 'technical debt.' In fact, it already tried! Windows 10X was a new system that separated the OS from user files and drivers. The problem was that Win32 apps had their kernel, drivers, and registry in their own container, meaning Microsoft had to basically run a 'mini-Windows' inside Windows 10X just to run them. And the Registry issue wasn't exactly sorted, either; it just got stuffed into a container. Windows 10X never made it to the public, and this was just one of the reasons why.

Linux's atomic designs will always keep me on Team Tux

If Microsoft ever manages to pull off an atomic Windows, I will gladly eat crow and applaud its achievement. However, I have the nasty feeling that getting an atomic Windows running would take a lot of work and break legacy apps. And because of that, Linux will keep that advantage for the foreseeable future.