Nix.dev

https://nix.dev/
Admin
Official documentation for getting things done with Nix, covering installation, tutorials, guides,...
Tokens:304,086
Snippets:4,674
Trust Score:9.6
Update:1 month ago
Show doc for...
Tokens:
Raw
### Complete configuration.nix example

Source: https://nix.dev/tutorials/nixos/nixos-configuration-on-vm

A full example of a configuration.nix file including bootloader, GNOME, and user setup.

```nix
 1{ config, pkgs, ... }:
 2{
 3  boot.loader.systemd-boot.enable = true;
 4  boot.loader.efi.canTouchEfiVariables = true;
 5
 6  services.xserver.enable = true;
 7
 8  services.xserver.displayManager.gdm.enable = true;
 9  services.xserver.desktopManager.gnome.enable = true;
10
11  users.users.alice = {
12    isNormalUser = true;
13    extraGroups = [ "wheel" ];
14    initialPassword = "test";
15  };
16
17  system.stateVersion = "24.05";
18}
```

--------------------------------

### Install from a Nix expression

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/install

Install the derivation defined in example.nix into the current profile.

```bash
$ nix-env --install --file example.nix
installing 'example'
$ ls ~/.nix-profile
foo-file
bar-file
manifest.nix
```

--------------------------------

### Example manifest.nix content

Source: https://nix.dev/manual/nix/2.35/command-ref/files/manifest.nix

This snippet shows the structure of a manifest.nix file after installing the hello package, containing derivation metadata and output paths.

```nix
[{
  meta = {
    available = true;
    broken = false;
    changelog =
      "https://git.savannah.gnu.org/cgit/hello.git/plain/NEWS?h=v2.12.1";
    description = "A program that produces a familiar, friendly greeting";
    homepage = "https://www.gnu.org/software/hello/manual/";
    insecure = false;
    license = {
      deprecated = false;
      free = true;
      fullName = "GNU General Public License v3.0 or later";
      redistributable = true;
      shortName = "gpl3Plus";
      spdxId = "GPL-3.0-or-later";
      url = "https://spdx.org/licenses/GPL-3.0-or-later.html";
    };
    longDescription = ''
      GNU Hello is a program that prints "Hello, world!" when you run it.
      It is fully customizable.
    '';
    maintainers = [{
      email = "edolstra+nixpkgs@gmail.com";
      github = "edolstra";
      githubId = 1148549;
      name = "Eelco Dolstra";
    }];
    name = "hello-2.12.1";
    outputsToInstall = [ "out" ];
    platforms = [
      "i686-cygwin"
      "x86_64-cygwin"
      "x86_64-darwin"
      "i686-darwin"
      "aarch64-darwin"
      "armv7a-darwin"
      "i686-freebsd13"
      "x86_64-freebsd13"
      "aarch64-genode"
      "i686-genode"
      "x86_64-genode"
      "x86_64-solaris"
      "js-ghcjs"
      "aarch64-linux"
      "armv5tel-linux"
      "armv6l-linux"
      "armv7a-linux"
      "armv7l-linux"
      "i686-linux"
      "m68k-linux"
      "microblaze-linux"
      "microblazeel-linux"
      "mipsel-linux"
      "mips64el-linux"
      "powerpc64-linux"
      "powerpc64le-linux"
      "riscv32-linux"
      "riscv64-linux"
      "s390-linux"
      "s390x-linux"
      "x86_64-linux"
      "mmix-mmixware"
      "aarch64-netbsd"
      "armv6l-netbsd"
      "armv7a-netbsd"
      "armv7l-netbsd"
      "i686-netbsd"
      "m68k-netbsd"
      "mipsel-netbsd"
      "powerpc-netbsd"
      "riscv32-netbsd"
      "riscv64-netbsd"
      "x86_64-netbsd"
      "aarch64_be-none"
      "aarch64-none"
      "arm-none"
      "armv6l-none"
      "avr-none"
      "i686-none"
      "microblaze-none"
      "microblazeel-none"
      "msp430-none"
      "or1k-none"
      "m68k-none"
      "powerpc-none"
      "powerpcle-none"
      "riscv32-none"
      "riscv64-none"
      "rx-none"
      "s390-none"
      "s390x-none"
      "vc4-none"
      "x86_64-none"
      "i686-openbsd"
      "x86_64-openbsd"
      "x86_64-redox"
      "wasm64-wasi"
      "wasm32-wasi"
      "x86_64-windows"
      "i686-windows"
    ];
    position =
      "/nix/store/7niq32w715567hbph0q13m5lqna64c1s-nixos-unstable.tar.gz/nixos-unstable.tar.gz/pkgs/applications/misc/hello/default.nix:34";
    unfree = false;
    unsupported = false;
  };
  name = "hello-2.12.1";
  out = {
    outPath = "/nix/store/src1vzij2z0slnakrsbpqpk20389z0k6-hello-2.12.1";
  };
  outPath = "/nix/store/src1vzij2z0slnakrsbpqpk20389z0k6-hello-2.12.1";
  outputs = [ "out" ];
  system = "x86_64-linux";
  type = "derivation";
}]
```

