···

       
116
       
116
       
 
       
  "sec-nixpkgs-release-25.05-lib-deprecations": [

     

       
117
       
117
       
 
       
    "release-notes.html#sec-nixpkgs-release-25.05-lib-deprecations"

     

       
118
       
118
       
 
       
  ],

     

       
119
       
119
       
+
       
  "sec-nixpkgs-release-25.05-lib-additions-improvements": [

     

       
120
       
120
       
+
       
    "release-notes.html#sec-nixpkgs-release-25.05-lib-additions-improvements"

     

       
121
       
121
       
+
       
  ],

     

       
119
       
122
       
 
       
  "sec-overlays-install": [

     

       
120
       
123
       
 
       
    "index.html#sec-overlays-install"

     

       
121
       
124
       
 
       
  ],

     

···

       
84
       
84
       
 
       
- Plasma 5 and Qt 5 based versions of associated software are deprecated in NixOS 25.05, and will be removed in NixOS 25.11. Users are encouraged to upgrade to Plasma 6.

     

       
85
       
85
       
 
       


     

       
86
       
86
       
 
       
- `rustPlatform.buildRustPackage` stops handling the deprecated argument `cargoSha256`. Out-of-tree packages that haven't migrated from `cargoSha256` to `cargoHash` now receive errors.

     

       
87
       
87
       
+
       


     

       
88
       
88
       
+
       
### Other notable changes {#sec-release-25.05-lib-notable-changes}

     

       
89
       
89
       
+
       


     

       
90
       
90
       
+
       
- `lib.packagesFromDirectoryRecursive` can now construct nested scopes matching the directory tree passed as input.

     

···

       
306
       
306
       
 
       
    # Type

     

       
307
       
307
       
 
       


     

       
308
       
308
       
 
       
    ```

     

       
309
       
309
       
-
       
    packagesFromDirectoryRecursive :: {

     

       
309
       
309
       
+
       
    packagesFromDirectoryRecursive :: (args :: {

     

       
310
       
310
       
 
       
      callPackage :: Path -> {} -> a,

     

       
311
       
311
       
 
       
      directory :: Path,

     

       
312
       
312
       
+
       
      recurseIntoDirectory? :: (args -> AttrSet) -> args -> AttrSet,

     

       
312
       
313
       
 
       
      ...

     

       
313
       
313
       
-
       
    } -> AttrSet

     

       
314
       
314
       
+
       
    }) -> AttrSet

     

       
314
       
315
       
 
       
    ```

     

       
315
       
316
       
 
       


     

       
316
       
317
       
 
       
    # Inputs

     
···

       
322
       
323
       
 
       
    `directory`

     

       
323
       
324
       
 
       
    : The directory to read package files from.

     

       
324
       
325
       
 
       


     

       
326
       
326
       
+
       
    `recurseIntoDirectory`

     

       
327
       
327
       
+
       
    : This argument is applied to the function which processes directories.

     

       
328
       
328
       
+
       
    : Equivalently, this function takes `processDir` and `args`, and can modify arguments passed to `processDir`

     

       
329
       
329
       
+
       
      (same as above) before calling it, as well as modify its output (which is then returned by `recurseIntoDirectory`).

     

       
325
       
330
       
 
       


     

       
326
       
331
       
 
       
    # Examples

     

       
327
       
332
       
 
       
    :::{.example}

     
···

       
342
       
347
       
 
       
    ::::{.example}

     

       
343
       
348
       
 
       
    ## Create a scope for the nix files found in a directory

     

       
344
       
349
       
 
       
    ```nix

     

       
345
       
345
       
-
       
    lib.makeScope pkgs.newScope (

     

       
346
       
346
       
-
       
      self: packagesFromDirectoryRecursive {

     

       
347
       
347
       
-
       
        inherit (self) callPackage;

     

       
348
       
348
       
-
       
        directory = ./my-packages;

     

       
349
       
349
       
-
       
      }

     

       
350
       
350
       
-
       
    )

     

       
350
       
350
       
+
       
    packagesFromDirectoryRecursive {

     

       
351
       
351
       
+
       
      inherit (pkgs) callPackage newScope;

     

       
352
       
352
       
+
       
      recurseIntoDirectory = f: { newScope, ... }@args:

     

       
353
       
353
       
+
       
        lib.recurseIntoAttrset (lib.makeScope newScope (self:

     

       
354
       
354
       
+
       
          f (args // {

     

       
355
       
355
       
+
       
            inherit (self) callPackage newScope;

     

       
356
       
356
       
+
       
          })

     

       
357
       
357
       
+
       
        ));

     

       
358
       
358
       
+
       
      directory = ./my-packages;

     

       
359
       
359
       
+
       
    }

     

       
351
       
360
       
 
       
    => { ... }

     

       
352
       
361
       
 
       
    ```

     

       
353
       
362
       
 
       


     
···

       
366
       
375
       
 
       
    :::{.note}

     

       
367
       
376
       
 
       
    `a.nix` cannot directly take as inputs packages defined in a child directory, such as `b1`.

     

       
368
       
377
       
 
       
    :::

     

       
369
       
369
       
-
       


     

       
370
       
370
       
-
       
    :::{.warning}

     

       
371
       
371
       
-
       
    As of now, `lib.packagesFromDirectoryRecursive` cannot create nested scopes for sub-directories.

     

       
