alex 7c88826f7c chore(kyojin): update to 1.8.26
Update the upstream flake pin and correct version reporting docs.

Evaluation reports 1.8.26. Build and test verification remains pending
on a remote builder or CI; do not build on this workstation.
2026-11-17 21:18:49 +03:00
2026-08-07 10:55:29 +03:00
2026-11-17 21:18:49 +03:00
2026-11-12 16:32:01 +03:00
2026-11-17 21:18:49 +03:00
2026-11-17 21:18:49 +03:00
2026-04-29 14:18:42 +03:00
2026-11-17 21:18:49 +03:00
2026-08-07 10:55:29 +03:00

millerson.name Nix Overlay

A custom Nix overlay and flake providing additional packages not found in upstream nixpkgs, built using numtide/blueprint for streamlined flake development.

Features

  • Custom packages - Additional software packaged for Nix
  • Two overlay strategies - Choose between binary-cache-friendly or dependency-sharing overlays
  • Blueprint-based - Uses modern Nix flake patterns with numtide/blueprint

Available Packages

Package Description Category
agnix Linter for AI agent config files (CLAUDE.md, AGENTS.md, SKILL.md, hooks, MCP), ships agnix, agnix-lsp and agnix-mcp AI Coding Agents
awg-tool CLI for AmneziaWG self-hosting — generates 1.0/1.5/2.0/3.0 obfuscation parameters, exports .conf and vpn:// configs, installs servers over SSH Networking
awgen Offline CLI for AmneziaWG configurations — harmonises native .conf and vpn:// inputs, generates client participants and tunnels, and analyses obfuscation Networking
aionui Free, open-source, Cowork app with AI Agents AI Coding Agents
codeaf Coding harness and software factory for open models: hand work off, then watch every project from one terminal AI Coding Agents
codex-api-proxy Local OpenAI-compatible HTTP proxy backed by Codex/OpenAI credentials AI LLM Gateway
codex-oauth-proxy Local proxy exposing a ChatGPT Codex account through OpenAI-compatible APIs AI LLM Gateway
container-use Containerized environments for coding agents AI Coding Agents
desloppify Multi-language codebase health scanner and technical debt tracker for AI agents AI Coding Agents
ds4 DeepSeek 4 Flash and PRO local inference engine for ROCm (Strix Halo) AI Inference
freebuff The world's strongest free coding agent AI Coding Agents
freetoken Local MoE-offload LLM inference runtime with OpenAI- and Anthropic-compatible APIs AI Inference
graphify Turn any folder of code, docs, papers, images, or videos into a queryable knowledge graph AI Coding Agents
g3 AI coding agent that writes code and executes commands, with multi-provider LLM support, context compaction, and desktop automation AI Coding Agents
haivemind Multi-model AI consensus, aggregation, and fusion runner for popular AI CLIs AI Coding Agents
hipengine ROCm-native local LLM inference engine with torch-free runtime for AMD RDNA GPUs AI Inference
magg MCP aggregator / meta-MCP server that aggregates, proxies and manages other MCP servers so agents can discover and manage tools at runtime, ships magg and mbro MCP Servers
marmel Autonomous agentic coding assistant with Manager + specialist subagent orchestration over any OpenAI-compatible LLM backend AI Coding Agents
mcp-gateway Universal Model Context Protocol gateway that sits between AI client and MCP tools/servers MCP Servers
memdoor Coding and automation agent in one CLI binary: runs locally or over SSH, with YAML workflows and a decision model in front of the chat model AI Coding Agents
nftables-analyzer Analyze nftables firewall rules and evaluate traffic queries Networking
nftablesbuilder Web interface to manage nftables rules with drag-and-drop rule creation Networking
shardr Decentralized LLM repository: content-addressed model store, BitTorrent-based sync, OpenAI-compatible serving via llama-server AI Inference
skillsmcp MCP server that exposes Agent Skills to AI agents via the Model Context Protocol MCP Servers
kubernetes-mcp-server Model Context Protocol (MCP) server for Kubernetes and OpenShift MCP Servers
kyojin Upstream Kyojin 1.8.26 with AMD ROCm SDK wheels and a host C compiler for Triton JIT AI Inference
hipfire AMD RDNA inference engine with TheRock compiler wrappers and quantization tools AI Inference
hipfire-kernels Precompiled hipfire kernels for gfx1151 AI Inference
gufo Gufo with XDNA2 NPU support and the Unsloth UD 3.1 compatibility patch AI Inference
xrt-amdxdna XRT with the amdxdna plugin, built against gufo's nixpkgs AI Inference
therock-rocm Locally maintained TheRock 10.1 SDK for gfx1151 AI Inference
strata Strata inference engine, API server and CPU vision encoder with ROCm 10 HIP support for gfx1151 AI Inference
crucible-strix-halo Crucible EXL3 inference engine and OpenAI-compatible server for gfx1151 with the ROCm 10 runtime AI Inference
strixite Source-built HIP inference engine and OpenAI-compatible server for gfx1151 / Zen 5 with ROCm 10 AI Inference
pwilkin-llama-cpp pwilkin llama.cpp fork with ROCm for gfx1151 AI Inference
strix-llama-cpp halo-box llama.cpp fork with Vulkan AI Inference
loop Corporate messenger for your team Communication
radar Modern Kubernetes visibility — topology, event timeline, service traffic, resource browsing, Helm management, and GitOps support Kubernetes
omniroute Unified AI router with 160+ providers, auto fallback, MCP/A2A, OpenAI-compatible APIs AI LLM Gateway
open-code-review AI-powered code review CLI combining deterministic pipelines with an LLM agent for line-level review comments AI Coding Agents
pilotdeck Task-oriented AI Agent productivity platform (source-built Electron desktop app, plus a headless server command) with WorkSpace isolation, white-box memory, and smart routing AI Agents
purpleflow Desktop orchestrator that runs Claude Code and Codex through plan, implementation, review and acceptance stages AI Coding Agents
pdfcraft PDF reader and editor written from scratch in Rust — comments, forms, page organizing, redaction — plus a headless pdfcraft-cli with an opt-in MCP server PDF Tools
relay-free-llm RESTful API to route user prompts to various AI model providers with automatic failover and intent-based routing AI LLM Gateway
stakpak DevOps AI agent that generates infrastructure code, debugs Kubernetes, configures CI/CD, and automates deployments AI Agents
traycer Open-source AI orchestration app for agentic coding AI Coding Agents

