From the first add to undoing a change.
Walk through a local Git workflow: staging, partial commits, diff inspection, restoration, history rewriting, and ignore rules.
Development tools.
Version control, terminal tools, and reusable everyday workflows.
69 articlesFollow a reading path
Separate Yazi's configuration, then wire up file openers.
Move from configuration-file responsibilities to openers, matching rules, and key bindings, updating older examples for Yazi 26.9.1.
From selecting files to handing the directory back to the shell.
Distinguish finding, filtering, selection, and the file buffer to complete batch operations and pass the final directory back on exit.
Nix and NixOS: storage, rollback, and declarative thinking
Understand the NixOS system model through the store, profiles, and imperative tools.
Nix syntax: attribute sets, lists, and built-in functions
Learn common data types, attribute access, and the basics of writing configuration expressions.
Nix functions and scope
Identify where each variable comes from in let, inherit, with, and function parameters.
Nix attribute sets: recursion and merging
Distinguish shallow merging in the language from the merging rules for NixOS module options.
Derivations: from expressions to build outputs
Trace the relationship between evaluation, building or downloading substitutes, and store outputs.
Flake structure: inputs and outputs
Understand Flake inputs, outputs, self, and the levels involved in capturing function arguments.
flake.lock and reproducibility
Record dependency sources with version locking while understanding the conditions for reproducible results.
Flake Utils and project templates
Generate outputs for multiple platforms and turn development environments into reusable templates.
External Flake references and collaboration
Connect external modules and packages, and check the relationships between dependency versions.
Migrating NixOS configuration to Flakes
Create a Flake entry point from an existing configuration, then perform checks, builds, and activation separately.
A tutorial on Flake projects and dependency management
Work through Flake commands and project structure, from input syntax to multi-host organization.
How Flake updates work
Distinguish input updates, package sets, system generations, and cache downloads.
Rolling back and manually editing flake.lock
Preserve existing changes before restoring the lock file, and distinguish dependency rollback from system-generation rollback.
Home Manager integration and modular configuration
Compare standalone and NixOS module modes, then split user configuration into modules.
Configuring a terminal environment with Home Manager
Use modules to configure Zsh, Starship, and common command-line tools.
Desktop and theme configuration with Home Manager
Separate system-session and user-appearance responsibilities when configuring Hyprland, Plasma, and GTK.
Home Manager files and symbolic links
Use home.file and XDG file options to manage read-only configuration and directory links.
Secrets management with Home Manager and NixOS
Separate public configuration from private data using encrypted files and runtime paths.
A tutorial on user-level configuration with Home Manager
A complete introduction to installation, program modules, dotfiles, services, and activation.
File and directory operations
Learn everyday file operations, from browsing and searching to links, archives, and disk-space queries.
Process and job management
Understand program execution and termination through process snapshots, signals, and foreground and background jobs.
Text processing and system queries
Move from paged viewing and text filtering to queries about memory, disks, networks, and ports.
Shell fundamentals
Combine command-line tools with pipes, redirection, variables, and history operations.
Fuzzy finding with fzf
Turn lists of files, processes, branches, and history entries into interactive selection inputs.
Passing arguments with xargs
Convert standard input into command arguments while handling delimiters, placeholders, parallelism, and empty input.
SSH authentication: directories, keys, and TOFU
Distinguish user identity, server identity, and the limits of trust on first use.
ssh-agent, passphrases, and keyrings
Understand the separate roles of private-key file protection, the agent signing interface, and desktop keyrings.
SSH usage guide: command-line operations
Generate and manage keys, inspect client configuration, and debug authentication.
Fish: from key bindings to an editable command line
Cover Emacs and Vi bindings, completion, abbreviations, PATH, events, and prompt configuration.
Foot: the boundaries of search, selection, and configuration
Distinguish keyboard modes, primary selection, font size, and the configuration lifecycle, with a complete key-binding reference.
Zellij: does the session survive when the window closes?
Move from panes and tabs to sessions, distinguishing reconnection, layout restoration, and process state.
Validating NixOS configuration with QEMU
From a minimal configuration to GNOME and Sway, distinguish VM declarations from persistent disk state.
Building a bootable NixOS ISO
Customize software, graphical desktops, and bootable images through installation-media modules.
Deploying NixOS over SSH
Distinguish local builds, temporary remote activation, persistent switching, and failure rollback.
Dividing deployment responsibilities between Terraform and NixOS
Manage cloud resources with Terraform, then deploy NixOS system configuration through a controlled process.
nix-ld: precompiled ELF binaries, loaders, and library paths
Start with an existing file that reports ENOENT, then connect ELF diagnostics, packaging fixes, and nix-ld configuration step by step.
Progressing from nix-shell to devShell and direnv
Separate temporary tools, locked project environments, and automatic directory loading into three clear steps.
Overlays, override, and overrideAttrs
Adjust arguments and add patches to existing package definitions, then make the system actually consume the overlay.
Nix development environments: languages, databases, and full-stack examples
Retain complete configurations for Python, Node, Rust, Go, Java, C/C++, Haskell, databases, and Justfile.
Dependency boundaries in Python, uv, and Matplotlib/Qt
Trace Python packages, system libraries, and plugin paths through Qt5Agg and PyPI wheel troubleshooting examples.
A NixOS learning roadmap: foundations, Flakes, user configuration, and beyond
Retain six learning modules, language ecosystems, and advanced resources, with clear prerequisites and progression.
Git's underlying model: objects, snapshots, and references
Use snapshots, the object database, and references to understand what Git operations change.
Git branches: merging, conflicts, and saving work in progress
Understand fast-forward and three-way merges, and use stash to manage unfinished work.
Remote collaboration with Git: fetching, tracking, and two remotes
Distinguish refreshing references, updating local branches, and pushing to a fork.
Advanced Git: rebasing, cherry-picking, and bisecting
Use rebase, cherry-pick, reflog, and bisect after understanding the boundaries of history rewriting.
A Git scenario handbook: correcting, undoing, and recovering
Choose a recovery path based on the current operation and what data has been saved, without compounding data loss.
sops principles: hybrid encryption and recipients
Understand the boundaries of encrypted version control, data keys, and authorization for multiple recipients.
sops-nix integration: runtime, ordering, and SSH host keys
Connect encrypted source files, runtime secret files, and service dependencies.
sops usage guide: command-line operations
Edit encrypted files, inspect their status, and manage recipients and data keys.
sops configuration templates and runtime rendering
Understand encryption rules, sops-nix configuration, and runtime placeholders field by field.
sops key migration and rotation
Migrate keys through a two-recipient transition, distinguishing authorization updates from credential revocation.
GitHub basics
Distinguish Git, GitHub, and gh, then work through sign-in, forking, pushing, and creating a PR.
GitHub repository management
Establish repository documentation, permissions, merge rules, and releases as a verifiable governance contract.
The GitHub contribution workflow
Move from issues and branches through PR review and checks to synchronization and cleanup after merging.
The GitHub Actions execution model
Understand events, workflows, jobs, runners, and steps, along with the distinct roles of matrices, caches, and artifacts.
Configuring CI with GitHub Actions
Design CI from local quality checks and connect stable check statuses to repository merge rules.
GitHub Actions security and troubleshooting
Locate CI risks and failures across event, permission, credential, runner, and supply-chain boundaries.
Nix CI: evaluation, builds, and output contracts
Use a teaching example with six theme outputs to distinguish Nix evaluation, builds, Actions records, and desktop runtime evidence.
Wine: the compatibility layer and prefixes
Understand Wine's DLLs, prefixes, configuration, and runtime boundaries through Windows API compatibility.
Proton: the gaming runtime
Distinguish Steam, official Proton, GE, and umu, and manage runners and prefixes per game.
Bottles: runners and application environments
Maintain dependencies, prefixes, and restore points through the manager while checking actual Flatpak permissions.
The relationship between Wine, Proton, and Bottles
Use the technical lineage, layered model, and scenario matrix to distinguish the responsibilities of compatibility engines and managers.
Wine and gaming environments on NixOS
Manage pinned software, Steam tool registration, Flatpak runtimes, and mutable prefixes as separate layers.
Troubleshooting Wine and Proton
Build a verifiable diagnostic process across the graphics stack, prefixes, media, audio, and logs.
Wine and Proton configuration boundaries
Use environment variables, DLLs, the registry, multiple GPUs, HDR, and performance parameters according to component and version.
umu, Wine and Proton: understanding compatibility tools and choosing Bottles runners
From running Proton outside Steam to choosing Soda, ProtoSoda, GE-Proton and other runners.
No articles match all of these filters.