Skip to the content
Know your tech before you buy it. Makers: get listed from $49/mo

Hydra

github.com

  • Free plan
  • Open source
  • Linux
  • Web
  • API
  • Self-hosted
7.8 Club score Visit github.com

What Hydra is

Hydra is a continuous integration service for Nix-based projects. It checks out source code periodically or continuously, builds it, runs tests and produces reports. Developers organize work into jobsets based on inputs; changes to inputs can trigger builds, and jobsets can depend on one another. Hydra supports Flake jobsets when their outputs expose a hydraJobs attribute set. Jobs can produce packages, ISO images and tarballs, and jobset inputs can use Git checkout sources. A JSON API is defined by the project's hydra-api.yaml specification. Hydra is intended for Nix and NixOS package developers, not people who only want to use NixOS. The software is open source under GPL-3.0 and listed as free. It is self-hosted, with no hosted option listed; running it is currently supported only on NixOS, and the repository recommends the NixOS module for production. Flakes are evaluated in restricted mode, limiting access to files outside the Nix store. Some state is stored in the database, so backups are needed.

Who it suits

Hydra is aimed at Nix and NixOS package developers who need builds, tests and reports organized through jobsets. It is not necessary simply to use NixOS.

Good to know, and what to watch

  • Builds, tests and reports on Nix projects
  • Jobsets can trigger on input changes
  • Can build packages, ISO images and tarballs
  • Provides a JSON API
  • Running Hydra is supported only on NixOS
  • No hosted option is listed
  • Database state means backups are needed

Hydra

Free

Open source

Getting started

  1. Open the Hydra project website
  2. Deploy Hydra on NixOS using the recommended NixOS module
  3. Define jobsets and their inputs
  4. Connect Git checkout sources, such as a GitHub repository
  5. Configure builds, tests, reports, and any package, ISO, or tarball outputs
  6. Arrange backups for state stored in the database

Limits to check

Hydra is currently supported only on NixOS, and some state is stored in its database, so a fully stateless configuration is not possible. Flake evaluation uses restricted mode and blocks access outside the Nix store, including fetched flake inputs.

The Club's review

Hydra is a continuous-integration system for projects built with Nix. It is aimed at Nix and NixOS package developers who can run their own infrastructure, not at people who merely use NixOS. Its strongest case is a jobset-centered workflow that can produce several Nix artifacts at no software cost, provided your team accepts NixOS-only deployment and the operational work of hosting it.

Overview

Hydra checks out source on a schedule or continuously, builds it, runs tests and publishes reports. Jobsets define the inputs and the work to perform; a change in an input can trigger a run, and one jobset can depend on another. This gives Nix projects an explicit, repeatable pipeline model, but it is a specialized one rather than a general CI service for arbitrary toolchains.

Hydra is useful when CI itself is part of a Nix project’s release process. It is unnecessary for someone who only wants to install or operate NixOS. Teams that need a hosted service, or that cannot standardize their build infrastructure on NixOS, should look elsewhere.

Key features

Jobsets, Flakes and outputs

Jobsets can consume Git checkout sources, with the documented examples using GitHub repositories. Flake jobsets are supported when their outputs expose a hydraJobs attribute set, giving Flake-based projects a direct way to publish build definitions to Hydra.

A jobset can build packages, ISO images and tarballs. That makes Hydra suitable for projects distributing both software packages and deployable images or source bundles. The benefit is breadth within the Nix ecosystem; it does not turn Hydra into a universal artifact system for unrelated build formats.

Build reporting and API

Hydra runs builds and tests and produces reports, so maintainers can track whether a change produced usable outputs. A JSON API, defined by the repository’s hydra-api.yaml specification, supports integrations that need to read or work with Hydra’s data programmatically.

Evaluation and security

Flakes are evaluated in restricted mode. They cannot access files outside the Nix store, including fetched Flake inputs. This is a useful security boundary, but projects whose evaluation expects to read external files must be structured around it.

Pricing

Hydra is open source under the GPL-3.0 license. The Hydra plan costs free, with no hosted option; the price covers the software, not the infrastructure and administration required to run it. Self-hosted runners and an artifact or dependency cache are part of the deployment model, so teams must provide and maintain that environment themselves.

This pricing fits Nix maintainers who want full control and can absorb operational work. It is less attractive to organizations that would rather pay for managed capacity, because there is no hosted Hydra service to remove the server and maintenance burden.

Platforms

Hydra provides a web interface and API and runs as self-hosted software on Linux. The project currently supports running Hydra only on NixOS and recommends its NixOS module for production. That makes NixOS a practical requirement for production operations, not merely one deployment option.

Who it's for

Hydra is best for Nix and NixOS package developers, distribution maintainers and teams whose build definitions already use jobsets or Flakes. It is a strong fit when producing packages, installation images and tarballs from one Nix-oriented pipeline matters more than cross-platform hosting.

It is a poor fit for teams seeking hosted CI, broad operating-system support or a tool for ordinary application development outside Nix. The system’s model rewards teams willing to understand Nix evaluation and maintain NixOS infrastructure.

