You know why reinstalling Linux is annoying? Because you have to remember (or write down) every piece of config you ever changed. Dark mode in KDE? Change it in settings. Some systemd unit tweak? Change it in /etc/systemd. Want to run some commands at boot? Use systemd (see above), or write an initrd hook (distro-specific). Need a specific version of an app? Need some files in /opt? Need certain packages installed? You better remember to do that!

In NixOS, you “reinstall” your OS every time you change a single setting, because reinstalling NixOS isn’t scary at all - everything that needs to be changed is configured in your configuration - just make sure /home and /var/lib are saved (and perhaps some other dirs, I have root on tmpfs and bind mount all persistent files I need to ensure I know what needs to be preserved on clean reinstall and what doesn’t).

Want to move it to a different PC? No problem, copy the files in /home and /var/lib and simply install NixOS using the configuration you already have on the new PC. Want to create a boot option with slightly different kernel or kernel options, or maybe even another DE? No problem, specializations got you covered. Something broke and you want to try an older version of your system? Just select it in your bootloader, it will “install” the old version of your system on boot!

And of course, this also means it’s easy to share configurations for specific use cases. Want to run on some specific hardware that doesn’t work out of the box? Perhaps nixos-hardware got you covered. Want a certain program set up? Maybe there’s already a NixOS option for system-level config or a home-manager option for user-level config, worst case you can write it yourself and share for everyone else in the community using flakes, and maybe open a PR to nixpkgs/home-manager. Want to share configuration between systems? That’s easy, put them in the same flake and write a common module shared between all of your systems.

Basically, if you’re fine with whatever comes out of the box in any Linux distro, you don’t need NixOS, but if you need configuration, if you run servers, it is a lifesaver. I switched from Arch, no regrets. I run my personal laptop, my server, which I effortlessly migrated from Oracle Cloud when they quit Russia, and my router on it, here’s my NixOS/home-manager config.

The only downsides are the learning curve and the fact that you can’t “just” run programs that expect a FHS layout. You can do it with workarounds like steam-run or appimage-run anyway, but overall be prepared to learn to package stuff for NixOS. Also if you have no experience with functional programming, the Nix language may be hard to understand at first.

Edit: home-manager is also available on all Linux distros and iirc even MacOS. Nix-the-package-manager is also available on all Linux distros and MacOS, and it’s useful for creating consistent developer environments, but it’s NixOS that really makes Nix shine.

I’m not remotely anything like an expert, and I don’t use NixOS (yet) myself, but I’ve been heavily researching it and I’ll try to explain it to you like I wish someone had explained it to me.

First, I’d like to point out that most Linux distros are more or less the same. The main differences between most distros are what kind of package manager it uses, how it handles software updates (delaying and testing them like Debian vs releasing them quickly like Arch for example), how many packages they have in their repositories, and what software, configurations, and themes they ship with. There’s a few different ones, like the new immutable distros (like Fedora Silverblue), or something like Gentoo where you compile everything from source code instead of downloading precompiled packages, but it doesn’t get much different than that.

NixOS is the first Linux distro I’ve seen that radically changes the formula.

The biggest thing is, everything is installed and configured “declaratively”. In a normal distro if you want to install Firefox, you type “sudo apt install firefox” and it puts Firefox on your computer. On NixOS, you edit a config file for your entire system and add Firefox to a list of packages you want installed on your system. Then, you run a command, and Nix adds it. This is nice because it gives you an easy way to keep track of exactly what’s on your system. If you want to remove something? Delete a line from your config and run it again.

This also works for other things. Configuration files also get set this way. On Arch, I had to edit a lot of files in /etc to get some virtual machines working properly. When I reinstalled one time, I had to figure out what I changed before and relearn everything to redo those changes. On NixOS, you tell your system what you want changed in that config and it does it all for you, exactly the same way every time. You can even do things like installing software from source code with it if you want a package Nix doesn’t have. You can have it automatically download the source code, and follow instructions to compile it and set it up.

There’s a lot more though.

