Nix in sbi

[Filippo-Galli]

Summary

Proposal to add optional Nix (a functional package manager for reproducible environments) support to sbi for reproducible development environments and Nix-based packaging, without changing existing infrastructure.

Motivation / Benefits

From my perspective, the main advantages would be:

• Reproducible development environment via shell.nix / flake.nix

  • Similar in spirit to using uv or venv, but with stronger guarantees about system-level dependencies and compiler toolchains.
  • Useful for contributors who want a fully pinned environment for Python, compilers, and optional CUDA / MPI stacks.

• Nix-based build system that can be used to create other packages or artifacts starting from sbi

  • Analogous to adding dependencies in uv or pyproject.toml, but expressed in Nix.
  • Enables building:
    • The sbi Python package itself as a Nix derivation.
    • Using the flake.nix, you could build a Nix derivation or other artifact formats (such as container images) that are useful for HPC or cluster deployment.

This would not change the current development or build infrastructure; it would simply provide an additional, optional way to develop and build sbi.

Proposed minimal setup

I'm not a Nix expert, but based on current best practices, the initial contribution could consist of three files:

1. flake.nix – main entry point

   • Defines:
     • packages.default: the sbi package as a Nix derivation.
     • devShells.default: a development shell with all required tools.
     • Optionally checks to run tests in a reproducible way.
     • Optionally an OCI image output for HPC/cluster usage.

2. default.nix – build recipe for the sbi package as a Nix derivation

   • Builds sbi from pyproject.toml (potentially using tools like pyproject.nix or similar).
   • Pins Python and key dependencies via nixpkgs.

3. shell.nix – convenience wrapper

   • Allows nix-shell or nix develop to quickly get a development environment.
   • Wraps the devShell from flake.nix for non-flake users if desired.

These files would:

• Pin Python and key dependencies via Nixpkgs (and/or integrate with pyproject.toml / uv.lock via tools like pyproject.nix or poetry2nix-style workflows).
• Provide a nix develop shell with all required tools for contributing to sbi.
• Optionally define:
  • A checks attribute to run tests in a fully reproducible way.
  • An OCI image output for HPC/cluster usage.

Questions / points to discuss

1. Interest from maintainers / community

   • Is this something the maintainers and community would be interested in?
   • Are there existing plans or constraints around packaging / environments that I should be aware of (e.g., interaction with conda-forge, uv, CI systems)?

2. Scope of initial contribution
   Would you prefer:

   • A minimal "dev shell only" PR first (just flake.nix + shell.nix to get a working nix develop environment), or
   • A more complete setup including:
     • Packaging (default.nix / packages in flake.nix),
     • Tests (checks in flake.nix)

Next steps

If this is welcome, I'm happy to:

• Prepare an initial PR with a basic flake.nix + shell.nix providing:
  • A working nix develop environment with Python and core dependencies.
  • Minimal documentation in CONTRIBUTING.md or a new NIX.md file.
• Iterate based on feedback to:
  • Add default.nix / proper packaging.
  • Add checks for running tests via Nix.
  • Optionally add OCI image support.
  • If it aligns with the project's goals, a future step could be submitting sbi to nixpkgs. This would:
    • Make sbi available as an official Nix package (nix-shell -p sbi).
    • Enable binary caching via the Nix cache system, speeding up installs for users.

Please let me know:

• Whether this direction aligns with the project's plans.
• What scope you'd prefer for the first PR.
• Any constraints or preferences I should keep in mind (e.g., Nix version, integration with CI, documentation style).

Thanks for considering this, and apologies if this is not the ideal place or format for such a suggestion.

[BHARATH0153]

This looks like a useful addition to the project, especially from a reproducibility and development-environment perspective.
I particularly like the idea of keeping Nix as an optional layer alongside the existing uv/pyproject.toml setup rather than replacing the current workflow.
One question I had is whether the scope could also include reproducible CI/testing and potentially a maintained Nix package for sbi. That could make the contribution even more useful for contributors and users working across different environments, including HPC systems.
Overall, I think this is a promising direction. It would be interesting to hear the maintainers thoughts on the proposed scope and priorities.

[janfb]

@Filippo-Galli thanks for asking before writing any code, and for the detailed proposal.

For now, we would prefer not to add further packaging setups to the sbi repository, to keep the maintenance work manageable.

The nixpkgs route you mention at the end fits us much better. The package would live, build and get cached in nixpkgs, the same way our conda-forge recipe serves conda users. sbi is not in nixpkgs yet, and neither are zuko and nflows, so those two would need packages too. torch, pyro-ppl and skorch are already there.

If you package sbi in nixpkgs and maintain it there, we are happy to link it from our installation guide next to conda and pixi. A small PR that adds a "Using Nix" section is welcome once the package is available.

Thanks again for offering this, Jan

[Filippo-Galli]

Thanks for your response and point of view.
Right now, I'm doing some experiment on my fork of the repo and seems working without any issue (I already package also zuko and nflows).
In case of accepted merge in nixpkgs I could maintain it without problems.

Thanks again for your response and have a nice day.

[Filippo-Galli]

Hi everyone, a quick update:

I spoke with a Nixpkgs reviewer, who explained that some of sbi’s dependencies, such as nflows, are too outdated to be included in Nixpkgs.

For anyone interested in using sbi with Nix, I’m maintaining [sbi-nix](https://github.com/Filippo-Galli/sbi-nix). The repository provides Nix build definitions for sbi and its dependencies, as well as a shell.nix for setting up a development environment.

Feedback are welcome!

[janfb]

Thanks @Filippo-Galli , that's super helpful!