Usage

As a Flake

Add to your flake.nix inputs:

inputs.millerson-nix-overlay.url = "git+https://git.millerson.name/alex/millerson-overlay.nix.git";

Then use in your outputs:

outputs = { nixpkgs, millerson-nix-overlay, ... }: {
  nixosConfigurations.your-host = nixpkgs.lib.nixosSystem {
    system = "x86_64-linux";
    modules = [
      millerson-nix-overlay.nixosModules.default
      # ... your other modules
    ];
  };
};

As an Overlay

Option 1: Default Overlay (Binary Cache Friendly)

Uses the packages built against this flake's nixpkgs revision. Binary cache hits work best when using the same nixpkgs revision.

nixpkgs.overlays = [ millerson-nix-overlay.overlays.default ];

Option 2: Shared Nixpkgs Overlay (Dependency Sharing)

Builds packages against your system's nixpkgs, sharing dependencies with the rest of your system. No second nixpkgs evaluation, but binary cache only hits when your nixpkgs revision matches ours.

nixpkgs.overlays = [ millerson-nix-overlay.overlays.shared-nixpkgs ];

Installing Packages

With flakes enabled:

# Try a package
nix run git+https://git.millerson.name/alex/millerson-overlay.nix.git#mcp-gateway

# Install permanently
nix profile install git+https://git.millerson.name/alex/millerson-overlay.nix.git#mcp-gateway

Inference Engines

The engine packages target AMD Strix Halo (gfx1151) on x86_64-linux. nixpkgs-engine pins the shared engine toolchain independently of the other packages. Gufo and Kyojin retain their upstream nixpkgs pins.

Kyojin uses the upstream 1.8.26 flake with its AMD ROCm SDK wheels. The serving wrappers also set CC for Triton's runtime C compilation. The upstream derivation reads its version from the source, matching the v1.8.26 tag. kyojin.tests.jit and kyojin.tests.cpu expose the upstream HIP compiler smoke check and CPU tests. The former nixpkgs PyTorch/ROCm package and its jitRocmSdk override have been removed.

Hipfire exports kernels, hipcc, rocm, llvmReadobj and llvmObjdump as package attributes. Set the model directory with hipfire.override { modelDir = "/path/to/models"; }. The upstream service module is available as nixosModules.hipfire, and its ROCm overlay as overlays.hipfire. Neither is enabled by the default module.