When you run that command to install/uninstall/configure everything in your system’s config file, it doesn’t just take your system as it is and change it. If you do that there’s a chance something got tweaked by you or some piece of software you’re running. That could screw the process up. So instead, Nix just nukes and reinstalls your entire filesystem from scratch, doing it exactly how you ask in the config file. That way, you know it’s exactly how you want it, nothing is different. (And in case you’re concerned like I was, I think it does this really fast somehow. And it also doesn’t touch your Home folder and any of your personal files)

This has some other bonuses too. It makes your system really hard to break. Since you’re installing your filesystem from scratch every time, it (I think) makes the entire thing unmodifiable. You can’t make changes to it directly. You don’t have to worry about a bad package or a virus breaking something. And yet you can still tweak it to your heart’s content, you just do it from that config file and it sets everything how you ask it to.

Plus, let’s say you install updates, and a package has a bug that breaks everything and your entire system isn’t even starting. You’re safe, because NixOS saves backups of your filesystem. All you have to do is pick an older one at boot time and it’ll take you to that one instead of the newer, broken version, and then you can fix the problem/broken package and go on with your day. (I think it does eventually start using a bit of disk space to have multiple copies. But you can go back and delete older copies.) Alternatively, just in case that fails for some reason, you still have your config file. If you save backups of that, or use something like Git to save every version of it to Github, all you have to do is run that file again and it’ll install your system exactly as it was before something broke.

The last big thing is reproduce-ability and package dependencies.

First, packages. A big problem with software development, and making all the packages for a Linux distro, is dependencies and what people refer to as “dependency hell”. Linux is cool because you can use one dependency for multiple packages. Package Bob can say “hey I need package Joe to run”, and package Fred can say the same thing. And you don’t need two copies of Joe, they can just share Joe. Unfortunately, occasionally you have a problem where Bob is designed to use version 1 of Joe, and Fred is designed to use version 2, and usually it’s hard to install both at the same time. The best you can do is make two packages of Joe for your distro, let’s say “joe-v1” and “joe-v2”, and tell the people that make Bob and Fred to make their packages say which Joe package they need. It gets complicated and messy, and is a big reason why things break on other distros.

This is also a problem with being a developer. If you make a script that runs Python 6, and then your computer updates to Python 7, your script might suddenly not working. And you better hope your distro has a “python-6” package that you now have to tell your script to use. And hopefully it’s not even more specific, like needing Python 6.13.7 when the “python-6” package is actually Python 6.14.2 and you can’t get the very specific version you need.

NixOS fixes this by letting you use specific, exact versions of a package, and have multiple of them at once, and have every package say exactly which one it needs. I don’t know if you’re familiar with checksums/hashes, but basically it makes a hash for every package. If you change anything in that package (the version, how it’s installed, build options, config files, anything), it’ll have a different hash. And if another package only works with a very exact version of a dependency package, it can say which one it needs with the hash, and it’ll just work because it’s set up exactly right.

And finally, because of all of this other stuff, your system is extremely reproducible. If your system breaks and you want to reinstall, throw your config file in and regenerate and it’ll be 100% identical to how it was. Throw it onto your second computer, give it out to people online, you name it. They’ll get the same thing. Do you run servers, and want to set up 30 to be just like each other? Normally you’d have to do that manually and hope you don’t mess something up, or learn a tool like Ansible. With Nix, just make a config file for it, throw it on all 30, and they’ll be the same. Or what if you’re a software developer, and you need to get a coworker to try what you made on their computer? Just give them the config, they can set up an identical test system and test it, tweak it, you name it, and you know it’ll run exactly the same between both computers.

I think there are some drawbacks to Nix. The biggest one is the learning curve. The configuration files are all written in a (simple but unique) programming language, also called the Nix langauge. You basically have to learn it, and the basics of Nix in general, to use NixOS and do all the first time setup. I’ve heard people say that a Linux user learning NixOS is like a Windows user learning Linux. It’s different, it’s a bit. Plus, the documentation seems like it’s in a rough spot right now. Multiple places that have documentation, none of them are totally complete, some are outdated, and they’re all a bit confusing. And lastly, it seems like because of how the setup is done, installing and configuring some things will be different and potentially a lot harder than on other distros.