Pros and cons

Pros

  • Purpose-built for Nix: Jobsets, Flake outputs and dependency relationships map directly to Nix project structure.
  • Multiple build products: Packages, ISO images and tarballs can be produced in the same jobset.
  • No software fee: GPL-3.0 open-source licensing keeps licensing cost at zero and permits self-hosted control.
  • Automation surface: Input-triggered builds, reports and a documented JSON API support repeatable maintenance workflows.

Cons

  • NixOS-only deployment: Running Hydra is currently supported only on NixOS, limiting infrastructure choices.
  • Operational state needs protection: Some state lives in a database, and a completely stateless configuration is not possible; backups are required.
  • Queue-runner risk: The documented hydra-queue-runner issue can leave builds queued without scheduling, creating a maintenance concern.
  • Restricted Flake evaluation: Builds cannot read outside the Nix store, which may require changes to project evaluation logic.

Alternatives

For a wider comparison of hosted and self-managed CI products, browse Continuous Integration Software. Choose that broader category when your pipelines are not centered on Nix or when you need deployment options beyond NixOS.

Verdict

Choose Hydra if you maintain Nix or NixOS packages and want open-source, jobset-driven CI that can build packages, images and tarballs under your control. Its zero license cost and native Flake workflow are compelling in that niche. Look elsewhere if you need hosted CI, non-NixOS deployment or an operationally stateless service; Hydra’s database-backed state, backup requirement and reported queue-runner issue make self-hosting a real responsibility.

The verdict

Hydra provides CI workflows tailored to Nix projects, including jobsets, Flakes and several build outputs. Its NixOS-only deployment support and database-backed state are important operational constraints.

Questions people ask

Is Hydra free and open source?

Yes. Hydra is listed as free and is licensed under GPL-3.0.

Who is Hydra for?

It is intended for Nix and NixOS package developers. It is not needed simply to use NixOS.

Can Hydra run as a hosted service?

Hydra is self-hosted, and no hosted option is listed.

Which deployment platform does Hydra support?

The repository says running Hydra is currently supported only on NixOS and recommends its NixOS module for production.

What can Hydra jobsets build?

Jobsets can build packages, ISO images, and tarballs, while checking out source, running tests, and producing reports.

Does Hydra provide an API?

Yes. Hydra provides a JSON API specified by the repository’s hydra-api.yaml file.

What the maker publishes

API
Hydra provides a JSON API defined by the repository's hydra-api.yaml specification. source
API
The repository includes a JSON API specification in hydra-api.yaml and points users to Swagger Editor for exploration. source
API surface
The hydra-api.yaml file contains 1,267 lines, including 1,220 lines of code. source
Binary cache
Successful builds become substitutable store paths that can feed a binary cache. source
Build model
Hydra evaluates Nix expressions into derivations and builds them on configured machines. source
Build outputs
A Hydra build is an instantiated job such as a package, ISO image, or tarball. source
Build products
Hydra can build jobs such as packages, ISO images, and tarballs as part of a jobset. source
Builds and tests
Hydra periodically or continuously checks out project source, builds it, runs tests, and produces reports. source
Checks distinction
Hydra does not use a flake's checks output as its job tree; checks are generally local or forge-CI gates. source
Database dependency
A self-hosted deployment uses PostgreSQL for persistent Hydra state. source
Declarative configuration
Hydra supports both imperative and declarative project and jobset configuration. source
Deployment
The repository says running Hydra is currently only supported on NixOS and recommends the NixOS module for production. source
Documentation
The project links to a Hydra User's Guide, NixOS Wiki material, hydra-cli, and a build-farm setup presentation. source
Evaluations
An evaluation interprets Nix code into derivation files that define the build jobs. source
Flakes
Hydra supports Flake jobsets whose outputs expose a hydraJobs attribute set. source
Flake support
For flakes, Hydra consumes the hydraJobs output attribute as its job tree. source
Foundation operations
The NixOS Foundation says its Hydra build farm has hundreds of macOS, x86-64 Linux, and aarch64 Linux build cores and executes more than 350,000 builds weekly. source
Independent review coverage
G2's Hydra page says it does not have enough reviews to provide buying insight; the listing is for a project-management product rather than NixOS Hydra. source
Independent technical assessment
An independent Nix documentation site describes Hydra as heavyweight for self-hosting and suggests lightweight forge CI for most application repositories. source
Integrations
Hydra jobset inputs can use Git checkout sources, and the documented examples use GitHub repositories. source
Intended users
Hydra is intended for Nix and NixOS package developers and is not needed simply to use NixOS. source
Jobsets
Jobsets are defined by their inputs, can trigger when inputs change, and may depend on other jobsets. source
Jobsets
Jobsets combine inputs with a Nix expression and can re-evaluate when inputs change. source
Known issue
The wiki reports that hydra-queue-runner can sometimes get stuck while builds remain queued and unscheduled. source

Checked against the maker's pages on 14 Oct 2026.