Gufo exports its matching xrt, npuDir and fabricClock as package attributes. The consumer must configure NPU power and fabric clocks before using the NPU. TheRock uses this repository's own SDK recipe and a pinned official AMD tarball. The 10.1.0 archive's internal package stamp is 10.1.0rc3. See TheRock maintenance notes for the source, update procedure and nixpkgs migration context. XRT still uses an individual recipe from the pinned nix-strix-halo source tree; its flake and Thunderbolt dependencies are not loaded.

Strata ships strata (the HIP engine), strata-server (the OpenAI/Anthropic HTTP server, also the default for nix run .#strata) and strata-vision (CPU image encoder). It uses the shared TheRock ROCm 10.1 SDK, compiles GPU kernels only for gfx1151, and uses upstream's portable AVX2 CPU baseline. Model weights and vision projectors are supplied separately.

Run nix run .#strata -- --help for server options, or invoke the engine directly with nix shell .#strata -c strata --help. For inference, pass strata-server --engine strata --config /path/to/strata.json; the upstream server configuration uses exe, args, cwd, tokenizer and model_name. Set exe to the packaged strata executable and use writable model/log paths outside the Nix store. Upstream's gfx1151 hipBLASLt table was calibrated on TheRock 7.14.1; its solution ids do not exist in ROCm 10.1's hipBLASLt, which reports the same version. The package ships a table recalibrated against the shared ROCm 10.1 SDK in bin/tuning/, where the engine finds it without STRATA_HIPBLASLT_TUNING; recalibrate it (tools/hip/tune_hipblaslt) when the SDK changes.

Crucible ships crucible-server (also nix run .#crucible-strix-halo) and crucible-engine. Upstream built the release engine with ROCm 7.2.4 and tested it with ROCm 10.1. This package uses the overlay's TheRock ROCm 10.1 runtime and the Python server from the matching tag. The package targets the Ryzen AI Max+ 395 / Radeon 8060S (gfx1151) with 128 GB RAM. Supply a compatible Qwen3.8-Flash-Next EXL3 pack separately:

nix run .#crucible-strix-halo -- /path/to/exl3-pack --ctx 32768

Use --help for serving options; the default endpoint is http://127.0.0.1:8790. Automatic release checks are disabled by default; update through Nix. The upstream checkout-management CLI (setup, update, and service installation) is not included. Model downloads and conversation state belong outside the Nix store. See the upstream setup guide for GPU memory configuration and model requirements.

Strixite builds from source with the shared TheRock ROCm 10.1 SDK for gfx1151 and the Zen 5 host CPU. It ships strix_server (the default entry point), convert_qwen4exp, convert_ngram_table, transcode_ngram_table, inspect_strixw and check_stream_calls. Supply the upstream .strixw weights, tokenizer and n-gram table separately, following the model setup.

STRIX_MODELS_DIR=/path/to/models nix run .#strixite -- --host 127.0.0.1

The default port is 5300. strix_server --help lists all settings; the commented upstream configuration is installed at share/strixite/strix-server.conf. Model and prompt-cache paths stay outside the Nix store. The upstream defaults assume a dedicated 128 GB machine; see its memory guide when sharing the GPU with a desktop or another model. nix run .#strixite.tests.gpu builds and runs the upstream kernel tutorial's CPU/GPU correctness checks on a machine with GPU access.

nftablesbuilder Runtime Notes

nftablesbuilder is a web interface for managing nftables. It consists of a root-launcher (nftablesbuilder) that spawns the unprivileged webserver binary and pipes encrypted commands between it and the nft binary.

Before running it you must:

  1. Copy the settings template to /etc/nftablesbuilder (the only fixed path):
    nix build .#nftablesbuilder
    cp result/share/nftablesbuilder/settings.example /etc/nftablesbuilder
    
    Adjust paths inside (html, webserver, nft, savepath, TLS files).
  2. Create a TLS key/certificate pair at the paths referenced by tlskey/tlscert (e.g. openssl req -x509 -newkey rsa:2048 -nodes ...).
  3. Run the launcher as root (it needs to write /etc/nftables.conf and run nft); the web interface listens on https://<server>:1969.

Note: upstream publishes the GUI only as a prebuilt tarball on nftablesbuilder.eu (served with a self-signed certificate, hence the curlOpts = "-k" in the derivation); the source repository is missing the settings crate, which this overlay patches in.

OpenCodeReview OpenCode Plugin (Home Manager)

The open-code-review package bundles its OpenCode plugin (the plugin file plus runtime node_modules) as passthru.opencode-plugin, built from the same source revision as the CLI. A Home Manager module symlinks it into ~/.config/opencode/plugins/ and puts the ocr CLI on PATH:

inputs.millerson-nix-overlay.url = "git+https://git.millerson.name/alex/millerson-overlay.nix.git";
inputs.home-manager.url = "github:nix-community/home-manager";
# in your home-manager configuration
imports = [ millerson-nix-overlay.homeManagerModules.default ];

programs.open-code-review = {
  enable = true;
  opencode.enable = true; # symlink plugin into ~/.config/opencode
};

Without Home Manager, symlink manually:

plugin=$(nix build --print-out-paths \
  git+https://git.millerson.name/alex/millerson-overlay.nix.git#open-code-review.passthru.opencode-plugin)
mkdir -p ~/.config/opencode/plugins
ln -sf $plugin/share/open-code-review/opencode/open-code-review.ts ~/.config/opencode/plugins/
ln -sfn $plugin/share/open-code-review/opencode/node_modules ~/.config/opencode/plugins/node_modules

Note: the node_modules symlink is shared across everything in the plugins directory; other manually-installed plugins with conflicting npm dependencies cannot coexist with it.

Codex OAuth Proxy (systemd user service)

On Linux with a running systemd user manager, the package provides lib/systemd/user/codex-oauth-proxy.service. Installing the package alone does not enable or start it. To use the packaged unit without Home Manager:

package=$(nix build --no-link --print-out-paths \
  git+https://git.millerson.name/alex/millerson-overlay.nix.git#codex-oauth-proxy)
systemctl --user enable --now "$package/lib/systemd/user/codex-oauth-proxy.service"
systemctl --user status codex-oauth-proxy.service

Keep the selected package in a Nix profile or another garbage-collection root while using its unit. To stop it and remove its enablement links:

systemctl --user disable --now codex-oauth-proxy.service

Do not manage the same unit with both this procedure and Home Manager.

Home Manager

Import the module and make the package available in Home Manager's pkgs:

imports = [ millerson-nix-overlay.homeManagerModules.default ];
nixpkgs.overlays = [ millerson-nix-overlay.overlays.default ];

programs.codex-oauth-proxy.enable = true;

The module installs the package and manages the user unit and its default.target link. Its package default selects pkgs.millerson-nix-overlay.codex-oauth-proxy, falling back to pkgs.codex-oauth-proxy. Importing homeManagerModules.default does not add an overlay. Supply the overlay to the actual Home Manager package set, or set programs.codex-oauth-proxy.package explicitly to this flake's package for your system.

Apply the configuration with your normal Home Manager activation. Enabling starts this service without changing systemd.user.startServices. To stop and disable a previously module-managed service, keep the import and apply:

programs.codex-oauth-proxy.enable = false;

Removing the import also removes the cleanup hook, so first activate with enable = false. A fresh disabled configuration leaves a manually managed same-named service untouched. Starting or stopping a module-managed service requires an available user manager; activation reports failure if it is unavailable. The module does not enable lingering or change the global service activation policy.

State and security

Both units use persistent OAuth state at %S/codex-oauth-proxy/auth.json, normally ~/.local/state/codex-oauth-proxy/auth.json in a user manager. The state directory has mode 0700 and the service umask is 0077. Upstream may migrate existing credentials when the destination is absent, and refreshes rewrite the credential file. Keep it writable and outside the Nix store and immutable Home Manager files. Disabling the service does not delete this credential state. Missing credentials do not prevent startup, but successful upstream requests require valid credentials.

The server binds all interfaces on port 9879 by default, not just loopback. Restrict access with your network/firewall configuration. The service does not add TLS or network access controls.

ADMIN_API_KEY protects upstream's admin endpoints. No default key is generated. If unset or empty, protected requests return HTTP 500; the server can still start. The packaged unit does not set this variable; a user-manager environment can supply it. Home Manager has an optional literal setting (placeholder only):

programs.codex-oauth-proxy.admin_api_key = "REPLACE_WITH_NON_SECRET_PLACEHOLDER";

The default null omits the assignment. A non-null value must contain printable ASCII; an empty string explicitly supplies an empty value. A literal key in this option is public in the Nix store, retained generations, and systemd introspection. Do not put a confidential production key here. This option is not a runtime secret-delivery mechanism.

Both units discard stdout and stderr because upstream logs token previews and other potentially sensitive request/response data. Production mode does not establish redaction. Application logs are therefore unavailable in the journal; systemd status and exit diagnostics remain. Do not override these output settings without first addressing upstream token logging.

PdfCraft (Home Manager)

pdfcraft is built from source (no upstream binaries are downloaded). A Home Manager module installs both programs it ships:

# in your home-manager configuration
imports = [ millerson-nix-overlay.homeManagerModules.default ];

programs.pdfcraft.enable = true;

That puts pdfcraft (the desktop app) and pdfcraft-cli (headless tool runner and the opt-in MCP server, pdfcraft-cli mcp) on PATH. The module adds programs.pdfcraft.package to home.packages; the default is pkgs.millerson-nix-overlay.pdfcraft, so nixpkgs.overlays must carry this flake's overlay, or set package yourself.

The package ships the two OCR models under share/pdfcraft/models, where the app looks beside its own bin/ — pdfcraft-cli run ocr_status reports "available": true. The optional craft-fonts build input is not used, so Japanese interface text falls back to an installed system font.

Development

Prerequisites

  • Nix with flakes enabled
  • treefmt-nix for formatting (optional)

Building Packages

# Build all packages for current system
nix build .#packages

# Build specific package
nix build .#mcp-gateway

# Enter development shell
nix develop

Project Structure

nix-overlay/
├── flake.nix                    # Flake definition
├── treefmt.toml                 # Code formatting configuration (nixfmt)
├── overlays/                    # Overlay implementations
│   ├── default.nix             # Binary-cache-friendly overlay
│   └── shared-nixpkgs.nix      # Dependency-sharing overlay
├── packages/                    # Package definitions
│   ├── agnix/                  # Linter for AI agent config files (CLI + LSP + MCP server)
│   ├── awg-tool/               # AmneziaWG parameter generation and SSH deployment CLI
│   ├── awgen/                  # Offline AmneziaWG configuration harmoniser and generator
│   ├── aionui/                 # AionUi - AI Cowork desktop app
│   ├── codeaf/                 # Coding harness and software factory for open models
│   ├── container-use/          # Containerized environments for coding agents
│   ├── default/                # Meta-package listing all packages
│   ├── desloppify/             # Codebase health scanner for AI agents
│   ├── ds4/                    # DeepSeek V4 Flash/PRO inference engine (ROCm)
│   ├── flake-inputs/           # Utility for caching flake inputs
│   ├── freebuff/               # Free coding agent (Codebuff)
│   ├── freetoken/             # Local MoE inference runtime (NVIDIA CUDA)
│   ├── graphify/               # Knowledge graph generator for code folders
│   ├── g3/                     # AI coding agent (g3 + g3-studio)
│   ├── haivemind/              # Multi-model AI consensus runner
│   ├── hipengine/              # ROCm-native LLM inference engine for AMD GPUs
│   ├── kubernetes-mcp-server/  # MCP server for Kubernetes and OpenShift
│   ├── kyojin/                 # ExLlamaV3-based inference engine for Strix Halo (gfx1151)
│   ├── loop/                   # Corporate messenger for your team
│   ├── mcp-gateway/            # MCP protocol gateway
│   ├── omniroute/              # Unified AI router with 160+ providers
│   ├── open-code-review/       # AI code review CLI (deterministic + LLM agent)
│   ├── pilotdeck/              # Task-oriented AI Agent platform (source-built Electron desktop app)
│   ├── purpleflow/             # Electron orchestrator for Claude Code and Codex stages
│   ├── pdfcraft/               # PDF reader and editor in Rust, with pdfcraft-cli
│   ├── radar/                  # Kubernetes UI (topology, timeline, Helm, GitOps)
│   ├── relay-free-llm/        # AI model provider routing gateway
│   ├── skillsmcp/              # MCP server for Agent Skills
│   ├── stakpak/                # DevOps AI agent for infrastructure automation
│   └── traycer/                 # AI orchestration desktop app (agentic coding)
└── README.md

Adding New Packages

  1. Create a new directory under packages/<package-name>/
  2. Add a package.nix with the package definition
  3. Create a default.nix that imports package.nix with proper arguments
  4. The package will be automatically picked up by blueprint

Example structure:

packages/my-package/
├── default.nix    # Import wrapper
└── package.nix    # Actual package definition

License

See LICENSE file for details.

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

S
Description
No description provided
Readme GPL-3.0 763 KiB
Languages
Nix 98.3%
C++ 1.7%