Case studyHow detaso ended environment drift with Flox, from local dev to productionHow detaso ended environment drift with FloxRead the case study →
Connect
  • GitHub
  • Mastodon
  • Twitter
  • Slack
  • Linkedin
  • YouTube
Bringing Nix to Work

Nix: the foundation for reproducible software

Nix gives teams a way to reproducibly build, package, and run software and environments. Learn how Nix works, where engineering teams use it, and why companies trust Flox to scale the use of Nix across the SDLC.

What is Flox? Flox is a Nix-based software delivery platform that scales reproducibility from local dev through CI to production. It gives teams and agents a deterministic foundation to build, publish, and run software, with SBOMs by default, automated package rebuilds, and policy-driven environment updates. Try Flox in 5 minutes 

Nix: one system for packages, environments and builds

Nix is an open source package manager, environment manager, and build system that takes a fundamentally different approach to building and delivering software.

Nix declaratively defines an environment, then realizes it from cached or locally built packages stored at unique immutable paths. Nix doesn't install software to the global filesystem, so conflicting versions of the same packages or dependencies can coexist on the same system, at the same time. Nix environments are declarative, so they're easy to inspect, upgrade, triage, and roll back: changes are atomic edits. Nix environments behave reproducibly across space and time and (unlike containers) are optimized for the platforms + hardware on which they run.

01

Package manager

Consume and compose software from a huge collection of pre-built packages. Use old and new versions of packages side by side, without conflicts.

02

Environment manager

Define an environment with the tools, dependencies, and runtime settings your software needs, then reproduce it across local development, CI, and production.

03

Build system

Describe how software should be built from source by declaring its dependencies, compilers, flags, and other build inputs.

10,000+

Contributors

140,000

Packages

Millions

of Historical Package-Version Combinations

Nix isn't just one thing

Nixpkgs is a living open source package repository built and maintained by thousands of contributors. It comprises one of the largest collections of inspectable software build recipes available anywhere.

Nix

The package manager, build system, language, and tooling used to declare, build, and manage software.

Nixpkgs

A community-maintained collection of more than 140,000 open source package recipes, with millions of historical package-version combinations.

NixOS

A Linux distribution whose packages, services, and system configuration are defined declaratively with Nix.

What's the difference between Nix, Nixpkgs and NixOS?

Nix, Nixpkgs and NixOS compared
NixNixpkgsNixOS
Used forBuilding, packaging and running software reproduciblyDeclarative build definitions Nix uses to fetch prebuilt packages / build them from sourceA Linux distribution with declarative system configuration
Needs NixOS?No, runs on Linux, macOS, and FreeBSD; comes with NixOSNo; but does include NixOS-specific softwareIt is the OS

Reproducibility by design

Reproducible

Explicitly declare the inputs for builds and environments, so both can be reproduced at any time and in any place without relying on machine state.

Isolated

Keep packages and conflicting dependency versions in separate, immutable paths rather than modifying shared system locations.

Declarative

Describe the desired software and configuration as code that can be versioned and reviewed.

Portable

Use the same definitions across supported operating systems, architectures, and stages of the SDLC.

Atomic

Make changes without partially mutating an environment or deployment, so upgrades, rollback, and automation stay predictable.

Traceable

Use Nix's authoritative dependency graph to see what an artifact contains, what it depends on, and how it was produced.

From developer laptops to production infrastructure

Development environments

Give teams a shared, reproducible set of project tools and dependencies they can work with together, then hand off to anyone, anywhere.

Learn more

Reproducible builds

Define builds from explicit inputs so they can be repeated, reviewed, and reproduced across developers and automation.

Learn more

CI and software delivery

Eliminate differences between local development and CI by using the same declared environment in both places.

Learn more

Containers and Kubernetes

Use Nix to define and reproducibly build distroless OCI images... or use it for dev and build environments while continuing to deploy with containers.

Learn more

AI, ML and GPU stacks

Compose frameworks, native libraries, compilers, CUDA dependencies, and model-serving tools into reproducible stacks that teams can version, reuse, and run anywhere.

Learn more

Security and software provenance

Use explicit dependency graphs and isolated builds to generate authoritative SBOMs, analyze vulnerability exposure, and trace artifacts back to their inputs.

Learn more

The organizational challenge

The people who write Nix don't have to be the same people who use it.

Nix often enters an organization by way of a small number of expert champions. They define packages, environments, and workflows for others to consume. If teams cannot use Nix definitions without expert help, these same champions become the de facto owners of every change, question... and failure.

Organizations that succeed with Nix focus on abstracting Nix-specific primitives and behaviors via easy-to-use interfaces and workflows. Developers can work with these without having to know much about Nix.

  1. Find the right starting point

    Start with chronic, visible problems: like when one developer's setup differs from another's; a build only works on certain machines; or a dependency stack is difficult to recreate exactly.

    Example: Antithesis moved off dev containers after Docker Hub rate limits and missing tools slowed every developer.

  2. Run a contained pilot

    Introduce Nix for a single environment or artifact type. If a requirement or use case is tightly scoped, consider extending this across a project or team.

    Example: SysEleven started by packaging Kubernetes CRDs with Nix before moving its whole operator stack.

  3. Create a familiar entry point

    Use familiar aliases or scripts to wrap Nix commands, or equip developers with higher-level tools that give them a way to benefit from Nix without becoming Nix experts.

    Example: At Bellroy, most developers only needed one command to enter their environment.

  4. Document and enable

    Use internal guides, workshops, templates and pairing to help teams understand the Nix model and adopt it effectively.

    Example: SysEleven's Nix champion ran hands-on demos and workshops, and paired with teams on request.

  5. Expand from proven value

    Extend Nix into CI, deployment, production, private packages, infrastructure or security as new needs emerge.

    Example: PDT Partners went from dev tools to scientific Python environments to production builds.

