Nix Team Creation

I think this is a great move, but like every FOSS project I am interested what the finding situation will look like, both short and long term.

(One guesses they have software dev jobs and will have some % of time dedicated to that).

The new Nix command syntax that was there up to 2.3 was always marked as experimental, but it worked fine for many years, I used it in many projects ... until it got deleted and replaced with flakes. I really hope they don't do that again. Flakes are de facto adopted by now, if they break it once more, it will fragment the ecosystem. Though there are rough edges where a breaking change would be beneficial in the long run.

A few of these problems are fixed with flakes - namely the dramatically improved composability. It becomes much simpler to understand how to use something when you are able to work on it in isolation. With the previous mono-repo nixpkgs assumption, you were basically required to not only learn nix-lang, but also nixpkgs and the nixpkgs workflow making it much harder to grasp the fundamentals.

With flakes, it is now significantly easier to create an standalone package or module for your specific needs since you import it just like nixpkgs. It also means that software doesn't have to be part of nixpkgs to be usable on the system - if a git repo has a flake it's just a matter of adding it as an input. Flakes represent such a massive improvement to the way that you interact with nix, I sincerely hope they become the default here soon. In the meantime, it is well worth your effort to learn them even if they aren't 'required' yet.

Unfortunately all of this is contingent on being able to grok the language in the first place which is where the documentation really falters. The nix pills talk about the basics of the language but it is very difficult to make anything useful without importing some libraries (i.e. nixpkgs) - and these libraries are not very well documented. I am aware of a documentation team being formed to help address this but it still remains the number one issue with nix, especially for newcomers. The unfortunate thing is that there are so many moving parts that it will take a considerable effort to explain the entire ecosystem without being overwhelming but still providing enough intuition for newcomers to get things done with Nix.

If anyone is interested, a recent SoN talk was given about efforts to improve the documentation. It touches on many of the things I bought up here: https://www.youtube.com/watch?v=WFRQvkfPoDI

Nixpkgs is certainly the core of the ecosystem, but it's not at all the whole ecosystem.

Other important parts of the NixOS ecosystem include:

  - NixOS, the main module system which adds many configuration management capabilities to Nix
  - Nix-Darwin and home-manager, extremely popular module systems for using Nix for configuration management on other operating systems
  - various deployment tools: NixOps, Hail, Colmena, deploy-rs, Terranix
  - pre-flake version pinning tools like Niv
  - flake libraries like flake-utils, flake-utils-plus, std, and flake-parts
  - development environment utilities and libraries like devshell, Lorri, and integrations like those of direnv and shadowenv
  - the Nix User Repository and various important overlays (e.g., the Emacs overlay, the Rust overlays)
  - the many 2nix conversion tools, some of which are chiefly distributed outside of Nixpkgs and used to package things in private or company collections rather than in Nixpkgs
  - arguably some proprietary commercial products and SaaS offerings, like Cachix, Hercules CI, and Flox
  - the NixOS hardware profiles collection
  - the Nix and NixOS manuals
  - important unofficial documentation sources, like nix.dev and nixos.wiki, and even important blog series like the Nix Pills or Ian Henry's reading of the official documentation
  - wrappers and developer applications based on Nix, like devboxes and nixpacks
  - GUI tools for working with Nix code or configuring NixOS, graphical app stores, etc.
  - editor integrations like rnix-lsp, nix-mode, and environment management plugins for various editors
  - a couple of really cool tools for automatically creating portable/deployable shell scripts with Nix (binlore + resholve)
  - tools for generating magic fat binaries based on container technologies, like nix-bundle
  - partial reimplementations of various parts of the Nix stack for specialized use in other programs, or sometimes aspiring to compete with Nix (like tvix)

Some of that stuff is included in Nixpkgs, but that's almost incidental— the ecosystem is not just the packages qua packages, but also various specialized tools and community knowledge which has been accumulated in the form of configuration modules and documentation. Those projects are first-class members of the Nix ecosystem in their own right, not only as things that might be included as packages in Nixpkgs :)

(And of course leveraging Nix successfully doesn't mean one has to evaluate or learn all of these tools. Most users will organically discover and stick with just a handful of them according to the demands of their own use cases. But in total, there is a really wide landscape of Nix-based and Nix-related software out there.)

For what it's worth most of the "packages" on chocolatey are just instructions for downloading those same installers and executing them in their respective silent modes. No one is repackaging those apps except for maybe some of the ones marked as "portable".