nix-doom-emacs-unstraightened is a Nix-based build system for Doom Emacs that bypasses straight.el by using Doom's CLI to export dependencies and then building them with Nix's emacsWithPackages. It provides a flake, overlay, Home Manager module, and a set of Nix expressions to build a fully reproducible Doom Emacs configuration with all dependencies pinned via Nix. The architecture consists of multiple steps: extracting package requirements from Doom via a Elisp script, applying Doom's pins to emacs-overlay packages, handling missing packages with IFD-based dependency detection, generating a Doom profile and profile loader, and finally wrapping the Emacs binary. The project features extensive CI/CD, automated daily flake updates, and a Cachix cache. It demonstrates sophisticated Nix patterns including IFD, fetchTree, structured overrides, and Emacs Lisp scripting within Nix builds.
nix-topology is a NixOS-based tool that automatically generates infrastructure and network diagrams as SVGs from NixOS configurations. It uses a global topology module to aggregate information from multiple NixOS hosts, extracting data about interfaces, services, containers, and virtual machines via specialized extractors. The gathered topology is then rendered using ELK for layout and converted to SVG via custom tools (elk-to-svg and html-to-svg), producing both a physical connection diagram (showing nodes as cards with hardware and service details) and a network-centric view (showing logical networks and their connections). The architecture is modular, with clear separation between information gathering, topology aggregation, and rendering.
TeslaMate is a self-hosted data logger for Tesla vehicles that collects telemetry via the Tesla API (both polling and streaming), stores data in PostgreSQL, and provides visualization through a Phoenix LiveView web interface and Grafana dashboards. It integrates with home automation systems via MQTT and supports importing historical vehicle data from CSV files (TeslaFi format). The application uses a supervision tree to manage background processes for data collection, MQTT publishing, import tasks, and update checking. Key features include geofencing for location-based cost tracking, encrypted storage for API tokens using Cloak, internationalization via Gettext, and custom Ecto expressions for geographic calculations. The architecture is monolithic with clear separation of concerns through Phoenix contexts (Log, Vehicles, Settings, Locations).
ctf-tools is a Nix flake that packages and manages CTF/security research tools. It provides a CLI interface (manage-tools) for installing, upgrading, and removing tools from a user's Nix profile. The system isolates each tool in its own derivation, builds from source or fetches prebuilt binaries from a Cachix cache, and handles complex packaging requirements like tools needing writable directories at runtime (BeEF, libc-database) or proprietary software requiring user-provided binaries (IDA). The architecture is modular with separate derivations for each tool, CI/CD for automated building and caching, and thoughtful handling of runtime dependencies through wrapper scripts.
This repository is a personal Nix configuration (dotfiles) for managing a heterogeneous fleet of machines: NixOS desktops and servers, macOS laptops (via nix-darwin), and Kubernetes clusters (k3s, KubeVirt). It is structured as a Nix flake with modular components for system configuration, home-manager profiles, package overlays, secrets management (agenix), and infrastructure monitoring (Grafana, Prometheus, VictoriaMetrics, Loki). The codebase demonstrates advanced Nix patterns: parameterized module generators for K3s and KubeVirt, automatic file scanning for module imports, declarative disk partitioning (disko), ephemeral root filesystems with persistent state (preservation), and sandboxed GUI applications (nixpak, bwrap). It also includes a custom desktop shell (noctalia) and extensive input method customization (Rime/Fcitx5). While highly personalized and not intended for direct reuse, the architectural patterns and modular design serve as a reference for building complex Nix-based infrastructure. The repository is actively maintained with eval tests and CI, but lacks integration tests for runtime services.
extra-container is a command-line tool for managing NixOS containers without requiring full system rebuilds. It builds container configurations using Nix and integrates them into the host system via systemd service files and garbage collection roots. The tool supports creating, starting, stopping, and accessing containers via shell. Key innovations include a minimal NixOS module set for fast evaluation (eval-config.nix) and compatibility abstractions for different NixOS versions. The tool is actively maintained with recent commits and uses modern Nix Flakes.
This is a personal dotfiles repository for NixOS, authored by Henrik Lissner (hlissner). It serves as a complete, declarative system configuration for multiple machines (laptops, desktops, and a HTPC) using Nix flakes. The repository defines the entire system—from the bootloader and kernel parameters to the desktop environment (Hyprland), shell (zsh, tmux), development tools, and custom utilities. It is not a standalone application but a collection of configuration files, NixOS modules, and scripts that together form a highly opinionated, reproducible computing environment. The architecture is centered around a Nix flake (flake.nix) that imports modular NixOS modules organized by category (desktop, development, editors, shell, services, hardware profiles, themes, etc.). A custom CLI tool called 'hey' (written in Janet) provides a command hub for system management tasks like rebuilding, garbage collection, profile switching, and dotfile synchronization. The desktop environment is heavily customized with Hyprland (Wayland compositor), rofi launcher menus, matugen-based dynamic theming, and a suite of utility scripts for screenshots, screen recording, audio, and more. While the repository is not designed for reuse by others (it explicitly warns against being used as a community framework), several components demonstrate high craftsmanship and could be extracted with minimal modification. The Janet libraries under lib/hey/ provide a reusable command-line argument parser, an async rofi interaction library, and general utility functions. The Nix library (lib/nixos.nix) implements a flake builder pattern that could be adapted for other multi-host NixOS setups. The matugen templates and rofi themes are also potentially reusable as standalone theming assets.
Prismaliser is a fully client-side single-page application that visualizes Prisma database schemas as interactive entity-relationship diagrams. It runs entirely in the browser: the user pastes a Prisma schema into a Monaco editor, the app parses it client-side via a vendored WASM module from Prisma's own schema parser, and renders the models, enums, and relations (1-1, 1-n, m-n) as an interactive React Flow graph. The app has no backend server – it is a static Vite SPA that can be self-hosted (Docker image provided). Recently, AT Protocol (Bluesky) integration was added allowing users to publish immutable snapshots of their diagrams (schema + node positions) to their own AT repository, share via canonical AT links, and manage published snapshots. OAuth login is browser-native using the atcute library family. The codebase is TypeScript strict, thoroughly tested (Vitest), and follows modern React patterns with Tailwind CSS v4 and CSS modules. The architecture is modular: a util layer handles Prisma parsing, graph generation, and layout (elkjs), while a dedicated atproto/ module handles OAuth, record creation, public retrieval, and share link parsing. The UI is built with React 19, using local state and hooks (no global state management). The project is actively maintained with recent commits and open issue triage.
This repository contains the complete LaTeX source for 'An Infinitely Large Napkin', a comprehensive advanced mathematics textbook by Evan Chen. The project is primarily a document production pipeline: the core content is a collection of modular .tex files organized by topic (algebra, topology, analysis, etc.), with extensive cross-references, custom macros, and Asymptote figures. However, the repository also exhibits strong software engineering practices: it includes a Nix flake for reproducible builds, GitHub Actions CI/CD workflows that compile the PDF and deploy to GitHub Pages, pre-commit hooks for code quality, and helper scripts (export-flowchart.sh, print-toc.py) for generating dependency graphs and split PDFs. This hybrid nature makes it both a textbook source and a well-automated document production application.
This repository is a comprehensive, declarative NixOS homelab configuration managed with the Clan framework. It defines the entire infrastructure for a multi-machine homelab including servers, desktops, and network devices, all version-controlled and reproducible. The system provisions self-hosted services (Caddy, Grafana, VictoriaMetrics, Vector, Blocky, Miniflux, Linkding, etc.), identity management (Authentik, Zitadel), monitoring and alerting, backup (Borgbackup), and desktop environments (KDE, i3). The architecture is modular: reusable NixOS feature modules under `modules/nixos/features/` follow a consistent pattern using `mkFeatureOptions` for enabling services with standardized options (domain, firewall, monitoring integration). Secrets are managed via SOPS with age encryption, and disk partitioning is handled by Disko templates. The repository is not a software application but an infrastructure-as-code project that demonstrates high craftsmanship in Nix module design, with clear separation of concerns, helper functions, and integration patterns. It is actively maintained but shows some technical drift due to deprecated identity providers and hardcoded IPs.