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