4. Build a package using Nix

Let’s build and run CMake:

nix build "nixpkgs#cmake"
./result/bin/cmake --help

Let’s build and run Pandoc:

nix build "nixpkgs#pandoc"
./result/bin/pandoc --version

Let’s build and run npm:

nix build "nixpkgs#nodePackages.npm"
./result/bin/npm --help

If you run ls result/bin you’ll notice that the package also includes npx.

Let’s build and run pip:

nix build "nixpkgs#python3Packages.pip"
./result/bin/pip --help

Let’s build and run kubectl:

nix build "nixpkgs#kubectl"
./result/bin/kubectl --help

Let’s build and run ripgrep:

nix build "nixpkgs#ripgrep"
./result/bin/rg --help

Let’s build and run scalafmt:

nix build "nixpkgs#scalafmt"
./result/bin/scalafmt --version

Here’s the package definition that builds our C++ package:

{
  packages = forAllSystems ({ pkgs }: {
    default =
      let
        binName = "zero-to-nix-cpp";
        cppDependencies = with pkgs; [ boost gcc poco ];
      in
      pkgs.stdenv.mkDerivation {
        name = "zero-to-nix-cpp";
        src = self;
        buildInputs = cppDependencies;
        buildPhase = "c++ -std=c++17 -o ${binName} ${./main.cpp} -lPocoFoundation -lboost_system";
        installPhase = ''
          mkdir -p "$out/share"
          cp -R dist/. "$out/share"/
        '';
      };
  });
}

For the full flake, see flake.nix on GitHub or run cat flake.nix. What you see here is a derivation that defines how to build the package, more specifically the mkDerivation function provided by Nix’s standard environment.

The package that results when you run nix build is a CLI tool that outputs a message. To run that tool:

./result/bin/zero-to-nix-cpp

You should see this output:

Hello from Nix + C++!

Here’s the package definition that builds our Haskell package:

{
  packages = forAllSystems ({ pkgs }: {
    default = pkgs.haskellPackages.mkDerivation {
      pname = "zero-to-nix-haskell";
      version = "0.1.0";
      src = self;
      license = pkgs.lib.licenses.cc-by-sa-40;
      executableHaskellDepends = with pkgs.haskellPackages; [
        base
      ];
    };
  });
}

For the full flake, see flake.nix on GitHub or run cat flake.nix. What you see here is a derivation that defines how to build the package, more specifically the haskellPackages.developPackage function provided by Nixpkgs.

The package that results when you run nix build is a CLI tool that outputs a message. To run that tool:

./result/bin/zero-to-nix-haskell

You should see this output:

Hello from inside a Haskell program built with Nix!

Here’s the package definition that builds our JavaScript package:

{
  packages = forAllSystems ({ pkgs }: {
    default = pkgs.buildNpmPackage {
      name = "zero-to-nix-javascript";

      buildInputs = with pkgs; [
        nodejs_latest
      ];

      src = self;

      npmDeps = pkgs.importNpmLock {
        npmRoot = ./.;
      };

      npmConfigHook = pkgs.importNpmLock.npmConfigHook;

      installPhase = ''
        mkdir $out
        cp dist/index.html $out
      '';
    };
  });
}

For the full flake, see flake.nix on GitHub or run cat flake.nix. What you see here is a derivation that defines how to build the package, more specifically the buildNpmPackage function, which is a wrapper around Nix’s built-in derivation function.

The package that results when you run nix build is a website built using the [Vite] framework. To view that website, open the HTML file at result/share/index.html.

Here’s the package definition that enables us to build our Python package:

{
  packages = forAllSystems ({ pkgs }: {
    default =
      let
        python = pkgs.python3;
      in
      python.pkgs.buildPythonApplication {
        name = "zero-to-nix-python";

        buildInputs = with python.pkgs; [ pip ];

        src = ./.;
      };
  });
}

For the full flake, see flake.nix on GitHub or run cat flake.nix. What you see here is a derivation that defines how to build the package, more specifically the buildPythonApplication function, which is a wrapper around Nix’s built-in derivation function.

The resulting package is an executable that prints to the terminal. To run the package:

./result/bin/zero-to-nix-python

You should see this terminal output:

Hello from inside a Python program built with Nix!

Here’s the package definition that enables us to build this Go package:

{
  packages = forAllSystems ({ pkgs }: {
    default = pkgs.buildGoModule {
      name = "zero-to-nix-go";
      src = self;
      vendorHash = "sha256-Ay1/QqbO2MyYgqJZKxrt1FZzLSgXbhSK3ceFPUlFujw=";
      goSum = ./go.sum;
      subPackages = [ "cmd/zero-to-nix-go" ];
    };
  });
}

For the full flake, see flake.nix on GitHub or run cat flake.nix. What you see here is a derivation that defines how to build the package, more specifically the buildGoModule function, which is a wrapper around Nix’s built-in derivation function.

The package that results when you run nix build is a web server built using the Gin framework. To run the package:

./result/bin/zero-to-nix-go

In another window, run curl http://localhost:8080 to receive a message from the server.

Here’s the package definition that enables us to build this Rust package:

{
  packages = forAllSystems ({ pkgs }: {
    default =
      let
        rustPlatform = pkgs.makeRustPlatform {
          cargo = pkgs.rustToolchain;
          rustc = pkgs.rustToolchain;
        };
      in
      rustPlatform.buildRustPackage {
        name = "zero-to-nix-rust";
        src = ./.;
        cargoLock = {
          lockFile = ./Cargo.lock;
        };
      };
  });
}

For the full flake, see flake.nix on GitHub or run cat flake.nix. What you see here is a derivation that defines how to build the package, more specifically the buildRustPackage function, which is a wrapper around Nix’s built-in derivation function.

To run the resulting package, which is an executable that prints to the terminal:

./result/bin/zero-to-nix-rust

You should see this terminal output:

Hello from Nix + Rust!

We’re not gonna lie to you: packaging Scala is pretty tricky. Fortunately, there’s a third-party project called sbt-derivation that provides some nice helpers, including a handy function called mkSbtDerivation, which is a wrapper around Nix’s built-in derivation function.

For the full flake behind this package, see flake.nix on GitHub or run cat flake.nix. To run the resulting package, which is an executable that prints to the terminal:

./result/bin/zero-to-nix-scala

You should see this terminal output:

Hello from Nix + Scala!