a fork of GNU Guix · phase 0 — bootstrap
Same bytes, same name — no matter who built them.
quix /kwɪks/ · like quicks, because that’s the point · quiche also accepted, in memory of the gooix/geeks debates · adj. quixotic
Quix keeps Guix’s foundations — Guile Scheme, declarative packages, reproducible builds — and rebuilds the distribution machinery around a content-addressed store, peer-to-peer substitutes, and Linux-first ergonomics.
full-history fork of GNU Guix, branched at 21067308 · 2026-07-06 · upstream merged on a regular cadence
The name is the checksum.
In Guix and Nix, a store path is the hash of the recipe: same inputs, same name — even when nobody has checked that the outputs agree. Quix inverts this. A store item is addressed by the BLAKE3 hash of its content: identical outputs are shared no matter who built them or how, and different bytes cannot hide behind the same name.
Content addressing is the only store model in Quix — not a mode, not an experiment. Verification, deduplication, and peer-to-peer distribution all fall out of one property: to check an item, hash it. A name you can check beats a name you must trust.
Six pillars, one machine.
intensional store
Items named by the BLAKE3 hash of their content, not their build recipe. The store dedups, verifies, and shares by construction.
p2p distribution
Farms publish small signed manifests; the bytes travel over BitTorrent v2 swarms with streaming verification. “Official” just means attested by keys you trust.
linux-first ergonomics
Foreign FHS binaries — Android SDK, Flutter, self-updating dev tools — run without patchelf, via namespace-built FHS views and loader shims.
honest nonfree support
Two variants chosen at install: principled (free only) and pragmatic (nonfree available, clearly separated, under a keyring the free variant never trusts).
performance
Parallel substitute fetching, parallel builds, a content-addressed eval cache. Determinism means parallelism cannot change results.
tiered packaging
A core monorepo, semi-independent team channels, and a namespaced
@handle/pkg community layer with signed attestations —
one install command across tiers.
From 2013 seeds to a toolchain that builds itself.
A store you can trust has to be grown from something you can inspect. Quix’s world rebuild starts from Guix’s pinned 2013 bootstrap seeds — a handful of static binaries with recorded hashes — and climbs rung by rung inside a build jail where undeclared inputs simply do not exist.
Imported as provenance-verified content: sha256 checked once at the boundary, BLAKE3 forever after.
The first tool built purely — no host toolchain, no network, no visible filesystem. Just seeds and store items.
Real packages lowered over the seed toolchain, their build phases run by the bootstrap Guile inside the jail.
Binutils and a C/C++-capable GCC, rebuilt by the seed compiler as a cross toolchain that never has to run its own test binaries.
A real, from-source C library — with its helper rungs, down to a from-source CPython that glibc’s own build scripts genuinely need.
Self-hosted: binutils-final and gcc-final built over the new glibc. GC then sweeps every seed compiler — and the world keeps running.
A statically linked BusyBox from the final toolchain. No interpreter, no shared libraries; its runtime closure is itself, alone.
Next: a minimal Linux kernel, an initramfs, and a QEMU serial boot — a system this store built end to end.
Every rung is proved the same way: root the artifact, garbage-collect the world, and watch it keep running.
The arc.
Phases are cumulative and each ends with something runnable. Dates are deliberately absent — the roadmap tracks order and scope, not schedule. Every item traces to a written decision record.
Bootstrap. The fork, the research sweep, fourteen ADRs, a working CA-store and daemon prototype, and the world-rebuild climb above.
Substitution MVP. Freeze the signed manifest object, publish webseed-backed BitTorrent v2 torrents, race the swarm against the farm with streaming BLAKE3 verification.
Store and trust. /quix/store as the primary store, the
native Scheme daemon, a curated keyring with quorum-by-diversity, and
a transparency log — fail-closed on an empty trust root.
Distro experience. Zero-config foreign binaries, the principled and pragmatic variants, quarterly core epochs with team and community tiers, parallel everything.
Community. Attestation tooling anyone can run, a contribution ledger with no leaderboards, installer images for both variants.
Where it stands, honestly.
Quix is in phase 0. There are no releases, no substitute servers, and no installer. There is a design record of fourteen architecture decisions, a test suite of twenty files and 435 assertions, a daemon prototype, and a bootstrap chain that runs — every artifact above exists and is reproducible from its seeds.
The public repository is being prepared. Until it opens, this page is the front door, and the upstream it grew from is the best place to start.