staging-nixos merge for 2026-03-25 (#503344)

<!-- To avoid merge conflicts, consider adding your item at an arbitrary place in the list instead. -->

- The system.nix file has been added has an alternative entry point to configuration.nix (and flake.nix) that allows to configure NixOS without using `nix-channel`.

  This file must evaluate to a NixOS system derivation or an attribute set of such derivations, in which case the attribute to build has to be selected with the `--attr` option of `nixos-rebuild` or `nixos-install`.

  For example,

  ```nix

  # system.nix

  let

    # Pinned Nixpkgs archive

    #

    # Use `curl -I https://channels.nixos.org/nixos-26.05` to get the

    # latest commit of the stable channel and `nix-prefetch-url --unpack`

    # to compute its sha256 hash.

    nixpkgs = builtins.fetchTarball {

      url = "https://github.com/NixOS/nixpkgs/archive/c217913993d6.tar.gz";

      sha256 = "026mprs324330pfazlgbw987qmsa8ligglarvqbcxzig2kgw0lqg";

    };

  in

  import "${nixpkgs}/nixos" {

    # Build NixOS using an external configuration.nix file,

    # or directly set your options here

    configuration = ./configuration.nix;

  }

  ```

  The default location of system.nix is `/etc/nixos/system.nix` and can be changed by setting the `<nixos-system>` search path.

  `nixos-rebuild` and `nixos-install` can now also load a system.nix file in the current directory (only if `--attr` is used) or from a directory specified with `--file`.

- The default kernel package has been updated from 6.12 to 6.18. All supported kernels remain available.

## New Modules {#sec-release-26.05-new-modules}

stdenv.mkDerivation (finalAttrs: {

  pname = "btrfs-progs";

  version = "6.19";

  version = "6.19.1";

  src = fetchurl {

    url = "mirror://kernel/linux/kernel/people/kdave/btrfs-progs/btrfs-progs-v${finalAttrs.version}.tar.xz";

    hash = "sha256-rWt5GmDrVj0zFLwY48R/awU6AyY5SItbCbnV55Id5rY=";

    hash = "sha256-uyfh7FTnw8C3suWW+FOnPAej1y8hvJQEIHPCTb8EV5Y=";

  };

  nativeBuildInputs = [

          '';

        }

        ''

          nixos-install --help | grep -F 'NixOS Reference Pages'

          nixos-install --help | grep -F "System Manager's Manual"

          nixos-install --help | grep -F 'configuration.nix'

          nixos-generate-config --help | grep -F 'NixOS Reference Pages'

          nixos-generate-config --help | grep -F "System Manager's Manual"

          nixos-generate-config --help | grep -F 'hardware-configuration.nix'

          # FIXME: Tries to call unshare, which it must not do for --help

.Sh DESCRIPTION

This command installs NixOS in the file system mounted on

.Pa /mnt Ns

, based on the NixOS configuration specified in

.Pa /mnt/etc/nixos/configuration.nix Ns

\&. It performs the following steps:

, or defined through the

.Fl -root

option, based on the NixOS configuration specified in

.Pa /mnt/etc/nixos/system.nix Ns

,

.Pa /mnt/etc/nixos/configuration.nix

or specified through the

.Fl -file Ns

,

.Fl -attr Ns

or

.Fl -flake Ns

options. It performs the following steps:

.

.Bl -enum

.It

.It

It runs Nix in

.Pa /mnt

to build the NixOS configuration specified in

.Pa /mnt/etc/nixos/configuration.nix Ns

\&.

to build the given NixOS configuration.

.

.It

It installs the current channel

\&.

.

.It Fl -file Ar path , Fl f Ar path

Enable and build the NixOS system from the specified file. The file must

Build the NixOS system from the specified file. The file must

evaluate to an attribute set, and it must contain a valid NixOS configuration

at attribute

.Va attrPath Ns

from nixpkgs. If specified without

.Fl -attr

option, builds the configuration from the top-level

attribute of the file.

attribute set of the file.

.

.It Fl -attr Ar attrPath , Fl A Ar attrPath

Enable and build the NixOS system from nix file and use the specified attribute

Build the NixOS system from nix file and use the specified attribute

path from file specified by the

.Fl -file

option. If specified without

.Fl -file

option, uses

.Va [root] Ns Pa /etc/nixos/default.nix Ns

\&.

option, it tires to find

.Pa system.nix

in

.Va root Ns Pa /etc/nixos Ns

, in current directory and iteratively in parent directories.

.

.It Fl -channel Ar channel

If this option is provided, do not copy the current

verbosity=()

attr=

buildFile=

buildingAttribute=1

# keys: module, by-attrset, flake, system

declare -A requestedBuildMethods

while [ "$#" -gt 0 ]; do

    i="$1"; shift 1

            ;;

        --system|--closure|--store-path)

            system="$1"; shift 1

            requestedBuildMethods["system"]=1

            ;;

        --flake)

          flake="$1"

          flakeFlags=(--extra-experimental-features 'nix-command flakes')

          requestedBuildMethods["flake"]=1

          shift 1

          ;;

        --file|-f)

                log "$0: '$i' requires an argument"

                exit 1

            fi

            if [ -f "$1" ]; then

                buildFile="$1"

            buildingAttribute=

            elif [ -f "$1/system.nix" ]; then

                buildFile="${1%/}/system.nix"

            else

                buildFile="${1%/}/default.nix"

            fi

            requestedBuildMethods["by-attrset"]=1

            shift 1

            ;;

        --attr|-A)

                exit 1

            fi

            attr="$1"

            buildingAttribute=

            requestedBuildMethods["by-attrset"]=1

            shift 1

            ;;

        --recreate-lock-file|--no-update-lock-file|--no-write-lock-file|--no-registries|--commit-lock-file)

    esac

done

# Finds a specific file in a directory or its parents

findInParents() {

    local dir=$1

    local filename=$2

    while [[ ! -f "$dir/$filename" ]] && [[ "$dir" != / ]]; do

        dir=$(dirname "$dir")

    done

    if [[ -f "$dir/$filename" ]]; then

        echo "$dir/$filename"

    else

        return 1

    fi

}

if ! test -e "$mountPoint"; then

    echo "mount point $mountPoint doesn't exist"

    exit 1

    checkPath="$(dirname "$checkPath")"

done

# Verify that user is not trying to use attribute building and flake

# at the same time

if [[ -z $buildingAttribute && -n $flake ]]; then

    echo "$0: '--flake' cannot be used with '--file' or '--attr'"

# If user requested multiple build methods, abort

if [[ ${#requestedBuildMethods[@]} -gt 1 ]]; then

    echo "error: multiple build methods requested: ${!requestedBuildMethods[@]}"

    exit 1

fi

# Get the path of the NixOS configuration file.

if [[ -z $flake && -n $buildingAttribute ]]; then

    if [[ -z $NIXOS_CONFIG ]]; then

        NIXOS_CONFIG=$mountPoint/etc/nixos/configuration.nix

findByAttrset() {

    # - From system.nix up from the current directory

    # - Hardcoded to $mountPoint/etc/nixos/system.nix

    # - Hardcoded to /etc/nixos/system.nix

    # (default.nix is also searched for backward compatibility)

    if resolvedBuildFile="$(findInParents "$PWD" system.nix)"; then

        buildFile=$resolvedBuildFile

        return 0

    elif resolvedBuildFile="$(findInParents "$PWD" default.nix)"; then

        buildFile=$resolvedBuildFile

        return 0

    elif [[ -f "/etc/nixos/system.nix" ]]; then

        buildFile="/etc/nixos/system.nix"

        return 0

    elif [[ -f "/etc/nixos/default.nix" ]]; then

        buildFile="/etc/nixos/default.nix"

        return 0

    fi

    return 1

}

    if [[ ${NIXOS_CONFIG:0:1} != / ]]; then

        echo "$0: \$NIXOS_CONFIG is not an absolute path"

findModule() {

    # - From NIXOS_CONFIG environment variable

    # - hardcoded to $mountPoint/etc/nixos/configuration.nix

    if [[ -n $NIXOS_CONFIG ]]; then

        return 0

    elif [[ -f "$mountPoint/etc/nixos/configuration.nix" ]]; then

        NIXOS_CONFIG="$mountPoint/etc/nixos/configuration.nix"

        return 0

    fi

    return 1

}

# If user didn't request a specific build method, try to find one

if [[ ${#requestedBuildMethods[@]} -eq 0 ]]; then

    # Flakes cannot be resolved without knowing hostname

    if findByAttrset; then

        requestedBuildMethods["by-attrset"]=1

    elif findModule; then

        requestedBuildMethods["module"]=1

    else

        echo "error: no build method found"

        exit 1

    fi

elif [[ -z $buildingAttribute ]]; then

    if [[ -z $buildFile ]]; then

        buildFile="$mountPoint/etc/nixos/default.nix"

    elif [[ -d $buildFile ]]; then

        buildFile="$buildFile/default.nix"

fi

elif [[ -n $flake ]]; then

# Find configuration files if not already found

if [[ -n "${requestedBuildMethods["flake"]}" ]]; then

    if [[ $flake =~ ^(.*)\#([^\#\"]*)$ ]]; then

       flake="${BASH_REMATCH[1]}"

       flakeAttr="${BASH_REMATCH[2]}"

        exit 1

    fi

    flakeAttr="nixosConfigurations.\"$flakeAttr\""

elif [[ -n "${requestedBuildMethods["by-attrset"]}" && -z $buildFile ]]; then

    findByAttrset

elif [[ -n "${requestedBuildMethods["module"]}" && -z $NIXOS_CONFIG ]]; then

    findModule

    if [[ ${NIXOS_CONFIG:0:1} != / ]]; then

        echo "$0: \$NIXOS_CONFIG is not an absolute path"

        exit 1

    fi

fi

# Resolve the flake.

if [[ -n $flake ]]; then

if [[ -n "${requestedBuildMethods["flake"]}" ]]; then

    flake=$(nix "${flakeFlags[@]}" flake metadata --json "${extraBuildFlags[@]}" "${lockFlags[@]}" -- "$flake" | jq -r .url)

fi

if [[ ! -e $NIXOS_CONFIG && -z $system && -z $flake && -n $buildingAttribute ]]; then

if [[ ! -e $NIXOS_CONFIG && -n "${requestedBuildMethods["module"]}" ]]; then

    echo "configuration file $NIXOS_CONFIG doesn't exist"

    exit 1

fi

if [[ ! -z $buildingAttribute && -e $buildFile && -z $system ]]; then

if [[ ! -e $buildFile && -n "${requestedBuildMethods["by-attrset"]}" ]]; then

    echo "configuration file $buildFile doesn't exist"

    exit 1

fi

# Build the system configuration in the target filesystem.

if [[ -z $system ]]; then

    outLink="$tmpdir/system"

    if [[ -z $flake && -n $buildingAttribute ]]; then

    if [[ -n "${requestedBuildMethods["module"]}" ]]; then

        echo "building the configuration in $NIXOS_CONFIG..."

        nix-build --out-link "$outLink" --store "$mountPoint" "${extraBuildFlags[@]}" \

            --extra-substituters "$sub" \

            '<nixpkgs/nixos>' -A system -I "nixos-config=$NIXOS_CONFIG" "${verbosity[@]}"

    elif [[ -z $buildingAttribute ]]; then

    elif [[ -n "${requestedBuildMethods["by-attrset"]}" ]]; then

        if [[ -n $attr ]]; then

            echo "building the configuration in $buildFile and attribute $attr..."

        else

        nix-build --out-link "$outLink" --store "$mountPoint" "${extraBuildFlags[@]}" \

            --extra-substituters "$sub" \

            "$buildFile" -A "${attr:+$attr.}config.system.build.toplevel" "${verbosity[@]}"

    else

    else # [[ -n "${requestedBuildMethods["flake"]}" ]]

        echo "building the flake in $flake..."

        nix "${flakeFlags[@]}" build "$flake#$flakeAttr.config.system.build.toplevel" \

            --store "$mountPoint" --extra-substituters "$sub" "${verbosity[@]}" \