In this in-depth NixOS review, we’ll explore what makes NixOS fundamentally different from traditional Linux distributions. From declarative configuration to fully reproducible systems, NixOS challenges everything you think you know about managing Linux.

But is it practical? Is it beginner friendly? And does the “immutable” architecture actually make your system better? In this video, you’ll get answers to those questions and more!

NixOS Review

Intro

Hello and welcome back to Learn Linux TV.

Today we’re finally taking a deep dive into NixOS — a distribution that’s been highly requested and sitting on my review list for quite a while. And now it’s time to give it a proper look.

At first glance, NixOS doesn’t seem unusual. This is a standard GNOME desktop, with familiar applications and a typical Linux workflow. During installation, you can choose from multiple desktop environments, so whether you prefer GNOME, Plasma, or something else, you’re covered.

But once you start customizing the system, that’s when you realize NixOS is fundamentally different.

NixOS isn’t managed the way most Linux distributions are. Instead of installing packages one by one and tweaking the system manually, NixOS uses a declarative configuration model. You describe the system you want in a configuration file, rebuild it, and NixOS generates that system for you.

That design makes it reproducible. You can take your configuration file, move it to another machine, rebuild, and end up with the same setup. It’s closer to infrastructure as code than traditional package management — and that changes how you think about managing your OS.

In this article, I’m going to walk through what makes NixOS different, how customization actually works, how its model compares to traditional distributions, and whether it makes sense as a daily driver.

Let’s dive in.

What is “NixOS”?

Let’s talk about what NixOS actually is, and how it differs from other Linux distributions.

First, NixOS isn’t built on top of another distro. Many Linux distributions are created from something else — Ubuntu from Debian, Mint from Ubuntu, Nobara from Fedora – and so on. However, NixOS stands on its own. It has its own package manager, its own design philosophy, and its own way of building the system.

You won’t be using apt or dnf here. Instead, NixOS is powered by the Nix package manager, which works very differently from traditional package managers.

Now from a day-to-day desktop perspective, things look normal. You pick a desktop environment during installation — GNOME, Plasma, Cinnamon, and others — and once you’re logged in, it behaves like any other Linux desktop. You have a browser, terminal, file manager, and the usual tools.

The difference appears when you start customizing the system.

NixOS is declarative. That means instead of manually installing packages and tweaking the system one step at a time, you describe the system you want in a configuration file. Then you rebuild the system from that declaration.

For example, if I want htop installed system-wide, I add it to /etc/nixos/configuration.nix, then run:

sudo nixos-rebuild switch

NixOS evaluates that configuration and builds a new system generation that includes htop. From that point forward, htop is part of the declared system state.

Over time, you build up a list of packages, services, and system settings in that configuration file. And because it’s just code, you can copy it to another machine, rebuild, and end up with essentially the same system. That’s why people compare NixOS to “infrastructure as code.” The operating system itself is defined in code.

Now, editing configuration.nix isn’t the only way to install software.

If you just want to install something for yourself, you can use:

nix profile install nixpkgs#vim

That installs vim into your user profile. It doesn’t modify the system configuration, and it won’t disappear when you rebuild. It’s simply not part of the declarative system definition.

That distinction is important.

Packages declared in configuration.nix define the system itself.

Packages installed with nix profile live in your user environment.

This brings us to a concept that often gets mixed up with NixOS: immutability.

NixOS isn’t immutable in the traditional “read-only root filesystem” sense like Fedora Atomic or Ubuntu Core. The root filesystem is writable. You can modify files manually if you want to.

Instead, NixOS achieves many of the same benefits people associate with immutability — reproducibility, atomic upgrades, and rollback — through a functional design.

When you rebuild the system, NixOS creates a new generation. Your previous generations remain available. If something goes wrong, you can boot into an earlier generation. That’s transactional and rollback-based, but it’s not the same thing as being read-only.

So rather than thinking of NixOS as immutable, it’s more accurate to think of it as declarative and generation-based.

You describe the system.

Nix builds it.

And every version of that system remains available.

That’s what makes it fundamentally different from most traditional distributions.

How does NixOS handle immutability?

Earlier I referred to immutability, but it’s important to be precise here. NixOS isn’t immutable in the traditional read-only filesystem sense like Fedora Atomic or Ubuntu Core.

Instead, NixOS achieves many of the same benefits through a different mechanism.

The key idea is generations.

When you edit configuration.nix and run sudo nixos-rebuild switch, NixOS doesn’t modify the system in place. It builds a new system generation in the Nix store and then switches a set of symlinks to point to that new generation.

Your previous generations remain available.

If something goes wrong, you can roll back to a previous generation either from the bootloader or from the command line. That’s how NixOS achieves atomic upgrades and safe rollback — not by making the entire filesystem read-only.

The Nix store itself, located under /nix/store, is immutable. Packages there are content-addressed and never modified in place. If something changes, a new version is built alongside the old one. But the rest of the filesystem — your home directory, /var, /etc — is writable like on any other Linux system.

So changes are not “lost on reboot.” They persist normally.

