NixOS 21.05 Released

This page summarizes the projects mentioned and recommended in the original post on news.ycombinator.com

Nutrient - The #1 PDF SDK Library
Bad PDFs = bad UX. Slow load times, broken annotations, clunky UX frustrates users. Nutrient’s PDF SDKs gives seamless document experiences, fast rendering, annotations, real-time collaboration, 100+ features. Used by 10K+ devs, serving ~half a billion users worldwide. Explore the SDK for free.
nutrient.io
featured
CodeRabbit: AI Code Reviews for Developers
Revolutionize your code reviews with AI. CodeRabbit offers PR summaries, code walkthroughs, 1-click suggestions, and AST-based analysis. Boost productivity and code quality across all major languages with each PR.
coderabbit.ai
featured
  1. nixos-generators

    Collection of image builders [maintainer=@Lassulus]

    One way is to use this project: https://github.com/nix-community/nixos-generators

    It's just a small wrapper but it shows you most of the targets available.

  2. Nutrient

    Nutrient - The #1 PDF SDK Library. Bad PDFs = bad UX. Slow load times, broken annotations, clunky UX frustrates users. Nutrient’s PDF SDKs gives seamless document experiences, fast rendering, annotations, real-time collaboration, 100+ features. Used by 10K+ devs, serving ~half a billion users worldwide. Explore the SDK for free.

    Nutrient logo
  3. nixpkgs

    Nix Packages collection & NixOS

  4. poetry2nix

    Convert poetry projects to nix automagically [maintainer=]

    - poetry can still be used by people who don't use Nix

    Regarding non-python dependencies, this is solved by overrides file[1]. You can override the override in your project as well.

    [1] https://github.com/nix-community/poetry2nix/blob/master/over...

  5. NixOS-docker

    Discontinued DEPRECATED! Dockerfiles to package Nix in a minimal docker container (by NixOS)

    There is one: https://github.com/NixOS/docker

    But it's more of a Nix docker image than a NixOS one, because half of the things that NixOS gives you don't really make much sense in a docker image (systemd in a container?).

  6. not-os

    An operating system generator, based on NixOS, that, given a config, outputs a small (47 MB), read-only squashfs for a runit-based operating system, with support for iPXE and signed boot.

    It's like an OS that has builtin salt/ansible/chef/puppet.

    Because Nix language describe the OS instead of what to change/configure it's superior to these tools, and solves the problem that supposedly same machines are drifting apart.

    For example if in the CM you tell it to install a package, then change your mind and remove the entry that does it. The package will remain installed.

    With NixOS if you remove the package from configuration, it's gone.

    I personally really like Nix's building capability. For example I can use it to generate a minimal docker container. It requires some knowledge, but I can also modify compilation options in dependencies (like remove unneeded functionality).

    It looks like there's also an option to similarly build lightweight OS images[1]. I haven't tried it yet but looks cool.

    [1] https://github.com/cleverca22/not-os

  7. rfcs

    The Nix community RFCs (by NixOS)

    > Basically every module also has an ‘extraConfig’ type of option

    This is actually changing so that the additional config can be merged/validated even if it can't be typed

    https://github.com/NixOS/rfcs/blob/master/rfcs/0042-config-o...

  8. Home Manager using Nix

    Manage a user environment using Nix [maintainer=@rycee]

    and then you can add, e.g., `nix-processmgmt-tools.common` to your `environment.systemPackages`.

    I think maybe the reason instructions aren't given for some projects is that they see those parts of the guide as mostly for beginners, and they expect advanced users to just figure it out. In the case of nix-processmgmt, I think Sander doesn't actually expect to have any users! In the latter case, an imperative install that users are expected to play with for a little while and then just throw away is supposed to be enough.

    You're right, though, that it's odd and disappointing that instructions for the preferred way of doing things are sometimes simply not given. A polite pull request or issue report would probably be well-received. My recommended strategy, if you get stuck, would be to ask for help getting those packages into scope declaratively on Discourse or Matrix, and then to offer the authors of these out-of-tree packages pull requests to modify their READMEs accordingly. :)

    1: https://github.com/gytis-ivaskevicius/flake-utils-plus

    2: https://github.com/nix-community/emacs-overlay#quickstart

    3: https://github.com/nix-community/home-manager/blob/master/ov...

    4: https://github.com/nix-community/home-manager/blob/master/de...

  9. CodeRabbit

    CodeRabbit: AI Code Reviews for Developers. Revolutionize your code reviews with AI. CodeRabbit offers PR summaries, code walkthroughs, 1-click suggestions, and AST-based analysis. Boost productivity and code quality across all major languages with each PR.

    CodeRabbit logo
  10. nix-processmgmt

    Experimental Nix-based process management framework

    My hope is that when Sander van der Burg finishes drafting his RFC for mainlining his process management framework [1], which abstracts over ways to manage local services from systemd to supervisord to Docker, we can actually unify the module collection in Nixpkgs with its clones in nix-darwin and home-manager, and offer a more complete Nix experience as a configuration/service manager rather than just a package manager on non-NixOS.

    Fwiw, you can already have nixos-rebuild read the home-manager configs for all of your users and deploy them as part of the normal NixOS config update process using the included NixOS module.

    ——

    1: https://github.com/svanderburg/nix-processmgmt

  11. config

  12. watchlog

    In general it is very nice. A common method is you create a `default.nix` file in the project you are working on and use tools that manage the deps for you. For example:

    Rust+Cargo: https://gitlab.com/kevincox/watchlog/-/blob/22c877065f763b3d...

    Node+NPM: https://gitlab.com/kevincox/kevincox-web-compiler/-/blob/9fa...

    My only Ruby project is private but I just rolled my own with:

    export "GEM_HOME=$out"

  13. In general it is very nice. A common method is you create a `default.nix` file in the project you are working on and use tools that manage the deps for you. For example:

    Rust+Cargo: https://gitlab.com/kevincox/watchlog/-/blob/22c877065f763b3d...

    Node+NPM: https://gitlab.com/kevincox/kevincox-web-compiler/-/blob/9fa...

    My only Ruby project is private but I just rolled my own with:

    export "GEM_HOME=$out"

  14. nix

    NixOS configurations for all of my machines as a single Nix flake (by rraval)

    I was able to make the switch over cold turkey after ~9 years of ArchLinux.

    By sheer happenstance, I blogged earlier this week about one particular killer feature that doesn't get enough air time: https://news.ycombinator.com/item?id=27344677

    My not-flake-yet configuration can be found at https://github.com/rraval/nix

  15. nixos-shell

    Spawns lightweight nixos vms in a shell

    >It doesn't work so well for I borrowed my coworker's computer for 5 minutes and want to use my own Vim configuration

    You could use something like nixos-shell[1] to spin up a headless VM of your machine into your current shell.

    [1]https://github.com/Mic92/nixos-shell

  16. nix

    Nix, the purely functional package manager

  17. napalm

    Support for building npm packages in Nix and lightweight npm registry [maintainer=?] (by nix-community)

    Sure. NPM is the easy case because the package-lock.json file can easily be read by Nix and contains hashes for all of the packages. This means that simply be importing the file into Nix you can have a reproducible build. No Nix-specific maintenance required.

    In the linked case I use this library to manage that https://github.com/nmattia/napalm (in that example I use master but for production I would pin a version). It simply parses the package-lock.json, downloads the packages and uses npm to build the node_modules folder. It also provides some convenient functions for building packages with "bin" files or just linking node_modules inside a build.

    Note that this is more for project development. It doesn't use the "system" packages (intentionally) for Node, it fetches whatever versions you have specified from NPM. Nix will only provide the "native" stuff like Node and NPM themselves and any native libraries.

  18. nixGL

    A wrapper tool for nix OpenGL application [maintainer=@guibou]

    Yeah, I’m not sure how up-to-date my knowledge is, but opengl and the like are exceptions to the usual deterministic handling of dependencies on non-NixOS distros, and one has to specify them. It was quite a time I ran nix on a non-nixos distro but there is this tool https://github.com/guibou/nixGL that meant to solve the issue of graphical programs.

  19. spack

    A flexible package manager that supports multiple versions, configurations, platforms, and compilers.

    It might be possible, but a better approach (and the one Guix used initially, iirc) is to just be compatible with the derivation format (kinda like object files in C/C++ compilation). The end result is basically a big dependency graph, so one may be able to write a different generator in front of it.

    Anyone who has done the basics in Prolog could "logically" pull this off (e.g. some rule requires another rule, or however Prolog works; it's been a long time since I looked at it), but all of the extra stuff in the library (e.g. all of the systemd tweaking, interface, etc) is a LOT of man hours.

    I heard about Spack [0] on a recent cppcast episode, which seems like a competitor to Nix (but from the supercomputing side of things), but I don't know if they do the OS-level stuff (vs. nix shell / conda / pip / gem replacement stuff).

    [0] https://spack.io/

  20. nix-bundle

    Bundle Nix derivations to run anywhere! [maintainer=@matthewbauer, @Artturin]

    Yes, it's extremely powerful once you truly understand Nix.

    There are efforts to improve documentation, but it still is lacking (I think the biggest problem is that Nix is so big, not just the OS but it can be utilized as a build system).

    Just with NixOS is not exactly clear how can you for example build your custom image.

    I think https://nix.dev/ is approaching the documentation from the right direction.

    There are also many pieces that people built that you need to find.

    For example some things that I found accidentally:

    * https://github.com/matthewbauer/nix-bundle

    * https://github.com/cleverca22/not-os

    Unfortunately those side projects often have even worse documentation.

  21. repology-rules

    Package normalization ruleset for Repology

    nixpkgs is of a very similar size to the aur, but is significantly more up to date: https://repology.org/

  22. matrix.to

    A simple stateless privacy-protecting URL redirecting service for Matrix

  23. nix-darwin

    nix modules for darwin

  24. dotfiles

    My NixOS dotfiles (by Mic92)

  25. archbox

    Easy to use Arch Linux chroot environment with some functionalities to integrate it with your existing Linux installation. Mirror of https://momodev.lemniskett.moe/lemniskett/archbox

    If you don't mind the storage penalty, it looks pretty convenient to set up an Arch Linux chroot and use packages from the AUR when you need to: https://github.com/lemniskett/archbox/blob/master/NIXOS_INST...

    Nixpkgs itself is several times the size of the base Arch Linux package collection, and by ‘non-unique’ package count, Nixpkgs is also much larger than the AUR. In addition to Nixpkgs, you can find Nix packages in several community ‘overlays’ for Nixpkgs as well as Nix's own user repositories.

    You can check to see whether everything you currently use/need is conveniently available for NixOS in a comprehensive-ish way through the combination of these two web search tools:

    • for Nixpkgs/NixOS: https://search.nixos.org/packages?channel=21.05

    • for NUR: https://nur.nix-community.org/

    NixOS also includes native Flatpak support.

    Fwiw, packaging most things for Nix is very easy. I left Arch in ~2010 because at the time the package management stack and default repos on Arch basically sucked compared to most distros I'd used and liked, and from then on I decided that if I wanted software that wasn't in my distro's repos I'd just package it myself. After taking a little time to learn the tools on whatever distro I was using, I never missed Arch or the AUR. Compared to other distros, packaging normal software from source is usually exceptionally easy on NixOS.

    If I were you I'd just dive right in and hit Nix's channel on Matrix with the Nixpkgs manual in hand if I found something I wanted to use that wasn't already packaged. But you can fall back on the options outlined above.

  26. NUR

    Nix User Repository: User contributed nix packages [maintainer=@Pandapip1]

    If you don't mind the storage penalty, it looks pretty convenient to set up an Arch Linux chroot and use packages from the AUR when you need to: https://github.com/lemniskett/archbox/blob/master/NIXOS_INST...

    Nixpkgs itself is several times the size of the base Arch Linux package collection, and by ‘non-unique’ package count, Nixpkgs is also much larger than the AUR. In addition to Nixpkgs, you can find Nix packages in several community ‘overlays’ for Nixpkgs as well as Nix's own user repositories.

    You can check to see whether everything you currently use/need is conveniently available for NixOS in a comprehensive-ish way through the combination of these two web search tools:

    • for Nixpkgs/NixOS: https://search.nixos.org/packages?channel=21.05

    • for NUR: https://nur.nix-community.org/

    NixOS also includes native Flatpak support.

    Fwiw, packaging most things for Nix is very easy. I left Arch in ~2010 because at the time the package management stack and default repos on Arch basically sucked compared to most distros I'd used and liked, and from then on I decided that if I wanted software that wasn't in my distro's repos I'd just package it myself. After taking a little time to learn the tools on whatever distro I was using, I never missed Arch or the AUR. Compared to other distros, packaging normal software from source is usually exceptionally easy on NixOS.

    If I were you I'd just dive right in and hit Nix's channel on Matrix with the Nixpkgs manual in hand if I found something I wanted to use that wasn't already packaged. But you can fall back on the options outlined above.

  27. nixos-config

    My NixOS configuration. (by casept)

    Given that you already have flakeified everything, it's not that hard to pull in a different version of nixpkgs and cherry-pick packages from it. I have a (somewhat complex) setup utilizing this: https://github.com/casept/nixos-config

  28. nix-update

    Swiss-knife for updating nix packages.

    I run [nix-update](https://github.com/Mic92/nix-update/) to update stuff. If you want to package something new, first identify the programming language/buildsystem the project is using and than look for a similar project in nixpkgs.

  29. flake-utils-plus

    Use Nix flakes without any fluff.

    and then you can add, e.g., `nix-processmgmt-tools.common` to your `environment.systemPackages`.

    I think maybe the reason instructions aren't given for some projects is that they see those parts of the guide as mostly for beginners, and they expect advanced users to just figure it out. In the case of nix-processmgmt, I think Sander doesn't actually expect to have any users! In the latter case, an imperative install that users are expected to play with for a little while and then just throw away is supposed to be enough.

    You're right, though, that it's odd and disappointing that instructions for the preferred way of doing things are sometimes simply not given. A polite pull request or issue report would probably be well-received. My recommended strategy, if you get stuck, would be to ask for help getting those packages into scope declaratively on Discourse or Matrix, and then to offer the authors of these out-of-tree packages pull requests to modify their READMEs accordingly. :)

    1: https://github.com/gytis-ivaskevicius/flake-utils-plus

    2: https://github.com/nix-community/emacs-overlay#quickstart

    3: https://github.com/nix-community/home-manager/blob/master/ov...

    4: https://github.com/nix-community/home-manager/blob/master/de...

  30. emacs-overlay

    Bleeding edge emacs overlay [maintainer=@adisbladis]

    and then you can add, e.g., `nix-processmgmt-tools.common` to your `environment.systemPackages`.

    I think maybe the reason instructions aren't given for some projects is that they see those parts of the guide as mostly for beginners, and they expect advanced users to just figure it out. In the case of nix-processmgmt, I think Sander doesn't actually expect to have any users! In the latter case, an imperative install that users are expected to play with for a little while and then just throw away is supposed to be enough.

    You're right, though, that it's odd and disappointing that instructions for the preferred way of doing things are sometimes simply not given. A polite pull request or issue report would probably be well-received. My recommended strategy, if you get stuck, would be to ask for help getting those packages into scope declaratively on Discourse or Matrix, and then to offer the authors of these out-of-tree packages pull requests to modify their READMEs accordingly. :)

    1: https://github.com/gytis-ivaskevicius/flake-utils-plus

    2: https://github.com/nix-community/emacs-overlay#quickstart

    3: https://github.com/nix-community/home-manager/blob/master/ov...

    4: https://github.com/nix-community/home-manager/blob/master/de...

  31. nur-combined

    A repository of NUR that combines all repositories [maintainer=@Mic92]

    You can use the Nix tooling to show the diff between two derivations' closure.

    I have a script which I use [1] after updating my Flakes to do just that : know what has been upgraded.

    [1] https://github.com/nix-community/nur-combined/tree/master/re...

  32. runix

    I hate that they mentioned about ru.nix, published it on github for short time and then unpublished it[1].

    [1] https://github.com/Shopify/runix/

  33. SaaSHub

    SaaSHub - Software Alternatives and Reviews. SaaSHub helps you find the best software and product alternatives

    SaaSHub logo
NOTE: The number of mentions on this list indicates mentions on common posts plus user suggested alternatives. Hence, a higher number means a more popular project.

Suggest a related project

Related posts

  • Never again

    4 projects | /r/ProgrammerHumor | 21 May 2023
  • Couple of noob questions

    6 projects | /r/Nix | 20 May 2023
  • How to install NordVPN onto NixOS

    3 projects | /r/NixOS | 25 Apr 2023
  • Nix: Taming Unix with Functional Programming

    18 projects | news.ycombinator.com | 5 Aug 2022
  • Best practices for organizing code repository for multiple machines? What about deployment?

    5 projects | /r/NixOS | 10 Apr 2022

Did you know that Nix is
the 27th most popular programming language
based on number of references?