Random Nix Links

misc_nix_links.md

Links

Resources:

• interactive language tour

  It's the basis for everything and a pretty simple functional language

  "JSON with functions footguns" - It does have some easy to overlook subtleties: inherit (x) y; vs. inherit x y; vs. let ... in vs. with ...; f: g: ret; vs. { f, g }: ret { f, g ? default, ...} @ attrs: ret

• nix-shell examples for various languages

• nix tutoirals

• Search: packages, options, functions

• Manuals: NixOS, nixpkgs, nix.conf, builtins, trivial builders, input references )

• Code: nixpkgs, nix built-status

• Technical Details: thesis, pills

• https://ayats.org/tags/nix/

• https://zero-to-nix.com/

• https://discourse.nixos.org/

Talks:

• Comparison: docker vs. nix
• showcase of nix
• vimjoyer tutorials
• Good enough
• nixcon
• Overlays
• nix-hour #19: module system
• nixcon: debugging closure size

Things beginners should stay away from (at first)

• Home-Manager
• Nixvim
• Disko
• Chaotic Nyx
• NUR
• Deployment Tools (nixos-anywhere, colmena, deploy-rs, etc.)

Snippets

Shell

let
  commit = "345c263f2f53a3710abe117f28a5cb86d0ba4059";
  pkgs = import (builtins.fetchTarball {
    url = "https://github.com/NixOS/nixpkgs/archive/${commit}.tar.gz";
  }) { config = {}; overlays = []; };
in

pkgs.mkShell {
  name = "nix intro";
  packages = [
    pkgs.clolcat
    pkgs.curl
  ];

  shellHook = ''
    echo Hallo von der nix shell
  '';
}

VM

# File: configuration.nix
# Build with:
#   NIXOS_CONFIG="$PWD/configuration.nix" nixos-rebuild build-vm
#   # ...you might need `nix-shell -p nixos-rebuild` as it's only installed on NixOS by default
# Run with:
#   ./result/bin/run-*-vm &

{ pkgs, lib, config, ... }:

{
  # imports = [ ./some-file.nix ];

  users.mutableUsers = false;
  users.users.root.hashedPassword = "";
  services.getty.autologinUser = "root";

  system.stateVersion = config.system.nixos.release;

  programs.git.enable = true;
  programs.neovim = { enable = true; defaultEditor = true; viAlias = true; vimAlias = true; };
  environment.systemPackages = with pkgs; [ ripgrep ];
  virtualisation.vmVariant = {
    virtualisation = {
      qemu.options = [ "-nographic" ];  # qemu.options = [ "-vga virtio" ];
      qemu.consoles = [ "ttyS0" ];
      diskImage = null; # "./nixos.qcow2";
      sharedDirectories.share = { source = toString ./.; target = "/etc/nixos"; };
      mountHostNixStore = true;
      writableStoreUseTmpfs = false;
    };
    boot.loader.grub.device = "nodev";
    fileSystems."/" = {};
  };
}

Clolcat docker image size with alpine and nix

# File: dockerlolcatalpine
FROM alpine:3.20.3
RUN : \
  apk update && \
  apk add --no-cache --repository=http://dl-cdn.alpinelinux.org/alpine/edge/testing/ lolcat
RUN cat > /entrypoint <<EOF
#!/bin/sh
echo -en "Nix build docker image\n" \
        "Much nice, such wow!\n" \
        "Can't contain happy.\n" | lolcat -f
EOF
RUN chmod +x /entrypoint
CMD [ "/entrypoint" ]
# Build with: docker build --tag dockerlolcatalpine --file dockerlolcatalpine . && docker run --rm dockerlolcatalpine

#File: dockerlolcat.nix
{ pkgs ? (import <nixpkgs> { config = { }; overlays = [ ]; }).pkgsMusl, lib ? pkgs.lib, ... }:

pkgs.dockerTools.streamLayeredImage {
  name = "dockerlolcatnix";
  tag = "latest";
  config.Cmd =
    let
      msg = pkgs.writeTextFile {
        name = "msg.txt";
        text = ''
          Nix build docker image
          Much nice, such wow!
          Can't contain happy.
        '';
      };
    in
    [ "${lib.getExe pkgs.clolcat}" "-f" "${msg}" ];
}
# $(nix-build dockerlolcat.nix --no-out-link) | docker load && docker run --rm dockerlolcatnix

$ docker images | grep lolcat
NAME                  TAG       IMAGE          AGE            SIZE
dockerlolcatalpine    latest    ba0f95047ef9   6 days ago     7.85MB
dockerlolcatnix       latest    55fb40eb145e   54 years ago   3.84MB

Shell History

Nix CLI

echo Nix is Great | figlet

which clolcat  # not there

echo Nix is Great | figlet | nix run "nixpkgs#clolcat"

echo Nix is Great | figlet | nix run "github:NixOS/nixpkgs/nixos-unstable#clolcat"

clolcat  # still not there 

Nix-Shells and the Nix-Store

nix-shell -p clolcat

which clolcat  # somewhere in /nix/store/ now

nix-shell shell.nix   # see snippets

which clolcat

