# What is Nix? Bringing Nix to work with Flox

> Markdown copy of https://flox.dev/nix/. Last updated 2026-11-12.

Nix gives teams a way to reproducibly build, package, and run software and environments. This page covers 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](https://flox.dev/docs/flox-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 and hardware on which they run.

- **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.
- **Environment manager.** Define an environment with the tools, dependencies, and runtime settings your software needs, then reproduce it across local development, CI, and production.
- **Build system.** Describe how software should be built from source by declaring its dependencies, compilers, flags, and other build inputs.

Nix ecosystem stats: 10,000+ contributors, 140,000 packages, millions of historical package-version combinations.

## Nix isn't just one thing

[Nixpkgs](https://flox.dev/blog/nixpkgs-the-big-recipe-book-of-open-source/) 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 | NixOS |
|---|---|---|---|
| Used for | Building, packaging and running software reproducibly | Declarative build definitions Nix uses to fetch prebuilt packages / build them from source | A Linux distribution with declarative system configuration |
| Needs NixOS? | No, runs on Linux, macOS, and FreeBSD; comes with NixOS | No; but does include NixOS-specific software | It _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.
- **Reproducible builds.** Define builds from explicit inputs so they can be repeated, reviewed, and reproduced across developers and automation.
- **CI and software delivery.** Eliminate differences between local development and CI by using the same declared environment in both places.
- **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.
- **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.
- **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.

## 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](https://flox.dev/nixinthewild/nix-in-the-wild-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](https://flox.dev/nixinthewild/nix-in-the-wild-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](https://flox.dev/nixinthewild/nix-in-the-wild-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](https://flox.dev/nixinthewild/nix-in-the-wild-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](https://flox.dev/nixinthewild/nix-in-the-wild-pdt-partners/) went from dev tools to scientific Python environments to production builds.

What successful adoptions have in common:

- **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.

## See how engineering teams put Nix to work

Nix is used across cloud infrastructure, security, financial services, retail, developer tools, scientific computing and open source software. The Nix in the Wild series explores how and why organizations adopted Nix, the problems they used it to solve, and what they learned along the way.

- [Antithesis](https://flox.dev/nixinthewild/nix-in-the-wild-antithesis/): deterministic software testing. Nix helps Antithesis maintain reproducibility and determinism across development, testing and deployment.
- [SysEleven](https://flox.dev/nixinthewild/nix-in-the-wild-syseleven/): reproducible Kubernetes infrastructure. SysEleven uses Nix to define binaries, OCI images and deployment manifests from declared inputs.
- [Google Project IDX](https://flox.dev/nixinthewild/nix-in-the-wild-project-idx/): personalized cloud development environments. Google's Project IDX selected Nix to provide fast, customizable development environments at scale. Project IDX is now Firebase Studio.
- [PDT Partners](https://flox.dev/nixinthewild/nix-in-the-wild-pdt-partners/): scientific computing and financial services. PDT expanded Nix from development tools into scientific environments, proprietary software, CI and production systems.

[Explore all Nix in the Wild stories](https://flox.dev/nixinthewild/)

## Voices from the Nix ecosystem

Captured at [Planet Nix 2026](https://planetnix.com/), 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.

- [How open source led Kelsey Hightower to Nix](https://youtube.com/shorts/iYwtWVfhgfU). Kelsey shares how he discovered Nix through the open-source community and what drew him to its approach to building and packaging software.
- [How far can you push Nix? Pretty much anywhere.](https://youtube.com/shorts/8UroDQp7ETM) Farid Zakaria explores the depth and flexibility of Nix, and the technical control it gives engineers willing to push its model further.
- [Secure software by construction](https://youtube.com/shorts/881i3WwAUtw). Ron Efroni explains how explicit dependencies, reproducibility and provenance can create a more secure foundation for the software supply chain.

### 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. See [planetnix.com](https://planetnix.com/), or [submit a talk](https://sessionize.com/planet-nix-2027).

## 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. [Learn more](https://flox.dev/bringing-nix-to-work/).

## 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.

## Nix glossary

Plain-language definitions for the terms behind Nix and Flox: [flox.dev/glossary/](https://flox.dev/glossary/).

## Keep reading

- [Bringing Nix to work at scale](https://flox.dev/bringing-nix-to-work/)
- [Enterprise Nix: a hands-on guide](https://flox.dev/blog/enterprise-nix-its-time-to-bring-nix-to-work/)
- [Nix in the Wild interviews](https://flox.dev/nixinthewild/)
- [Nixpkgs: the big recipe book](https://flox.dev/blog/nixpkgs-the-big-recipe-book-of-open-source/)
- [Using Nix flakes with Flox](https://flox.dev/blog/extending-flox-with-nix-flakes/)
- [Nix and Flox glossary](https://flox.dev/glossary/)
