Nix Hydra Store: Official Merch, Games & Collectibles
The phrase "nix hydra store" lands in two very different worlds depending on who is typing it. For developers and system administrators, it points to the intersection of the Nix package manager's immutable /nix/store directory and Hydra, the continuous integration server built specifically to evaluate, build, and distribute Nix expressions at scale. For players, it points to Nix Hydra, the mobile game studio behind titles like Egg Baby and Feral Hearts, and the in-app storefronts that lived inside those games. Both meanings are legitimate, and both are worth understanding.
This guide focuses primarily on the technical side, because that is where the term carries the most weight today. The Nix store and Hydra form a tightly coupled pipeline: Hydra builds packages into the store, signs them, and publishes them to binary caches that thousands of machines pull from every day. If you have ever run a command like nix build and watched it download a prebuilt result instead of compiling from source, you have already benefited from this arrangement, even if you never touched Hydra directly.
Understanding the Nix Store and What It Actually Guarantees
The Nix store lives at /nix/store on virtually every Nix installation. Every package, library, configuration file, and script that Nix manages gets placed there under a path that begins with a cryptographic hash followed by a human-readable name, such as /nix/store/9x2k...-openssl-3.0.13. That hash is derived from the inputs used to produce the artifact — the source code, compiler flags, dependencies, and build script. Change any input, and the hash changes, which means the resulting path changes too. Two different versions of the same library can never overwrite one another.
This content-addressed model is the reason the Nix store is treated as immutable once a path is registered. Files inside a store path are read-only, and nothing gets modified in place. Upgrades do not patch existing packages; they create new store paths and update references to point at them. The practical effect is that you can install and run conflicting software versions side by side without any of the usual dependency hell, and you can roll back an entire system configuration to a previous state with a single command.
Content Addressing and Immutable Paths
A store path's hash is not simply a checksum of the finished files, which would be circular and impractical. Instead, Nix computes the hash from the derivation — the build recipe stored as a .drv file — and from the transitive closure of everything that derivation depends on. This means the path is known in advance, before the build even starts. Build tools can therefore reference exact output locations, and caching works cleanly because identical derivations always produce identical paths on every machine.
The immutability guarantee has a second benefit that is easy to overlook: garbage collection becomes safe and predictable. Because nothing writes into an existing store path, Nix can determine precisely which paths are still reachable from your profiles, running processes, or explicitly declared roots, and delete everything else. You never have to reason about half-upgraded packages or partially overwritten libraries, because that state simply cannot exist in a functioning Nix store.
Why the Store Model Changes Dependency Management
Traditional Linux distributions resolve dependencies by agreeing on a single version of each shared library and hoping every package is compatible with it. That works until it does not, and the failure modes range from cryptic symbol errors to silently broken applications. Nix sidesteps the problem entirely by giving each dependency its own store path and embedding exact references into the binaries that need it. Nothing is shared unless it is genuinely identical.
The tradeoff is disk usage, since duplicates can accumulate across environments, but Nix mitigates this with hard links and NAR-format archives that deduplicate identical files. In practice, a well-maintained Nix machine often uses less space than a comparable container-based setup, because container images duplicate entire userlands while Nix shares the pieces that match. That efficiency is what makes the store a practical foundation for CI systems like Hydra rather than just an academic curiosity.
Hydra as the Build Engine Behind the Store
Hydra is an open-source continuous integration and build farm that the NixOS project originally developed to build its own packages. It is not a generic CI runner bolted onto Nix; it was designed from the ground up around Nix derivations, which is why it can evaluate an entire package set, schedule thousands of builds across a pool of workers, and publish results in a form that any Nix client can consume directly. The public instance at hydra.nixos.org is one of the largest build farms of its kind.
Architecturally, Hydra consists of several cooperating services: a PostgreSQL database holding jobsets, evaluations, and build records; an evaluator that runs Nix evaluations to turn a jobset specification into a set of derivations; a queue runner that dispatches those derivations to build machines; and a web frontend for browsing results. When a build finishes successfully, Hydra registers the output in the Nix store on the build machine and makes it available for distribution.
Jobsets, Evaluations, and Build Scheduling
A jobset is Hydra's unit of work definition. It combines a Nix expression — conventionally a release.nix file or a flake reference — with a set of inputs such as Git repositories or tarballs. Every time an input changes, Hydra triggers a new evaluation. That evaluation is a pure Nix operation: it produces a complete list of derivations without building anything, which means Hydra can instantly tell you what would need to be rebuilt and reuse cached results for everything unchanged.
Scheduling happens through the queue runner, which can distribute builds across remote machines that share a store via distributed builds. If a derivation's output already exists in the store — perhaps because another jobset built the same thing — Hydra skips the work entirely and records it as a cached success. For large package sets this is transformative, since a typical Nixpkgs evaluation produces tens of thousands of derivations and most of them are already built.
Publishing Results to a Binary Cache
Building packages is only half the value. The other half is making those builds reachable by ordinary users without recompiling anything. Hydra can be configured to push successful build outputs to a binary cache, typically an HTTP server or S3-compatible bucket serving NAR archives alongside narinfo metadata files. Each narinfo record lists the store path, its references, its size, and a cryptographic signature.
Signatures matter because Nix clients verify them before trusting a cache. The cache operator generates a key pair, keeps the secret key on the build infrastructure, and distributes the public key to clients through their Nix configuration. Once a client lists that cache as a substituter, any matching store path can be downloaded and verified locally, which is exactly how a fresh NixOS install pulls down a working system in minutes rather than hours.
Running Your Own Nix Hydra Build and Cache Setup
Self-hosting Hydra is a realistic project for teams that maintain internal packages or need reproducible builds they control. On NixOS, the setup is largely declarative: enabling services.hydra provisions the database, the frontend, and the queue runner, while a services.hydra-build machine handles execution. The manual walks through creating an admin user, registering the first project, and pointing it at a repository, after which Hydra takes over on its own schedule.
Storage planning deserves attention before you commit. Hydra accumulates store paths quickly, especially when a jobset tracks an actively developed branch, and a naive configuration can fill a disk within weeks. Think about how long build artifacts should be retained, whether you need to keep failed build logs, and whether a separate machine should host the binary cache to isolate it from the build workers. Getting these decisions right early prevents painful migrations later.
Configuring Substituters and Trusted Keys
For clients to consume your cache, they need two things in nix.conf: the cache URL listed under substituters, and your public key listed under trusted-public-keys. The public key identifies which signatures the client will accept, and without it Nix will refuse to substitute paths from your cache even if they are present and downloadable. Keys are generated with nix-store --generate-binary-cache-key or the equivalent nix key generate-secret command, and the secret half should never leave your build infrastructure.
A common pattern is to layer caches so that clients check the public cache.nixos.org first for upstream packages and your private cache second for internal artifacts. Ordering affects performance rather than correctness, since Nix verifies signatures regardless, but putting the cache most likely to contain a requested path earlier in the list reduces latency. You can also use nix copy to move paths between caches manually when you need to seed a new mirror or backfill a gap.
Garbage Collection and Storage Hygiene
The Nix store never deletes anything on its own, which is a feature until it becomes a disk-space emergency. Garbage collection is driven by roots — symlinks in /nix/var/nix/gcroots and profiles that mark paths as in use. Running nix-collect-garbage removes everything unreachable from those roots; adding the --delete-older-than flag trims profile generations beyond a chosen age. On NixOS, nix.gc.automatic schedules this as a systemd timer so it never becomes a manual chore.
On a Hydra machine, garbage collection needs more care. Build results that have not yet been uploaded to a cache may be deleted if nothing references them, so it is wise to either push to the cache immediately after each build or maintain explicit GC roots for the outputs you intend to keep. Many operators also run a periodic nix store verify pass, which checks that store paths still match their recorded hashes and flags corruption early — particularly valuable on storage that has been running unattended for years.
The Other Nix Hydra: The Game Studio
Before the term became associated with build infrastructure in some circles, Nix Hydra was a widely recognized independent mobile game developer. The studio built narrative-driven titles with distinctive art styles, most notably Egg Baby, a virtual pet game that amassed a large player base, and Feral Hearts, a character-driven adventure game. Their games included cosmetic and progression storefronts where players could purchase items, which is one of the ways the phrase "Nix Hydra store" surfaces in casual search queries today.
That overlap creates genuine ambiguity. Someone searching for the studio's in-game shop and someone searching for a binary cache configuration are looking for completely unrelated answers, and search engines do not always separate them well. Being explicit about which one you mean — "Hydra CI binary cache" or "Nix Hydra game" — dramatically improves the results you get from documentation, forums, and community chat channels.
Nix Hydra's Games and In-App Storefronts
The studio's games were built around long-term engagement rather than one-off purchases. Egg Baby, for instance, combined a nurturing loop with a catalog of accessories, habitats, and customization items, all surfaced through an in-game shop. Feral Hearts took a narrative approach, with content unlocks and cosmetic options forming the commercial layer. These storefronts were a fairly standard free-to-play model: core gameplay free, optional purchases for expression and convenience.
What set the games apart was the emphasis on atmosphere and personality. Rather than optimizing purely for retention metrics, the design leaned into character writing, hand-drawn art, and small narrative moments. That reputation still carries weight among players who remember the titles, and it is part of why the name continues to appear in searches years after the studio's most active period.
Why the Name Overlap Matters in Practice
If you are writing documentation, filing an issue, or asking for help on a forum, ambiguity costs time. A request about a "Nix Hydra store problem" could reasonably be interpreted as a failing binary cache, a missing signing key, a Hydra evaluation error, or a question about a defunct mobile game's shop. Naming the exact component — Hydra queue runner, substituter configuration, store path collision — puts you in front of the right audience immediately.
For anyone maintaining a public knowledge base, it also helps to use the full technical phrasing in headings and page titles. "Nix store" and "Hydra CI" are precise, searchable, and unambiguous. That small amount of extra specificity is usually the difference between an answer arriving in ten minutes and a thread sitting unanswered for a week.
Whether you are standing up a private Hydra instance to serve signed binaries to your fleet, tuning garbage collection so your build machine survives the month, or simply trying to figure out which Nix Hydra you actually meant, the practical path forward is the same: name the component, read the manual for that specific piece, and test on a scratch machine before touching anything production depends on. The Nix ecosystem rewards precision, and the store at the center of it is remarkably good at telling you exactly what went wrong when something does.