Post

A Beginner's Guide to the Nix Ecosystem

Posted
By Joseph Chao-Chung Kuo
9 min read
A Beginner's Guide to the Nix Ecosystem

Table of Contents

Introduction: What is Nix?

Welcome to the world of Nix! If you’re tired of the frustrations caused by traditional package managers or want a more reproducible and isolated environment for your projects, Nix is the solution.

At its core, Nix is a package manager and build system that provides a declarative way to define, build, and manage software packages and entire systems. Unlike traditional package managers, Nix ensures reproducibility, isolation, and immutability, making it a go-to choice for developers, system administrators, and anyone who values consistency.

The Nix ecosystem consists of several key components:

  • Nixpkgs: The core repository of all packages available in Nix.
  • nix-env: The tool used to manage packages at the user level.
  • nix-shell: A tool to create isolated, reproducible development environments.
  • NixOS: A Linux distribution that uses Nix to manage system configurations.
  • Nix Flakes: An experimental feature in Nix for versioned, self-contained environments and packages.

In this guide, we’ll explore these components, explain their use cases, and provide practical examples of how you can use them.

Installing Nix Tools

Before diving into the Nix ecosystem, you need to install the necessary tools. Here’s how to install them:

Installing Nix

To install Nix, you can follow the instructions on the official Nix Installation Guide.

For most users, the easiest way is to run:

1

