How Daniel Robbins turned a frustration with binary packages into a source-based meta-distribution, gave Linux the USE flag, and accidentally founded an optimization culture that outlived its own benchmarks — and why "compile everything from source" still wins in the corners where it wins.
Linux
-
The Story of Gentoo -
The Story of Ubuntu How a South African dot-com millionaire who flew to the ISS forked Debian into "Linux for human beings," mailed free CDs to the planet, lost almost every technical bet he made — Unity, Mir, Upstart, convergence — and still ended up owning the operating system the cloud actually runs on.
-
Linux Networking Fundamentals From the TCP/IP model, IP addressing, CIDR, and NAT to network configuration, routing, DNS, firewalls, and troubleshooting — the concepts every developer needs and the Linux commands that put them to work.
-
The Story of Linux How a Finnish student's 1991 hobby kernel, posted to a Usenet group with the caveat that it "won't be big and professional like gnu," collided with a free GNU userland, a frozen BSD lawsuit, and the GPL — and became the operating system of the cloud, the supercomputer, and three billion phones.
-
Random Number Generation for Engineers Random number generation is one of the few places where a single wrong function call silently destroys the security of an entire system. This is a practical, security-aware guide to the three categories engineers must keep straight — TRNG, PRNG, and CSPRNG — how the Linux kernel actually produces randomness in 2026, the catastrophic seeding failures that have leaked real private keys, and exactly which API to call and which to never touch.
-
Immutable Linux Distros: NixOS, Silverblue, and bootc Immutable Linux distros promise atomic updates, first-class rollback, and the end of "it worked yesterday." We walk what immutable actually means at the filesystem level, the three architectures shaping it in 2026 (NixOS, OSTree-based Silverblue, and the new bootc OCI-native model), the cost in developer ergonomics, and who should actually run one.
-
NVMe-over-Fabrics: Block Storage at Near-Local Latency Over the Network NVMe-over-Fabrics extends the NVMe queue model across a network so a host can talk to remote SSDs the same way it talks to local ones. This post is about how the queue-pair model actually maps to RDMA, TCP, and Fibre Channel transports, why TCP made the protocol mainstream, how namespaces and ANA multipath behave in practice, and where NVMe-oF beats and loses to plain iSCSI and direct-attached disk.
-
Why Your Homelab Burns 300W Doing Nothing Where 300W of idle homelab power actually goes, and how to claw most of it back: C-states, ASPM, powertop, HDD spindown, BIOS settings, consolidation onto mini-PCs, and scheduled wake-on-LAN — with the savings math worked out at real electricity prices.
-
traceroute, ping, and the Network Troubleshooting Toolkit How ping, traceroute, mtr, and a dozen supporting tools actually work under the hood, plus a practical symptom-to-tool methodology for diagnosing network problems from first principles.
-
Choosing a Linux Distribution: A Field Guide A no-tribalism field guide to choosing a Linux distribution by use case, covering family trees, package managers, release models, the immutable wave, and the RHEL source controversy.
-
FreeBSD and OpenBSD for the Linux Admin The BSDs for engineers who only know Linux. The single biggest mental shift — a unified base system versus the distro model — then FreeBSD's jails (the original containers), the bhyve hypervisor, native ZFS, and the ports/pkg world; OpenBSD's security pedigree (pledge, unveil, W^X, secure-by-default) and pf, the cleanest firewall syntax in existence. Where a BSD still beats Linux for routers, firewalls, and storage appliances — and the honest places it does not.
-
Integrating Linux with Active Directory Single sign-on across a mixed fleet: joining Linux hosts to a domain with realmd and SSSD, Kerberos and GSSAPI for SSH, mapping AD users and groups to POSIX, sudo rules sourced from AD, Samba for file shares and as a domain member, and the alternative of FreeIPA with an AD trust. Making one identity work everywhere without running everything on Windows.
-
The Linux Window Manager Landscape A dense technical tour of how Linux manages windows in 2026: the architecture of X11 versus Wayland, the three WM paradigms, every notable compositor and WM worth knowing, what you give up running without a DE, and a decision guide for what to actually run.
-
ThinLinc: Linux Remote Desktops and VDI A technical deep-dive into Cendio's ThinLinc: its VNC-based architecture, master/agent brokering model, device redirection, HPC use cases, and how it stacks up against NoMachine, X2Go, xrdp, and plain VNC.
-
Your Steam Deck Is a Linux PC: Non-Gaming Uses The Steam Deck is a full x86-64 Linux machine that happens to have a game launcher as its default shell. Here is how to actually use it as one — and where its immutable OS design will push back.
-
Linux Networking with ip, nftables, and tc The modern Linux networking toolkit: the ip command for link, address, route, and namespace management, nftables replacing iptables with tables, chains, sets and verdict maps, and tc for traffic shaping and network emulation.
-
Linux Performance Analysis Systematic Linux performance analysis: the USE method, CPU profiling with perf and flamegraphs, memory pressure with vmstat and /proc/meminfo, I/O profiling with iostat and blktrace, dynamic tracing with bpftrace one-liners, and strace for syscall inspection.
-
Linux Security Hardening Baseline A practical Linux security hardening baseline: CIS Benchmark controls, kernel hardening via sysctl, AppArmor mandatory access control, seccomp syscall filtering, auditd for syscall monitoring, SSH hardening, fail2ban, unattended-upgrades, and systemd unit sandboxing.
-
LVM and Linux Filesystem Comparison LVM from physical volumes through logical volumes, thin provisioning, LVM snapshots, online resize, and a practical comparison of ext4, XFS, Btrfs, and ZFS on Linux — with guidance on when to use each and how to configure them.
-
systemd Deep Dive A thorough guide to systemd: unit file anatomy for Service, Timer, Socket, and Target units, dependency ordering, socket activation, journald log management, journalctl filtering, systemd-analyze for boot profiling, drop-in overrides, and user-mode systemd instances.
-
WireGuard from Scratch WireGuard from the ground up: Noise Protocol Framework cryptography, key generation, wg-quick configuration, full-tunnel vs split-tunnel routing, site-to-site VPN setup, wg show diagnostics, and honest performance benchmarks against OpenVPN and IPsec.
-
HAProxy Deep Dive: Load Balancing, ACLs, and SSL Termination at Scale The HAProxy configuration DSL from first principles: frontends, backends, ACL-based routing, all load balancing algorithms, stick tables for rate limiting, SSL termination with automatic certificate renewal, the runtime API, and Prometheus observability — all without a sidecar.
-
Proxmox VE: The Comprehensive Guide A complete guide to Proxmox Virtual Environment: installation and post-setup hardening, KVM virtual machines with cloud-init, LXC containers, ZFS and Ceph storage, bridged and VLAN networking, clustering with Corosync, high availability, GPU passthrough, Proxmox Backup Server, and automation via the REST API and Terraform.
-
ZFS for the Homelab: Storage That Doesn't Lie A practical guide to ZFS on Linux: pool layout decisions (RAIDZ vs mirrors), dataset properties, snapshot strategies, send/receive replication for offsite backup, scrub scheduling, and ARC tuning for systems where RAM is not unlimited.
-
Azure Linux 4.0 and Azure Container Linux GA: Microsoft's Hardened OS for Cloud-Native and AI Workloads Microsoft announced Azure Linux 4.0 preview and Azure Container Linux GA at OSS Summit NA 2026 — a Fedora-based VM OS with atomic updates, AI-workload hardening, and a TCMalloc-Azure performance upgrade, alongside a sub-300MB container-only image purpose-built for AKS.
-
eBPF for Observability: Writing Your First Program What eBPF actually is, how the verifier and JIT compiler work, bpftrace one-liners for immediate production insight, writing a real tracing program in C with libbpf, and the production tools built on top of it — Cilium, Pixie, and Parca.
-
Nix and NixOS: Reproducible Infrastructure from the Ground Up Declarative system configuration, the Nix store, flakes, home-manager, and why 'it works on my machine' becomes irrelevant — along with an honest account of where Nix makes your life harder before it makes it better.
-
Building Modern Toolchains on Enterprise Linux: Python, Compilers, and Utilities on SLES 15 and Friends How to give users modern tools — recent Python, compilers, and CLI utilities — on deliberately-frozen enterprise distros like SLES 15 and RHEL, comparing Spack, EasyBuild, Nix, conda, and containers without breaking the stable base.
-
Ghostty Terminal: Mitchell Hashimoto's GPU-Accelerated Terminal A look at Ghostty, Mitchell Hashimoto's GPU-accelerated terminal — where it fits among Alacritty, Kitty, and WezTerm, what its native-UI and zero-config approach gets right, and whether it should be your daily driver.
-
Tiling Window Managers in 2026: Hyprland, Aerospace, and the End of the Linux Ghetto Tiling window managers have left the Linux ghetto — Hyprland on Wayland and AeroSpace on macOS bring keyboard-driven tiling to the mainstream. What they do, how they differ, and how to actually adopt one in 2026.
-
BPF Performance Tools Tour: bcc, bpftrace, and libbpf A tour of the eBPF performance tooling that has reshaped Linux observability — bcc, bpftrace, and libbpf — with practical one-liners and scripts for tracing kernel and userspace events at production scale.
-
Flamegraphs: Reading and Generating How to read and generate flamegraphs — the visualization that turned profiling into something engineers enjoy — covering CPU, off-CPU, and differential flamegraphs, and the perf and eBPF pipelines that produce them.
-
perf: Linux's Best Profiler A practical guide to perf, the profiler that actually shows you what the CPU is doing — sampling, hardware counters, call graphs, and the workflows that feed flamegraphs — written for engineers starting serious Linux performance work.
-
auditd: Linux's Syscall Logger A practical guide to Linux's audit daemon — how auditd logs security-relevant events at the syscall level, how to write rules that capture what compliance and threat detection need, and how to turn its verbose output into something usable.
-
BIOS/UEFI Deep Dive: Boot Phases, Secure Boot, Measured Boot, and TPM What's really happening before your OS loads — UEFI boot phases, Secure Boot, Measured Boot, and the TPM — explained well enough to debug boot failures, sign your own kernel modules, and understand the modern firmware attack surface.
-
FRRouting in Production: The Linux Router That Replaces Cisco for Many Use Cases FRRouting turns commodity Linux into a serious router — the stack behind Cumulus, SONiC, and Cilium's BGP mode. How to run BGP and OSPF in production, and where FRR is a genuine alternative to Cisco and Juniper.
-
GPU Passthrough End-to-End A complete guide to PCIe GPU passthrough with VFIO and KVM — IOMMU groups, binding the device, firmware quirks, NVIDIA's Code 43, and the SR-IOV and vGPU options — so you can hand a GPU to a VM and debug it when it breaks.
-
Kea DHCP: The Successor to ISC DHCP A migration and getting-started guide for Kea, ISC's ground-up replacement for the end-of-life dhcpd — its JSON config model, hooks, REST API, and built-in high availability, with mappings from old dhcpd.conf patterns.
-
KVM/libvirt Without Proxmox How to run VMs on plain Linux with KVM, QEMU, and libvirt — no Proxmox web UI — so that when something breaks at 2 a.m. you understand the layers underneath. virsh, networking, storage pools, and cloud-init from first principles.
-
OSPF for DevOps Engineers: Link-State Routing Without the CCNA OSPF link-state routing explained for DevOps engineers, not CCNA candidates — enough theory to run multiple routers with FRR in a homelab or datacenter, understand areas and LSAs, and debug why a route isn't where you expect.
-
PAM Configuration Deep Dive How Linux PAM really decides whether you get a shell — the module stack, control flags, and the auth, account, session, and password phases — so you can read /etc/pam.d, add MFA or SSSD, and debug a silent login rejection.
-
PCIe for Systems Engineers PCIe for people who currently stop at `lspci` — lanes, generations, bifurcation, and IOMMU explained well enough to diagnose a GPU training at half speed or an NVMe drive hitting a third of its rated IOPS from `lspci -vvv` output.
-
SELinux in Practice (Not 'Disable It') How to actually work with SELinux instead of disabling it — reading denials, using audit2allow responsibly, understanding contexts and booleans, and keeping the one mechanism designed to contain a compromised service enabled.
-
Standalone Ceph Without Proxmox: cephadm, Pool Design, and Day-2 Operations Running Ceph on plain Linux without Proxmox hiding the complexity — bootstrapping with cephadm, designing pools and CRUSH rules for your hardware, exposing RBD, CephFS, and RGW, and the day-2 operations that keep a cluster healthy.
-
Btrfs in Production: Snapshots, Send/Receive, Quotas, and the Pitfalls An honest assessment of running Btrfs in production — what it gets right with snapshots, send/receive, and transparent compression, where it's still dangerous with RAID5/6, and how to use its quotas and tooling without getting burned.
-
Environment Modules with Lmod: How `module load` Actually Works How `module load` actually works — Lmod as a thin Lua layer that rewrites your shell environment — and how to build a hierarchical software tree that serves hundreds of HPC users with conflicting toolchains and no filesystem collisions.
-
fio Benchmarking Cookbook: Stop Using dd, Start Measuring What Matters Why `dd` tells you almost nothing about storage, and how to measure what matters with fio — building realistic jobs for IOPS, throughput, and latency across queue depths so your numbers reflect real workloads rather than cache.
-
LUKS and Full-Disk Encryption: Root Partitions, TPM Unlock, and Key Management Full-disk encryption on Linux with LUKS beyond the installer defaults — how dm-crypt and LUKS headers work, keyslot and key rotation, TPM-backed and automated unlock, and a recovery plan for when you need one years later.
-
RDMA and InfiniBand From the Ground Up: Why It's Fast and How to Diagnose It Why RDMA and InfiniBand deliver 400 Gbps at single-microsecond latency with the CPU idle — how kernel-bypass and the verbs model work, how RoCE differs, and how to diagnose a fabric that isn't hitting its datasheet.
-
XFS Tuning and Internals: Allocation Groups, Log Layout, and Real Workload Tuning What's actually happening underneath the Linux filesystem you've used by default for years — XFS allocation groups, the journal layout, and the tuning that matters for real workloads like large, full, write-heavy volumes.
-
Compiling OpenAccess and OAScript on Non-RHEL Linux: A Deep Dive A comprehensive guide to building OpenAccess and OAScript from source on SLES 15, Ubuntu, and other non-RHEL Linux distributions — covering the SI2 Docker build environment, GLIBC compatibility strategies, OAScript's Tcl build system in detail, and producing portable shared libraries.
-
Linux Memory Management Deep Dive A comprehensive guide to Linux virtual memory, huge pages, NUMA topology, OOM killer tuning, /proc/meminfo interpretation, and using perf mem to find memory bottlenecks.
-
Swift on the Server: A Technical Deep Dive for Experienced Engineers A technically rigorous guide to Swift beyond iOS and macOS — covering Swift NIO, Vapor, Hummingbird, the Swift 6 concurrency model, embedded Swift, Lambda deployments, and an honest assessment of where server-side Swift wins and where it doesn't.
-
The Modern Terminal Stack: A Complete CLI Upgrade Guide From fish/zsh with plugins to starship, zoxide, fzf, ripgrep, bat, eza, and atuin — the definitive guide to building a fast, ergonomic, and beautiful terminal setup in 2026.
-
eBPF for Observability A practical guide to using eBPF for deep observability — tracing system calls and kernel events with bpftrace, profiling applications with BCC tools, and building network visibility with Cilium.
-
IPv6 Practical Guide: Addressing, Dual-Stack, and Running IPv6 in Your Homelab A hands-on guide to IPv6 — addressing schemes, SLAAC vs DHCPv6, dual-stack configuration, prefix delegation, firewalling, and running IPv6 end-to-end in a homelab or production network.
-
Linux Hardening Checklist A practical Linux hardening checklist covering CIS benchmark controls, auditd syscall monitoring, AppArmor and SELinux mandatory access control, kernel parameter tuning, and automated scoring with Lynis.
-
Linux Namespaces and cgroups: The Kernel Primitives That Make Containers Possible A deep dive into the Linux kernel features that underpin every container runtime — namespaces for isolation and cgroups for resource control. Understanding these makes you a better operator and demystifies what Docker and Kubernetes are actually doing.
-
NFS and Network Storage: A Complete Guide from Homelab to the Cloud An exhaustive guide to network storage — NFSv3 vs NFSv4, Samba/SMB, iSCSI block storage, Lustre parallel filesystems, and Ceph, plus how all of these map to homelab deployments and cloud equivalents on Azure, AWS, and GCP.
-
Talos Linux: The Immutable, API-Driven Kubernetes OS with No SSH A comprehensive guide to Talos Linux — the minimal, immutable OS designed exclusively for Kubernetes. Covers the architecture, bootstrapping clusters from scratch, machine configs, day-2 operations, upgrades, and why no SSH makes your infrastructure more secure and reproducible.
-
ZFS for Homelabbers: Datasets, Snapshots, Send/Receive Replication, and Scrub Schedules A practical guide to ZFS for homelab operators — pool creation and tuning, datasets and properties, snapshots and rollbacks, automated replication with zfs send/receive, and the scrub/SMART schedules that keep your data safe long-term.
-
Ansible Playbooks: Idempotent Configuration Management at Any Scale A comprehensive guide to Ansible for sysadmins, DevOps engineers, and homelabbers — covering installation, inventory management, playbook anatomy, Jinja2 templating, roles, Ansible Vault, and practical playbooks for bootstrapping servers, deploying Docker apps, and running bulk OS updates.
-
Bare Metal Provisioning: PXE Boot, iPXE, and Fully Automated OS Installs A deep-dive into network booting and automated OS provisioning — covering the full PXE/iPXE boot chain, dnsmasq and TFTP setup, Ubuntu autoinstall, Debian preseed, Kickstart for Rocky Linux, cloud-init post-provisioning, and a complete Docker Compose provisioning stack that takes a server from blank to configured without touching a USB drive.
-
Bash Scripting Patterns That Hold Up in Production Practical patterns for writing robust Bash scripts: error handling, argument parsing, logging, traps, and portability techniques that survive contact with real systems.
-
Gaming on Linux in 2026: Better Than You Think A comprehensive guide to gaming on Linux in 2026 — Steam and Proton compatibility, native games, Lutris, Wine, GPU drivers, performance tuning, and the distributions best suited for gaming.
-
jq: The Command-Line JSON Processor You Should Already Know A comprehensive guide to jq for filtering, transforming, and scripting with JSON — from basic field access to advanced reshaping, real-world CLI integrations, and production scripting patterns.
-
Linux Desktop Environments: GNOME, KDE, XFCE, and Beyond A comprehensive comparison of Linux desktop environments — GNOME, KDE Plasma, XFCE, Cinnamon, MATE, LXQt, Budgie, and more. Covers philosophy, resource usage, customization, Wayland vs X11, and how to choose the right one for your needs.
-
NFS Filers in Azure: A Complete Management Guide Everything you need to know about managing NFS storage in Azure — Azure NetApp Files and Azure Files NFS — covering provisioning, quotas, user usage, export policies, snapshots, monitoring, and production best practices.
-
Podman vs Docker: Rootless Containers, Pods, and the Case for Switching A deep technical comparison of Podman and Docker covering the daemonless architecture, rootless containers, Kubernetes-native pods, systemd Quadlets, and a practical migration guide for sysadmins and developers ready to make the switch.
-
Shell Scripting for Sysadmins: Automating the Work That Never Ends Practical shell scripting for system administrators — automating user management, log rotation and analysis, disk monitoring, service health checks, backup routines, and scheduled maintenance tasks with real, reusable scripts.
-
SSH Hardening: Locking Down the Door Every Server Has Open A complete SSH hardening guide — key-based authentication, sshd configuration, ProxyJump, agent forwarding, SSH certificates, port knocking, two-factor auth, and auditing who can get in and what they can do.
-
strace and ltrace: Debugging Processes at the System Call Level A practical deep-dive into strace and ltrace — the essential Linux tools for understanding exactly what a process is doing at the kernel and library level. Covers real debugging scenarios, filtering techniques, performance tracing, and interpreting output.
-
The Linux Boot Process: From Power Button to Login Prompt A thorough walkthrough of how Linux boots — from BIOS/UEFI firmware through the bootloader, kernel initialization, initramfs, systemd, and all the way to a running userspace. Includes debugging techniques for each stage.
-
WireGuard VPN: Fast, Modern, and Actually Understandable A complete WireGuard guide — how it works, server and peer setup, split tunneling, road warrior config for laptops and phones, site-to-site networking, key management, and troubleshooting.
-
The Complete VPS Setup Guide: Security, Performance, and Quality of Life A comprehensive guide to setting up a VPS the right way — from choosing a vendor and hardening your first boot, to SSH mastery, firewall configuration, monitoring, backups, and quality-of-life improvements that make remote administration a pleasure.
-
SLURM: The HPC Job Scheduler — From Basics to Advanced Administration A comprehensive deep-dive into SLURM — history, architecture, user commands, advanced workflows, cluster administration, and tracking job efficiency.
-
Essential Unix Commands Every Developer Should Know A practical guide to the most useful Unix commands for daily development work.
-
What is Linux? A Beginner's Introduction Understanding Linux, its history, and why it matters for developers and system administrators.
-
Linux File System Hierarchy Explained Understanding the directory structure of Linux and where everything belongs.
-
Linux File Permissions Demystified Understanding read, write, execute permissions and how to manage them effectively.
-
Linux Package Management: apt, yum, and Beyond Managing software on Linux with package managers across different distributions.
-
Linux User and Group Management Creating users, managing groups, and controlling access on Linux systems.
-
Linux Process Management Understanding and managing processes, signals, and jobs in Linux.
-
Systemd: Managing Services and the Init System Understanding systemd, service management, and unit files on modern Linux systems.
-
Shell Scripting Fundamentals for Linux Writing effective bash scripts for automation and system administration.
-
Linux Performance Tuning and Monitoring Advanced techniques for monitoring and optimizing Linux system performance.