echo ... | clolcat

cd ~/devel/python/stechuhr  # advanced example

What did nix actually do?

Depencency tree...

nix-visualize $(realpath $(which clolcat)) -c .viz.cfg -s nix -o clol.png

nix-tree --derivation 'nixpkgs#nix'

chromium --new-window https://mercurytechnologies.github.io/looking-glass-viewer/ >/dev/null 2>&1 &

./nix-closure-graph/nix-closure-graph --lg 'nixpkgs#jupyter' | xclip -i -selection clipboard

Garbage Collector Roots

nix-build shell.nix  # see snippets

ls -hl result

ls -hl /nix/var/nix/gcroots/auto/ | grep -F "$(pwd)"

cat result

Where do packages come from

firefox --new-window https://github.com/nixos/nixpkgs

vi /etc/nixpkgs/pkgs/tools/misc/clolcat/default.nix

NixOS

firefox --new-window https://search.nixos.org/options

vi configuraiton.nix

NIXOS_CONFIG="$PWD/configuration.nix" nixos-rebuild build-vm --max-jobs auto --builders ''

ll result/system/

./result/bin/run-nixos-vm -nographic; reset

Other targets Docker, VM-Images, Raspi-Images, WSL, ...

firefox --new-window https://github.com/nix-community/nixos-generators?tab=readme-ov-file#supported-formats
firefox https://github.com/nix-community/NixOS-WSL

Cross Compilation

nix build nixpkgs#pkgsCross.riscv64.clolcat

file result/bin/clolcat

Remote builders, caches, ipfs, overlay-store

Module Systems

# File: options.nix
{ lib, config, ... }:
let
  inherit (lib) types mkOption;

  toyType = types.submodule (
    { name, ... }: # name, lib, options, config, specialArgs
    {
      options = {
        name = mkOption {
          type = types.str;
          default = name;
          readOnly = true;
        };

        manual = mkOption {
          type = with types; nullOr str;
          description = "Where the toys manual is";
          default = "default";
        };
      };
    }
  );
in
{
  options = {
    description = mkOption { type = types.str; default = "My toybox"; };
    toys = mkOption {
      type = with types; attrsOf toyType;
    };
  };

  config = {
    # This toy is in every toybox
    toys.teddyBear = { manual = "https://mr-snuggles.com"; };
  };
}

# File: default.nix

let
  pkgs = import <nixpkgs> { config = {}; overlays = []; };
  result = pkgs.lib.evalModules {
    modules = [
      ./options.nix  # <-- this is where we use our module
      {
        toys = {
          barbie = { manual = "https://martell.com"; };
          marbles = { manual = null; };
        };
      }
    ];
  };
in
result.config

# nix eval --file default.nix | nix run 'nixpkgs#alejandra' -- --quiet -

# Example for an impure way to deal with python dependencies

let
  commit = "91a00709aebb3602f172a0bf47ba1ef013e34835";
  pkgs = import (builtins.fetchTarball {
    url = "https://github.com/NixOS/nixpkgs/archive/${commit}.tar.gz";
  }) { config = {}; overlays = []; };
in
#{  # flake variant
#  outputs = { self, nixpkgs, ... }: let
#    system = "x86_64-linux";
#    pkgs = nixpkgs.legacyPackages."${system}";
#  in {
# devShells.${system}.default =
pkgs.mkShell {
  name = "impurePythonEnv";

  # Pure Part (python deps from nixpkgs):
  buildInputs = with pkgs; [
    python3Packages.python python3Packages.venvShellHook  # we need a python interpreter for the venv hook
    python3Packages.requests # a nixpkgs-packaged python requirements
    git openssl # system dependencies (runtime or for pip install ...)
  ];

  # Impure Part:
  venvDir = "./.venv";
  postVenvCreation = ''
    if [ -r requirements.txt ]; then
      pip install -r requirements.txt  # install non-nix packaged requirements
    fi
    pip install click
  '';

  postShellHook = ''
    python -c 'import requests, click
    print(f"{requests.__version__ = }\n{click.__version__ = }")
    c = requests.get("https://api.github.com/repos/NixOS/nixpkgs/commits/nixos-unstable").json()["sha"]
    print(f"latest nixos-unstable commit: {c}")'
    echo using ${commit}
  '';
}
#;  };
#}

Configuration options for nix:

echo '
allowed-users = @wheel
auto-optimise-store = true
experimental-features = nix-command flakes repl-flake
flake-registry = /etc/nix/registry.json
max-jobs = auto
nix-path = nixpkgs=/etc/nixpkgs
require-sigs = true
sandbox = true
sandbox-fallback = false
trusted-users = root @wheel
use-xdg-base-directories = true
builders-use-substitutes = true' | sudo tee -a /etc/nix.conf

cp -b /etc/nix/registry.json /etc/nix/registry.json~
echo '{
  "version": 2,
  "flakes": [ { 
      "from": { "type": "indirect", "id": "nixpkgs" },
      "to": { "type": "path", "path": "/etc/nixpkgs" }
    } ]
}' | sudo tee /etc/nix/registry.json

sudo systemctl restart nix-daemon.service