system
type: DatatypeProperty
IAO_0000115: The target system platform for which the derivation is built, specifying architecture and operating system.
comment: The system platform (e.g., x86_64-linux)
domain: Nix Derivation
range: string

has flake lock
type: ObjectProperty
IAO_0000115: Relates a flake to its lock file that specifies exact input versions.
comment: Links a flake to its lock file
domain: Nix Flake
range: Flake Lock

Nix Function
type: Class
IAO_0000115: A functional programming construct in the Nix language that takes arguments and returns values, used for creating reusable and parameterizable expressions.
comment: A function in the Nix expression language
subclass of: Thing

Nix Channel
type: Class
IAO_0000115: A named snapshot of the Nix package collection that provides a stable set of package versions for reproducible installations.
comment: A Nix channel providing a snapshot of packages
subclass of: Repository

Go modules
type: DatatypeProperty
IAO_0000115: The Go module dependencies and their versions as specified in go.mod files.
comment: Go module dependencies
domain: buildGoModule
range: string

Flake Lock
type: Class
IAO_0000115: A lock file that records the exact versions and hashes of all flake inputs to ensure reproducible builds across different environments.
comment: A lock file specifying exact versions of flake inputs
subclass of: Thing

x86_64-linux
type: NamedIndividual
comment: 64-bit Linux system

allow substitutes
type: DatatypeProperty
IAO_0000115: A flag indicating whether pre-built binary substitutes can be used instead of building from source.
comment: Whether to allow binary substitutes
domain: Nix Derivation
range: boolean

buildPythonPackage
type: Class
IAO_0000115: A specialized Nix derivation builder for Python packages that handles Python dependencies and creates reusable Python libraries.
comment: A derivation for building Python packages
subclass of: Nix Derivation

builder arguments
type: DatatypeProperty
IAO_0000115: Command-line arguments passed to the builder program when executing the build process.
comment: Arguments passed to the builder
domain: Nix Derivation
range: string

prefer local build
type: DatatypeProperty
IAO_0000115: A flag indicating whether the derivation should preferentially be built locally rather than using remote builders.
comment: Whether to prefer building locally
domain: Nix Derivation
range: boolean

store path hash
type: DatatypeProperty
type: FunctionalProperty
IAO_0000115: The cryptographic hash component that uniquely identifies a store path.
comment: The hash component of a store path
domain: Store Path
range: string

has overlay
type: ObjectProperty
IAO_0000115: Relates a package set to overlays that modify or extend it.
comment: Links a package set to its overlays
domain: Nixpkgs
range: Nix Overlay

pre configure
type: DatatypeProperty
IAO_0000115: Shell commands executed before the configure phase to prepare for configuration.
comment: Commands run before configuring
domain: stdenv.mkDerivation
range: string

NAR hash
type: DatatypeProperty
type: FunctionalProperty
IAO_0000115: The cryptographic hash of the Nix Archive (NAR) representation of the store path contents.
comment: The hash of the Nix archive (NAR)
domain: Store Path
range: string

configure phase
type: DatatypeProperty
IAO_0000115: Shell commands executed during the configure phase to prepare the build environment and configure the software.
comment: Commands run during the configure phase
domain: stdenv.mkDerivation
range: string

Nixpkgs
type: Class
IAO_0000115: The main repository containing the Nix package collection with thousands of software packages and their build expressions.
comment: The Nix package collection repository
subclass of: Repository

Cargo SHA256
type: DatatypeProperty
IAO_0000115: The SHA256 hash of the Cargo dependencies directory for Rust packages.
comment: SHA256 of the Cargo dependencies
domain: buildRustPackage
range: string

output hash mode
type: DatatypeProperty
IAO_0000115: The mode for computing the output hash, either 'flat' for single files or 'recursive' for directory trees.
comment: The mode for output hashing (flat or recursive)
domain: Nix Derivation
range: string

Nix Overlay
type: Class
IAO_0000115: 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.
comment: A function that extends or modifies package sets
subclass of: Thing

