Say Goodbye to “It Works on My Machine”: Why You Need Nix Flakes

We’ve all been there. You clone a repository, run the setup script, and immediately hit a wall of errors. Your Node.js version is too new, your colleague’s Python version is too old, and the production server is running something else entirely.

While Docker and language-specific version managers (like nvm or pyenv) help, they often feel like heavy workarounds.

Enter Nix Flakes—the modern standard for declarative, reproducible development environments.

What Exactly is a Nix Flake?

Think of a Nix Flake as a self-contained package with a strict contract. At its core, it’s just a directory containing a flake.nix file.

The magic sauce: Nix Flakes introduce a flake.lock file (conceptually identical to package-lock.json in npm or Cargo.lock in Rust). It pins the exact Git revisions of your inputs (like nixpkgs).

This means if your project builds today, it will build exactly the same way 5 years from now, on any machine, without pulling in unexpected updates that break your setup.

Why You Should Use Flakes for Your Projects

• Instant Dev Shells (nix develop): No more global installations. Run one command, and Nix temporarily drops you into a shell with your compiler, database, and linters ready to go.
• Absolute Reproducibility: The lockfile guarantees that everyone on the team is running the exact same binary versions down to the C libraries.
• Clean Composability: You can easily reference other Flakes directly via GitHub URLs as inputs.
• Zero System Clutter: When you exit the development shell, your system remains completely clean.

How It Looks in Action

Here is a minimal flake.nix that spins up a development environment with С and clang-tools:

Nix

{
  description = "My awesome C project";

  inputs = {
    nixpkgs.url = "github:nixos/nixpkgs/nixos-unstable";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = { self, nixpkgs, flake-utils }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        pkgs = import nixpkgs { inherit system; };
      in
      {
        devShells.default = pkgs.mkShell {
          packages = with pkgs; [
            clang-tools
            pkg-config
            gcc
            gnumake
          ];

          shellHook = ''
            echo "Welcome to the flake dev shell!"
          '';
        };
      });
}

Simply run nix develop, and you are ready to code!

(By the way, if writing this boilerplate feels tedious, I actually built a handy template snippet for this in my own Neovim distribution)

How to Get Started

To jump into the Flakes ecosystem, you’ll need to install Nix first. It runs beautifully on Linux, macOS, and WSL.

Download and Install Nix here

Tip: Because Flakes are technically still an “experimental” feature (despite being the de facto community standard), you’ll just need to add experimental-features = nix-command flakes to your nix.conf after installation.

Give Nix Flakes a try on your next side project. Once you experience zero-config onboarding, there’s no going back!