From Mint to NixOS: Why a Long-Time Linux User Made the Switch

Background

I started daily driving Linux back in 2019. The start of that journey was rough, and I still deeply appreciate the help I received in those early days from the old guard who kept me moving forward.

Early on, I quickly found my home with Linux Mint and its Cinnamon desktop. As the saying goes, "You don't choose a Linux desktop; the desktop chooses you." Built on top of a stable foundation with a rich package infrastructure, Cinnamon provided a familiar experience that bridged the gap from Windows.

It also afforded me excellent customization options right out of the box, such as configuring custom keyboard shortcuts or setting up auto-login startup scripts, while always getting out of my way. No adverts, no pop-ups, just a fast and efficient desktop environment.

I won't lie, though: I distro-hopped multiple times just to see if the grass was greener. Through those escapades, I quickly realized I am definitely not a GNOME person; I do not like polyfilling my desktop experience with a suite of extensions. And as much as I appreciate KDE Plasma, I learned that with great customization comes great responsibility because it was far too easy for me to break my environment with just a few theme toggles. This is not a dig at those desktop environments; it just means I am not wired for that kind of experience.

As I continued my Linux journey, my priorities shifted. I wanted a predictable operating system that could act as a trusted companion, both for my daily life as a software developer and as a casual user wanting to watch Netflix on the weekends. This is what made me appreciate Linux Mint even more. It featured a predictable release cycle, a stable package base built on Ubuntu LTS, and Timeshift to guard against system breakage during upgrades.

However, two major friction points always bothered me:

1. Stable but Stale Packages: Linux Mint's software is incredibly stable, but it is rarely fresh. For example, the okular package is consistently several versions behind upstream. It does the job, but I often wished for fresher packages. Flatpaks are an option, sure, but I prefer my software to be served natively from the distro's package manager first. I only want to reach out to alternative sources like PPAs or Flatpaks as a last resort.
2. Setup and Reinstallation Felt Like a Chore: Don't get me wrong, reinstalling Linux Mint and configuring it to a productive state is still miles faster than doing the same on Windows or macOS. But it always felt like a chore that could be automated in a more reusable, auditable way. I had a collection of shell scripts I ran after every fresh install, but they felt messy, imperative, and difficult to maintain. There had to be a better way.

Specialized distributions like Arch Linux or Fedora address the fresh package problem well, and I even experimented with a few immutable distros. But in the end, none of them quite let me get on with my life the way I was accustomed to.

Recently, Linux Mint announced a change in their release cycle, moving major releases from three times a year to just once a year in December. This meant the next major update wouldn't arrive until December 2026. This became the catalyst for me to look for an alternative: a distro that matched the stability and dependability of Mint, but solved my existing gripes.

Enter NixOS

I had played around with NixOS about a year ago, and it originally caught my eye for three reasons:

1. Declarative Configuration: Via a single file (/etc/nixos/configuration.nix), you can specify your entire operating system, including packages, system services, and users. By the time you reboot, everything is perfectly reconstructed.
2. Massive Repository: NixOS has one of the largest package ecosystems available, boasting close to 100K packages in their official repository. This gives me immediate access to a massive variety of fresh, well-maintained software.
3. Atomic Generations: NixOS layers the operating system whenever packages are added or updated. It tracks these states via generations, allowing you to easily roll back to a previous working state from the bootloader if an upgrade ever fails. It is like Timeshift, but built directly into the DNA of the OS package management.

Installation

The installation process for NixOS is relatively straightforward and handles much like any other modern Linux distribution. It utilizes the graphical Calamares installer, which allows you to choose your preferred desktop environment right from the wizard. Naturally, I chose Cinnamon.

Packages and User Management

The real fun begins once you boot into your fresh system. To handle my multi-user workflow, since I maintain distinct personal and work profiles, I defined both users and their specific package requirements directly inside /etc/nixos/configuration.nix.

Packages can be isolated to a single user or exposed globally across the system.

  # Personal Profile
  users.users."gavin" = {
    isNormalUser = true;
    description = "Gavin";
    extraGroups = [ "networkmanager" "wheel" "docker" ];
    packages = with pkgs; [
      pnpm
      nodejs_22
      localsend
      ansible
      bun
      php85
      go
    ];
  };

  # Work Profile
  users.users.gmurambadoro = {
    isNormalUser = true;
    # Generated via: mkpasswd -m sha-512
    hashedPassword = "<encrypted password>";
    description = "Gavin Work";
    extraGroups = [ "networkmanager" "docker" "wheel" ];
    packages = with pkgs; [
      pnpm
      nodejs_22
      awscli2
    ];
  };

Global Packages

For foundational utilities and system-wide software, I populate the global system profile array:

  # List packages installed in system profile
  environment.systemPackages = with pkgs; [
    google-chrome
    chromium
    bat
    tilix
    kazam
    ffmpeg
  ];

As a developer, I can also cleanly configure system daemons like Docker alongside flatpak backends right in the configuration file:

  # Enable the Docker daemon
  virtualisation.docker.enable = true;

  # Avoid granting root-level permissions to the Docker group
  virtualisation.docker.rootless = {
    enable = true;
    setSocketVariable = true;
  };

  # Automatically configure a Flatpak repository for all users 
  systemd.services.flatpak-repo = {
    wantedBy = [ "multi-user.target" ];
    path = [ pkgs.flatpak ];
    script = ''
      flatpak remote-add --if-not-exists flathub https://flathub.org/repo/flathub.flatpakrepo
    '';
  };

Developer Setup and Aliases

To ensure the system stays fresh without manual intervention, NixOS lets you declare automated, unattended updates. I have mine set to pull weekly:

  # Unattended upgrades
  system.autoUpgrade = {
    enable = true;
    dates = "weekly";
    persistent = true; # Catches up if the machine was turned off during the slot
    flags = [
      "--update-input"
      "nixos"
    ];
  };

I also map my essential quality-of-life shell aliases directly into the environment setup:

  # Shell aliases
  environment.shellAliases = {
    ls = "eza -lh --color=auto --group-directories-first";
    rebuild = "sudo nixos-rebuild switch";
    cat = "bat";
    nixos-list-generations = "nixos-rebuild list-generations";
    nixos-delete-generations = "sudo nix-collect-garbage -d";
    nixos-edit-configuration = "sudo nvim /etc/nixos/configuration.nix";
  };

Whenever I modify this configuration, applying the changes is a single command away: sudo nixos-rebuild switch. The system builds itself on the fly to match the exact state declared in the file. (Note: Occasionally, a full reboot is still ideal to ensure desktop-level environment changes completely hook in.)

Key Takeaway

I have been daily driving NixOS for a short while now, and honestly, half the time I forget that I am not on Linux Mint anymore. The operating system is incredibly responsive, and my daily development workflow has not missed a single beat.

NixOS is a mature ecosystem that has been around for over two decades. Because I am still in the early stages of adopting it, I am intentionally avoiding complex setups like Flakes or advanced home-manager workflows right away.

The fundamental superpower of NixOS is its declarative core and the ironclad guarantee that I can instantly roll back to a working generation if a change goes sideways. Concepts like the Nix language, flakes, and transient development shells are incredibly powerful tools, but I am content taking it one step at a time. nix-shell environments already look incredibly promising for project isolation, and I plan to experiment with them next.

So far, so good.