NixOS/nix.dev

Features

• Package Managers - Implements a functional package manager for automating the retrieval, installation, and dependency management of software.
• Declarative Linux Distributions - Provides a complete Linux distribution where the system state is defined entirely via a declarative configuration file.
• Functional Build Derivations - Uses a deterministic functional language to describe build tasks, ensuring identical inputs always produce the same outputs.
• Declarative Configuration Systems - Defines the entire operating system state through a declarative configuration system to enable predictable deployments.
• Build and Dependency Management - Implements a reproducible build system that manages a strict set of inputs and outputs to ensure consistent software builds.
• Functional - Provides a deterministic functional package manager that ensures reproducible binary outputs from the same inputs.
• Content-Addressable Stores - Uses a content-addressable store to uniquely identify and isolate packages based on the cryptographic hash of their inputs.
• Binary Cache Managers - Directs the package manager to fetch pre-built binaries from specific remote servers to avoid source rebuilds.
• Binary Cache Distributions - Implements a binary-cache mechanism for sharing pre-compiled artifacts via remote servers.
• Binary Cache Hosting - Hosts pre-built objects on a network server to share artifacts and eliminate redundant compilation across different machines.
• Build Artifact Caching - Stores compiled binaries in a cache to avoid rebuilding unchanged dependencies from source.
• Configuration Composers - Aggregates separate expressions into a single attribute set to define system configurations.
• Shell Environment Configurations - Provides the ability to create reproducible shell environments with specific packages and environment variables.
• Development Environments - Provides automated, consistent development environments that launch instantly when entering a project directory.
• Declarative Environment Configurations - Uses version-controlled files to define development environment tooling and setup in a declarative format.
• Environment Provisioning - Provisions isolated development shells with all necessary dependencies and environment variables.
• Global Dependency Pinning - Maps pinned dependencies to system-wide lookup paths to ensure consistency during system rebuilds.
• Version Rollbacks - Enables reverting software installations to previous states using versions preserved in the content-addressable store.
• Nix Packages - Offers comprehensive technical documentation and guides for managing packages using the Nix functional language.
• Functional Package Manager Integrations - Implements a purely functional package model that ensures deterministic builds and supports multiple coexisting versions.
• Functional Expressions - Uses a deterministic functional language to describe build inputs and environment variables for reproducible packages.
• Package Dependency Management - Validates that all dependencies are explicitly specified by isolating packages from global system locations.
• Dependency Isolation - Isolates packages in unique directories to ensure that all runtime dependencies are explicitly and completely specified.
• Functional Package Management - Implements a package manager using a lazy-evaluated functional language for isolated dependencies and atomic upgrades.
• Package Installers - Provides command-line tools to fetch and install software packages from various sources.
• Version Locking - Generates lockfiles that record specific commit hashes and checksums to guarantee absolute build reproducibility.
• Declarative Shells - Enables the creation of reproducible shells where runtimes and libraries are defined declaratively.
• Remote Repository Code Fetchers - Programmatically tracks and retrieves external code and data from remote repositories for use in build derivations.
• Version Pinning Tools - Pins packages to exact commit hashes via URLs to ensure that build expressions remain deterministic and reproducible.
• Versioned Package Managers - Allows multiple versions of the same software to coexist in isolated paths to prevent dependency conflicts.
• Deterministic Build Metadata - Ensures bit-for-bit deterministic outputs by using functional logic to control all build inputs and metadata.
• Declarative Configuration Schemas - Defines named options with types and default values to create structured configuration schemas.
• Build Dependency Management - Explicitly manages the required libraries and toolchains that must be present during the software build process.
• Distributed Build Systems - Offloads compilation tasks to remote computing clusters and shares binaries via a distributed cache.
• Dependency Version Locking - Provides mechanisms for recording exact package versions in lock files to ensure consistent, reproducible builds.
• Infrastructure as Code Frameworks - Provides a framework for generating bootable images and virtual machines from version-controlled configuration files.
• Isolated Build Environments - Creates temporary, isolated build environments to ensure deterministic binary outputs regardless of the host system.
• Deterministic Package Definitions - Provides a functional language to ensure that package definitions always yield identical, reproducible outputs.
• Remote Resource Fetching - Retrieves source code, tarballs, and other remote resources from the network into a content-addressable store.
• Reproducible Build Systems - Implements a build system using content-addressable storage and isolated environments to guarantee reproducible software outputs.
• Development Environment Reproducibility - Defines shell environments and scripts that produce identical results across different machines.
• Lock-File Pinning - Tracks specific revisions of remote sources in lock files to maintain reproducibility across different environments.
• Software Packaging - Provides tools for constructing software packages with a deterministic and reproducible structure.
• Atomic System Updates - Implements atomic system updates using symlink switching to ensure instant upgrades and reliable rollbacks.
• Atomic System Upgrades - Provides atomic system updates that allow immediate reversal to previous working configurations.
• System State Rollbacks - Allows reverting to a previous working system configuration directly from the bootloader menu.
• Configuration Modularization - Supports splitting large configurations into multiple files by importing separate modules.
• Purely Functional Derivations - Models software builds as purely functional derivations where identical inputs always produce identical binary outputs.
• Build Input-Output Declarations - Provides structured project entrypoints to declare inputs and outputs for consistent, reproducible builds.
• Reproducible Builds - Prevents external system states from altering outputs by explicitly defining all build environment parameters.
• System Configuration Management - Manages the entire operating system state declaratively to enable predictable deployments and full-system rollbacks.
• User-Defined Types - Uses attribute sets, lists, and primitive types to define complex data structures within configurations.
• Package Store Sweepers - Scans the content-addressable store to remove unreferenced packages and reclaim disk space.
• User-Level Installers - Provides non-privileged software installation where users can maintain their own personal software profiles.
• Binary Package Managers - Fetches pre-compiled binaries from remote caches and verifies them with public keys to accelerate installation.
• Build Environment Shells - Allows build-time dependencies to be shared with interactive shells for easier compilation and debugging.
• Custom Build Hooks - Allows developers to override default build steps to execute custom shell commands and hooks during compilation.
• Configuration Module Composition - Aggregates separate configuration fragments into a single merged attribute set to manage complex system settings.
• Hierarchical Configuration Namespaces - Creates hierarchical configuration structures using submodules to organize related options.
• Cross-Platform Build Targets - Supports creating binaries for different target platforms by defining specific toolchains and platform configurations.
• Package Overrides - Enables overriding specific arguments of an existing package derivation to produce customized software variants.
• Dependency Resolvers - Implements a functional mechanism to resolve complex interdependent dependency graphs between package recipes.
• Virtual Machine Provisioning - Provisions virtual machine instances using infrastructure-as-code tools and system images.
• Environment Activation - Automatically loads a declarative shell environment when entering a project directory.
• Module Dependency Declarations - Specifies requirements between configuration modules to ensure a correct order of evaluation.
• Configuration Value Mergers - Combines values for the same attribute from different expressions based on their data types to resolve configuration conflicts.
• Package Customizations - Allows for the modification and tailoring of existing software packages to meet specific build or runtime requirements.
• Parameterization - Allows modifying build derivations through custom arguments to avoid code duplication in package recipes.
• Dependency Override Managers - Allows programmatic swapping of pinned remote sources to test different versions of a dependency without modifying the main recipe.
• Direct URL Installations - Allows downloading and configuring software packages directly from web addresses for rapid setup.
• Verifiable Source Fetching - Downloads source code archives from URLs and ensures integrity via cryptographic hashes.
• Shell Environment Managers - Spawns ephemeral shell environments with specific tools without altering the global system state.
• Remote Software Deployers - Pushes software configurations and packages to remote machines for centralized fleet management.
• Source Builds - Allows compiling software packages directly from source code to apply custom build options.
• Distributed Build Clusters - Supports distributing compilation tasks across remote servers to increase build speed and resource utilization.
• Configuration Deployment - Provisions remote machines by delivering system configurations via SSH or hardware installers.
• Configuration Merging Engines - Provides a mechanism for combining global and local configuration attribute sets using recursive merging logic.
• Docker Image Building - Generates Docker images directly from declarative package definitions and architecture specifications.
• Continuous Integration Pipelines - Integrates reproducible build processes and verification workflows into continuous integration pipelines.
• Dependency Alignment - Overrides recursive library dependencies to ensure a single, synchronized version is used across the entire project.
• Binary and Source Installation - Supports software installation using either pre-built binary packages from caches or by compiling from source.
• Incremental Configuration Updates - Enables pushing updated configuration files to running instances without the need to recreate the entire machine.
• Software Distribution - Provides curated distributions of software packages optimized for compatibility and stability.
• Remote Server Provisioning - Automates the installation of a complete system configuration onto remote Linux machines via SSH.
• NixOS Deployments - Enables the deployment of systems using NixOS modules and Flakes for precise dependency tracking.
• Remote Toolkit Deployments - Updates system settings on remote hosts without requiring a full re-installation of the OS.
• Remote Build Orchestration - Offloads the compilation process to remote servers to reduce local resource consumption.
• System Image Generation - Creates bootable ISOs, virtual machines, and Docker images derived from a single system configuration.
• Disk and Mount Management - Allows declarative specification of disk partitions, filesystem formats, and mount points.
• Bootable Image Creation - Generates customized, bootable disk images from declarative configuration files for hardware execution.
• Virtual Machines - Creates QEMU-based virtual machines directly from declarative system configuration files.
• Conditional Logic - Implements conditional logic within configuration files to apply settings only when specific criteria are met.
• Configuration Expression Resolvers - Loads and evaluates functional expressions and resource relationships from external files.
• Interactive Read-Eval-Print Loops - Includes an interactive REPL for testing expressions and inspecting values in real-time.
• Variable Bindings - Implements let-bindings to assign names to values for reuse within a specific scope.
• Custom Type Constraint Enforcement - Validates that configuration values adhere to specific expected types to ensure system stability.
• Lazy-Evaluation Expression Engines - Employs a lazy-evaluation expression engine to manage complex dependencies and modular configuration imports efficiently.
• Module Configuration Resolution - Processes a set of modules to resolve and merge final configuration values for the system.
• Recursive Attribute References - Allows linking attributes within a configuration set to each other to avoid repeating values.
• Source File Evaluation - Allows computing the value of expressions stored in files directly from the command line.
• Binary Signing - Ensures the authenticity of binaries served from a cache using cryptographic key pairs for signing.
• Data Type Validation - Enforces data type constraints on configuration options to ensure the system state adheres to a structured schema.
• Reproducible Scripts - Enables the creation of reproducible scripts with explicit dependency declarations for consistent execution across environments.
• Disk Space Cleaners - Includes a garbage collector to remove unreferenced packages and reclaim system storage.
• System Administration Guides - Provides detailed administration guides for deploying and managing a declarative Linux distribution.
• User Software Profiles - Allows non-privileged users to install and manage software within individual, personal profiles.
• System Integration Test Runners - Runs integration tests within virtual machines to verify system behavior before deployment.

Star history