I've been using NixOS for years now (the 1st commit is from 2020). The benefits I particularly enjoy:

• mostly-atomic updates and rollbacks
• versioned configuration, with history in Git
• uniformity of configuration across machines - my allowed SSH pubkeys are in NixOS config, so I only have one source-of-truth to update if I want to add or revoke one (and then rebuild every machine, of course (maybe I should invent an automated provisioning/deploy system)).
• (advanced, but not complex) composable configuration - NixOS has modules.
  • I enable my user and Wireguard in every machine, along with the Prometheus host exporter
  • I enable more Prometheus exporters in servers - nginx, and whatnot.
• (advanced, complex) programmable config
• (advanced) overlays - easily change your OS

If a software update goes south, just reboot into the last known good one, until you have time to figure out what broke. This only applies to OS config, it doesn't apply to data, so if you need to migrate your Postgres to a new on-disk format, or such, you still need a snapshot or backup of some sort.

It's very easy to keep config in Git - I'm aware of etckeeper, but NixOS treats your Git repo as the primary source of truth, not a tacked-on addition.

It's possible to write parametric configurations, to loop over machines, etc. For example, here's how I import the module that enables and unfirewalls Prometheus exporters, in one particular machine:

(import ../modules/wireguard-prometheus-exporters.nix { exporters = [ "knot" "nginx" "nginxlog" "node" "postgres" "redis" "systemd" "wireguard" ]; })  

Other machines don't have knot or redis, so I just omit them from the list.
Here's a simplified snippet of the implementation:

{ exporters, }:  # this is a lambda taking a parameter, the list of Prometheus exporters per host  
{ config, lib, ... }:  
{  
      services.prometheus.exporters = lib.genAttrs exporters (  
      exporter: { enable = true; }  
      # ... etc. There's more stuff here, but this is the gist.  
}  

This thing above produces approximately this NixOS config:

services.prometheus.exporters.knot = { enable = true; };  
services.prometheus.exporters.nginx = { enable = true; };  
services.prometheus.exporters.nginxlog = { enable = true; };  
# ... etc  

Edit: I forgot about overlays. You can patch software, or switch to forks, much more easily with NixOS. For example, here I'm applying some mods to my laptop:

  nixpkgs.overlays = [  
    (import ../overlays/wlvncc-overlay.nix) # add clipboard support  
  ];  

and here's its definition - nothing could be simpler.

final: prev: {  
  wlvncc = prev.wlvncc.overrideAttrs (old: {  
    patches = (old.patches or [ ]) ++ [ ./wlvncc-clipboard-sync.patch ];  
  });  
}  

The patch itself is generated by git diff in the source of wlvncc. Alternatively, I could have switched to a fork, here's how: https://wiki.nixos.org/wiki/Overlays#Overriding_a_version

The first steps are rather rough, yeah. Once you have your workflow, it takes like 30 seconds to permanently install a program. Never as straightforward as an apt install micro, but well, that's where we come to the point of NixOS.

Personally, I like NixOS, because:

• I know what's on my machine. It's written down in my configuration, rather than me having run apt install micro ages ago and then I never apt purged it when I stopped using it.
• Similarly, I can easily undo changes. I have my configuration in Git, so I can look at what I changed and git revert it. Maybe I set my EDITOR env when I switched to Micro and it'd be a good idea to set that back. By having a Git history, I can't forget stuff like that.
• I can sync my configuration between my personal laptop, my work laptop and my home server. And it's not just naive copying of dot files, where some settings might not make sense on one of the hosts, but rather I can tweak individual settings as I see fit.

I'm on nixos now for several years: Don't stick with it if you don't have the issues it's solving! Nix is an own language, literally - and you'd have to learn it to really get comfortable with it.

To give you the personal anecdote:

I'm running arch an my desktop and laptop and nixos on my server. The main reason for nixos me is "protection from myself": with having the generations and deterministic definitions allows me to test something and discard it without any leftovers.

It's just a completely different mindset. For my server I want to first define my system and then build it. On my client I want to quickly install something.

And to make it worse: reading the manual is mockery in my opinion, created by the Linux equivalent of the Cenobites who ravel in our suffering. In my opinion, documentation quality reaches from arch simi on the one hand to the nixos... thing on the other.

I’m just tacking on to the existing responses, but for me, the huge benefit I get that no one else has hit on yet is automated setup of partitions, LUKS, ZFS on root, and zswap (mostly via disko).

https://github.com/nix-community/disko

It’s sooooo much nicer than wiring those up by hand.

And I have a custom USB iso based on the nixos installer, with has an ssh server running by default, with my pubkey already wired up. So I can plug in a USB to a new device, boot from it, run recon remotely to figure out how I want to set up the disks, then run a full install from my laptop over SSH with a single command (via nixos-anywhere).

https://github.com/nix-community/nixos-anywhere

NixOS is an absolute gem.

I've been running NixOS for about a year now (servers+desktop+laptop) and I love it!

I config sometging once, push it to Git and all other devices follow.

Everything is in one place and everything uses NixOS/HomeManager modules, so everything is configured using the same syntax/language.

It is quite difficult to get started with, but it is so nice when you get the hang of it.

Also, I work in IT with declarative tools like Kubernetes and Terraform. NixOS lets me treat my machines the same way with declarative code, so it is actually pretty intuitive to me.

I am in no way an expert on the matter, but I will gladly try to answer any questions you may have :)

NixOS really is my endgame OS and after having tried many different distros, this is what I will be sticking with for the forseable future :)

I have not used NixOS, but heavily use their package manager at work. In the package manager context, there are two big benefits:

1. You can have directory specific environments. For example, with direvn once you 'cd foo' you can magically have a JDK, go installed that doesn't impact the rest of your system
2. By putting flake into your repo you can guarantee that each developer will have the same environment

Glancing at NixOS, it looks like it follows the same pattern but at the OS layer. If you like declarative configuration that could be an upside. The bigger upside would come if you have multiple machines that you want to behave the same.

/etc/nixos config file . fill it in and run nixos rebuild switch and that becomes your new default system.

https://search.nixos.org/packages

This link helps you find packages, and the options give you the command to add to your config, install it adhoc or install into the current session.

If you have a broadcom WiFi card you may need to add a few lines to your hardware config, but normally you don't touch it.