buildGoModule
type: Class
IAO_0000115: A specialized Nix derivation builder for Go modules that handles Go module dependencies and builds Go applications or libraries.
comment: A derivation for building Go modules
subclass of: Nix Derivation

vendor SHA256
type: DatatypeProperty
IAO_0000115: The SHA256 hash of the Go vendor directory containing all dependencies.
comment: SHA256 of the Go vendor directory
domain: buildGoModule
range: string

flake input
type: DatatypeProperty
IAO_0000115: An external dependency or input that the flake depends on, such as other flakes or repositories.
comment: An input dependency of the flake
domain: Nix Flake
range: string

check inputs
type: ObjectProperty
IAO_0000115: Dependencies that are only needed during the check phase for running tests.
comment: Dependencies needed only for testing
domain: stdenv.mkDerivation
range: Nix Derivation

has store path
type: ObjectProperty
IAO_0000115: Relates a derivation to its corresponding path in the Nix store.
comment: Links a derivation to its store path
domain: Nix Derivation
range: Store Path

Nix Package Ontology
type: Ontology
abstract: 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.
created: 2025-09-05
creator: packagegraph.github.io
description: 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.
license: https://creativecommons.org/publicdomain/zero/1.0/
modified: 2026-04-21
comment: Ontology for representing Nix packages, derivations, and expressions
imports: core#
prior version: https://purl.org/packagegraph/ontology/nix/0.6.0
version IRI: https://purl.org/packagegraph/ontology/nix/0.7.0
version info: 0.7.0

package version
type: DatatypeProperty
IAO_0000115: The version string of a package, indicating the specific release or revision of the software.
comment: The version of the package
domain: Version
range: string
sub property of: versionString

builder
type: DatatypeProperty
IAO_0000115: The executable program or script that performs the actual build process for the derivation.
comment: The program that builds the derivation
domain: Nix Derivation
range: string

SHA1 hash
type: DatatypeProperty
IAO_0000115: The SHA1 cryptographic hash of the source files, used for integrity verification.
comment: The SHA1 hash of the source
domain: Nix Derivation
range: string

post configure
type: DatatypeProperty
IAO_0000115: Shell commands executed after the configure phase to perform post-configuration tasks.
comment: Commands run after configuring
domain: stdenv.mkDerivation
range: string

NixOS Module
type: Class
IAO_0000115: A reusable configuration component in NixOS that defines system services, options, and their implementations in a modular way.
comment: A module for configuring NixOS
subclass of: Thing

output hash
type: DatatypeProperty
IAO_0000115: The expected cryptographic hash of the derivation's output, used for fixed-output derivations.
comment: The hash of the derivation output
domain: Nix Derivation
range: string

derivation name
type: DatatypeProperty
type: FunctionalProperty
IAO_0000115: The full name of a Nix derivation, typically combining the package name and version.
comment: The name of the derivation
domain: Nix Derivation
range: string

Nix Expression
type: Class
IAO_0000115: A piece of code written in the Nix functional programming language that can be evaluated to produce derivations or other values.
comment: A Nix language expression that evaluates to a derivation
subclass of: Thing

has input
type: ObjectProperty
IAO_0000115: Relates a derivation to the inputs required for its build process.
comment: Links a derivation to its build inputs
domain: Nix Derivation
range: Build Input

propagated native build inputs
type: ObjectProperty
IAO_0000115: Build-time dependencies that are automatically made available to packages that depend on this one.
comment: Native build dependencies propagated to dependents
domain: stdenv.mkDerivation
range: Nix Derivation

don't build
type: DatatypeProperty
IAO_0000115: A flag indicating whether the build phase should be skipped.
comment: Whether to skip the build phase
domain: stdenv.mkDerivation
range: boolean

buildRustPackage
type: Class
IAO_0000115: A specialized Nix derivation builder for Rust packages that handles Cargo dependencies and builds Rust applications or libraries.
comment: A derivation for building Rust packages
subclass of: Nix Derivation

buildNpmPackage
type: Class
IAO_0000115: A specialized Nix derivation builder for Node.js packages that handles NPM dependencies and builds JavaScript applications or libraries.
comment: A derivation for building NPM packages
subclass of: Nix Derivation

