The target system platform for which the derivation is built, specifying architecture and operating system.
The system platform (e.g., x86_64-linux)
system
Relates a flake to its lock file that specifies exact input versions.
Links a flake to its lock file
has flake lock
A functional programming construct in the Nix language that takes arguments and returns values, used for creating reusable and parameterizable expressions.
A function in the Nix expression language
Nix Function
A named snapshot of the Nix package collection that provides a stable set of package versions for reproducible installations.
A Nix channel providing a snapshot of packages
Nix Channel
The Go module dependencies and their versions as specified in go.mod files.
Go module dependencies
Go modules
A lock file that records the exact versions and hashes of all flake inputs to ensure reproducible builds across different environments.
A lock file specifying exact versions of flake inputs
Flake Lock
64-bit Linux system
A flag indicating whether pre-built binary substitutes can be used instead of building from source.
Whether to allow binary substitutes
allow substitutes
A specialized Nix derivation builder for Python packages that handles Python dependencies and creates reusable Python libraries.
A derivation for building Python packages
buildPythonPackage
Command-line arguments passed to the builder program when executing the build process.
Arguments passed to the builder
builder arguments
A flag indicating whether the derivation should preferentially be built locally rather than using remote builders.
Whether to prefer building locally
prefer local build
The cryptographic hash component that uniquely identifies a store path.
The hash component of a store path
store path hash
Relates a package set to overlays that modify or extend it.
Links a package set to its overlays
has overlay
Shell commands executed before the configure phase to prepare for configuration.
Commands run before configuring
pre configure
The cryptographic hash of the Nix Archive (NAR) representation of the store path contents.
The hash of the Nix archive (NAR)
NAR hash
Shell commands executed during the configure phase to prepare the build environment and configure the software.
Commands run during the configure phase
configure phase
The main repository containing the Nix package collection with thousands of software packages and their build expressions.
The Nix package collection repository
Nixpkgs
The SHA256 hash of the Cargo dependencies directory for Rust packages.
SHA256 of the Cargo dependencies
Cargo SHA256
The mode for computing the output hash, either 'flat' for single files or 'recursive' for directory trees.
The mode for output hashing (flat or recursive)
output hash mode
A function that takes a package set and returns a modified version, used to add new packages or override existing ones without modifying the original package set.
A function that extends or modifies package sets
Nix Overlay
A specialized Nix derivation builder for Go modules that handles Go module dependencies and builds Go applications or libraries.
A derivation for building Go modules
buildGoModule
The SHA256 hash of the Go vendor directory containing all dependencies.
SHA256 of the Go vendor directory
vendor SHA256
An external dependency or input that the flake depends on, such as other flakes or repositories.
An input dependency of the flake
flake input
Dependencies that are only needed during the check phase for running tests.
Dependencies needed only for testing
check inputs
Relates a derivation to its corresponding path in the Nix store.
Links a derivation to its store path
has store path
The Nix extension models the purely functional Nix package management ecosystem. It captures Nix derivations, store paths, flakes, build phases (configure, build, install, check), and language-specific builders (stdenv.mkDerivation, buildPythonPackage, buildGoModule). The ontology represents Nix's content-addressable store and reproducible build model.
A comprehensive ontology for modeling Nix packages, derivations, expressions, flakes, and the Nix package management ecosystem including store paths, build phases, and language-specific builders.
Ontology for representing Nix packages, derivations, and expressions
Nix Package Ontology
The version string of a package, indicating the specific release or revision of the software.
The version of the package
package version
The executable program or script that performs the actual build process for the derivation.
The program that builds the derivation
builder
The SHA1 cryptographic hash of the source files, used for integrity verification.
The SHA1 hash of the source
SHA1 hash
Shell commands executed after the configure phase to perform post-configuration tasks.
Commands run after configuring
post configure
A reusable configuration component in NixOS that defines system services, options, and their implementations in a modular way.
A module for configuring NixOS
NixOS Module
The expected cryptographic hash of the derivation's output, used for fixed-output derivations.
The hash of the derivation output
output hash
The full name of a Nix derivation, typically combining the package name and version.
The name of the derivation
derivation name
A piece of code written in the Nix functional programming language that can be evaluated to produce derivations or other values.
A Nix language expression that evaluates to a derivation
Nix Expression
Relates a derivation to the inputs required for its build process.
Links a derivation to its build inputs
has input
Build-time dependencies that are automatically made available to packages that depend on this one.
Native build dependencies propagated to dependents
propagated native build inputs
A flag indicating whether the build phase should be skipped.
Whether to skip the build phase
don't build
A specialized Nix derivation builder for Rust packages that handles Cargo dependencies and builds Rust applications or libraries.
A derivation for building Rust packages
buildRustPackage
A specialized Nix derivation builder for Node.js packages that handles NPM dependencies and builds JavaScript applications or libraries.
A derivation for building NPM packages
buildNpmPackage
The unstable NixOS channel
nixos-unstable
Shell commands executed during the install phase to install the built software into the output directory.
Commands run during the install phase
install phase
The standard Nix derivation builder that provides a common build environment with typical build phases and utilities for most software packages.
A derivation built using the standard environment
stdenv.mkDerivation
A named output provided by the flake, such as packages, apps, or development shells.
An output provided by the flake
flake output
ARM64 macOS system
aarch64-darwin
Dependencies that are needed for running installation verification tests.
Dependencies needed for install checks
install check inputs
Shell commands executed after the install phase to perform additional installation tasks.
Commands run after installation
post install
A specification in the Nix language that describes how to build a software package, including its dependencies, build instructions, and metadata.
A Nix derivation describing how to build a package
Nix Derivation
A flag indicating whether the check phase should be executed to run tests.
Whether to run the check phase
do check
A flag indicating whether the install phase should be skipped.
Whether to skip the install phase
don't install
A specialized Nix derivation builder for Python applications that handles Python dependencies and creates standalone executable applications.
A derivation for building Python applications
buildPythonApplication
Build-time dependencies that run on the build platform and are used during compilation. This maps to the core build-time dependency concept.
Build-time dependencies for the build platform. In Nix, these are dependencies that run on the build host.
native build inputs
Shell commands executed during the check phase to run tests and verify the build.
Commands run during the check phase
check phase
Runtime dependencies that are automatically made available to packages that depend on this one.
Dependencies propagated to dependents
propagated build inputs
Shell commands executed during the build phase to compile and build the software.
Commands run during the build phase
build phase
The size in bytes of the Nix Archive (NAR) representation of the store path.
The size of the Nix archive in bytes
NAR size
NixOS 23.11 stable channel
nixos-23.11
A Linux distribution built on top of the Nix package manager that allows declarative system configuration and atomic upgrades.
The NixOS operating system configuration
NixOS
The human-readable name component of a store path, typically including package name and version.
The name component of a store path
store path name
The cryptographic hash of the NPM dependencies for Node.js packages.
Hash of NPM dependencies
NPM dependencies hash
A Nix-based tool for declaratively managing user-specific packages, dotfiles, and configurations in a reproducible manner.
A tool for managing user environments with Nix
Home Manager
A dependency or resource required during the build process of a Nix derivation, including libraries, tools, or other packages.
An input to the build process
Build Input
64-bit macOS system
Runtime dependencies that are needed when the built package is executed. This maps to the general concept of a runtime dependency in the core ontology.
Runtime dependencies available to the package. In Nix, these are dependencies for the target platform.
build inputs
A unique path in the Nix store identified by a cryptographic hash that contains the result of building a derivation or other store objects.
A path in the Nix store
Store Path
The URL location from which the source code or archive can be downloaded.
The URL where the source can be downloaded
source URL
The Cargo.lock file content or path that specifies exact versions of Rust dependencies.
Cargo.lock file content or path
Cargo lock
Relates a Nix expression to the derivation that results from evaluating that expression.
Links a Nix expression to the derivation it evaluates to
evaluates to
Shell commands executed after the build phase to perform post-build processing.
Commands run after building
post build
A derivation that has been processed and stored in the Nix store with a unique hash-based path, ready for building or already built.
A derivation that has been instantiated in the Nix store
Store Derivation
The source code, archive, or files that serve as input for building the package.
The source code or files for the package
source
A self-contained Nix project with explicitly declared inputs and outputs that provides reproducible builds and dependency management.
A self-contained unit with reproducible dependencies
Nix Flake
ARM64 Linux system
aarch64-linux
The MD5 cryptographic hash of the source files, used for integrity verification.
The MD5 hash of the source
MD5 hash
The SHA256 cryptographic hash of the source files, used for integrity verification.
The SHA256 hash of the source
SHA256 hash
The unstable nixpkgs channel
nixpkgs-unstable
The cryptographic hash algorithm used to compute the output hash (e.g., sha256, sha1, md5).
The algorithm used for the output hash
output hash algorithm
A human-readable description of what the flake provides or does.
Description of the flake
flake description
The base name of a package without version information, used as the primary identifier for the software.
The package name part of the derivation
package name
Shell commands executed during the fixup phase to perform post-installation cleanup and adjustments.
Commands run during the fixup phase
fixup phase
Shell commands executed before the build phase to prepare for compilation.
Commands run before building
pre build