What is different is that only changes declared in your configuration file are guaranteed to be part of the system definition. Manual tweaks outside that model may work, but they aren’t part of your declarative setup and won’t be reproduced automatically on another machine.

That’s a big distinction.

NixOS gives you reproducibility and rollback, but through functional package management and generation switching — not by locking down the root filesystem.

Now, does that make NixOS only for experts?

Not necessarily.

There is a learning curve. You need to be comfortable editing configuration files and rebuilding the system. But conceptually, once you understand that you’re defining the system instead of manually tweaking it, it can actually feel more structured than something like Arch.

It’s different — but not inherently harder.

Installation

Let’s move on to the installation process.

Is installing NixOS difficult?

Not really — at least if you use the graphical ISO.

Like most modern distributions, you download an ISO file, write it to a USB drive, boot into a live environment, test hardware compatibility, and then launch the installer.

The graphical edition of NixOS uses the Calamares installer — the same installer used by many other distributions — so the process will feel familiar. You’ll choose your language, disk layout, user account, and desktop environment, and then the system installs just like Ubuntu or Fedora would.

When you boot the live environment, you can choose GNOME or Plasma to try things out. During installation, you’ll actually have even more desktop choices available, including options like Xfce and others, depending on the image you’re using.

Now, it’s worth mentioning that NixOS also provides a minimal ISO. That version doesn’t include a graphical installer — it’s a manual, terminal-based installation process. That’s more advanced and gives you full control, but most users will likely stick with the graphical ISO.

Once installation completes, you reboot, log in, and at first everything feels like a normal Linux desktop.

The real differences don’t show up until you start customizing the system — and that’s where NixOS really sets itself apart.

NixOS manages software differently

One thing you’ll notice right away is that there isn’t a traditional graphical package manager installed by default.

If you’re used to GNOME Software on Fedora or Ubuntu, you won’t find it managing system packages here. That’s because NixOS doesn’t use traditional package management at all. GNOME Software doesn’t understand the Nix package manager.

You can install GNOME Software if you want, but it’ll only manage things like Flatpaks. System packages are handled through Nix itself.

On NixOS, the primary way to install system-wide software is declarative. You add packages to your configuration file and rebuild the system. When you run:

sudo nixos-rebuild switch

Nix evaluates your configuration and builds a new system generation that includes those packages.

That rebuild process is typically fast, and more importantly, it’s atomic. The new system is prepared before it becomes active. If something goes wrong, you can roll back to a previous generation.

Now at this point, you might be wondering: why design a distro this way at all?

Traditional distros work fine. You install packages, update them, remove them — it’s straightforward.

The reason NixOS takes a different approach comes down to reproducibility and safety.

Because the entire system configuration is declared in code, you can reproduce the same setup across machines with confidence. And because every rebuild creates a new generation, you always have a fallback. If a configuration change introduces a problem, you can roll back cleanly without manually undoing individual package changes.

That rollback mechanism is often compared to immutability — but it’s important to be precise.

NixOS doesn’t make the root filesystem read-only like Fedora Atomic or openSUSE MicroOS. It achieves similar benefits — atomic upgrades and rollbacks — through its functional package model and generation switching.

In other words, it’s not immutable in the filesystem sense. It’s transactional and declarative.

And that’s what makes it powerful.

You’re not manually patching the system. You’re defining it.

Personally, I really like this approach. It feels modern. It feels structured. You’re not constantly modifying the system in place — you’re building defined system states and switching between them safely.

Now, immutable-style distributions in general are still evolving. Fedora Atomic, openSUSE MicroOS, Ubuntu Core — these approaches are gaining traction, but they’re still maturing in the broader Linux ecosystem.

What makes NixOS interesting is that it has been living in this declarative, generation-based world for a long time. While other distributions are experimenting with transactional updates and image-based systems, NixOS has already been operating on a fundamentally different model.

And the fact that you can use it as a daily driver today says a lot about how mature that model has become.

Should you use it?

So, should you use NixOS? Should it be your daily driver?

For many people, yes — I think it’s absolutely worth serious consideration.

But it’s not for everyone.

NixOS is fundamentally different from most Linux distributions. If you prefer managing your system entirely through graphical tools and rarely touching configuration files, it may feel unfamiliar. On the other hand, if you’re comfortable editing config files and using the terminal, the learning curve is very manageable.

It’s not harder than something like Arch — it’s just different. Once you understand the declarative model, it can actually feel more structured and predictable than traditional package management.

As for me, I genuinely enjoy using NixOS. I love the reproducibility, the generation-based rollbacks, and the clarity of defining the system in code. That said, it hasn’t replaced my daily driver — at least not yet.

The main reason is that I already have my own configuration management workflow that accomplishes similar goals. If I didn’t, I’d seriously consider using NixOS full-time.

But even if you don’t switch permanently, I highly recommend trying it.

Not just because it’s a solid distribution — but because it challenges how you think about managing Linux. And even if you decide it’s not for you, understanding the Nix model will broaden your perspective on what’s possible with a Linux system.