372
       
372
       
-
       


     

       
373
       
373
       
-
       
    In particular, files under `b/` can only require (as inputs) other files under `my-packages`,

     

       
374
       
374
       
-
       
    but not to those in the same directory, nor those in a parent directory; e.g, `b2.nix` cannot directly

     

       
375
       
375
       
-
       
    require `b1`.

     

       
376
       
376
       
-
       
    :::

     

       
377
       
378
       
 
       
    ::::

     

       
378
       
379
       
 
       
  */

     

       
379
       
380
       
 
       
  packagesFromDirectoryRecursive =

     

       
380
       
381
       
 
       
    {

     

       
381
       
382
       
 
       
      callPackage,

     

       
382
       
383
       
 
       
      directory,

     

       
384
       
384
       
+
       
      recurseIntoDirectory ? lib.id,

     

       
383
       
385
       
 
       
      ...

     

       
384
       
384
       
-
       
    }:

     

       
386
       
386
       
+
       
    }@args:

     

       
385
       
387
       
 
       
    let

     

       
386
       
388
       
 
       
      inherit (lib) concatMapAttrs removeSuffix;

     

       
387
       
389
       
 
       
      inherit (lib.path) append;

     
···

       
390
       
392
       
 
       
    if pathExists defaultPath then

     

       
391
       
393
       
 
       
      # if `${directory}/package.nix` exists, call it directly

     

       
392
       
394
       
 
       
      callPackage defaultPath {}

     

       
393
       
393
       
-
       
    else concatMapAttrs (name: type:

     

       
394
       
394
       
-
       
      # otherwise, for each directory entry

     

       
395
       
395
       
-
       
      let path = append directory name; in

     

       
396
       
396
       
-
       
      if type == "directory" then {

     

       
397
       
397
       
-
       
        # recurse into directories

     

       
398
       
398
       
-
       
        "${name}" = packagesFromDirectoryRecursive {

     

       
399
       
399
       
-
       
          inherit callPackage;

     

       
400
       
400
       
-
       
          directory = path;

     

       
401
       
401
       
-
       
        };

     

       
402
       
402
       
-
       
      } else if type == "regular" && hasSuffix ".nix" name then {

     

       
403
       
403
       
-
       
        # call .nix files

     

       
404
       
404
       
-
       
        "${removeSuffix ".nix" name}" = callPackage path {};

     

       
405
       
405
       
-
       
      } else if type == "regular" then {

     

       
406
       
406
       
-
       
        # ignore non-nix files

     

       
407
       
407
       
-
       
      } else throw ''

     

       
408
       
408
       
-
       
        lib.filesystem.packagesFromDirectoryRecursive: Unsupported file type ${type} at path ${toString path}

     

       
409
       
409
       
-
       
      ''

     

       
410
       
410
       
-
       
    ) (builtins.readDir directory);

     

       
395
       
395
       
+
       
    else let

     

       
396
       
396
       
+
       
      f = { callPackage, ... }@newArgs:

     

       
397
       
397
       
+
       
        concatMapAttrs (name: type:

     

       
398
       
398
       
+
       
          # otherwise, for each directory entry

     

       
399
       
399
       
+
       
          let path = append directory name; in

     

       
400
       
400
       
+
       
          if type == "directory" then {

     

       
401
       
401
       
+
       
            # recurse into directories

     

       
402
       
402
       
+
       
            "${name}" = packagesFromDirectoryRecursive (newArgs // {

     

       
403
       
403
       
+
       
              directory = path;

     

       
404
       
404
       
+
       
            });

     

       
405
       
405
       
+
       
          } else if type == "regular" && hasSuffix ".nix" name then {

     

       
406
       
406
       
+
       
            # call .nix files

     

       
407
       
407
       
+
       
            "${removeSuffix ".nix" name}" = callPackage path {};

     

       
408
       
408
       
+
       
          } else if type == "regular" then {

     

       
409
       
409
       
+
       
            # ignore non-nix files

     

       
410
       
410
       
+
       
          } else throw ''

     

       
411
       
411
       
+
       
            lib.filesystem.packagesFromDirectoryRecursive: Unsupported file type ${type} at path ${toString path}

     

       
412
       
412
       
+
       
          ''

     

       
413
       
413
       
+
       
        ) (builtins.readDir directory);

     

       
414
       
414
       
+
       
      in

     

       
415
       
415
       
+
       
        recurseIntoDirectory f args;

     

       
411
       
416
       
 
       
}

     

···

       
1946
       
1946
       
 
       
  "sec-nixpkgs-release-25.05-lib-deprecations": [

     

       
1947
       
1947
       
 
       
    "release-notes.html#sec-nixpkgs-release-25.05-lib-deprecations"

     

       
1948
       
1948
       
 
       
  ],

     

       
1949
       
1949
       
+
       
  "sec-nixpkgs-release-25.05-lib-additions-improvements": [

     

       
1950
       
1950
       
+
       
    "release-notes.html#sec-nixpkgs-release-25.05-lib-additions-improvements"

     

       
1951
       
1951
       
+
       
  ],

     

       
1949
       
1952
       
 
       
  "sec-release-24.11": [

     

       
1950
       
1953
       
 
       
    "release-notes.html#sec-release-24.11"

     

       
1951
       
1954
       
 
       
  ],