Nix – A Powerful Package Manager For Linux And Unix

Nix is a unique, powerful package manager and build system that takes a unique approach to managing software packages and builds on Linux and other Unix-like operating systems.

Unlike other package managers, Nix provides the ability to install multiple versions of the same package side-by-side, offers atomic upgrades and rollbacks, supports per-user package management, and facilitates easy setup of package development environments, among many other features.

The Nix package manager was originally developed for NixOS, a GNU/Linux distribution that takes a unique approach to package and configuration management. NixOS was initially started as a research project by Eelco Dolstra in 2003.

Nix is particularly popular in the scientific and research communities, where reproducibility and reliable builds are essential.

It is also gaining traction in other areas, such as DevOps and cloud infrastructure management, due to its powerful features and unique approach to package management.

Features

Nix package manager is completely different from the traditional Linux package managers in-terms of functionality and features.

Here are some key points about Nix package manager:

1. Pure Functional Build Model

Nix builds packages in isolated environments, ensuring that builds are reproducible and not affected by the host system's configuration. This is achieved through the use of a purely functional build model.

2. Nix Store

Packages are stored in the Nix store, which is a folder (/nix/store) containing all the packages and their dependencies. Each package has a unique cryptographic hash as its file name, ensuring that different versions of packages can coexist without conflicts.

3. Nix Expressions

Packages are defined using a domain-specific language called the Nix Expression Language, which is a lazy, purely functional language. Nix expressions describe how to build packages from source code.

4. Declarative Approach

Nix takes a declarative approach to package management, where you specify the desired state of your system, and Nix ensures that the system is brought to that state.

5. Reproducible Builds

Due to the pure functional model and isolated builds, Nix can guarantee reproducible builds, meaning that building the same package on different machines at different times will produce bit-for-bit identical results.

6. Atomic Upgrades and Rollbacks

Nix supports atomic upgrades and rollbacks, allowing you to switch between different versions of packages or the entire system with ease.

7. Nix Channels

Nix channels are a way to distribute collections of Nix expressions, enabling easy updates and sharing of packages across different systems.

8. Nixpkgs

Nixpkgs (pronounced "Nix packages") is a vast collection of Nix expressions, software packages, and build utilities that form the foundation of the Nix ecosystem.

Often referred to as the "Nix standard library" (or Nix stdlib), Nixpkgs is a single repository (mono repo) housing over 80,000 package definitions along with the tools needed to manage them.

It also includes modules for NixOS and all the necessary components to build and deploy a complete Nix system. Many tools within the Nix ecosystem rely on this standard library for their functionality.

9. NixOS

NixOS is a Linux distribution built on top of the Nix package manager, taking the declarative approach to system configuration and package management to the next level.

10. NixOps

NixOps is a tool for deploying NixOS machines in a network or cloud environment, using the same declarative approach as NixOS itself.

11. Multi-user Environments

Nix supports multi-user package management, allowing multiple users on the same system to install and manage packages without interfering with each other. This feature is particularly useful in shared or development environments.

12. Isolation and Sandboxing

By isolating dependencies and building packages in sandboxes, Nix prevents side effects between package builds and runtime environments.

This isolation improves security and reduces the chances of "dependency hell," where conflicting dependencies cause packages to fail.

13. Immutable Packages

Packages in Nix are stored in an immutable store, typically found at /nix/store. Each package has a unique path that includes a hash of all inputs that went into building it.

This design prevents conflicts between packages and allows multiple versions of a package to coexist on the same system without interference.

Nix Expression Language

The Nix expression language is a domain-specific, purely functional language used primarily for package management in the Nix ecosystem. Here are some key characteristics of the language:

• Purely Functional: Operations in the Nix language are pure, meaning they do not have side effects. This ensures that Nix expressions can be reliably reproduced.
• Lazy Evaluation: Nix evaluates expressions lazily, computing values only when they are needed. This can improve performance and allows for more complex expressions.
• Dynamic Typing: The language is dynamically typed, which means that types are checked at runtime rather than at compile-time.
• Built-in Functions: It includes built-in functions specifically designed to interact with the Nix store, which is the underlying system that manages files and packages.
• String Interpolation: Nix supports string interpolation, allowing variables to be embedded within strings easily.
• Derivations: A core concept in Nix is the idea of derivations, which are precise descriptions of how to build a package from source code.

Example:

Nix expressions are written in the Nix expression language, which is a purely functional, domain-specific language used to describe how packages should be built and composed. Here's a simple Nix expression that defines a package called hello:

with import <nixpkgs> {};

stdenv.mkDerivation {
  name = "hello";
  src = fetchFromGitHub {
    owner = "example";
    repo = "hello";
    rev = "0.1.0";
    sha256 = "0000000000000000000000000000000000000000000000000000";
  };
  buildInputs = [ gcc ];
}

Let's break this code down and see what each option does:

1. with import <nixpkgs> {};: This line imports the Nixpkgs collection of packages, which is a set of Nix expressions that define a large number of packages.
2. stdenv.mkDerivation { ... }: This is a function provided by the standard environment (stdenv) that creates a derivation, which is a recipe for building a package. It takes a set of attributes as arguments.
3. name = "hello";: This sets the name of the package to "hello".
4. src = fetchFromGitHub { ... };: This specifies the source code for the package, which is fetched from a GitHub repository. The fetchFromGitHub function is provided by Nixpkgs, and takes arguments like the owner, repository name, revision (commit hash or tag), and a SHA256 hash of the source code for verification.
5. buildInputs = [ gcc ];: This specifies the dependencies required to build the package, in this case, the GNU Compiler Collection (GCC).

When you evaluate this Nix expression using the nix-build command, Nix will fetch the source code from GitHub, create a isolated build environment with the specified dependencies (GCC), and build the package according to its build instructions (not shown in this example).

Nix expressions can be much more complex, defining multiple packages, setting environment variables, patching source code, and more.

The key aspects are the declarative nature of the expressions, the use of functions and attributes to define packages, and the ability to compose and override existing package definitions.

For those interested in learning more about writing Nix expressions, the NixOS manual and various online resources like nix.dev provide comprehensive guides and tutorials.

Infographic for Nix Package Manager

If you're a visual guy, here is a simple infographic for Nix. You can use this as reference manual for Nix. Feel free to download it and keep it near your system.

Install Nix in Linux

The good thing about Nix is it is an universal package manager. So, you don't need to be on a NixOS to use it. You can install and use Nix package manager on any Linux system of your choice.

To learn how to install Nix in Linux, refer the following guide:

• How to Install Nix Package Manager in Linux

Getting Started with Nix

The following tutorial explains how to use Nix package manager to perform day-to-day general package management operations such as installing, removing, updating, upgrading, and building packages.

• Getting Started With Nix Package Manager

Frequently Asked Questions

Here's a FAQ (Frequently Asked Questions) for the Nix package manager to help you get a better understanding of its capabilities and usage:

Conclusion

Nix offers a straightforward and efficient way to handle software on Linux and Unix systems. It removes the usual headaches of software conflicts and updates, ensuring that your computer runs smoothly.

With Nix, you can easily manage different versions of software and undo updates if needed. It's a reliable tool for both personal use and professional projects, helping everyone work with the same software environment.

Whether you're a developer, a system administrator, or just someone who uses a computer, Nix can make your life easier and your work more productive.

Resource:

• Nix Website

Related Read:

• Linuxbrew – A Common Package Manager For Linux And Mac OS X