--------------------------------

### Install the Nix build

Source: https://nix.dev/manual/nix/2.35/development/building

Install the compiled Nix binary to the local output directory.

```bash
[nix-shell]$ installPhase
[nix-shell]$ ./outputs/out/bin/nix --version
nix (Nix) 2.12
```

--------------------------------

### Install packages from tarball URLs

Source: https://nix.dev/manual/nix/2.35/release-notes/rl-1.9

Examples of using Nix expression tarballs directly in command-line tools.

```bash
$ nix-env -f https://github.com/NixOS/nixpkgs-channels/archive/nixos-14.12.tar.gz -iA firefox
```

```bash
$ nix-build https://github.com/NixOS/nixpkgs/archive/master.tar.gz -A hello
```

```bash
$ nix-shell -p pan -I nixpkgs=https://github.com/NixOS/nixpkgs-channels/archive/8a3eea054838b55aca962c3fbde9c83c102b8bf2.tar.gz
```

```bash
$ nixos-rebuild test -I nixpkgs=https://github.com/NixOS/nixpkgs-channels/archive/nixos-unstable.tar.gz
```

--------------------------------

### Initialize shell for package search

Source: https://nix.dev/tutorials/packaging-existing-software

Starts a nix-shell with git and ripgrep installed to facilitate local repository searching.

```bash
$ nix-shell -p git ripgrep
[nix-shell:~]$
```

--------------------------------

### Install nix-serve

Source: https://nix.dev/manual/nix/2.35/package-management/binary-cache-substituter

Install the nix-serve daemon from Nixpkgs to enable HTTP binary cache serving.

```bash
$ nix-env --install --attr nixpkgs.nix-serve
```

--------------------------------

### Store path examples

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix

Examples of referencing store paths and derivations.

```text
/nix/store/10l19qifk7hjjq47px8m2prqk1gv4isy-hello-2.10
```

```text
/nix/store/p7gp6lxdg32h4ka1q398wd9r2zkbbz2v-hello-2.10.drv
```

```text
/nix/store/p7gp6lxdg32h4ka1q398wd9r2zkbbz2v-hello-2.10.drv^out
```

```text
/nix/store/p7gp6lxdg32h4ka1q398wd9r2zkbbz2v-hello-2.10.drv^*
```

--------------------------------

### Install Nix on Linux

Source: https://nix.dev/install-nix

Use the multi-user installation script for Linux systems.

```bash
$ curl -L https://nixos.org/nix/install | sh -s -- --daemon
```

--------------------------------

### Install a store path

Source: https://nix.dev/manual/nix/2.35/release-notes/rl-0.8

Install an already built store path directly.

```bash
$ nix-env -i /nix/store/hsyj5pbn0d9i...-aterm-2.3.1
```

--------------------------------

### Install from binary tarball

Source: https://nix.dev/manual/nix/2.35/installation/installing-binary

Manual steps to download, unpack, and run the Nix installer from a tarball.