Reduce dependence on individual experts

Encode package-, environment-, and workflow-specific knowledge in versioned Nix definitions, then make that knowledge reusable by others using scripts, commands, and higher-level tools.

Prioritize the developer experience

Preserve familiar workflows. Let developers work with the commands, editors, build tools, and project conventions they prefer while Nix supplies the underlying software and environment.

Build a shared foundation

Reuse the same definitions across the SDLC. Developers, CI, and platform teams work from the same software and environment definitions... instead of reconstructing the stack at each stage.

Voices from the Nix ecosystem

Captured at Planet Nix 2026, these conversations with engineers and open-source leaders explore what makes Nix different, what its model makes possible, and why more teams are bringing it into their development workflows.

Meet the Nix community at Planet Nix

Planet Nix is the Nix conference hosted by Flox, held alongside SCaLE in Pasadena, California. Engineers and open-source maintainers share how they use Nix in production. Planet Nix 2027: April 1–2.

Bring Nix to work with Flox

Teams define software and configuration once, then reproduce build and runtime environments across local development, CI, and production. Developers work with simple, intuitive commands and declarative, human-readable manifests. Nix experts can extend Flox build or runtime environments with flakes, Nix expressions, custom builds, and private packages.

How Nix and Flox work together

Is Flox an alternative to Nix?

Not exactly. Flox is built on Nix. It uses Nix and Nixpkgs as a foundation for reproducible packages, environments, and builds, while adding enterprise-grade workflows for versioning and sharing environments; building, publishing, and distributing private software packages; and promoting reproducible environments across the SDLC.

Do I need to know Nix to use Flox?

Not at all. Flox builds on top of Nix rather than replacing it. Developers use a familiar syntax and subcommands like `init`, `install`, `push`, and `activate` to create, modify, share, and run Flox environments. They define Flox environments declaratively in human-readable TOML. With Flox, developers do not need to know Nix to install packages; define dependencies; reproduce an environment across supported systems; or build, package, and publish their own software for different operating systems, CPU architectures, and GPU-accelerated hardware.

Can existing Nix users use Flox?

Yes. Nix users can continue working with the Nix-based workflows, primitives, and mental model they know and love. Nix flakes can function as inputs to Flox environments, while Nix expressions can define custom Flox builds or be used as inputs to those builds. Teammates who do not know Nix can reuse Nix definitions in Flox, package and publish the resultant software, and distribute it to consumers across the organization. Teams can reuse custom-built software packages in Flox environments alongside software from Nixpkgs and private catalogs.

What is the difference between Nix and Flox?

Nix is a package manager, build system, and declarative model for working with software. Flox builds on top of Nix to provide a deterministic foundation for the SDLC: it gives organizations a shared, authoritative model they can use to define, reproduce, distribute, and govern software from local development to production.

Flox adds team and enterprise distribution, sharing, and governance capabilities that Nix does not provide on its own: FloxHub for versioning and sharing environments; private catalogs for publishing and reusing custom software across teams and systems; and built-in SBOM generation for software inventory and audit.

Does Flox replace NixOS?

No. Nix, NixOS, and Flox are related, but each does different things.

Nix is a package manager, build system, and declarative model for defining software by declaring its inputs and reproducing the resultant outputs and dependency graph.

NixOS is a Linux distribution, comparable in scope to Debian, Ubuntu, Fedora, or Red Hat Enterprise Linux. Unlike those distributions, NixOS applies the declarative Nix model to the operating system as a whole. Users declaratively define their packages, services, users, and system configuration. NixOS takes those definitions and builds a complete, versioned system configuration.

Flox builds on Nix so teams can define, version, and reproduce the same environment across the SDLC, promoting known-good environment versions without reconstructing the software stack each time. Flox environments can run as-is on NixOS as well as any other supported systems.

Questions about Nix itself

What is Nix used for?

Reproducible development environments, reproducible builds, CI, container images, AI and GPU stacks, and generating SBOMs from the dependency graph. Teams often start with developer environments.

Is Nix the same as NixOS?

No. Nix is the package manager and build system; NixOS is a Linux distribution built on it. Nix runs on macOS and other Linux distributions without NixOS.

What's the easiest way to try Nix on a real project?

Pick one visible problem, like a setup that differs between developers, and use Nix for that single environment first. Expand to the rest of the project once it works.

How do I adopt Nix incrementally in an existing codebase?

Run a contained pilot on one environment or artifact type, give developers a familiar entry point, document what works, then extend Nix into CI and production as needs come up.

One of my engineers keeps mentioning Nix. Should I care?

Probably. Nix removes "works on my machine" problems and gives you a full record of what every artifact contains, which helps with SBOMs and security reviews. The usual risk is that only one or two experts understand it; adopting it through a tool like Flox spreads the benefits without making everyone learn Nix.

Ready to bring Nix to work?

Start building a reproducible environment with Flox, or talk to our team about expanding Nix across your organization.