I thought Nix is the ecosystem?
nixpkgs is the ecosystem, since it contains all the packages.
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)
(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.)
However, if I can't find what I need in the documentation then it can be a problem. That's specially true for installing software. I'm not too familiar with the language to make entire new packages. Most things are using flakes and I haven't wrapped my head around them yet. Other things are not really compatible with its philosophy (like software packaged as Wine bottles).
Nix itself: same problem when the package doesn't exist. But when it does, it's wonderful. I'm even using it in OSX, instead of homebrew (with home-manager).
Hopefully this team will help smooth some of the rough edges.
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
As for flakes, they're not that big a change. There's some entry point which you have to learn about - a special file (flake.nix) that defines inputs and outputs according to some predefined structure. But the output leafs are just normal nix code - it's just that there's some builtins that can't be used because they do side effects at runtime. But that's less important than it sounds, because if you're using nixpkgs (as a library/input or as a source for copypasting) then it's flake-safe.
I always wondered why there are no wine packages using nix. Sure, it is likely not legal, but I would absolutely love to have an MS office package that mandates a specific hashed file (that I can torrent and add to the nix store - this way I don’t even risk viruses), and the install itself is deterministically done (perhaps with some headless GUI clicking here and there).
Edit: fixing autocorrect typos.
> the code replaces my notes entirely.
I think this ends up being one of the key selling points for Nix for developer machines.
What is Nickel? Is this an officially endorsed project? It’s run by Tweag — do they run Nix? Most core contributors work for Tweag. What is the fate of the Nix language? Should I start investing in this new language?
Why is documentation still so bad? Why is there not a clear and official answer to documentation generation? Syntax linting? Testing? Who is in charge of trying to fix SEO for documentation?
Nix is technologically sound but is struggling organizationally from its explosive growth
it gives me hope. I just wish the boilerplate were less arcane. Nix is a relatively elegant language, I'm not sure why nixpkgs is so ugly.
The old development style mentioned reminds me of that excessively mentioned essay about Lisp hackers keeping to themselves. I wonder if there's something intrinsic to certain developer-oriented projects like these that lead people to tinker with them on their own for long periods of time.
I'm blown away by what Nix/NixOS has accomplished without having a formal team in place. Kudos to the maintainer(s), community and best wishes to the new Nix Team.
(One guesses they have software dev jobs and will have some % of time dedicated to that).