```bash
$ pushd $(mktemp -d)
$ export VERSION=2.19.2
$ export SYSTEM=x86_64-linux
$ curl -LO https://releases.nixos.org/nix/nix-$VERSION/nix-$VERSION-$SYSTEM.tar.xz
$ tar xfj nix-$VERSION-$SYSTEM.tar.xz
$ cd nix-$VERSION-$SYSTEM
$ ./install
$ popd
```

--------------------------------

### Example manifest.json structure

Source: https://nix.dev/manual/nix/2.35/command-ref/files/manifest.json

A sample JSON structure showing the version and elements array containing installed package metadata.

```json
{
  "version": 1,
  "elements": [
    {
      "active": true,
      "attrPath": "legacyPackages.x86_64-linux.zoom-us",
      "originalUrl": "flake:nixpkgs",
      "storePaths": [
        "/nix/store/wbhg2ga8f3h87s9h5k0slxk0m81m4cxl-zoom-us-5.3.469451.0927"
      ],
      "uri": "github:NixOS/nixpkgs/13d0c311e3ae923a00f734b43fd1d35b47d8943a"
    },
    …
  ]
}
```

--------------------------------

### Display installer help flags

Source: https://nix.dev/manual/nix/2.35/installation/installing-binary

Shows available command line arguments for the Nix installer.

```bash
$ curl -L https://nixos.org/nix/install | sh -s -- --help
```

--------------------------------

### Install all derivations from a file

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/install

Installs all derivations defined in a specific Nix expression file.

```bash
$ nix-env --file ~/foo.nix --install '.*'
```

--------------------------------

### CLI pinning examples

Source: https://nix.dev/reference/pinning-nixpkgs

Examples of using -I and NIX_PATH to pin Nixpkgs via the command line.

```bash
$ nix-build -I ~/dev
```

```bash
$ nix-build -I nixpkgs=http://nixos.org/channels/nixos-22.11/nixexprs.tar.xz
```

```bash
$ nix-build -I nixpkgs=channel:nixos-22.11
```

```bash
$ NIX_PATH=nixpkgs=http://nixos.org/channels/nixos-22.11/nixexprs.tar.xz nix-build
```

```bash
$ NIX_PATH=nixpkgs=channel:nixos-22.11 nix-build
```

--------------------------------

### Install Nix on macOS

Source: https://nix.dev/install-nix

Use the recommended multi-user installation script for macOS.

```bash
$ curl -L https://nixos.org/nix/install | sh
```

--------------------------------

### Start shell for specific package

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-develop

Starts a shell environment for the GNU Hello package from nixpkgs.

```bash
nix develop nixpkgs#hello
```

--------------------------------

### Install Nix on Windows (WSL2)

Source: https://nix.dev/install-nix

Choose between single-user or multi-user installation depending on systemd support.

```bash
$ curl -L https://nixos.org/nix/install | sh -s -- --no-daemon
```

```bash
$ curl -L https://nixos.org/nix/install | sh -s -- --daemon
```

--------------------------------

### Specify Installables via File

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix

Use the --file flag to interpret installables from a Nix file.

```bash
--file /path/to/nixpkgs hello
```

--------------------------------

### Perform a dry-run installation

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/install

Simulates an installation to see which paths will be downloaded or built without modifying the profile.

```bash
$ nix-env --file '<nixpkgs>' --install --attr hello --dry-run
(dry run; not doing anything)
installing ‘hello-2.10’
this path will be fetched (0.04 MiB download, 0.19 MiB unpacked):
  /nix/store/ikwkxz4wwlp2g1428n7dy729cg1d9hin-hello-2.10
  ...
```

--------------------------------

### Complete configuration.nix file

Source: https://nix.dev/tutorials/nixos/nixos-configuration-on-vm

The full example configuration combining user, package, and system settings.

```nix
 1{ config, pkgs, ... }:
 2{
 3  boot.loader.systemd-boot.enable = true;
 4  boot.loader.efi.canTouchEfiVariables = true;
 5
 6  users.users.alice = {
 7    isNormalUser = true;
 8    extraGroups = [ "wheel" ]; # Enable ‘sudo’ for the user.
 9    initialPassword = "test";
10  };
11
12  environment.systemPackages = with pkgs; [
13    cowsay
14    lolcat
15  ];
16
17  system.stateVersion = "24.05";
18}
```

