Nix Package Operations

Nix Package Operations encompass the set of commands and procedures used to manage software packages within the Nix package manager ecosystem. These operations include installing, upgrading, removing, querying, and maintaining packages in a purely functional manner. Unlike traditional package managers, Nix ensures reproducibility and isolation by storing packages in unique paths based on their exact build dependencies and configurations. This approach allows multiple versions of the same package to coexist without conflict.

Package Installation and Upgrading

Installing Packages

Installing a package in Nix is done using the nix-env command or through Nix Flakes and Nix profiles. The core command for installation is:

nix-env -iA nixpkgs.<package-name>

This command installs a specified package from the Nix Packages collection (nixpkgs). Nix downloads the package derivation, builds it if necessary, and places it in the Nix store. The environment profile is then updated to include the binaries and resources of the installed package.

Upgrading Packages

To upgrade packages, the user updates the package list and upgrades installed packages using:

nix-env -u

This command upgrades all installed packages to their latest available versions from the channels currently configured. It recalculates the dependencies and updates references in the user profile.

Package Removal and Rollback

Removing Packages

Packages can be uninstalled from a user profile by:

nix-env -e <package-name>

This removes the package from the user’s environment profile but does not delete the package from the Nix store if other profiles or derivations use it. The Nix store’s garbage collector manages unreferenced packages.

Rollback to Previous Generations

Nix tracks all profile generations, enabling users to rollback to a previous state if an upgrade or installation causes issues. To list generations:

nix-env --list-generations

To rollback:

nix-env --rollback

This switches the user environment back to the previous generation, restoring the prior set of installed packages seamlessly.

Querying and Searching Packages

Searching for Packages

Nix provides powerful search capabilities to find packages by name or attribute:

nix-env -qaP '<search-term>'

• -q queries available packages
• -a includes all packages
• -P shows attribute names

This helps users identify the exact package attribute path for installation.

Inspecting Package Information

To inspect detailed information about a package, including version, dependencies, and build instructions:

nix-env -qaP --description <package-name>

or by querying the store with:

nix-store -q --requisites /nix/store/<hash>-<package-name>

This reveals the closure of dependencies.

Building and Rebuilding Packages

Building Packages from Source

Nix can build packages from source using the derivation files (.drv), which specify build instructions and dependencies. To build a package directly:

nix-build '<nixpkgs>' -A <package-name>

This command downloads, builds, and stores the package, returning the path in the Nix store to the built result.

Rebuilding Packages

Users can rebuild packages to apply patches, change build flags, or update dependencies by modifying the Nix expression and running nix-build accordingly. This supports reproducible builds by ensuring builds are deterministic and isolated.

Profiles and Environments

Managing User Profiles

Nix manages multiple user profiles, which are independent collections of installed packages. Each profile tracks generations, allowing for isolated environments per project or user.

Using Nix Shell for Temporary Environments

nix-shell creates ephemeral environments with specific package dependencies without installing them permanently:

nix-shell -p <package-name1> <package-name2>

This is useful for development and testing, as it launches a shell with the requested packages available for the session.

Garbage Collection and Store Maintenance

Garbage Collection

Since Nix stores all packages immutably with unique hashes, unreferenced packages accumulate over time. To clean up unused packages safely, the garbage collector is run:

nix-collect-garbage

or to aggressively delete all unreferenced packages:

nix-collect-garbage -d

This frees disk space by removing store paths not referenced by any profile or system configuration.

Verifying Store Integrity

To verify the integrity and consistency of the Nix store, the command:

nix-store --verify --check-contents

can be run. This checks if the stored packages match their expected cryptographic hashes and rebuilds or flags inconsistencies as needed.

Advanced Package Operations

Pinning Package Versions

Nix allows pinning specific versions of packages to guarantee reproducible environments by locking the version of nixpkgs or package attributes used. This is typically done by specifying commit hashes or versions in Nix expressions or flakes.

Creating Custom Packages

Users can create custom packages by writing Nix expressions that describe the build phases, sources, and dependencies. These expressions can be imported into profiles or used with nix-build for custom workflows.

Binary Caches and Substitutes

Nix supports binary caches to store pre-built packages, allowing faster installation by downloading binaries instead of building from source. Users can manage and configure these caches to optimize package operations in large environments.

Summary of Key Commands

Nix Package Operations provide a robust, atomic, and reproducible way to handle software packages, leveraging the unique functional package management approach of Nix. This ensures environments are isolated, upgrades are safe, and rollbacks are straightforward, supporting advanced use in development, deployment, and system maintenance.