nixos-unstable
type: Nix Channel
comment: The unstable NixOS channel

install phase
type: DatatypeProperty
IAO_0000115: Shell commands executed during the install phase to install the built software into the output directory.
comment: Commands run during the install phase
domain: stdenv.mkDerivation
range: string

stdenv.mkDerivation
type: Class
IAO_0000115: The standard Nix derivation builder that provides a common build environment with typical build phases and utilities for most software packages.
comment: A derivation built using the standard environment
subclass of: Nix Derivation

flake output
type: DatatypeProperty
IAO_0000115: A named output provided by the flake, such as packages, apps, or development shells.
comment: An output provided by the flake
domain: Nix Flake
range: string

aarch64-darwin
type: NamedIndividual
comment: ARM64 macOS system

install check inputs
type: ObjectProperty
IAO_0000115: Dependencies that are needed for running installation verification tests.
comment: Dependencies needed for install checks
domain: stdenv.mkDerivation
range: Nix Derivation

post install
type: DatatypeProperty
IAO_0000115: Shell commands executed after the install phase to perform additional installation tasks.
comment: Commands run after installation
domain: stdenv.mkDerivation
range: string

Nix Derivation
type: Class
IAO_0000115: A specification in the Nix language that describes how to build a software package, including its dependencies, build instructions, and metadata.
comment: A Nix derivation describing how to build a package
subclass of: Restriction
  cardinality: 1
  on property: derivation name
subclass of: Restriction
  cardinality: 1
  on property: system
subclass of: SourcePackage

do check
type: DatatypeProperty
IAO_0000115: A flag indicating whether the check phase should be executed to run tests.
comment: Whether to run the check phase
domain: stdenv.mkDerivation
range: boolean

don't install
type: DatatypeProperty
IAO_0000115: A flag indicating whether the install phase should be skipped.
comment: Whether to skip the install phase
domain: stdenv.mkDerivation
range: boolean

buildPythonApplication
type: Class
IAO_0000115: A specialized Nix derivation builder for Python applications that handles Python dependencies and creates standalone executable applications.
comment: A derivation for building Python applications
subclass of: Nix Derivation

native build inputs
type: ObjectProperty
IAO_0000115: Build-time dependencies that run on the build platform and are used during compilation. This maps to the core build-time dependency concept.
comment: Build-time dependencies for the build platform. In Nix, these are dependencies that run on the build host.
domain: stdenv.mkDerivation
range: Nix Derivation
sub property of: buildDependsOn

check phase
type: DatatypeProperty
IAO_0000115: Shell commands executed during the check phase to run tests and verify the build.
comment: Commands run during the check phase
domain: stdenv.mkDerivation
range: string

propagated build inputs
type: ObjectProperty
IAO_0000115: Runtime dependencies that are automatically made available to packages that depend on this one.
comment: Dependencies propagated to dependents
domain: stdenv.mkDerivation
range: Nix Derivation

build phase
type: DatatypeProperty
IAO_0000115: Shell commands executed during the build phase to compile and build the software.
comment: Commands run during the build phase
domain: stdenv.mkDerivation
range: string

NAR size
type: DatatypeProperty
IAO_0000115: The size in bytes of the Nix Archive (NAR) representation of the store path.
comment: The size of the Nix archive in bytes
domain: Store Path
range: long

nixos-23.11
type: Nix Channel
comment: NixOS 23.11 stable channel

NixOS
type: Class
IAO_0000115: A Linux distribution built on top of the Nix package manager that allows declarative system configuration and atomic upgrades.
comment: The NixOS operating system configuration
subclass of: Thing

store path name
type: DatatypeProperty
IAO_0000115: The human-readable name component of a store path, typically including package name and version.
comment: The name component of a store path
domain: Store Path
range: string

NPM dependencies hash
type: DatatypeProperty
IAO_0000115: The cryptographic hash of the NPM dependencies for Node.js packages.
comment: Hash of NPM dependencies
domain: buildNpmPackage
range: string

