The other side of rwx.
Read a full ls listing to understand numeric permissions, directory access, deletion, special bits, and practical troubleshooting.
Linux
Articles about Linux.
107 articlesFollow a reading path
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.
Rootless containers: whose file permissions count?
Trace UID mappings through bind mounts, persistent data, and network boundaries to explain Podman's permission checks.
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.
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.
No articles match all of these filters.