Search.
Find projects, articles, and reading paths.
shell-switcher
A sequenced handover for stopping, starting, and checking the state of desktop shells.
Mellow × Matugen
Generate a palette, image-based highlights, and a complete theme configuration together, so input-method candidate windows follow the desktop colors.
some-NixOS-skills
Separate evaluation, building, and live verification into evidence-aware Nix workflows for coding agents.
myNixOSConfig
Separate system settings, user settings, and desktop variants into composable modules, making the environment traceable and rebuildable.
GitHub Kanban
Bring notifications, review requests, issues, and followed activity into a desktop panel, with scattered information in one view.
Wallpaper collection
Lunar landscapes, cities in the clouds, and pixel signals. Favorite scenes gathered into an evolving personal wallpaper collection.
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.
The other side of rwx.
Read a full ls listing to understand numeric permissions, directory access, deletion, special bits, and practical troubleshooting.
After login, who takes over the desktop?
Follow a login from authentication and session entries through environment setup, autostart, and logout to see how each layer hands off control.
From assets to candidate window: the complete dynamic theme pipeline.
Connect Fcitx5 nine-slice assets, layout, and blur masks to Matugen colors and Nix runtime directories.
If configuration is reproducible, why do apps still forget?
From GNOME defaults and Home Manager activation to Flatpak's management scope, distinguish declarations, preferences, and data.
What does Distrobox actually export?
Walk through GUI and CLI exports, arguments, wrapper scripts, shared paths, troubleshooting, and removing exported entries.
Define the fields first, then make notes queryable.
Start with YAML and inline fields, distinguish pages, tasks, and four output formats, then work through sources, conditions, sorting, and expressions.
Turn projects, tasks, and reading into useful queries.
Build query pages around five practical questions, retain the full grouping and flattening process, and clarify time boundaries, task status, and missing fields.
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.
Rootless containers: whose file permissions count?
Trace UID mappings through bind mounts, persistent data, and network boundaries to explain Podman's permission checks.
How does Quadlet turn container declarations into services?
Follow source files, systemd generation, startup verification, persistent data, and readiness checks, then diagnose service failures.
NixOS: the foundations of a declarative system
Understand how NixOS works through configuration, build outputs, and generations.
Installing NixOS: installation media, partitions, and initial configuration
Understand prerequisites and steps for both graphical and manual installation.
NixOS configuration basics: options and modules
Organize a system configuration around boot, networking, users, packages, and services.
Managing a system with Flakes and Home Manager
Separate the responsibilities of dependency entry points, system modules, user configuration, and project development environments.
The NixOS command line: old and new interfaces and everyday maintenance
Distinguish commands for system activation, user profiles, temporary environments, and garbage collection.
NixOS generation management and garbage collection
Understand the generation lifecycle through inspection, activation, history removal, and storage reclamation.
Specialisation: multiple configuration variants in one generation
Declare variants under a base configuration and distinguish runtime activation from changes that require a reboot.
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.
Which layers does an input candidate window pass through?
Separate the communication and rendering responsibilities of toolkits, windowing protocols, compositors, the shell, and Fcitx5.
Hyprland special workspaces: a drawer for your windows
Separate toggling, launching, and window matching to configure multiple named special workspaces in full.
Plasma 5: historical notes on desktop customization
Preserve the original configuration and tool references while clarifying older-version issues, session differences, and plugin compatibility.
Plasma 6: moving from X11 habits to Wayland
Preserve the original configuration and tool references while clarifying older-version issues, session differences, and plugin compatibility.
Arch Linux philosophy and installation planning
Understand pre-installation choices through rolling releases, boot modes, and storage planning.
Kernel management, systemd-boot, and UKIs
Combine the kernel, initramfs, and command line into a UKI, and understand the limits of signing and TPM measurement.
Pacman hooks, the AUR, and build security
Distinguish the roles of official repositories, AUR build scripts, and isolated environments in package-management automation.
Btrfs subvolume layouts and Snapper snapshots
Define separate state boundaries for the system, user data, and logs, then configure a recoverable snapshot workflow.
Hardening with LUKS2, Secure Boot, and TPM2
Combine disk encryption, boot verification, and runtime access control while retaining a recovery route for each layer.
Performance choices and an everyday maintenance checklist
Use measurements to choose kernels, compressed swap, and power management, and establish checks after rolling updates.
Common Pacman commands and how to remember their flags
Use the S, Q, R, and U operation groups to distinguish repository queries, local queries, removal, and local package installation.
Diagnosing slow Pacman downloads and choosing mirrors
Locate download bottlenecks step by step through networking, mirror status, and parallel downloads.
informant: Arch news and Pacman hooks
Flag unread Arch news before installation or upgrade transactions, with separate entry points for reading and configuration.
Arch Linux with Btrfs: manual installation and archinstall
Work through UEFI, Btrfs subvolumes, the base system, GRUB, and the archinstall installation process.
Configuring GNOME, input methods, and snapshots
Progress from desktop components and graphics and audio drivers to applications, input methods, shortcuts, and snapshots.
GNOME laptop management and desktop customization
Configure hybrid graphics, power, and hibernation, then adjust GNOME, Zsh, and terminal appearance.
KVM, GPU passthrough, and gaming on Arch Linux
Set up virtual machines and device passthrough, and distinguish the runtime boundaries of Steam, Wine, and Waydroid.
Swap, kernels, and troubleshooting on an Arch desktop
Retain full operational details for compressed swap, kernel switching, system cleanup, and common desktop problems.
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.
Building and running container images with dockerTools
Manage application derivations, runtime closures, and container data state separately.
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.
Designing layered desktop and development environments
Choose between the host, Flatpak, Distrobox, virtual machines, and servers based on dependency and permission boundaries.
Declarative GNOME desktop management
Organize desktop, login, theme, and input-method configuration responsibilities into module groups.
GNOME module options reference
Trace module source code to clarify desktop entry points, service switches, application groups, and exclusion mechanisms.
Managing GSettings defaults and dconf state
Distinguish schema defaults, vendor overrides, and the user database to choose the right declarative interface.
From settings diffs to declarations and extensions
Export differences, verify schema keys and types, then declare packages and the enabled-extension list.
Building GNOME variants with Specialisation
Derive independent system toplevels from the parent module graph, with clear inheritance, override, and recovery paths.
kmscon and uwsm in Wayland sessions
Investigate the lifecycles of DRM handoff, systemd user sessions, and XDG autostart separately.
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.
Garbage collection, store optimization, and rollback generations
Distinguish deleting generation references, reclaiming store objects, and switching to older system configurations.
Colmena: building, transferring, and activating multiple nodes
Organize node configurations with a hive and clarify the boundary between local builds and remote application.
NixOS on Raspberry Pi: images, hardware, and services
Move from SD images and first boot to board interfaces, common services, and maintenance on low-memory devices.
NixOS configuration organization, maintenance, and troubleshooting
Retain a complete working checklist for version control, module organization, update backups, secure development, and failure recovery.
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.
Nix commands explained: builds, environments, profiles, and systems
Retain new and legacy CLI commands, store operations, system installation, and Home Manager commands while clarifying easily confused flags.
nh: a unified workflow for Nix systems, users, and cleanup
Cover nh commands, module options, specialisations, search, environment variables, and upstream contribution guidance.
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.
Docker basics: images, containers, and the daemon
Understand container startup through the client, API, containerd, and OCI runtime.
The Docker command line: images, containers, volumes, and networks
Learn common flags and distinguish the effects of running, stopping, and deleting resources.
Dockerfiles and image builds
Organize image recipes around entry commands, multi-stage builds, and cache optimization.
Compose: defining multi-service applications
Manage single-host applications with services, dependencies, profiles, watch, and secrets.
Docker networking and storage
Choose network modes and persistence methods, with clear port-exposure and data-lifecycle boundaries.
Docker in production: resources, security, and recovery
Check container operating conditions through limits, logs, updates, credentials, and backups.
Declaring Docker and containers on NixOS
Organize engine settings, container definitions, and credential inputs with system modules.
Swarm: from service replicas to cluster orchestration
Understand stacks, overlay networks, and rolling updates, and check Compose compatibility boundaries.
Docker and Podman: architecture, compatibility, and coexistence
Compare engine control models, permissions, and ecosystems to choose tools by workload.
Podman fundamentals
Understand Podman's architecture and permission model through containers, images, and OCI runtimes.
A basic Podman usage guide
Learn commands for installation, images, containers, volumes, networks, and everyday maintenance.
Rootless configuration: mappings, ICMP, and registries
Build on the existing permission-boundaries article with administrator configuration and rootless environment requirements.
Pods and Kubernetes manifests
Organize local containers that share networking, and check the scope of Kubernetes manifest imports and exports.
Pods and multi-service configuration with Quadlet
Add a complete dependency template for Pod, database, API, and proxy resources.
Compose providers and interoperability with Docker tools
Separate the responsibilities of Compose implementations, the Podman wrapper, and the compatible API socket.
Managing Podman on NixOS
Declare container runtime environments through system modules, Home Manager, or quadlet-nix.
Advanced Podman operations and tuning
Manage resources, health, image toolchains, logs, and storage cleanup.
Distrobox fundamentals: userspace and host integration
Understand which resources are shared by default and the boundaries provided by rootless operation, images, and containers.
Distrobox installation and backend configuration
Build a working container environment layer by layer, from the backend and UID mappings to first entry.
Distrobox image and container lifecycles
Use complete commands to manage creation, entry, upgrades, deletion, and temporary userspaces.
Distrobox desktop discovery and background-service integration
Handle app/bin export verification and the separate lifecycle of init services independently.
Distrobox declarative manifests and advanced workflows
Cover assemble, GPUs, multi-container collaboration, and platform-specific practices while distinguishing manifests from service-management contracts.
Distrobox on NixOS: package environments and host paths
Configure a rootless backend on a declarative host and diagnose boundaries between Nix profiles, graphics, and traditional userspaces.
Distrobox backups: images, package lists, and shared data
Preserve the guest environment in three complementary ways and clarify separate recovery responsibilities for shared directories and application data.
Distrobox internals: packages, configuration, and command resolution
Use real path diagnostics to explain the different origins of same-named tools, shared configuration, and Nix binaries.
The responsibilities of KVM, QEMU, and libvirt
Build a foundation for understanding the management stack, from hardware virtualization and the KVM API to QEMU's device model.
KVM host installation, permissions, and network preparation
Check host capabilities, distribution components, management authorization, and the actual default-network state one by one.
Managing domains, storage, networks, and recovery with virsh
Retain command categories and XML parameters while distinguishing persistent definitions, running instances, snapshots, and offline backups.
virt-manager: VM creation, hardware panels, and remote control
Map the GUI creation wizard, device settings, and remote display to actual domain configuration and authentication requirements.
KVM firmware, VFIO, virtiofs, and image chains
Explain advanced parameters and document compatibility and recovery requirements for passthrough, image changes, and shared directories.
Declaring KVM host capabilities on NixOS
Configure libvirt through version-pinned module interfaces while managing networking, firmware, and VM runtime state outside the configuration.
Choosing KVM management and automation tools
Compare desktop, web, and automation tools, distinguishing libvirt frontends, independent platforms, and offline image building.
Waydroid architecture: LXC, Binder, and session bridging
Understand Waydroid through container management, user sessions, and Android services.
Waydroid installation and basic setup
Check Wayland, kernel, and graphics requirements, then install images and verify startup layer by layer.
Waydroid integration on NixOS
Use actual module source code to distinguish system declarations, Android images, and user runtime state.
Waydroid GPU detection and hardware acceleration
Diagnose rendering issues through DRM nodes, Android graphics properties, and compositor interactions.
Waydroid bridges, NAT, and security boundaries
Troubleshoot container networking step by step through veth, bridges, DHCP, DNS, and firewalls.
Waydroid properties, multi-window mode, and ARM translation
Adjust windows, input, and translation to application needs while keeping configuration records that allow rollback.
Waydroid troubleshooting and FAQ
Locate failures using evidence from the kernel, container, network, graphics, and application layers.
Waydroid tips: windows, translation, and shared directories
Retain Ivon's practical tips and operational details, with notes on historical versions and compatibility boundaries.
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.
Making notes queryable
Obsidian Dataview: from field conventions to queries organized around your needs.
A terminal file workbench
From Yazi's configuration responsibilities to navigation, batch operations, and handing directories back to the shell.
Container permissions and lifecycles
Use Podman user mappings and Quadlet service generation to understand container boundaries on the host.
Who is working beneath the desktop?
From file permissions to login sessions and an input candidate window on screen.
You can rebuild the environment. What about its state?
Which parts of a working environment do declarative configuration and container entry points each address?
NixOS system foundations and configuration
From installation and configuration organization to activation, generations, and variant maintenance.
The Nix language and build model
Understand how configuration works through attribute sets, function scope, module merging, and derivations.
Flakes: project and dependency management
From input graphs to system outputs, understand locking, updates, and rollback.
Home Manager: managing user configuration
Bring programs, files, and user services into declarative configuration.
Linux command-line fundamentals and composition
Six guides connect files, processes, text, the shell, fzf, and xargs.
SSH authentication, agents, and command-line workflows
Clarify authentication in both directions, then understand key protection and everyday operations.
Shells, terminals, and sessions
Which layer of interaction do Fish, Foot, and Zellij each manage?
The Linux desktop: protocols, windows, and customization
Input-method communication, Hyprland workspaces, and Plasma version migration.
Arch Linux
A practical path from installation and boot to package management, snapshots, security, and the GNOME desktop.
NixOS virtualization and deployment
From disposable VMs to images, remote nodes, and cloud resources, manage build outputs separately from runtime state.
A declarative GNOME desktop on NixOS
From module enablement to user settings and session lifecycles, identify the layer responsible for each desktop setting.
Nix development environments and binary compatibility
From project shells to language dependencies, ELF loaders, and package overrides.
Nix commands and long-term maintenance
Connect the command reference, nh, generation cleanup, and configuration organization.
NixOS node deployment and ARM devices
From Colmena deployment targets to Raspberry Pi images and hardware services.
Git: from snapshots to collaboration and recovery
Build a complete workflow through the object model, local operations, branches, remotes, and recovery.
SOPS encrypted configuration and key lifecycles
From hybrid encryption to runtime deployment, editing, templates, and key migration.
GitHub repositories and collaboration
Move from remote hosting to repository governance, then complete a contribution that can be reviewed.
GitHub Actions and CI
Turn local checks into continuous integration with explicit permissions, results, and failure evidence.
Docker: from running containers to application orchestration
Follow images, builds, Compose, networking, storage, and production operations through to Swarm and engine selection.
Podman container workflows
From images and rootless fundamentals to Pods, Quadlet, Compose, and NixOS management.
Distrobox: userspace, desktop integration, and recoverable environments
From the sharing model to NixOS practice, manage trusted cross-distribution userspaces from end to end.
KVM host and management foundations
From virtualization responsibilities to host setup and management workflows you can verify.
Advanced KVM capabilities and platform choices
Design recoverable configurations around devices, firmware, image chains, and management tools.
Waydroid
Understand Android container integration, graphics and network paths, and application compatibility.
Wine and application environments
Understand the compatibility engine, then maintain Windows applications with separate prefixes and managers.
Proton gaming, deployment, and troubleshooting
Choose a supported path for running games, then manage configuration and investigate failures layer by layer.
No matching results.