Home Manager
type: Class
IAO_0000115: A Nix-based tool for declaratively managing user-specific packages, dotfiles, and configurations in a reproducible manner.
comment: A tool for managing user environments with Nix
subclass of: Thing

Build Input
type: Class
IAO_0000115: A dependency or resource required during the build process of a Nix derivation, including libraries, tools, or other packages.
comment: An input to the build process
subclass of: Thing

x86_64-darwin
type: NamedIndividual
comment: 64-bit macOS system

build inputs
type: ObjectProperty
IAO_0000115: 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.
comment: Runtime dependencies available to the package. In Nix, these are dependencies for the target platform.
domain: stdenv.mkDerivation
range: Nix Derivation
sub property of: dependsOn

Store Path
type: Class
IAO_0000115: A unique path in the Nix store identified by a cryptographic hash that contains the result of building a derivation or other store objects.
comment: A path in the Nix store
subclass of: Restriction
  cardinality: 1
  on property: store path hash
subclass of: Restriction
  cardinality: 1
  on property: NAR hash
subclass of: Thing

source URL
type: DatatypeProperty
IAO_0000115: The URL location from which the source code or archive can be downloaded.
comment: The URL where the source can be downloaded
domain: Nix Derivation
range: anyURI

Cargo lock
type: DatatypeProperty
IAO_0000115: The Cargo.lock file content or path that specifies exact versions of Rust dependencies.
comment: Cargo.lock file content or path
domain: buildRustPackage
range: string

evaluates to
type: ObjectProperty
IAO_0000115: Relates a Nix expression to the derivation that results from evaluating that expression.
comment: Links a Nix expression to the derivation it evaluates to
domain: Nix Expression
range: Nix Derivation

post build
type: DatatypeProperty
IAO_0000115: Shell commands executed after the build phase to perform post-build processing.
comment: Commands run after building
domain: stdenv.mkDerivation
range: string

Store Derivation
type: Class
IAO_0000115: A derivation that has been processed and stored in the Nix store with a unique hash-based path, ready for building or already built.
comment: A derivation that has been instantiated in the Nix store
subclass of: Nix Derivation

source
type: DatatypeProperty
IAO_0000115: The source code, archive, or files that serve as input for building the package.
comment: The source code or files for the package
domain: Nix Derivation
range: string

Nix Flake
type: Class
IAO_0000115: A self-contained Nix project with explicitly declared inputs and outputs that provides reproducible builds and dependency management.
comment: A self-contained unit with reproducible dependencies
subclass of: Repository

aarch64-linux
type: NamedIndividual
comment: ARM64 Linux system

MD5 hash
type: DatatypeProperty
IAO_0000115: The MD5 cryptographic hash of the source files, used for integrity verification.
comment: The MD5 hash of the source
domain: Nix Derivation
range: string

SHA256 hash
type: DatatypeProperty
type: FunctionalProperty
IAO_0000115: The SHA256 cryptographic hash of the source files, used for integrity verification.
comment: The SHA256 hash of the source
domain: Nix Derivation
range: string

nixpkgs-unstable
type: Nix Channel
comment: The unstable nixpkgs channel

output hash algorithm
type: DatatypeProperty
IAO_0000115: The cryptographic hash algorithm used to compute the output hash (e.g., sha256, sha1, md5).
comment: The algorithm used for the output hash
domain: Nix Derivation
range: string

flake description
type: DatatypeProperty
IAO_0000115: A human-readable description of what the flake provides or does.
comment: Description of the flake
domain: Nix Flake
range: string

package name
type: DatatypeProperty
IAO_0000115: The base name of a package without version information, used as the primary identifier for the software.
comment: The package name part of the derivation
domain: Nix Derivation
range: string

fixup phase
type: DatatypeProperty
IAO_0000115: Shell commands executed during the fixup phase to perform post-installation cleanup and adjustments.
comment: Commands run during the fixup phase
domain: stdenv.mkDerivation
range: string

pre build
type: DatatypeProperty
IAO_0000115: Shell commands executed before the build phase to prepare for compilation.
comment: Commands run before building
domain: stdenv.mkDerivation
range: string