All Posts
15 posts
tmux-agents: Publishing Coding Agent State into tmux Pane Options
A Rust CLI that detects coding agents running in tmux panes and writes their state back onto tmux as pane options, so the status line is the UI and there is no daemon, no socket, and no protocol to version.
Dotfiles, Part 6: Ephemeral and Declarative Edge Access
Two new modes for the cf CLI: throwaway tunnels that gate a local port behind a login and clean up after themselves, and a declarative reconciler that keeps self-hosted Cloudflare Access apps in sync from Nix.
8020: Bridging the 80/20 Endurance Library to intervals.icu
A Rust CLI that scrapes the 80/20 Endurance workout library, converts 621 FIT files to intervals.icu DSL text, and uploads them. Born from sixteen months of Ironman training.
Dotfiles, Part 5: Custom Tooling and the Platform Edges
A Cloudflare CLI with a tunnel state machine, GNU Stow inside Nix, triple-platform service modules, secure credential hashing, declarative ZFS, and dev shell bootstrapping.
Dotfiles, Part 4: Network-Aware Services — From Split Tunneling to Topology-Driven DNS
ProtonVPN with network namespace split tunneling, ad-blocking derived from VLAN topology, DHCP-to-DNS sync, and dynamic WireGuard peer onboarding — all as composable NixOS modules.
Dotfiles, Part 3: Secrets, Fleet Management, and the User Bridge
How I bootstrap 9 machines with sops-nix, clan-core, and a user module pattern that solves the secrets chicken-and-egg problem — plus service exposure via Caddy and Cloudflare Tunnel.
Dotfiles, Part 2: A NixOS Home Router — From VLANs to Declarative DNS
Building a full home router as composable NixOS modules — typed options, auto-derived nftables rules, VLAN isolation, and a custom Go CLI for Cloudflare DNS sync.
Dotfiles, Part 1: Why Dendritic Flakes Work for Managing 9 Machines
How I use import-tree, flake-parts, and clan-core to manage NixOS, macOS, and WSL machines from a single flake — without maintaining a central import list.
DC Mini Part 7: Developer Ergonomics — xtask, Nix, and the Prelude
Build orchestration with xtask, reproducible toolchains with Nix flakes, and a prelude pattern for managing imports in a complex embedded workspace.
DC Mini Part 6: Multi-Priority Executors, DFU, and a PWM Neopixel
Interrupt-driven task prioritization with embassy, a watchdog-protected dual-bank bootloader, and driving WS2812 LEDs with DMA — the infrastructure glue of DC Mini.
DC Mini Part 5: One Protocol, Two Transports
How DC Mini defines its RPC interface once and serves it identically over USB and BLE — with code generation for Python and Rust clients.
DC Mini Part 4: Event-Driven Orchestration with derive(From)
How DC Mini uses a central event bus and inversion of control to keep async sensor tasks decoupled — and why adding a new sensor is just a match arm.
DC Mini Part 3: The Bus Manager — Power-Aware Peripheral Sharing Without Alloc
Building a generic bus lifecycle manager in no_std Rust that lazily initializes, reference-counts, and tears down shared peripherals — all without a heap.
DC Mini Part 2: Typed Resource Bundles and the BSP Pattern
How DC Mini uses Rust's type system to enforce pin allocation at compile time, preventing an entire class of embedded bugs.
DC Mini Part 1: Designing Firmware for a Wearable EEG
A look at the architecture behind DC Mini — an open-hardware 16-channel EEG wearable built with Rust, embassy-rs, and a three-crate firmware design.