Name

       nix eval - evaluate a Nix expression

Synopsis

       nix eval [option…] installable

Examples

       • Evaluate a Nix expression given on the command line:

       # nix eval --expr '1 + 2'

       • Evaluate a Nix expression to JSON:

       # nix eval --json --expr '{ x = 1; }'
       {"x":1}

       • Evaluate a Nix expression from a file:

       # nix eval -f ./my-nixpkgs hello.name

       • Get the current version of the nixpkgs flake:

       # nix eval --raw nixpkgs#lib.version

       • Print the store path of the Hello package:

       # nix eval --raw nixpkgs#hello

       • Get a list of checks in the nix flake:

       # nix eval nix#checks.x86_64-linux --apply builtins.attrNames

       • Generate a directory with the specified contents:

       # nix eval --write-to ./out --expr '{ foo = "bar"; subdir.bla = "123"; }'
       # cat ./out/foo
       bar
       # cat ./out/subdir/bla
       123

Description

       This  command  evaluates  the Nix expression installable and prints the result on standard
       output.

Output format

       nix eval can produce output in several formats:

       • By default, the evaluation result is printed as a Nix expression.

       • With --json, the evaluation result is printed in JSON format. Note that  this  fails  if
         the result contains values that are not representable as JSON, such as functions.

       • With  --raw,  the evaluation result must be a string, which is printed verbatim, without
         any quoting.

       • With --write-to path, the evaluation result must be a string or a nested  attribute  set
         whose  leaf  values are strings. These strings are written to files named path/attrpath.
         path must not already exist.

Options

       • --apply expr
         Apply the function expr to each argument.

       • --json
         Produce output in JSON format, suitable for consumption by another program.

       • --raw
         Print strings without quotes or escaping.

       • --read-only
         Do not instantiate each evaluated derivation. This improves performance, but  can  cause
         errors when accessing store paths of derivations during evaluation.

       • --write-to path
         Write a string or attrset of strings to path.

       Common evaluation options:

       • --arg name expr
         Pass the value expr as the argument name to Nix functions.

       • --argstr name string
         Pass the string string as the argument name to Nix functions.

       • --eval-store store-url
         The Nix store to use for evaluations.

       • --impure
         Allow access to mutable paths and repositories.

       • --include / -I path
         Add path to the list of locations used to look up <...> file names.

       • --override-flake original-ref resolved-ref
         Override the flake registries, redirecting original-ref to resolved-ref.

       Common flake-related options:

       • --commit-lock-file
         Commit changes to the flake’s lock file.

       • --inputs-from flake-url
         Use the inputs of the specified flake as registry entries.

       • --no-registries
         Don’t  allow  lookups  in the flake registries. This option is deprecated; use --no-use-
         registries.

       • --no-update-lock-file
         Do not allow any updates to the flake’s lock file.

       • --no-write-lock-file
         Do not write the flake’s newly generated lock file.

       • --override-input input-path flake-url
         Override a specific flake input (e.g. dwarffs/nixpkgs).  This  implies  --no-write-lock-
         file.

       • --recreate-lock-file
         Recreate the flake’s lock file from scratch.

       • --update-input input-path
         Update a specific flake input (ignoring its previous entry in the lock file).

       Options that change the interpretation of installables:

       • --derivation
         Operate on the store derivation rather than its outputs.

       • --expr expr
         Interpret installables as attribute paths relative to the Nix expression expr.

       • --file / -f file
         Interpret installables as attribute paths relative to the Nix expression stored in file.
         If file is the character -, then a Nix expression will be read from standard input.

                                                                                     nix3-eval(1)