3.7k
Connect
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.

Explore how Nix works
Bring Nix to your team

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.

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 project environments with the tools and dependencies developers need, then reproduce those environments across platforms and infrastructure.

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. Explore Nixpkgs: The Big Recipe Book of Open Source

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.

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

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.

Kelsey Hightower

How open source led Kelsey Hightower to Nix

Kelsey Hightower
Kelsey shares how he discovered Nix through the open-source community and what drew him to its approach to building and packaging software.

Farid Zakaria

How far can you push Nix? Pretty much anywhere.

Farid Zakaria
Farid explores the depth and flexibility of Nix, and the technical control it gives engineers willing to push its model further.

Ron Efroni

Secure software by construction

Ron Efroni
Ron explains how explicit dependencies, reproducibility and provenance can create a more secure foundation for the software supply chain.

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.

Explore all Nix in the Wild stories

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.

  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.

  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.

  4. Document and enable

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

  5. Expand from proven value

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

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.

Bring Nix to work with Flox

Flox is a developer environment platform built on open source Nix. 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

Nix glossary

Jump into plain-language definitions for the terms behind Nix and Flox.

See the full glossary

Ready to bring Nix to work?

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

Get started with FloxBook a demo

Empowering
Developers

We're building the future of software and infrastructure management. We'd love to hear what you think!

Sign in to FloxHubContact us
FloxFloxFloxFloxFloxFloxFlox