--------------------------------

### Perform a single-user installation

Source: https://nix.dev/manual/nix/2.35/installation/installing-binary

Forces the installer to perform a single-user setup where the user owns the /nix directory.

```bash
$ bash <(curl -L https://nixos.org/nix/install) --no-daemon
```

--------------------------------

### Initialize project directory

Source: https://nix.dev/tutorials/nixos/provisioning-remote-machines

Create and enter a new directory for the provisioning project.

```bash
mkdir remote
cd remote
```

--------------------------------

### Install Nix in single-user mode

Source: https://nix.dev/manual/nix/2.35/installation/index.html

Alternative installation method for systems without systemd, though it lacks the security and isolation of the multi-user setup.

```bash
__
$ curl -L https://nixos.org/nix/install | sh -s -- --no-daemon
```

--------------------------------

### Display build and download information

Source: https://nix.dev/manual/nix/2.35/release-notes/rl-0.12

Example output showing derivations to be built and paths to be downloaded with their total size.

```text
the following derivations will be built:
  /nix/store/129sbxnk5n466zg6r1qmq1xjv9zymyy7-activate-configuration.sh.drv
  /nix/store/7mzy971rdm8l566ch8hgxaf89x7lr7ik-upstart-jobs.drv
  ...
the following paths will be downloaded/copied (30.02 MiB):
  /nix/store/4m8pvgy2dcjgppf5b4cj5l6wyshjhalj-samba-3.2.4
  /nix/store/spc1m987vlibchdx369qwa391s738s7l-libunwind-0.98.6
  ...
```

--------------------------------

### Manual flake initialization equivalent

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-flake-new

The manual steps equivalent to running nix flake new.

```bash
mkdir dest-dir
cd dest-dir
nix flake init
```

--------------------------------

### Start the nix-serve server

Source: https://nix.dev/manual/nix/2.35/package-management/binary-cache-substituter

Launch the server on a specified port to begin serving store paths.

```bash
$ nix-serve -p 8080
```

--------------------------------

### Overriding Nix Arguments

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/install

Examples of using --arg and --argstr to override function arguments during package installation.

```bash
nix-env --install --attr pkgname --arg system "i686-freebsd"
```

```bash
nix-env --install --attr pkgname --argstr system i686-linux
```

--------------------------------

### Next steps workflow guidance

Source: https://nix.dev/manual/nix/2.35/development/cli-guideline

Illustrates how to suggest logical next steps to users after completing an initialization task.

```bash
$ nix init --template=template#python
Initializing project `template#python`
          in `/home/USER/dev/new-project`

  Next steps
    |> nix develop   -- to enter development environment
    |> nix build     -- to build your project
```

--------------------------------

### Debug build failure output

Source: https://nix.dev/tutorials/packaging-existing-software

Example console output showing a failed nix-build due to a missing install target in the Makefile.

```bash
$ nix-build -A icat
this derivation will be built:
  /nix/store/x1d79ld8jxqdla5zw2b47d2sl87mf56k-icat.drv