sh <(curl -L https://nixos.org/nix/install)  # Install Nix

This will install the Nix package manager on your system.

Installing Nixpkgs

Nixpkgs is included with the Nix installation. You can access it via Nix commands like nix-env and nix-shell.

Installing NixOS

If you’re using NixOS, you’ll need to install the full operating system. You can follow the instructions on the NixOS Installation Guide.

If you’re not using NixOS but want to try it in a virtual machine or as a secondary system, you can use tools like VirtualBox or VMware to install it in a VM.

Installing Nix Flakes

Nix Flakes are an experimental feature. To enable them, use the following command after installing Nix:

1

nix --experimental-features 'flakes'  # Enable Nix Flakes

Nixpkgs: The Heart of Nix

What is nixpkgs?

Nixpkgs is a collection of Nix expressions that define how software packages are built, configured, and installed. It’s essentially a repository of all the software available for Nix, providing everything from common programming languages to entire software stacks.

In Nix, everything is built using these Nix expressions, which are simple and powerful configurations that allow for declarative package management.

Use Cases & Example

You can use Nixpkgs to install and manage software packages in a way that ensures consistency across environments. Whether you’re on macOS, Linux, or another supported platform, you can install software from Nixpkgs and rest assured that it will behave the same way every time.

Example: Installing a package from Nixpkgs

1

nix-env -iA nixpkgs.hello  # Install the 'hello' package from Nixpkgs

Explanation

  • nix-env: This is the command used for managing user-level packages. It works with the nixpkgs repository to install, remove, and upgrade software.
  • nixpkgs: It’s a huge collection of Nix expressions that describe how to build and configure software packages.

nix-env: Managing Packages in User Environments

What is nix-env?

nix-env is the primary tool for managing software packages on a user level. It allows you to install, remove, and upgrade packages easily, all while ensuring that the installed packages are isolated and reproducible.

Use Cases & Example

Installing a package:

1

nix-env -iA nixpkgs.git  # Install Git

Listing installed packages:

1

nix-env -q  # List installed packages

Uninstalling a package:

1

nix-env -e git  # Uninstall Git

Managing profiles:

1

nix-env -p /path/to/profile  # Switch to a specific profile

Explanation

  • Install, List, and Uninstall: You can easily install, list, and remove packages in your environment with nix-env.
  • Profiles: With Nix, you can manage multiple profiles for different environments, ensuring that each environment has its own isolated set of packages.

nix-shell: Isolated Development Environments

What is nix-shell?

nix-shell is an incredibly powerful tool that allows you to create isolated development environments with all the necessary dependencies for your project. It ensures that your development environment is consistent across different systems.

Use Cases & Example

Let’s say you’re working on a Python project, and you need a specific set of dependencies. You can define a shell.nix file, which Nix will use to create an environment with those dependencies.

Example: Running nix-shell with Python:

1

nix-shell -p python3  # Start a shell with Python 3 installed

Creating a custom environment with a shell.nix file:

1
2
3
4
5

# shell.nix for a Python project
{ pkgs ? import <nixpkgs> {} }:
pkgs.mkShell {
  buildInputs = [ pkgs.python3 pkgs.python3Packages.numpy ];
}

Running the environment:

1

nix-shell  # Enter the environment defined in shell.nix

Explanation

  • Isolation: nix-shell ensures that your development environment is isolated from the rest of your system.
  • Reproducibility: Using shell.nix, you can define exactly what packages and dependencies your project requires, ensuring that the environment is the same every time you enter it.
  • Customization: You can customize the shell.nix file to install any dependencies, including compilers, libraries, or even specific versions of languages.

NixOS: Declarative System Configuration

What is NixOS?

NixOS is a Linux distribution that uses the Nix package manager to manage the entire system configuration. Unlike traditional Linux distributions, NixOS uses declarative configurations, which means you describe your system’s setup in configuration files, and NixOS ensures that the system matches the desired state.

Use Cases & Example

With NixOS, you can define your entire system’s environment, including software, services, users, and more, in a single configuration file. This makes it easy to reproduce setups across machines.

Example: NixOS system configuration (/etc/nixos/configuration.nix):

1
2
3
4
5

{ config, pkgs, ... }:
{
  environment.systemPackages = with pkgs; [ vim git ];
  services.openssh.enable = true;
}

Applying the configuration:

1

sudo nixos-rebuild switch  # Apply the configuration changes

Explanation

  • Declarative Configuration: In NixOS, everything is managed declaratively through the configuration file. You specify what software and services you want, and NixOS ensures it’s all configured correctly.
  • Reproducibility: Because the entire system is defined in configuration files, you can easily recreate your setup on any machine.

Nix Flakes: The Future of Nix

What are Nix Flakes?

Nix Flakes are an experimental feature in Nix that allow you to create versioned, self-contained packages and environments. They simplify dependency management, improve reproducibility, and provide a more standardized way of working with Nix.

Use Cases & Example

Flakes make it easier to manage complex dependencies and set up reproducible environments. They can be used in projects to define exactly how the project and its dependencies should be built and run.

Example: Running a flake from GitHub:

1

nix run github:nixos/nixpkgs  # Run the Nixpkgs project from a flake

Example flake.nix:

1
2
3
4
5
6
7

{
  description = "My Nix project";
  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-21.05";
  outputs = { self, nixpkgs, ... }: {
    packages.x86_64-linux.myApp = nixpkgs.legacyPackages.x86_64-linux.callPackage ./myApp.nix { };
  };
}

Explanation

  • Flakes: Flakes simplify the process of defining reproducible environments and managing dependencies in a versioned, self-contained way.
  • Versioning: With flakes, you can ensure that your projects are always using specific versions of dependencies, making them more stable and predictable.

Comparison: Nix vs Conda, Pixi, and Docker

While Nix offers powerful features, you might be wondering how it compares to other tools like Conda, Pixi, or Docker. Here’s a comparison:

  • Nix vs Conda: Both Nix and Conda allow you to create isolated environments, but Nix is more general-purpose, working not just for Python or data science environments but for system-wide package management. Conda is a great tool for Python and R environments, while Nix is much more flexible and powerful, offering a complete package management system for any language or software.

  • Nix vs Pixi: Pixi is a tool for containerized environments, similar to Docker. Nix offers more control over the environment and package management, with a focus on reproducibility. Pixi focuses on isolating applications into containers, while Nix isolates dependencies at a finer granularity.

  • Nix vs Docker: Docker is often used for packaging applications and running them in isolated containers. While Docker excels at isolating the entire environment and application, Nix works at a deeper level by allowing you to manage the entire system configuration declaratively. Nix offers better reproducibility and isolation in terms of dependencies, while Docker is better for application deployment.

Bringing it All Together: A Practical Workflow

Now that we’ve covered the basics of Nix, let’s see how everything fits together in a real-world workflow.

  1. Install a package using nix-env:
1

nix-env -iA nixpkgs.python3
  1. Create a shell.nix file for a project:
1
2
3
4

{ pkgs ? import <nixpkgs> {} }:
pkgs.mkShell {
  buildInputs = [ pkgs.python3 pkgs.python3Packages.numpy ];
}
  1. Run the environment with nix-shell:
1

nix-shell  # Enter the environment
  1. Define a project’s environment using a flake.nix file:
1
2
3
4
5
6
7

{
  description = "Python Project with Numpy";
  inputs.nixpkgs.url = "github:nixos/nixpkgs/nixos-21.05";
  outputs = { self, nixpkgs, ... }: {
    packages.x86_64-linux.myApp = nixpkgs.legacyPackages.x86_64-linux.callPackage ./myApp.nix { };
  };
}

Conclusion and Useful Resources

Congratulations! You’ve learned the basics of the Nix ecosystem and how to start using it to manage your development environments and system configurations. With tools like nix-env, nix-shell, and NixOS, you can create reproducible, isolated environments that make your development process smoother and more consistent.

Useful Resources:

Useful Tips:

  • Start small: Begin with nix-env to manage user-level packages, then gradually explore more advanced tools like nix-shell and NixOS.
  • Don’t be afraid to experiment with nix-shell and flake.nix to define custom environments for different projects.

Happy Nixing!

IT, package management
nix
This post is licensed under CC BY 4.0 by the author.