NixOS is probably overkill for what a lot of desktop users actually need. Awesome features that if you have them you probably won’t ever want to live without, but a lot of things that are aimed at software developers and sysadmins, and with the learning curve it might not be worth it. If you run any normal distro and never need to reinstall your distro ever, you’d basically never need the features of NixOS.

But if you get past the learning curve, NixOS seems to be the most powerful, flexible, unbreakable distro in existence at the moment. At least it is of the ones I know about.

Sorry for the lengthy reply! And again, I’m absolutely not an expert. It’s been almost my sole obsession the last month or two and I’ve been trying to understand everything as well as I can, but someone with real experience will probably find things I said that are wrong. But I wanted to explain it in a way that makes sense to pre-learning-about-Nix me from a couple weeks ago, because everything I’ve seen from longtime NixOS users seems to be full of confusing jargon, and hopefully it helps you too!

Do not turn to the Lovecraftian package manager unless you dare. It consumes all, it is all. Your flesh and mind will be ripped in twine across dimensions… if you are a package.

If you’re binary your head will be ripped open and it’s contents modified to fit a new reality.

There is no package, nor source, nor binary that shall be exempt.

All shall be consumed, digested and brought to a new reality.

It will kill the old gods, as there will be only one package manager.

It will consume you.

If you are worried that your computer will screw you with a bad update tomorrow, and the possibility of setting up your system like it’s a wishlist.

• Rock solid
• Native rollbacks if you break you system
• The ability to list every software you want to use/try
• Every little tweak you do to a program can be written in a file
• You NixOS config will get you the same OS everywhere

• 1 config for all my devices (pc, laptop, aarch64 server)
• 1 config language that I have to learn for the most part
• stuff won’t randomly break on an update, and even if I mess something up, I can press the up arrow when booting to boot an older generation
• everything is organized in 1 place (especially useful for my server, cause docker containers, NixOS container, native services are in the same spot)

It’s use case is to make it easy for a server admin to be able to reproduce a given server in an exact way.

You then take the config to a lab, upgrade and/or make a change. Then redeploy the new build in a very controlled manner effecting minimal downtime.

When used on a home desktop the config has the potential to become a chore in itself to administer which is more suited to those who prefer a minimal install.

If you like to tinker and try that latest fad app nixos is not going to be nice for you.

1 config to rule them all.

Also this: https://itsfoss.com/why-use-nixos/

Cloud systems invented this concept called ‘declarative environments’ basically you describe the software in a container or os and the container orchestrator builds it for you. The same every time, you just give it a recipe.

Nixos is that for desktops.

It takes away a lot of the bullshit, experimentation and breaking of a classic os.

That being said, I always considered that the fun part, so ymmv.

It’s like docker for server applications, it takes care of everything for you behind the scenes and just works (ish).

NixOS allows me to back up all the configuration for my entire complex hypervisor server by just saving one folder, since it centralizes all system configuration in /etc/nixos. That is an absolute godsend.

And that’s just one example, practically any NixOS installation is easily reproducible by just grabbing the configuration files from that folder. It makes configuring a new install a breeze.

NixOS will make you cofee every morning, fix your car, make your waifu real and establish a long lasting commune system in your country of residence.

Lets you do a lot of things…

• define your own system config, down to configuration for each program or service
• lets you modify package (derivations) easily. Need to enable a compilation option, change source, add a patch, etc? You can do it.
• Can revert between system generations in case of bugs or whatever reason

Something new. Everything works nicely on existing distros, so we can explore new ways of doing things.

NixOS is first one that really restarted my gears.

Imho not really a worth while venture. Easier solutions exist for most use cases.

https://www.youtube.com/watch?v=IRRtk320j2A&pp=ygURbml4b3MgY2hyaXMgdG90dXM%3D