...
error: builder for '/nix/store/x1d79ld8jxqdla5zw2b47d2sl87mf56k-icat.drv' failed with exit code 2;
       last 10 log lines:
       >   195 | # warning "_BSD_SOURCE and _SVID_SOURCE are deprecated, use _DEFAULT_SOURCE"
       >       |   ^~~~~~~
       > icat.c: In function 'main':
       > icat.c:319:33: warning: ignoring return value of 'write' declared with attribute 'warn_unused_result' [8;;https://gcc.gnu.org/onlinedocs/gcc/Warning-Options.html#index-Wunused-result-Wunused-result8;;]
       >   319 |                                 write(tempfile, &buf, 1);
       >       |                                 ^~~~~~~~~~~~~~~~~~~~~~~~
       > gcc -o icat icat.o -lImlib2
       > installing
       > install flags: SHELL=/nix/store/8fv91097mbh5049i9rglc73dx6kjg3qk-bash-5.2-p15/bin/bash install
       > make: *** No rule to make target 'install'.  Stop.
       For full logs, run 'nix log /nix/store/x1d79ld8jxqdla5zw2b47d2sl87mf56k-icat.drv'.
```

--------------------------------

### Build and install Nix from source

Source: https://nix.dev/manual/nix/2.35/installation/building-source

Standard sequence of commands to clone, configure, build, and install Nix using Meson and Ninja.

```bash
git clone https://github.com/NixOS/nix.git
cd nix
meson setup build
cd build
ninja
(sudo) ninja install
```

--------------------------------

### Example nix-cache-info File

Source: https://nix.dev/manual/nix/2.35/protocols/binary-cache/nix-cache-info

A sample configuration file defining the store directory, mass query preference, and priority.

```text
StoreDir: /nix/store
WantMassQuery: 1
Priority: 30
```

--------------------------------

### Install and Uninstall Nix via Rust Installer

Source: https://nix.dev/manual/nix/2.35/release-notes/rl-2.34

Commands to install or remove the Nix environment using the new beta Rust-based installer.

```bash
curl -sSfL https://artifacts.nixos.org/nix-installer | sh -s -- install
```

```bash
/nix/nix-installer uninstall
```

--------------------------------

### Install Nix via binary tarball

Source: https://nix.dev/manual/nix/2.35/release-notes/rl-1.7

Use this command to install Nix using the improved binary tarball installer.

```bash
$ bash <(curl -L https://nixos.org/nix/install)
```

--------------------------------

### Run Nix Multi-User Installer on Linux

Source: https://nix.dev/manual/nix/2.35/release-notes/rl-2.1

Use the --daemon flag with the Nix installer script to perform a multi-user installation on Linux systems running systemd.

```bash
sh <(curl -L https://nixos.org/nix/install) --daemon
```

--------------------------------

### Build the Nix manual from scratch

Source: https://nix.dev/manual/nix/2.35/development/documentation

Commands to build the manual documentation from the source repository.

```bash
nix-build -E '(import ./.).packages.${builtins.currentSystem}.nix.doc'
```

```bash
nix build .#nix-manual
```

--------------------------------

### Install arbitrary package version

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/install

Installs an arbitrary version of a package.

```bash
$ nix-env --install gcc
installing `gcc-3.3.2'
```

--------------------------------

### Build the formatter

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-formatter-build

Example output showing the execution of the nix formatter build command and the resulting store path.

```bash
__
# nix formatter build
/nix/store/cb9w44vkhk2x4adfxwgdkkf5gjmm856j-treefmt/bin/treefmt
```

--------------------------------

### Setup old version environment

Source: https://nix.dev/guides/recipes/dependency-management

Initialize a new directory with a different version of Nixpkgs using npins.

```bash
$ nix-shell
[nix-shell]$ mkdir old
[nix-shell]$ cd old
[nix-shell]$ npins init --bare
[nix-shell]$ npins add github nixos nixpkgs --branch nixos-21.11
```

--------------------------------

### Install a specific version of Nix

Source: https://nix.dev/manual/nix/2.35/installation/installing-binary

Downloads and runs the installer for a defined version.

```bash
$ export VERSION=2.19.2 
$ curl -L https://releases.nixos.org/nix/nix-$VERSION/install | sh
```

--------------------------------

### Query installed packages

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/query

Lists all packages currently installed in the user environment.

```bash
$ nix-env --query
bison-1.875c
docbook-xml-4.2
firefox-1.0.4
MPlayer-1.0pre7
ORBit2-2.8.3
…
```

--------------------------------

### Create a local file for testing

Source: https://nix.dev/tutorials/working-with-local-files

Create a dummy file to demonstrate how file sets handle individual files.

```bash
$ touch some-file
```

--------------------------------

### Add a directory to the Nix store

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-store-add

Example demonstrating the creation of a directory and its subsequent addition to the Nix store.

```bash
# mkdir dir
# echo foo > dir/bar

# nix store add ./dir
/nix/store/6pmjx56pm94n66n4qw1nff0y1crm8nqg-dir

# cat /nix/store/6pmjx56pm94n66n4qw1nff0y1crm8nqg-dir/bar
foo
```

--------------------------------

### Example .narinfo file content

Source: https://nix.dev/manual/nix/2.35/protocols/binary-cache/narinfo

A sample .narinfo file demonstrating the required fields and format for a store object.

```text
StorePath: /nix/store/n5wkd9frr45pa74if5gpz9j7mifg27fh-foo
URL: nar/1w1fff338fvdw53sqgamddn1b2xgds473pv6y13gizdbqjv4i5p3.nar.xz?sha256=1w1fff338fvdw53sqgamddn1b2xgds473pv6y13gizdbqjv4i5p3
Compression: xz
FileHash: sha256:09ymwqf5i9q7d4dm7x4pjjcqqj0qrcp5lnznbh42gfsci5hcbqqm
FileSize: 4029176
NarHash: sha256:09ymwqf5i9q7d4dm7x4pjjcqqj0qrcp5lnznbh42gfsci5hcbqqm
NarSize: 34878
References: g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar n5wkd9frr45pa74if5gpz9j7mifg27fh-foo
Deriver: g1w7hy3qg1w7hy3qg1w7hy3qg1w7hy3q-bar.drv
Sig: asdf:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
Sig: qwer:AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA==
CA: fixed:r:sha256:1lr187v6dck1rjh2j6svpikcfz53wyl3qrlcbb405zlh13x0khhh
```

--------------------------------

### System features configuration example

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-help-stores

Example value for the system-features configuration setting.

```text
"kvm"
```

--------------------------------

### Bundle Hello application

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-bundle

Bundles the hello package from nixpkgs and executes the resulting binary.

```bash
# nix bundle nixpkgs#hello
# ./hello
Hello, world!
```

--------------------------------

### Git repository structure example

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix

Example directory structure for a git-based flake.

```text
.
└── baz
    ├── blah
    │   └── file.txt
    └── flake.nix
```

--------------------------------

### Remove single-user Nix installation

Source: https://nix.dev/manual/nix/2.35/installation/uninstall

Removes files associated with a single-user Nix installation.

```bash
rm -rf /nix ~/.nix-channels ~/.nix-defexpr ~/.nix-profile ~/.local/share/nix ~/.local/state/nix ~/.cache/nix
```

--------------------------------

### Configure icat.nix with fetchzip

Source: https://nix.dev/tutorials/packaging-existing-software

Initial setup for icat.nix using fetchzip as the source fetcher.

```nix
 1# icat.nix
 2{
 3  stdenv,
 4  fetchzip,
 5}:
 6
 7stdenv.mkDerivation {
 8  pname = "icat";
 9  version = "v0.5";
10
11  src = fetchzip {
12    # ...
13  };
14}
```

--------------------------------

### Create hello.c source file

Source: https://nix.dev/tutorials/cross-compilation

A simple C program to demonstrate cross-compilation.

```c
#include <stdio.h>

int main (void)
{
  printf ("Hello, world!\n");
  return 0;
}
```

--------------------------------

### Perform a multi-user installation

Source: https://nix.dev/manual/nix/2.35/installation/installing-binary

Forces the installer to set up the Nix daemon and system users.

```bash
$ bash <(curl -L https://nixos.org/nix/install) --daemon
```

--------------------------------

### Compare installed and available versions

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/query

Compares the versions of installed packages against those available in the channels.

```bash
$ nix-env --query --compare-versions
...
acrobat-reader-7.0 - ?      (package is not available at all)
autoconf-2.59      = 2.59   (same version)
firefox-1.0.4      < 1.0.7  (a more recent version is available)
...
```

--------------------------------

### CLI Action Feedback Example

Source: https://nix.dev/manual/nix/2.35/development/cli-guideline

Demonstrates providing clear, descriptive feedback for long-running commands like nix build.

```text
$ nix build
 Downloaded python3.8-poetry 1.2.3 in 5.3 seconds
 Downloaded python3.8-requests 1.2.3 in 5.3 seconds
...
   Success! You have successfully built my-project.
$
```

--------------------------------

### Educational tips during build processes

Source: https://nix.dev/manual/nix/2.35/development/cli-guideline

Provides an example of how to display helpful tips and status information during long-running build operations without being intrusive.

```bash
$ nix build
    Started building my-project 1.2.3
 Downloaded python3.8-poetry 1.2.3 in 5.3 seconds
 Downloaded python3.8-requests 1.2.3 in 5.3 seconds
------------------------------------------------------------------------
      Press `v` to increase logs verbosity
         |> `?` to see other options
------------------------------------------------------------------------
      Learn something new with every build...
         |> See last logs of a build with `nix log --last` command.
------------------------------------------------------------------------
  Evaluated my-project 1.2.3 in 14.43 seconds
Downloading [12 / 200]
         |> firefox 1.2.3 [#########>       ] 10Mb/s | 2min left
   Building [2 / 20]
         |> glibc 1.2.3 -> buildPhase: <last log line>
------------------------------------------------------------------------
```

--------------------------------

### Install a specific output path

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/install

Installs a package directly from its store output path.

```bash
$ nix-env --install /nix/store/y3cgx0xj1p4iv9x0pnnmdhr8iyg741vk-gcc-3.4.3
```

--------------------------------

### Start a shell with overridden package configurations

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-shell

Demonstrates passing complex Nix expressions to the --packages flag.

```bash
$ nix-shell --packages sqlite 'git.override { withManual = false; }'
```

--------------------------------

### Importing a Nix file

Source: https://nix.dev/tutorials/nix-language

Demonstrates creating a file and importing it to evaluate its contents.

```bash
$ echo 1 + 2 > file.nix
```

```nix
import ./file.nix
```

```text
3
```

--------------------------------

### Query store path for installable

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-path-info

Prints the store path produced by a specific installable.

```bash
nix path-info nixpkgs#hello
```

--------------------------------

### List installed packages in a profile

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-profile-list

Displays the packages currently installed in the default profile.

```bash
# nix profile list
Name:               gdb
Flake attribute:    legacyPackages.x86_64-linux.gdb
Original flake URL: flake:nixpkgs
Locked flake URL:   github:NixOS/nixpkgs/7b38b03d76ab71bdc8dc325e3f6338d984cc35ca
Store paths:        /nix/store/i6i08pl20rh0lm46g38wk3bfnvhdl43d-gdb-11.1

Name:               blender-bin
Flake attribute:    packages.x86_64-linux.default
Original flake URL: flake:blender-bin
Locked flake URL:   github:edolstra/nix-warez/91f2ffee657bf834e4475865ae336e2379282d34?dir=blender
Store paths:        /nix/store/rlgr8vjhcv6v2rv7ljgl0pr6g74r0cg9-blender-bin-3.1.2
```

--------------------------------

### Initial project configuration

Source: https://nix.dev/guides/recipes/sharing-dependencies

The starting point for a project defined in default.nix before integrating the development shell.

```nix
1# default.nix
2let
3  nixpkgs = fetchTarball "https://github.com/NixOS/nixpkgs/tarball/nixos-23.11";
4  pkgs = import nixpkgs { config = {}; overlays = []; };
5in
6{
7  myPackage = pkgs.callPackage ./package.nix {};
8}
```

--------------------------------

### Run local project with arguments

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-run

Executes the default installable in the current directory with provided arguments.

```bash
nix run . -- arg1 arg2
```

--------------------------------

### Verify Nix installation

Source: https://nix.dev/install-nix

Check the installed version of Nix in a new terminal session.

```bash
$ nix --version
nix (Nix) 2.11.0
```

--------------------------------

### Start a shell with a package

Source: https://nix.dev/manual/nix/2.35/command-ref/new-cli/nix3-env-shell

Starts a shell session providing the specified package from a flake.

```bash
# nix shell nixpkgs#youtube-dl
# youtube-dl --version
2020.11.01.1
```

```bash
# nix shell nixpkgs/nixos-20.03#hello
```

--------------------------------

### Deploy system with nixos-anywhere

Source: https://nix.dev/tutorials/nixos/provisioning-remote-machines

Builds the configuration and disk script, then executes the deployment to the target host.

```bash
toplevel=$(nixos-rebuild build --no-flake)
diskoScript=$(nix-build -E "((import <nixpkgs> {}).nixos [ ./configuration.nix ]).diskoScript")
nixos-anywhere --store-paths "$diskoScript" "$toplevel" root@target-host
```

--------------------------------

### Execute Local Installer Artifact

Source: https://nix.dev/manual/nix/2.35/development/testing

Run the installer using a locally downloaded and unpacked artifact.

```bash
sh <path/to/artifact>/install --tarball-url-prefix file://<path/to/artifact>
```

--------------------------------

### Displaying build progress in Nix

Source: https://nix.dev/manual/nix/2.35/development/cli-guideline

Example of providing a progress overview for long-running commands like nix build.

```text
__
$ nix build
    Started building my-project 1.2.3
 Downloaded python3.8-poetry 1.2.3 in 5.3 seconds
 Downloaded python3.8-requests 1.2.3 in 5.3 seconds
------------------------------------------------------------------------
      Press `v` to increase logs verbosity
         |> `?` to see other options
------------------------------------------------------------------------
      Learn something new with every build...
         |> See last logs of a build with `nix log --last` command.
------------------------------------------------------------------------
  Evaluated my-project 1.2.3 in 14.43 seconds
Downloading [12 / 200]
         |> firefox 1.2.3 [#########>       ] 10Mb/s | 2min left
   Building [2 / 20]
         |> glibc 1.2.3 -> buildPhase: <last log line>
------------------------------------------------------------------------
```

--------------------------------

### Generate Installer Artifacts

Source: https://nix.dev/manual/nix/2.35/development/testing

Manually build the installer script and tarball for a specific system architecture.

```bash
nix build .#hydraJobs.installerScriptForGHA.<system-double>
```

--------------------------------

### Install pre-commit hooks

Source: https://nix.dev/manual/nix/2.35/development/building

Install git hooks to ensure code is formatted before every commit.

```bash
pre-commit-hooks-install
```

--------------------------------

### Instantiate and build a Nix expression

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-instantiate

Demonstrates instantiating a derivation from a file and building it using nix-store.

```bash
$ nix-instantiate test.nix (instantiate)
/nix/store/cigxbmvy6dzix98dxxh9b6shg7ar5bvs-perl-BerkeleyDB-0.26.drv

$ nix-store --realise $(nix-instantiate test.nix) (build)
...
/nix/store/qhqk4n8ci095g3sdp93x7rgwyh9rdvgk-perl-BerkeleyDB-0.26 (output path)

$ ls -l /nix/store/qhqk4n8ci095g3sdp93x7rgwyh9rdvgk-perl-BerkeleyDB-0.26
dr-xr-xr-x    2 eelco    users        4096 1970-01-01 01:00 lib
...
```

--------------------------------

### Print Hello World in Python

Source: https://nix.dev/contributing/documentation/style-guide

A basic example of syntax highlighting for Python code.

```python
print("Hello, World!")
```

--------------------------------

### Set NIX_SSL_CERT_FILE for installation

Source: https://nix.dev/manual/nix/2.35/installation/env-variables

Configure a custom certificate bundle before running the Nix installation script.

```bash
$ export NIX_SSL_CERT_FILE=/etc/ssl/my-certificate-bundle.crt
$ curl -L https://nixos.org/nix/install | sh
```

--------------------------------

### Install a specific store derivation

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/install

Installs a specific derivation file, typically generated by nix-instantiate.

```bash
$ nix-env --install /nix/store/8la6y31fmm6i4wfmby6avly1wf718xnj-gcc-3.4.3.drv
```

--------------------------------

### Install with restricted outputs

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/install

Install the modified derivation to verify that only the specified output is present in the profile.

```bash
$ nix-env --install --file example-outputs.nix
installing 'example'
$ ls ~/.nix-profile
bar-file
manifest.nix
```

--------------------------------

### Query available packages

Source: https://nix.dev/manual/nix/2.35/command-ref/nix-env/query

Lists all packages available for installation.

```bash
$ nix-env --query --available
firefox-1.0.7
GConf-2.4.0.1
MPlayer-1.0pre7
ORBit2-2.8.3
…
```
Tokens:
Raw