nami alpha Docs

Options

All 55 keys a nami file can have, each with an example. The same list as nami options prints.

Each example is checked when nami is built: it loads as it's written here. In a terminal, nami options prints this list, and nami check finds mistakes in a file.

Every file

Any nami file may have these: the computer's, yours and a project's.

packages

a list: - name, - name: version, or - name: with its own setup under it

What to install, - name a line. A package with its own setup is - name:, with the setup under it: its files (~/.gitconfig: in user.nami, /etc/... in computer.nami), its desktop settings by schema (org.gnome.TextEditor:), login-shell: true (zsh, fish) and version:. What's no one package's goes in the file's own files:, settings:, env:...; services are in services: (- syncthing). Names come from the catalog (nami search); a name alone is the newest. name: version picks one: firefox: 150 is the newest 150.x, python3: 3.12.4 exactly that (nami versions <name> lists them). Paths starting with ./ are your own recipes. In your user.nami, flathub:<app id> is an app from Flathub (- flathub:com.spotify.Client; nami search <word> --flathub finds them): installed with Flatpak, for you alone (flatpak --user), and taken off when it comes off the list. bundle:github:<owner>/<repo> (or bundle:https://<folder>) is an app made with nami bundle, with the key its updates are signed with (- bundle:github:ada/myapp: { key: 3F2A 9C01 5B7E 22D4 8A10 C3F9 0E6B 7D21 }; installing one in Settings writes it): downloaded from there and checked against that key, for you alone, and taken off when it comes off the list. A name is the catalog's package, set up by the folder of that name in the nearest packages/ folder above the file when there is one: a program's setup (tailscale, cups), or a set of packages and settings with no program of its own (namios, namios-look, printing), as an apt metapackage does. A path (../packages/tailscale) is used as written; nixpkgs:niri is the catalog's package alone, even where a folder has its name. An entry ending in .nami is a set of your own: a file next to this one (./work.nami), or one in a git repo (github:owner/repo/gaming.nami, @ref for a branch or tag; git+https://host/repo.git@v2#gaming.nami), pinned in nami.lock the first time (nami layers --update moves it). What a set says goes underneath this file: lists joined, settings merged, and where both say something, this file wins. It builds on one set at most; packages only add, and what must be one (timezone, login-screen...) comes down that one line of files. nami show --flat prints it all, each line with the file it came from.

packages:
  - namios
  - ./work.nami
  - python3: 3.12
  - openssh:
      /etc/ssh/sshd_config.d/10-nami.conf: |
        PasswordAuthentication no
  - gnome-text-editor:
      org.gnome.TextEditor:
        show-line-numbers: true

The nami file format the file is written in, for any .nami file. Without it, a file is format 1, the only one yet. A later nami that reads files differently will write a higher number, and a nami that doesn't know it says so (this file needs a newer nami: nami self-update) instead of reading it wrong.

format: 1
packages:
  - htop

unfree

true or false

Whether software that isn't free (Steam, Spotify, Discord, ...) may be installed. Allowed unless this is false; such apps are built on your computer, since the binary cache doesn't carry them.

unfree: false

replace

map: package -> recipe path or package

Swap a library in every package that uses it, without building them again: a fixed libpng, the day the fix is out. The replacement is a recipe (extends: libpng with patches:) or another package of the catalog. Each package that uses the library is copied with the old library's path written over by the new one's, as NixOS' replaceDependency does; nami refuses when the new one lacks a soname or a symbol the old had (that needs building again). In one package only: - firefox: { replace: { libpng: ./libpng-fix } }. Apply says where it replaced it.

replace:
  libpng: ./recipes/my-tool   # a recipe: extends: libpng, with a patch

Whether the computer installs updates by itself. auto, the default: once a day nami gets the newest catalog and the newest nami, then the computer's apps (on namiOS, a new version of the system for the next start; the version before stays in the boot menu). manual: only when someone clicks Update Now in Updates, or runs nami os-update as root. On namiOS manual keeps nami-update.timer off, as without: [nami-update.timer] does; on another distribution nami adds the timer, or takes it away, when the file is applied.

updates: manual

cleanup

a duration (30d), off, or { older-than, keep }

When old changes, and the app versions only they use, are removed by themselves. A change stays after the next one replaces it, so nami undo is instant; once it's older than this, it goes, with the files in /nix/store nothing else uses. The current change and the 3 newest always stay, whatever their age. Unset, it's 30 days; off keeps old changes until nami gc; { older-than: 90d, keep: 5 } says both. In user.nami it's for your own changes, in computer.nami for the computer's (on namiOS, the versions in the boot menu: the one running and the one before it always stay). It runs with the daily update, and when you next use nami. When the disk with /nix has less than 10% or 5 GB free, old changes go early, by the same rules but whatever their age. Settings › Storage has the same choice.

cleanup: 7d

history

number

How many changes to keep in history, to go back to: after each apply, older ones go (the current one always stays). keep-generations: is its old name, which works until nami 1.0.

history: 10

caches

list of {url, key}

Extra binary caches to download from before building, such as one you fill with nami push.

caches:
  - url: https://cache.example.org
    key: me-1:6NCHdD59X431o0gWypbMrAURkbJ16ZPMQFGspcDShjY=

env

map of NAME: value

Environment variables: in your user.nami, for your shells and your desktop session; in computer.nami or a package.nami, for everyone's logins and desktop, on a computer nami made. A value may use the login's variables: $HOME, $XDG_RUNTIME_DIR.

env:
  EDITOR: nvim
  PAGER: less -R
  SSH_AUTH_SOCK: $XDG_RUNTIME_DIR/gnupg/S.gpg-agent.ssh

settings

schema: { key: value }

Desktop settings (GNOME and other GSettings apps), applied with gsettings. Keys you remove are reset to their defaults; rollback restores earlier values. In computer.nami they're what everyone starts with (each person can still change theirs); in user.nami, yours. A value YAML can't say (a tuple, a dictionary) is GVariant text tagged !gvariant; a relocatable schema takes its path, schema:/path/.

settings:
  org.gnome.desktop.interface:
    color-scheme: prefer-dark
    clock-format: 24h
  org.gnome.desktop.wm.preferences:
    num-workspaces: 4
  org.gnome.desktop.input-sources:   # GVariant text, for what YAML can't say
    sources: !gvariant "[('xkb', 'us'), ('xkb', 'dk')]"

services (package)

- name, or - unit.type

Run the systemd unit a package ships (lib/systemd/system/<name>.service; a template's instance as name@instance), enabled and started. The package is installed with it. In computer.nami it's the computer's; in your user.nami it's yours (systemctl --user). Named whole (cups.socket, pipewire-pulse.socket), it's that unit, from whichever installed package brings it; in computer.nami, { per-person: true } turns it on for each person, as they log in. Needs systemd.

services:
  - syncthing@ada
  - cups.socket

services (package, changed)

- name: { enable, package, env, after, restart, user }

A package's unit with changes (written as a drop-in). package: when the unit isn't named after its package; enable: false installs it without starting it.

services:
  - tailscaled:
      package: tailscale
      env: { PORT: "41641" }
      restart: always

services (your own)

name: { run, script, at, user, env, after, restart, dir, description, systemd }

Your own service. run: is the command line; a command's name is looked up in your packages, then the system profile, then /usr/bin and the like. System services run as a fresh user with /var/lib/<name> for data unless user: names one. Restarts on failure unless restart: says otherwise. Changing it restarts it; removing it stops it.

services:
  - myapp:
      run: myapp-server --port 8080
      env: { RUST_LOG: info }
      after: [network-online.target]
      user: myapp

services (script, timer)

name: { script, at }

A service whose command is several lines: script: runs them with bash -e (instead of run:). at: starts it on a schedule (systemd's OnCalendar: daily, weekly, *-*-* 04:00) through a timer, instead of at boot; it isn't restarted after it finishes.

services:
  - backup:
      script: |
        cd /srv
        tar czf /backup/srv.tgz .
      at: daily

services (systemd keys)

name: { systemd: { Unit|Service|Install|Timer: { Key: value } } }

Any other systemd setting, written into the unit (or a package unit's drop-in) as it is; a list for a key that repeats. Your own User= or Restart= replaces nami's default; Install's WantedBy replaces the default target.

services:
  - backup:
      script: restic backup /home
      systemd:
        Service: { Type: oneshot, Nice: 10, IOSchedulingClass: idle }
        Unit: { Before: [sleep.target] }

services (its files)

name: { /etc/path: text, settings or { source } }

A service's own files go under it, written as files: are (text, settings in the file's own format, or a file from your repo); the service restarts when nami changes one. An app's setup goes under what turns it on: a service's here, a program's under its package. An entry with only files is on.

services:
  - adguardhome:
      /etc/adguardhome.yaml:
        dns: { port: 53 }
  - myapp:
      run: myapp-server --config /etc/myapp/config.toml
      /etc/myapp/config.toml:
        port: 8080

files

/etc/path: text, settings or { source }

In computer.nami: files under /etc, written as a person's are: text as is, settings in the file's own format, or a file or folder from next to the nami file. A file already there is kept as <file>.nami-backup and comes back when you remove the entry. /etc/passwd, shadow, sudoers, fstab and the like are refused.

files:
  /etc/ssh/sshd_config.d/10-nami.conf: |
    PasswordAuthentication no
  /etc/myapp/config.toml:
    port: 8080

files (mode)

/etc/path: { content|source, mode }

A file with its own permissions (default 0644), owned by root.

files:
  /etc/sudoers.d/90-ops:
    content: "%ops ALL=(ALL) ALL\n"
    mode: "0440"

files (secret)

/etc/path or /run/path: { content, owner, group, mode }, with a !secret in it

On a computer nami made: a file with a secret in it (the whole file, or a setting in it). It's decrypted with the computer's own key as the computer starts, into /run (memory, never the disk or the store): root's alone (0600; 0400 in /run/nami/secrets), or owner:/group:/mode:'s. An /etc path links to it. A file under /run without a secret is written as the computer starts too (0644 unless mode: says). Wi-Fi networks: wifi:.

files:
  /run/nami/secrets/backup-token:
    content: !secret "YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB0cmF5LWV4YW1wbGUK"
    owner: backup
    mode: "0400"

files (reload, restarts)

/etc/path or /run/path: { content|source, reload, restarts }

What to run when nami changes the file on a running computer (nami apply), so what reads it sees the change: reload: a command (or a list), restarts: a unit (or a list), restarted if it's running (restart: before, which still works until nami 1.0; a service's own restart: is when systemd starts it again). Not as the computer starts: everything starts with the new files then. When a package's file gives a file with these and yours gives just its text or settings, yours is its content:: the two contents merge (settings key by key, text replaced) and the options stay; that's how packages: [tailscale] and your /etc/tailscale/up.conf go together.

files:
  /etc/ssh/sshd_config.d/10-nami.conf:
    content: "PasswordAuthentication no\n"
    restarts: sshd.service
  /etc/NetworkManager/conf.d/90-dns.conf:
    content: { main: { dns: default } }
    reload: nmcli general reload

services (a package's unit, by its whole name)

unit.type, or unit.type: { per-person: true }

How a package runs on the computer, in its package.nami (used whenever the computer has that package). A service named whole (cups.socket, docker.service) is a unit the packages bring, turned on where its [Install] says (as systemctl enable); { per-person: true }: each person's own, as they log in.

services:
  - cups.socket
  - pipewire.socket: { per-person: true }
files:
  /etc/tmpfiles.d/cups.conf: |
    d /var/spool/cups 0710 root lp -

computer.nami

Only the computer's file: what the computer is, and who's on it.

wifi

name: { password, ssid, security, hidden, autoconnect, identity, eap, phase2 }

On a computer nami made: Wi-Fi networks, by name. With a password (a !secret) it's WPA2 or WPA3, without one it's open; a company's is security: enterprise with identity: and password: (eap: peap or ttls, phase2: mschapv2 or pap); security: sae is WPA3 only. Each is a NetworkManager connection in /run/NetworkManager/system-connections (root's alone), its password opened with the computer's key as it starts; nami apply tells NetworkManager at once. ssid: when the network's name isn't the entry's, hidden: true, autoconnect: false.

hostname: laptop
wifi:
  home: { password: !secret "YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB0cmF5LWV4YW1wbGUK" }
  cafe: {}
  office: { security: enterprise, identity: ada, password: !secret "YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB0cmF5LWV4YW1wbGUK" }

tailscale

- ../packages/tailscale, and files: /etc/tailscale/up.conf { set, up }

On a computer nami made: Tailscale, nami's tailscale example (nami new laptop --from tailscale copies it to ../packages). Without settings, sudo tailscale up logs in in the browser. Its settings are a file, /etc/tailscale/up.conf: set: holds tailscale set flags (hostname, operator, ssh, accept-routes, exit-node, advertise-exit-node, advertise-routes, ...), applied at every start and when nami apply changes them, without logging in again; up: the flags only tailscale up takes (login-server, advertise-tags). An auth key in /run/nami/secrets/tailscale-auth-key (a !secret) logs it in by itself the first time it starts. An exit node or subnet router also lists tailscale-router (IP forwarding). MagicDNS names resolve through systemd-resolved, as on Ubuntu.

packages:
  - ../packages/tailscale
hostname: laptop
files:
  /etc/tailscale/up.conf:
    set: { operator: ada, ssh: true, accept-routes: true }
  /run/nami/secrets/tailscale-auth-key: !secret "YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB0cmF5LWV4YW1wbGUK"

desktop

niri, or a list

A namiOS computer, made with nami usb (computer.nami): the desktops to pick from on its login screen. The first is the default. Each comes with its package folder in packages: (niri's, which namios lists); desktop: picks and orders them. None: a computer with a text console, like a server.

packages:
  - ../packages/namios
desktop: niri
hostname: laptop

login-screen

gdm or greetd

The login screen (the display manager), when the desktops' files bring more than one: namiOS's own is on greetd, niri's alone GDM. Left out, it's the one listed nearest this file (namios's own, before niri's GDM); listed as near, the file must say (nami check asks). Each is its package's folder (gdm's, namios-greeter's, in nami's examples), and the name is its service's.

packages:
  - ../packages/niri
  - ../packages/namios-greeter
login-screen: greetd

users

name: { admin, name, password, groups, child, hours, without }

Who can log in. Made from a config repo (nami usb github:you/nami-config, or a clone of it), the first admin gets the repo's user.nami at their first login, as nami apply <repo> gives it; anyone else runs that with their own repo. Without password (a hash from mkpasswd), nami usb asks for one. groups are more groups they're in, as usermod -aG would put them (docker: docker without sudo). With no users, nami usb asks for one (an admin). child: true is a child (parental controls, the parental-controls package that desktop lists): no sudo, and no apps of their own (the computer's are theirs, an admin chooses them); hours is when they may use the computer (they log in only then, and their session ends when the hours do), without the apps they can't use (off their menu).

users:
  ada:
    admin: true
    name: Ada
    groups: [docker]
  sam:
    child: true
    hours: 07:00-20:00
    without: [discord, steam]

The computer's name, time zone, language (a locale) and keyboard layout. Left out, the name is nami, and the rest are those of the computer nami usb runs on (else UTC, en_US.UTF-8 and us).

hostname: laptop
timezone: Europe/Copenhagen
language: da_DK.UTF-8
keyboard: dk

without

list of package or service names

Packages the packages you list bring that you don't want on the computer. A package folder's name (printing, plymouth) leaves out that folder wherever it's listed, with all it sets up. A service named whole (systemd-networkd.service) is kept off on a computer nami made (masked): the computer's, or each person's (gcr-ssh-agent.socket).

packages:
  - ../packages/namios
without:
  - printing
  - gnome-calculator

user.nami

Only a person's file, ~/user.nami: their shell, their dotfiles.

aliases (user.nami)

map of name: command

Shell aliases for bash, zsh and fish.

aliases:
  ll: ls -la
  gs: git status

namiOS's desktop, read as the file changes: dock: (on, size: small, medium or large, magnification: off, small or large, position: bottom, left or right, hide, open-apps, pinned: apps by their menu entry's name), all-apps: folders: (All Apps' folders, each a name and its apps by their menu entry's name), minimize: genie or scale, and backups: (your home every hour, to go back in time: on, true by itself; to: disk:<label> or a folder, also there; leave-out: folders, or names and patterns anywhere, in place of the usual caches and the Trash; nami backup status says what it does).

namios:
  dock:
    on: true
    size: medium
    position: bottom
    pinned: [firefox, org.gnome.Nautilus]
  minimize: genie

shell (user.nami)

map of bash|zsh|fish: lines

Lines run at the end of your shell's startup, in interactive shells: prompts, plugins, tools' init lines. nami_share <path> finds an installed package's share/<path>.

shell:
  zsh: |
    eval "$(starship init zsh)"
    source "$(nami_share zsh-autosuggestions/zsh-autosuggestions.zsh)"

The shell your terminals open: their bash hands over to it, without root or chsh. A bash you start from it stays bash, and while it isn't installed nothing changes.

packages:
  - zsh:
      login-shell: true

files (user.nami: settings)

path: nested settings

A file in your home (in user.nami every file is ~/...), as settings written in its own format, picked from the file name: .json, .toml, .yaml, .ini/.conf, gitconfig, .env.

packages:
  - git:
      ~/.gitconfig:
        user: { name: Ada, email: ada@example.org }
        init: { defaultBranch: main }

A file with exactly this text, for a format nami doesn't write itself (a vimrc, a script, Lua, KDL...). JSON, TOML, YAML, INI and gitconfig files are always settings (nested YAML), never text; to keep one as it is, put it in your repo and use { source: ./... }.

files:
  ~/.vimrc: |
    set number
    syntax on

files (user.nami: source)

path: { source: ./path }

A file or folder copied from next to your nami file.

files:
  ~/.config/nvim: { source: ./dotfiles/nvim }

env (user.nami: secret)

NAME: !secret ...

An environment variable whose value is a secret, encrypted right in the file (write it plain, !secret hunter2, and nami secret seal encrypts it; see nami secret). It's decrypted into private files of yours on apply, never into the store.

env:
  GITHUB_TOKEN: !secret "YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB0cmF5LWV4YW1wbGUK"

files (user.nami: secret)

path: !secret ..., or settings with secrets in them, or { content, mode }

A file with a secret in it (the whole file, or a setting in it), written for you alone (mode 0600, or the mode you give), never into the store.

files:
  ~/.config/rclone/rclone.conf:
    s3: { type: s3, secret_access_key: !secret "YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB0cmF5LWV4YW1wbGUK" }
  ~/.ssh/id_ed25519: { content: !secret "YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB0cmF5LWV4YW1wbGUK", mode: "0600" }

files (user.nami: mutable)

path: { mutable: true, content|source }

A normal, editable copy instead of a read-only link, for apps that save their own settings. Your edits are kept unless nami file changes the file.

files:
  ~/.config/Code/User/settings.json:
    mutable: true
    content: { editor.fontSize: 14 }

files (user.nami: options)

path: { content|source, mode, owner, group, mutable, reload, restarts }

A file's options, the same in every nami file, for a file in a home and one in /etc. They're options only with content: (what it says: text or settings) or source: (a file or folder next to the nami file), so a settings file can still have a mode: key of its own. mode: is its permissions ("0640"); a file in your home with a mode is written in place, as one with a secret is. owner: and group: are for the computer's files (in /etc or /run, with a secret in them). mutable: true is for a file in a home that apps may change. reload: and restarts: are for the computer's files, when nami changes one (see files (reload, restarts)). A key a file can't have where it is is refused, saying where it goes.

files:
  ~/.netrc:
    content: "machine example.org login ada password hunter2\n"
    mode: "0400"
  ~/.config/app/config.yaml:
    content: { theme: dark }
    mode: "0600"

project.nami

What's particular to a project's file.

env (project secret)

NAME: !secret ...

In a project's project.nami: an environment variable that's a secret, encrypted right in the file. nami shell, run, env and up decrypt it with your key, into their environment only. A service's env: and exports: take them too.

env:
  STRIPE_KEY: !secret "YWdlLWVuY3J5cHRpb24ub3JnL3YxCi0+IFgyNTUxOSB0cmF5LWV4YW1wbGUK"

packages (project: sets)

an entry ending in .nami: a path, or a file in a git repo

In a project's project.nami: the set it builds on (one; that set can list another), shared by a team: a file in the repo (./nami/common.nami), or one in a git repo (github:owner/repo/node.nami[@ref], git+https://host/repo.git@ref#node.nami). Their packages, env, tasks and services are the project's too; lists are joined, settings merged, and where both say something, the project's own file wins. A set from a repo is pinned to a commit in the project's nami.lock the first time (nami says which), so whoever clones the project gets the same; nami layers --update (or nami shell --upgrade) moves it, and --locked refuses one that isn't pinned. In a repo's set, ./paths and names are its repo's; tasks and services run in the project's folder. A set from a repo can't bring secrets: they go in the project's own file. nami hook uses only what's pinned and fetched.

packages:
  - github:acme/dev/node-service.nami
  - nodejs: 22

services (project, files)

- ./services/<name>.nami, or with { version, port, ports, args, env, exports, ... } under it

In a project's project.nami: what it needs running while you work on it, started by nami up (-d: in the background) and stopped by nami down; no root or systemd. A service file is listed by its path and named after it (./services/postgres.nami is postgres); nami's examples/services has postgres, mysql (MariaDB), redis and mailpit to copy into your project. Their data, sockets and logs are in the project's .nami folder. What they give the project (DATABASE_URL, PGHOST, REDIS_URL, SMTP_PORT, ...) is in nami shell, nami run and nami env. version: picks their package's version; any other key changes theirs.

services:
  - ./services/postgres.nami
  - ./services/redis.nami: { version: 7 }
  - ./services/mailpit.nami: { port: 2525 }

services (project, your own)

name: { run, env, dir, port, ports, ready, ready-timeout, restart, as-root, init, exports, stop-signal, packages }

A project's own process, run like a service file's: run: with the project's tools and environment, in the project's folder (or dir:). ready: is a command that succeeds once it's ready (else its ports answering is), within ready-timeout: (3 minutes; 10m, 600); it's restarted when it ends, after 1s, 2s, 4s, ... up to 30s (restart: on-failure only when it fails, restart: no never); as-root: no: it won't run as root, so as root nami runs it as nobody; init: runs once, before its first start; exports: are variables it gives the project. {state} (its folder in .nami), {sockets} (a short folder for its unix sockets), {port}, {port.<name>}, {project} and {project.dir} are filled in. A second postgres is a copy of its service file by another name (./services/testdb.nami).

services:
  - worker:
      run: npm run worker
      env: { QUEUE: default }
  - ./services/testdb.nami: { port: 5433 }

package.nami

The parts of Linux a package folder (packages/<name>/package.nami) adds to. Its build keys are on Your own packages.

files (package.nami: a systemd unit)

/etc/systemd/system/<name>: text

A service a package needs and doesn't bring (nixpkgs leaves some to NixOS), where systemd looks for it: /etc/systemd/system/<name>, each person's at /etc/systemd/user/<name> (started as they log in), or a change to one as a drop-in (/etc/systemd/system/gdm.service.d/nami.conf). Turn it on in services:.

services:
  - avahi-daemon.service
files:
  /etc/systemd/system/avahi-daemon.service: |
    [Unit]
    Description=Avahi mDNS/DNS-SD Stack
    [Service]
    ExecStart=/run/current-system/sw/bin/avahi-daemon --syslog
    [Install]
    WantedBy=multi-user.target

A file or folder worked out from what's installed, as the system is put together: a shell script writes it to $out ($packages: every package's folder; coreutils, grep, sed and find to hand). tools are packages whose programs it runs, fetched for that and not put on the computer.

files:
  /etc/nami-os/schemas:
    tools: [glib.dev]
    script: |
      mkdir -p "$out"
      for p in $packages; do cp "$p"/share/glib-2.0/schemas/*.xml "$out"/ 2>/dev/null || true; done
      glib-compile-schemas "$out"

login (package.nami)

program: login | password | su | rules; all: lines

The login rules (PAM). A program a package brings that checks who you are gets its rules: login (as logging in), password (the password alone), su (root goes ahead, anyone else gives their password), or the rules themselves. all: are lines for every way to log in, each after nami's own of its kind; an auth sufficient one (a fingerprint) is tried before the password.

login:
  sudo: su
  all:
    - auth sufficient /run/current-system/sw/lib/security/pam_fprintd.so max-tries=1 timeout=10

setuid (package.nami)

list of paths in the packages

Programs that act as root for whoever runs them (sudo, passwd, mount), copied to /run/wrappers/bin with the setuid bit, as they must be.

setuid: [bin/sudo]

groups (package.nami)

group: everyone | admins

Groups the people on the computer join, everyone or its admins (the group itself comes from the package's sysusers file).

groups:
  scanner: everyone
  lpadmin: admins

name-lookup (package.nami)

list of NSS entries

Ways to look up computers' names before DNS, in /etc/nsswitch.conf's hosts line; their modules are found in the packages.

name-lookup: ["mdns_minimal [NOTFOUND=return]"]

boot (package.nami)

kernel, microcode, initrd-programs, initrd-modules, kernel-options

What starts before the computer's own disk is there: kernel (by its nixpkgs name: linux_zen, linux_xanmod; nixpkgs' default without; the packages built for a kernel, linuxPackages.nvidia_x11, are then that one's: kernel-zen lists it), microcode (archives the kernel reads first, from the packages: the processor's updates), initrd-programs and initrd-modules (what the initrd needs: cryptsetup and dm_crypt, to unlock an encrypted disk), kernel-options (the kernel's command line, in every boot entry: a hardware fix like pcie_aspm=off; each package's are joined).

boot:
  initrd-programs: [bin/cryptsetup]
  initrd-modules: [dm_crypt, xts]
  kernel-options: [pcie_aspm=off]

drivers (package.nami)

firmware, graphics, graphics-32bit, kernel-modules: lists of package names

Drivers: firmware goes in /lib/firmware (linux-firmware, in base); graphics are the graphics drivers, whose libraries go together in /run/opengl-driver, where OpenGL, EGL, Vulkan and GBM look (mesa, in desktop); graphics-32bit are their 32-bit builds, in /run/opengl-driver-32, for 32-bit programs (pkgsi686Linux.mesa, in steam); kernel-modules are packages of modules built for the system's kernel (linuxPackages), which join its own in /lib/modules. packages/nvidia/package.nami has all three.

drivers:
  firmware: [linuxPackages.nvidia_x11.firmware]
  graphics: [linuxPackages.nvidia_x11.out]
  kernel-modules: [linuxPackages.nvidia_x11_stable_open]

libraries (package.nami)

list of package names

Libraries for programs built for other distributions (a downloaded tarball, an AppImage, a game, npm's and pip's prebuilt programs): they ask for their loader at /lib64/ld-linux-x86-64.so.2, which is nix-ld when a package lists it, and it finds their libraries in these packages' lib/ (a package's lib output too), and only for them: the system's own programs don't see them. Each package's are joined; other-linuxes and other-linuxes-desktop list a generous set. A person's own come with nami libraries --add <program>.

packages: [nix-ld]
libraries: [zlib, openssl, libx11, gtk3]

How to tell a package works, on a computer nami made: a name, a command, and what its output has (a regular expression). It's a file of its own next to the package.nami; tests/usb.sh runs them all.

"printing runs":
  run: lpstat -r
  expect: "scheduler is running"

secure-boot (package.nami)

shim / mokmanager: { from, sha256, file }

Where the computer's Secure Boot start comes from: shim (signed by Microsoft) and its MokManager, a file each in a Debian package (from: its addresses, the first that answers; its sha256; the file in it). nami's own is packages/secure-boot/package.nami, which base lists; shim starts systemd-boot and kernels signed with the computer's own key.

secure-boot:
  shim:
    from: https://deb.debian.org/debian/pool/main/s/shim-signed/shim-signed_1.51+16.1-2_amd64.deb
    sha256: ...
    file: usr/lib/shim/shimx64.efi.signed
  mokmanager:
    from: https://deb.debian.org/debian/pool/main/s/shim-helpers-amd64-signed/shim-helpers-amd64-signed_1+16.1+2_amd64.deb
    sha256: ...
    file: usr/lib/shim/mmx64.efi.signed

hardware (package.nami)

pci / usb: a list of "vendor:device" (hex), or "vendor:*" for any of the vendor's

What hardware the package is for, by the ids lspci -nn and lsusb show. nami doctor says which packages (nami's examples and your packages/ folder's) a computer's devices are for and how to add one it doesn't list; nami check of the computer's own file notes a listed one it has nothing for (fine when the file is for other computers too). It changes nothing that's installed: nvidia's drivers load only with an NVIDIA card either way.

hardware:
  pci: ["10de:1b80", "10de:1b81"]
  usb: ["046d:*"]

Something wrong or missing here? nami report tells us, or Report a problem in the nami window.