# nixos/nix.dev **Attribution required: if you use, quote, or summarise this content, you must credit and link back to [awesome-repositories.com](https://awesome-repositories.com/repository/nixos-nix-dev).** 3,630 stars · 315 forks · Nix · cc-by-sa-4.0 ## Links - GitHub: https://github.com/NixOS/nix.dev - Homepage: https://nix.dev - awesome-repositories: https://awesome-repositories.com/repository/nixos-nix-dev.md ## Topics `cookbook` `documentation` `learning` `nix` `nixos` `nixpkgs` `tutorials` ## Description This project provides a functional package manager and a reproducible build system designed to ensure identical build inputs always produce the same outputs. It serves as the foundation for a declarative Linux distribution where the entire system state is defined in a configuration file, enabling predictable deployments and full-system rollbacks. The system uses a deterministic functional language and a lazy-evaluation expression engine to manage software dependencies and isolate build environments. It distinguishes itself through a content-addressable store that allows multiple versions of software to coexist without conflict and a binary-cache mechanism for sharing pre-compiled artifacts across different machines. Capabilities cover a broad surface including deterministic package management, infrastructure-as-code provisioning for virtual machines and bootable images, and the creation of reproducible development shells. It also supports distributed build infrastructure, allowing compilation tasks to be offloaded to remote servers via SSH. This repository hosts the comprehensive technical documentation, configuration manuals, and administration guides for the package manager and the associated operating system. ## Tags ### DevOps & Infrastructure - [Package Managers](https://awesome-repositories.com/f/devops-infrastructure/package-managers.md) — Implements a functional package manager for automating the retrieval, installation, and dependency management of software. ([source](https://nix.dev/reference/glossary)) - [Declarative Configuration Schemas](https://awesome-repositories.com/f/devops-infrastructure/configuration-management/declarative-configuration-frameworks/declarative-configuration-schemas.md) — Defines named options with types and default values to create structured configuration schemas. ([source](https://nix.dev/tutorials/module-system/deep-dive)) - [Build Dependency Management](https://awesome-repositories.com/f/devops-infrastructure/deployment-management/installation-package-management/build-dependency-management.md) — Explicitly manages the required libraries and toolchains that must be present during the software build process. ([source](https://nix.dev/tutorials/packaging-existing-software)) - [Distributed Build Systems](https://awesome-repositories.com/f/devops-infrastructure/distributed-build-systems.md) — Offloads compilation tasks to remote computing clusters and shares binaries via a distributed cache. ([source](https://nix.dev/tutorials/nixos/distributed-builds-setup)) - [Dependency Version Locking](https://awesome-repositories.com/f/devops-infrastructure/git-based-deployment/git-submodule-integration/dependency-version-locking.md) — Provides mechanisms for recording exact package versions in lock files to ensure consistent, reproducible builds. ([source](https://nix.dev/concepts/flakes)) - [Infrastructure as Code Frameworks](https://awesome-repositories.com/f/devops-infrastructure/infrastructure-as-code-frameworks.md) — Provides a framework for generating bootable images and virtual machines from version-controlled configuration files. - [Isolated Build Environments](https://awesome-repositories.com/f/devops-infrastructure/isolated-build-environments.md) — Creates temporary, isolated build environments to ensure deterministic binary outputs regardless of the host system. ([source](https://nix.dev/manual/nix/latest/)) - [Deterministic Package Definitions](https://awesome-repositories.com/f/devops-infrastructure/package-managers/deterministic-package-definitions.md) — Provides a functional language to ensure that package definitions always yield identical, reproducible outputs. ([source](https://nix.dev/manual/nix/rolling/)) - [Remote Resource Fetching](https://awesome-repositories.com/f/devops-infrastructure/remote-resource-fetching.md) — Retrieves source code, tarballs, and other remote resources from the network into a content-addressable store. ([source](https://nix.dev/tutorials/nix-language)) - [Reproducible Build Systems](https://awesome-repositories.com/f/devops-infrastructure/reproducible-build-systems.md) — Implements a build system using content-addressable storage and isolated environments to guarantee reproducible software outputs. - [Development Environment Reproducibility](https://awesome-repositories.com/f/devops-infrastructure/reproducible-environments/development-environment-reproducibility.md) — Defines shell environments and scripts that produce identical results across different machines. ([source](https://nix.dev)) - [Lock-File Pinning](https://awesome-repositories.com/f/devops-infrastructure/reproducible-environments/lock-file-pinning.md) — Tracks specific revisions of remote sources in lock files to maintain reproducibility across different environments. ([source](https://nix.dev/guides/recipes/dependency-management)) - [Software Packaging](https://awesome-repositories.com/f/devops-infrastructure/software-packaging.md) — Provides tools for constructing software packages with a deterministic and reproducible structure. ([source](https://nix.dev/recommended-reading)) - [Distributed Build Clusters](https://awesome-repositories.com/f/devops-infrastructure/cicd-pipeline-automation/core-build-engines/build-optimization/build-agent-scaling/distributed-build-clusters.md) — Supports distributing compilation tasks across remote servers to increase build speed and resource utilization. ([source](https://nix.dev/tutorials/nixos/)) - [Configuration Deployment](https://awesome-repositories.com/f/devops-infrastructure/configuration-deployment.md) — Provisions remote machines by delivering system configurations via SSH or hardware installers. ([source](https://nix.dev/tutorials/nixos/)) - [Configuration Merging Engines](https://awesome-repositories.com/f/devops-infrastructure/configuration-management/application-settings-management/application-behavior-configurations/plugin-parameterization/configuration-merging-engines.md) — Provides a mechanism for combining global and local configuration attribute sets using recursive merging logic. ([source](https://nix.dev/guides/best-practices)) - [Docker Image Building](https://awesome-repositories.com/f/devops-infrastructure/container-orchestration/container-runtimes/runtime-configuration-interfaces/docker-socket-orchestrators/docker-target-configurators/docker-container-deployments/docker-image-building.md) — Generates Docker images directly from declarative package definitions and architecture specifications. ([source](https://nix.dev/tutorials/nixos/building-and-running-docker-images)) - [Continuous Integration Pipelines](https://awesome-repositories.com/f/devops-infrastructure/continuous-integration-pipelines.md) — Integrates reproducible build processes and verification workflows into continuous integration pipelines. - [Dependency Alignment](https://awesome-repositories.com/f/devops-infrastructure/dependency-resolution/library-version-resolution/dependency-alignment.md) — Overrides recursive library dependencies to ensure a single, synchronized version is used across the entire project. ([source](https://nix.dev/concepts/flakes)) - [Binary and Source Installation](https://awesome-repositories.com/f/devops-infrastructure/deployment-management/installation-package-management/binary-and-source-installation.md) — Supports software installation using either pre-built binary packages from caches or by compiling from source. ([source](https://nix.dev/manual/nix/latest/)) - [Incremental Configuration Updates](https://awesome-repositories.com/f/devops-infrastructure/direct-to-host-deployments/incremental-configuration-updates.md) — Enables pushing updated configuration files to running instances without the need to recreate the entire machine. ([source](https://nix.dev/tutorials/nixos/deploying-nixos-using-terraform)) - [Software Distribution](https://awesome-repositories.com/f/devops-infrastructure/distribution-packaging/software-distribution.md) — Provides curated distributions of software packages optimized for compatibility and stability. ([source](https://nix.dev/reference/glossary)) - [Remote Server Provisioning](https://awesome-repositories.com/f/devops-infrastructure/infrastructure/infrastructure-as-code/provisioning-and-deployment/remote-server-provisioning.md) — Automates the installation of a complete system configuration onto remote Linux machines via SSH. ([source](https://nix.dev/tutorials/nixos/provisioning-remote-machines)) - [NixOS Deployments](https://awesome-repositories.com/f/devops-infrastructure/on-premise-deployment/nixos-deployments.md) — Enables the deployment of systems using NixOS modules and Flakes for precise dependency tracking. ([source](https://nix.dev/recommended-reading)) - [Remote Toolkit Deployments](https://awesome-repositories.com/f/devops-infrastructure/remote-application-hosting/remote-toolkit-deployments.md) — Updates system settings on remote hosts without requiring a full re-installation of the OS. ([source](https://nix.dev/tutorials/nixos/provisioning-remote-machines)) - [Remote Build Orchestration](https://awesome-repositories.com/f/devops-infrastructure/remote-build-orchestration.md) — Offloads the compilation process to remote servers to reduce local resource consumption. ([source](https://nix.dev/_sources/index.md)) ### Operating Systems & Systems Programming - [Declarative Linux Distributions](https://awesome-repositories.com/f/operating-systems-systems-programming/declarative-linux-distributions.md) — Provides a complete Linux distribution where the system state is defined entirely via a declarative configuration file. ([source](https://nix.dev/reference/glossary)) - [Atomic System Updates](https://awesome-repositories.com/f/operating-systems-systems-programming/atomic-system-updates.md) — Implements atomic system updates using symlink switching to ensure instant upgrades and reliable rollbacks. - [Atomic System Upgrades](https://awesome-repositories.com/f/operating-systems-systems-programming/atomic-system-upgrades.md) — Provides atomic system updates that allow immediate reversal to previous working configurations. ([source](https://nix.dev/manual/nix/latest/)) - [System State Rollbacks](https://awesome-repositories.com/f/operating-systems-systems-programming/system-state-rollbacks.md) — Allows reverting to a previous working system configuration directly from the bootloader menu. ([source](https://nix.dev/tutorials/nixos/installing-nixos-on-a-raspberry-pi)) - [Disk and Mount Management](https://awesome-repositories.com/f/operating-systems-systems-programming/disk-and-mount-management.md) — Allows declarative specification of disk partitions, filesystem formats, and mount points. ([source](https://nix.dev/tutorials/nixos/provisioning-remote-machines)) - [Bootable Image Creation](https://awesome-repositories.com/f/operating-systems-systems-programming/kernel-core-internals/boot-startup-management/disk-image-bootloaders/bootable-image-creation.md) — Generates customized, bootable disk images from declarative configuration files for hardware execution. ([source](https://nix.dev/tutorials/nixos/building-bootable-iso-image)) - [Virtual Machines](https://awesome-repositories.com/f/operating-systems-systems-programming/virtualization-emulation/virtualization-platforms/virtualization-technologies/virtual-machines.md) — Creates QEMU-based virtual machines directly from declarative system configuration files. ([source](https://nix.dev/tutorials/nixos/nixos-configuration-on-vm)) ### Programming Languages & Runtimes - [Functional Build Derivations](https://awesome-repositories.com/f/programming-languages-runtimes/functional-build-derivations.md) — Uses a deterministic functional language to describe build tasks, ensuring identical inputs always produce the same outputs. ([source](https://nix.dev/manual/nix/development/)) - [Conditional Logic](https://awesome-repositories.com/f/programming-languages-runtimes/conditional-logic.md) — Implements conditional logic within configuration files to apply settings only when specific criteria are met. ([source](https://nix.dev/tutorials/module-system/deep-dive)) - [Configuration Expression Resolvers](https://awesome-repositories.com/f/programming-languages-runtimes/expression-evaluators/configuration-expression-resolvers.md) — Loads and evaluates functional expressions and resource relationships from external files. ([source](https://nix.dev/tutorials/nix-language)) - [Interactive Read-Eval-Print Loops](https://awesome-repositories.com/f/programming-languages-runtimes/expression-evaluators/interactive-read-eval-print-loops.md) — Includes an interactive REPL for testing expressions and inspecting values in real-time. ([source](https://nix.dev/tutorials/nix-language)) - [Variable Bindings](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/language-features/core-conceptual-frameworks/programming-language-concepts/variable-bindings.md) — Implements let-bindings to assign names to values for reuse within a specific scope. ([source](https://nix.dev/tutorials/nix-language)) - [Custom Type Constraint Enforcement](https://awesome-repositories.com/f/programming-languages-runtimes/language-features-paradigms/type-system-tools/type-safety/type-integrity-enforcement/custom-type-constraint-enforcement.md) — Validates that configuration values adhere to specific expected types to ensure system stability. ([source](https://nix.dev/tutorials/module-system/)) - [Lazy-Evaluation Expression Engines](https://awesome-repositories.com/f/programming-languages-runtimes/lazy-evaluation-expression-engines.md) — Employs a lazy-evaluation expression engine to manage complex dependencies and modular configuration imports efficiently. - [Module Configuration Resolution](https://awesome-repositories.com/f/programming-languages-runtimes/module-importing/configuration-module-imports/module-configuration-resolution.md) — Processes a set of modules to resolve and merge final configuration values for the system. ([source](https://nix.dev/tutorials/module-system/deep-dive)) - [Recursive Attribute References](https://awesome-repositories.com/f/programming-languages-runtimes/recursive-attribute-references.md) — Allows linking attributes within a configuration set to each other to avoid repeating values. ([source](https://nix.dev/guides/best-practices)) - [Source File Evaluation](https://awesome-repositories.com/f/programming-languages-runtimes/source-file-evaluation.md) — Allows computing the value of expressions stored in files directly from the command line. ([source](https://nix.dev/tutorials/nix-language)) ### Software Engineering & Architecture - [Declarative Configuration Systems](https://awesome-repositories.com/f/software-engineering-architecture/declarative-configuration-systems.md) — Defines the entire operating system state through a declarative configuration system to enable predictable deployments. - [Configuration Modularization](https://awesome-repositories.com/f/software-engineering-architecture/application-lifecycle-management/configuration-management/automation-and-templating-frameworks/configuration-modularization.md) — Supports splitting large configurations into multiple files by importing separate modules. ([source](https://nix.dev/tutorials/module-system/deep-dive)) - [Purely Functional Derivations](https://awesome-repositories.com/f/software-engineering-architecture/architectural-design-patterns/design-patterns/functional-design-patterns/pure-functional-logic-implementations/purely-functional-derivations.md) — Models software builds as purely functional derivations where identical inputs always produce identical binary outputs. - [Build Input-Output Declarations](https://awesome-repositories.com/f/software-engineering-architecture/project-structure-standardization/build-input-output-declarations.md) — Provides structured project entrypoints to declare inputs and outputs for consistent, reproducible builds. ([source](https://nix.dev/concepts/flakes)) - [Reproducible Builds](https://awesome-repositories.com/f/software-engineering-architecture/reproducible-builds.md) — Prevents external system states from altering outputs by explicitly defining all build environment parameters. ([source](https://nix.dev/guides/)) - [Data Type Validation](https://awesome-repositories.com/f/software-engineering-architecture/data-schema-validation/data-type-validation.md) — Enforces data type constraints on configuration options to ensure the system state adheres to a structured schema. ([source](https://nix.dev/tutorials/module-system/deep-dive)) - [Reproducible Scripts](https://awesome-repositories.com/f/software-engineering-architecture/reproducible-builds/reproducible-scripts.md) — Enables the creation of reproducible scripts with explicit dependency declarations for consistent execution across environments. ([source](https://nix.dev/tutorials/first-steps/)) ### Part of an Awesome List - [Build and Dependency Management](https://awesome-repositories.com/f/awesome-lists/devtools/build-and-dependency-management.md) — Implements a reproducible build system that manages a strict set of inputs and outputs to ensure consistent software builds. ([source](https://nix.dev/concepts/)) - [Functional](https://awesome-repositories.com/f/awesome-lists/devtools/package-managers/functional.md) — Provides a deterministic functional package manager that ensures reproducible binary outputs from the same inputs. ### Data & Databases - [Content-Addressable Stores](https://awesome-repositories.com/f/data-databases/storage-abstraction/content-addressable-stores.md) — Uses a content-addressable store to uniquely identify and isolate packages based on the cryptographic hash of their inputs. - [User-Defined Types](https://awesome-repositories.com/f/data-databases/data-structure-definitions/user-defined-types.md) — Uses attribute sets, lists, and primitive types to define complex data structures within configurations. ([source](https://nix.dev/tutorials/nix-language)) - [Package Store Sweepers](https://awesome-repositories.com/f/data-databases/storage-garbage-collection/package-store-sweepers.md) — Scans the content-addressable store to remove unreferenced packages and reclaim disk space. ([source](https://nix.dev/manual/nix/development/)) ### Development Tools & Productivity - [Binary Cache Managers](https://awesome-repositories.com/f/development-tools-productivity/binary-cache-managers.md) — Directs the package manager to fetch pre-built binaries from specific remote servers to avoid source rebuilds. ([source](https://nix.dev/guides/)) - [Binary Cache Distributions](https://awesome-repositories.com/f/development-tools-productivity/binary-cache-managers/binary-cache-uploads/binary-cache-distributions.md) — Implements a binary-cache mechanism for sharing pre-compiled artifacts via remote servers. ([source](https://nix.dev/guides/recipes/)) - [Binary Cache Hosting](https://awesome-repositories.com/f/development-tools-productivity/binary-cache-managers/binary-cache-uploads/binary-cache-hosting.md) — Hosts pre-built objects on a network server to share artifacts and eliminate redundant compilation across different machines. ([source](https://nix.dev/tutorials/nixos/binary-cache-setup)) - [Build Artifact Caching](https://awesome-repositories.com/f/development-tools-productivity/build-artifact-caching.md) — Stores compiled binaries in a cache to avoid rebuilding unchanged dependencies from source. ([source](https://nix.dev/_sources/index.md)) - [Configuration Composers](https://awesome-repositories.com/f/development-tools-productivity/configuration-composers.md) — Aggregates separate expressions into a single attribute set to define system configurations. ([source](https://nix.dev/tutorials/module-system/)) - [Shell Environment Configurations](https://awesome-repositories.com/f/development-tools-productivity/development-environment-management/environment-provisioning-configuration/developer-environment-tooling/shell-environment-configurations.md) — Provides the ability to create reproducible shell environments with specific packages and environment variables. ([source](https://nix.dev/tutorials/nix-language)) - [Development Environments](https://awesome-repositories.com/f/development-tools-productivity/development-environments.md) — Provides automated, consistent development environments that launch instantly when entering a project directory. ([source](https://nix.dev/guides/recipes/)) - [Declarative Environment Configurations](https://awesome-repositories.com/f/development-tools-productivity/development-environments/declarative-environment-configurations.md) — Uses version-controlled files to define development environment tooling and setup in a declarative format. ([source](https://nix.dev/tutorials/first-steps/declarative-shell)) - [Environment Provisioning](https://awesome-repositories.com/f/development-tools-productivity/environment-provisioning.md) — Provisions isolated development shells with all necessary dependencies and environment variables. ([source](https://nix.dev/manual/nix/development/)) - [Global Dependency Pinning](https://awesome-repositories.com/f/development-tools-productivity/global-package-managers/global-dependency-upgrading/global-dependency-pinning.md) — Maps pinned dependencies to system-wide lookup paths to ensure consistency during system rebuilds. ([source](https://nix.dev/guides/recipes/dependency-management)) - [Version Rollbacks](https://awesome-repositories.com/f/development-tools-productivity/installed-package-management/version-rollbacks.md) — Enables reverting software installations to previous states using versions preserved in the content-addressable store. ([source](https://nix.dev/manual/nix/stable/)) - [Nix Packages](https://awesome-repositories.com/f/development-tools-productivity/nix-packages.md) — Offers comprehensive technical documentation and guides for managing packages using the Nix functional language. - [Functional Package Manager Integrations](https://awesome-repositories.com/f/development-tools-productivity/nix-packages/functional-package-manager-integrations.md) — Implements a purely functional package model that ensures deterministic builds and supports multiple coexisting versions. - [Functional Expressions](https://awesome-repositories.com/f/development-tools-productivity/nix-packages/functional-package-manager-integrations/functional-expressions.md) — Uses a deterministic functional language to describe build inputs and environment variables for reproducible packages. ([source](https://nix.dev/manual/nix/latest/)) - [Package Dependency Management](https://awesome-repositories.com/f/development-tools-productivity/package-dependency-management.md) — Validates that all dependencies are explicitly specified by isolating packages from global system locations. ([source](https://nix.dev/manual/nix/development/)) - [Dependency Isolation](https://awesome-repositories.com/f/development-tools-productivity/package-dependency-management/dependency-isolation.md) — Isolates packages in unique directories to ensure that all runtime dependencies are explicitly and completely specified. ([source](https://nix.dev/manual/nix/stable/)) - [Functional Package Management](https://awesome-repositories.com/f/development-tools-productivity/package-dependency-managers/functional-package-management.md) — Implements a package manager using a lazy-evaluated functional language for isolated dependencies and atomic upgrades. - [Package Installers](https://awesome-repositories.com/f/development-tools-productivity/package-installers.md) — Provides command-line tools to fetch and install software packages from various sources. ([source](https://nix.dev/tutorials/first-steps/)) - [Version Locking](https://awesome-repositories.com/f/development-tools-productivity/project-version-managers/toolchain-versioning/version-locking.md) — Generates lockfiles that record specific commit hashes and checksums to guarantee absolute build reproducibility. ([source](https://nix.dev/reference/pinning-nixpkgs)) - [Declarative Shells](https://awesome-repositories.com/f/development-tools-productivity/shell-environment-managers/declarative-shells.md) — Enables the creation of reproducible shells where runtimes and libraries are defined declaratively. ([source](https://nix.dev/guides/recipes/python-environment)) - [Remote Repository Code Fetchers](https://awesome-repositories.com/f/development-tools-productivity/source-code-repositories/remote-repository-code-fetchers.md) — Programmatically tracks and retrieves external code and data from remote repositories for use in build derivations. ([source](https://nix.dev/guides/)) - [Version Pinning Tools](https://awesome-repositories.com/f/development-tools-productivity/version-pinning-tools.md) — Pins packages to exact commit hashes via URLs to ensure that build expressions remain deterministic and reproducible. ([source](https://nix.dev/tutorials/first-steps/towards-reproducibility-pinning-nixpkgs)) - [Versioned Package Managers](https://awesome-repositories.com/f/development-tools-productivity/versioned-package-managers.md) — Allows multiple versions of the same software to coexist in isolated paths to prevent dependency conflicts. ([source](https://nix.dev/manual/nix/development/)) - [Deterministic Build Metadata](https://awesome-repositories.com/f/development-tools-productivity/workflow-automation-tools/build-task-automation/build-automation/android-build-standards/build-process-standardization/deterministic-build-metadata.md) — Ensures bit-for-bit deterministic outputs by using functional logic to control all build inputs and metadata. ([source](https://nix.dev/manual/nix/stable/)) - [User-Level Installers](https://awesome-repositories.com/f/development-tools-productivity/application-installers/user-level-installers.md) — Provides non-privileged software installation where users can maintain their own personal software profiles. ([source](https://nix.dev/manual/nix/latest/)) - [Binary Package Managers](https://awesome-repositories.com/f/development-tools-productivity/binary-package-managers.md) — Fetches pre-compiled binaries from remote caches and verifies them with public keys to accelerate installation. ([source](https://nix.dev/guides/recipes/add-binary-cache)) - [Build Environment Shells](https://awesome-repositories.com/f/development-tools-productivity/build-environment-configurators/build-environment-shells.md) — Allows build-time dependencies to be shared with interactive shells for easier compilation and debugging. ([source](https://nix.dev/guides/recipes/sharing-dependencies)) - [Custom Build Hooks](https://awesome-repositories.com/f/development-tools-productivity/build-environment-configurators/build-environment-shells/build-phase-automation/custom-build-hooks.md) — Allows developers to override default build steps to execute custom shell commands and hooks during compilation. ([source](https://nix.dev/tutorials/packaging-existing-software)) - [Configuration Module Composition](https://awesome-repositories.com/f/development-tools-productivity/configuration-defaults/recursive-composition/configuration-module-composition.md) — Aggregates separate configuration fragments into a single merged attribute set to manage complex system settings. - [Hierarchical Configuration Namespaces](https://awesome-repositories.com/f/development-tools-productivity/configuration-generators/typed-configuration-classes/namespaced-configuration-classes/hierarchical-configuration-namespaces.md) — Creates hierarchical configuration structures using submodules to organize related options. ([source](https://nix.dev/tutorials/module-system/deep-dive)) - [Cross-Platform Build Targets](https://awesome-repositories.com/f/development-tools-productivity/cross-platform-build-targets.md) — Supports creating binaries for different target platforms by defining specific toolchains and platform configurations. ([source](https://nix.dev)) - [Package Overrides](https://awesome-repositories.com/f/development-tools-productivity/dependency-managers/artifact-distribution-systems/software-packages/package-overrides.md) — Enables overriding specific arguments of an existing package derivation to produce customized software variants. ([source](https://nix.dev/tutorials/callpackage)) - [Dependency Resolvers](https://awesome-repositories.com/f/development-tools-productivity/dependency-resolvers.md) — Implements a functional mechanism to resolve complex interdependent dependency graphs between package recipes. ([source](https://nix.dev/tutorials/callpackage)) - [Virtual Machine Provisioning](https://awesome-repositories.com/f/development-tools-productivity/development-environment-management/environment-provisioning-configuration/virtual-machine-provisioning.md) — Provisions virtual machine instances using infrastructure-as-code tools and system images. ([source](https://nix.dev/tutorials/nixos/deploying-nixos-using-terraform)) - [Environment Activation](https://awesome-repositories.com/f/development-tools-productivity/environment-activation.md) — Automatically loads a declarative shell environment when entering a project directory. ([source](https://nix.dev/guides/recipes/direnv)) - [Module Dependency Declarations](https://awesome-repositories.com/f/development-tools-productivity/external-module-declarations/runtime-module-declarations/module-dependency-declarations.md) — Specifies requirements between configuration modules to ensure a correct order of evaluation. ([source](https://nix.dev/tutorials/module-system/)) - [Configuration Value Mergers](https://awesome-repositories.com/f/development-tools-productivity/merge-conflict-resolution/configuration-value-mergers.md) — Combines values for the same attribute from different expressions based on their data types to resolve configuration conflicts. ([source](https://nix.dev/tutorials/module-system/)) - [Package Customizations](https://awesome-repositories.com/f/development-tools-productivity/nix-packages/package-customizations.md) — Allows for the modification and tailoring of existing software packages to meet specific build or runtime requirements. ([source](https://nix.dev/recommended-reading)) - [Parameterization](https://awesome-repositories.com/f/development-tools-productivity/package-build-recipes/parameterization.md) — Allows modifying build derivations through custom arguments to avoid code duplication in package recipes. ([source](https://nix.dev/tutorials/callpackage)) - [Dependency Override Managers](https://awesome-repositories.com/f/development-tools-productivity/package-dependency-managers/dependency-override-managers.md) — Allows programmatic swapping of pinned remote sources to test different versions of a dependency without modifying the main recipe. ([source](https://nix.dev/guides/recipes/dependency-management)) - [Direct URL Installations](https://awesome-repositories.com/f/development-tools-productivity/package-installers/direct-url-installations.md) — Allows downloading and configuring software packages directly from web addresses for rapid setup. ([source](https://nix.dev/_sources/index.md)) - [Verifiable Source Fetching](https://awesome-repositories.com/f/development-tools-productivity/package-manifests/source-archives/verifiable-source-fetching.md) — Downloads source code archives from URLs and ensures integrity via cryptographic hashes. ([source](https://nix.dev/tutorials/packaging-existing-software)) - [Shell Environment Managers](https://awesome-repositories.com/f/development-tools-productivity/shell-environment-managers.md) — Spawns ephemeral shell environments with specific tools without altering the global system state. ([source](https://nix.dev/tutorials/first-steps/)) - [Remote Software Deployers](https://awesome-repositories.com/f/development-tools-productivity/software-deployment-tools/remote-software-deployers.md) — Pushes software configurations and packages to remote machines for centralized fleet management. ([source](https://nix.dev/_sources/index.md)) - [Source Builds](https://awesome-repositories.com/f/development-tools-productivity/source-builds.md) — Allows compiling software packages directly from source code to apply custom build options. ([source](https://nix.dev/_sources/index.md)) ### System Administration & Monitoring - [System Configuration Management](https://awesome-repositories.com/f/system-administration-monitoring/system-configuration-management.md) — Manages the entire operating system state declaratively to enable predictable deployments and full-system rollbacks. ([source](https://nix.dev/manual/nix/development/)) - [Disk Space Cleaners](https://awesome-repositories.com/f/system-administration-monitoring/disk-space-cleaners.md) — Includes a garbage collector to remove unreferenced packages and reclaim system storage. ([source](https://nix.dev/manual/nix/prev-stable/)) - [System Administration Guides](https://awesome-repositories.com/f/system-administration-monitoring/system-administration-guides.md) — Provides detailed administration guides for deploying and managing a declarative Linux distribution. - [User Software Profiles](https://awesome-repositories.com/f/system-administration-monitoring/user-software-profiles.md) — Allows non-privileged users to install and manage software within individual, personal profiles. ([source](https://nix.dev/manual/nix/prev-stable/)) ### Hardware & IoT - [System Image Generation](https://awesome-repositories.com/f/hardware-iot/embedded-build-systems/system-image-generation.md) — Creates bootable ISOs, virtual machines, and Docker images derived from a single system configuration. ([source](https://nix.dev/tutorials/nixos/)) ### Security & Cryptography - [Binary Signing](https://awesome-repositories.com/f/security-cryptography/binary-signing.md) — Ensures the authenticity of binaries served from a cache using cryptographic key pairs for signing. ([source](https://nix.dev/tutorials/nixos/binary-cache-setup)) ### Testing & Quality Assurance - [System Integration Test Runners](https://awesome-repositories.com/f/testing-quality-assurance/software-testing/e2e-integration-testing/integration-testing-frameworks/system-integration-test-runners.md) — Runs integration tests within virtual machines to verify system behavior before deployment. ([source](https://nix.dev/tutorials/nixos/))