nix-direnv VS rust-overlay

BTW: I personally use direnv with nix-direnv. This basically works by setting your shell with proper tooling when you enter the directory.

I'm not sure what you mean by nix env, maybe you are referring to nix-direnv?

Although currently I'm using direnv + nix-direnv. Keep in mind that direnv has builtin nix support which is very basic and doesn't do any caching. So you still needs this add-on to preserve roots.

I distinguish between system level things and user level things, even though I don't really have different users on my machine. I install the bare minimum number of packages + a lot of different drivers in the configuration.nix, and desktop and editor related things in HM. For development environment, I have environment per project using mkShell and https://github.com/nix-community/nix-direnv, which allows you to switch to the specific environment once you cd into the directory. (Although I do have python installed globally with some commonly used packages such as numpy, so I can just start python and write something when I need to, without creating an environment)

I further make my software projects so that when I click a link I go into an environment pre-loaded with their dependencies so dropping in/out of projects is always frictionless. I do this with the reproducibility guarantees of nix, along with glue like nix-direnv and envrc-mode to direnv.

(I also use nix-direnv)

direnv

Personally I use nix-direnv. No longer the need to run nix develop or nix-shell. By setting up a .envrc with either use nix or use flake it will automatically install all the packages from default/shell.nix or flake.nix

Direnv is installed using the nix-direnv installation instructions under "Via configuration.nix in NixOS". I read some recommendations that envrc.el is a better alternative then direnv.el, and after some testing I have to agree. (envrc-global-mode) is enabled in my config. This works perfectly with a normal emacs instance.

I'm trying to understand overlays in order to make a proper rustup install (I've read that this overlay is the best way to go).

real-world example: https://github.com/oxalica/rust-overlay/blob/master/flake.nix

In this language context specifically, if one wanted to manage their workspace with Nix I would reach for Riff and/or oxalica/rust-overlay first, since they are deliberately more aware of Rust-specific nuance. In the latter's case it has compatibility paths with rustup-toolchain files as well, for allowing your peers who can't or won't adopt Nix to continue to feel like first-class participants in the project. Another alternative I don't have experience with would be nix-community/fenix.

p.s. I'm not sure if it's mentioned much of anywhere, but it'd be neat if there was a way to figure out the appropriate cargo from a rust-toolchain/rust-toolchain.toml if present, ala https://github.com/oxalica/rust-overlay. Funnily enough 95% of my development time is in Rust, but I don't actually have it installed globally, fun times being a NixOS user. I'd definitely make the argument that cargo is an external dependency!

Many of us have moved to https://github.com/oxalica/rust-overlay over Mozilla's overlay.

We added rust-overlay, so we can easily specify different rust versions without relying on nixpkgs to give us what ever rust version in there.

If it's Rust, you can use https://github.com/oxalica/rust-overlay to get any version you want very easily without pinning an instance of nixpkgs just for it.

asdf does not allow you to keep three different versions of the same language, so I'm not sure how that compares? It's not super-trivial to do in Nix, but at least you can do it.

asdf is also no different than Nix when it comes to minor/major versions. You're at the mercy of what the plugin does, other than that you have to create your own plugin from scratch or make a fork. Nix has the option to patch things up more easily at least.

How does this compare to https://github.com/oxalica/rust-overlay/ ? Can fenix ingest a rust-toolchain file and provide packages from it?

Can you say a bit about how this compares to oxalica’s rust overlay?

I frequently try to do something, say use (from the README of rust overlay):