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.
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 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.
Consume and compose software from a huge collection of pre-built packages. Use old and new versions of packages side by side, without conflicts.
Define an environment with the tools, dependencies, and runtime settings your software needs, then reproduce it across local development, CI, and production.
Describe how software should be built from source by declaring its dependencies, compilers, flags, and other build inputs.
Contributors
Packages
of Historical Package-Version Combinations
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.
The package manager, build system, language, and tooling used to declare, build, and manage software.
A community-maintained collection of more than 140,000 open source package recipes, with millions of historical package-version combinations.
A Linux distribution whose packages, services, and system configuration are defined declaratively with Nix.
| 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 |
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.
Keep packages and conflicting dependency versions in separate, immutable paths rather than modifying shared system locations.
Describe the desired software and configuration as code that can be versioned and reviewed.
Use the same definitions across supported operating systems, architectures, and stages of the SDLC.
Make changes without partially mutating an environment or deployment, so upgrades, rollback, and automation stay predictable.
Use Nix's authoritative dependency graph to see what an artifact contains, what it depends on, and how it was produced.
Give teams a shared, reproducible set of project tools and dependencies they can work with together, then hand off to anyone, anywhere.
Learn moreDefine builds from explicit inputs so they can be repeated, reviewed, and reproduced across developers and automation.
Learn moreEliminate differences between local development and CI by using the same declared environment in both places.
Learn moreUse Nix to define and reproducibly build distroless OCI images... or use it for dev and build environments while continuing to deploy with containers.
Learn moreCompose frameworks, native libraries, compilers, CUDA dependencies, and model-serving tools into reproducible stacks that teams can version, reuse, and run anywhere.
Learn moreUse explicit dependency graphs and isolated builds to generate authoritative SBOMs, analyze vulnerability exposure, and trace artifacts back to their inputs.
Learn moreThe 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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Nix helps Antithesis maintain reproducibility and determinism across development, testing and deployment.
Nix in the Wild · 06 August 2025SysEleven uses Nix to define binaries, OCI images and deployment manifests from declared inputs.
Nix in the Wild · 2 Nov 2023Google's Project IDX selected Nix to provide fast, customizable development environments at scale. Project IDX is now Firebase Studio.
Nix in the Wild · 27 June 2023PDT expanded Nix from development tools into scientific environments, proprietary software, CI and production systems.
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.



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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
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.
Jump into plain-language definitions for the terms behind Nix and Flox.
Start building a reproducible environment with Flox, or talk to our team about expanding Nix across your organization.