Why Nix?

Nix is a package manager which focuses on reproducibility, declarativeness and reliability. These features make it easier to deal and work with packages because they solve a lot of the issues related to package management. Now how does Nix achieve this?

Firstly on the point of reproducibility, Nix builds packages in isolation from each other and gives each package a unique hash which ensures that they are reproducible, unique and don't have undeclared dependencies. If it works on one machine, it will also work on another. Moreover by having a unique hash for each package we can also have several different versions of the same package installed at once since these will all get their own unique path in the Nix store. This is especially important when different applications have dependencies on different versions of the same package — it prevents "DLL hell".

Secondly on the point of declarativeness, Nix packages are declared using the Nix language which is heavily inspired by functional programming. In fact package expressions are just functions! This declarativeness makes it easier to read and reason about package builds. Furthermore, it becomes trivial to share development and build environments.

Lastly on the point of reliability. Nix ensures that installing or upgrading a package cannot break other packages. This allows you to easily roll back to previous versions and ensures that no package is in an inconsistent state during an upgrade.

Nix also makes it less painful to deal with packages and dependencies in development environments. Whenever you want to create a new development environment you can simply use nix-shell which creates an interactive shell based on a Nix expression. For anyone familiar with virtualenv this is similar. For example if I want to create a development environment for python I could do something like this. nix-shell -p python38. If I want to include some python packages I could do this nix-shell -p "python38.withPackages (pkgs: with pkgs; [ pandas requests ])". However once you require more than a couple of packages and you want to configure other stuff in the shell it gets tiresome to write long Nix expressions. Instead what we do is create a shell.nix file to put our expression in.

{ pkgs ? import <nixpkgs> {} }:

pkgs.mkShell {
  name = "python38-dev-shell";
  buildInputs =
    let ps = pkgs.python3Packages; in
      with pkgs; [
        python3
        ps.matplotlib
        ps.requests
        ps.virtualenv
     ];
}

Now we can simply run nix-shell in the project directory and voile we are dropped into our development environment. We can also add this file to our project repository so that any collaborators can get access to exactly the same development environment we are using.

Nix also makes packaging software less of a hassle. Not only do you get to use the Nix language to package software in a declarative manner, but you also get access to all the helper functions that the Nix community has built to make it simpler to package software. No longer do you need to know all the details about building software for your favourite language. Nix build helpers do all the heavy lifting for you. This severely reduces the barrier to entry for contributing packages. In fact Nix was the first ever package manager I contributed packages to because of how easy it was and probably one of the reasons the Nixpkgs repository has so many packages even though they require contributions to be reviewed in a pull request (which is a good thing), unlike software repositories like the AUR where anything goes.

{ lib, python3Packages }:

python3Packages.buildPythonApplication rec {
  pname = "colorz";
  version = "1.0.3";

  src = python3Packages.fetchPypi {
    inherit pname version;
    sha256 = "0ghd90lgplf051fs5n5bb42zffd3fqpgzkbv6bhjw7r8jqwgcky0";
  };

  propagatedBuildInputs = with python3Packages; [ pillow scipy ];

  checkPhase = ''
    $out/bin/colorz --help > /dev/null
  '';

  meta = with lib; {
    description = "Color scheme generator";
    homepage = "https://github.com/metakirby5/colorz";
    license = licenses.mit;
    maintainers = with maintainers; [ skykanin ];
  };
}

Here Nix provides the buildPythonApplication builder for packaging python applications which makes it very simple for us to build the application. We simply need to provide a src for the package and the build inputs. Here the checkPhase is simply making sure that the CLI runs properly after building.

{ pkgs ? import <nixpkgs> {} }:

pkgs.callPackage ./derivation.nix {}

This has been a surface level showcase of Nix's features, there are plenty more like creating minimal docker images using dockerTools, declaring and deploying cloud images through nix-ops and even an entire GNU/Linux distribution called NixOS which is built around the Nix package manager and brings its features to the entire operating system. If this has peaked your interest you can download Nix here and checkout the resource section below.

For newcomers I would highly recommend checking out the nix.dev guide. Other than that you will probably also end up reading the manuals for Nix and Nixpkgs at some point for a more in depth understanding of how things work.