envrc VS emacs-direnv

buffer-env: A pure-Elisp version of the direnv utility. Useful to make Emacs aware of Python virtualenvs (which, judging by the questions posted here, is unfortunately still a complication for a lot of people). Similar to (and inspired by) envrc, but doesn't require the direnv program.

Yes, most Nix users employ https://direnv.net or the equivalent for your IDE of choice. Emacs for instance has https://github.com/purcell/envrc which set per-buffer variables.

Also take a look at the envrc package. I think it handles multiple projects better.

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.

In conjunction with installing direnv on your favorite text editor, it's a very hassle free experience. Everything happens automatically. If you use Emacs, i higly recommend envrc.el

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 don't use flake.nix, only shell.nix, though check if the envrc package works any better for you. https://github.com/purcell/envrc

As an alternative to emacs-direnv, I’d recommend the “envrc” package.

btw, my main issue regarding tramp was the fact that I didn't have my environment generated by direnv, via the https://github.com/purcell/envrc package. I use direnv almost exclusively to activate my nix-shell, so I can access the exact software dependencies required by that directory of a project.

I'm not familiar with these tools too but I highly recommend to look at https://github.com/purcell/envrc. If you are not familiar with direnv I suggest to try it with nix-shell/flakes before.

env-commander-mode is a simple mode which allows any shell commands that Emacs invokes to run one or more commands beforehand to initialize the shell environment. There are many Emacs packages which can configure process environments, for example, direnv, but they lack the ability to go a step further and define shell functions and aliases, which is often required by "virtual environment" tools. For those who prefer interacting with shell commands via shell-command rather than shell, eshell, or term, env-commander-mode is here to assist.

I'm using nix to manage python dependencies (see excerpt of flake.nix below) but this means those python dependencies are in a /nix directory, so when lsp tries to figure out project root for them, it thinks they have nothing to do with my own project. Also I'm using emacs-direnv to transparently switch into nix environments (.envrc + use flake), so direnv (correctly) unloads my LSP executable (configured in flake.nix), so even if they should be considered totally separate projects LSP-mode doesn't know how to start up the server.

I've had a good experience with direnv[1] and emacs-direnv[2].

Direnv can automatically load an environment when you enter a directory, so it automatically "opens" virtualenvs/nix shells/etc. The Emacs direnv mode ensures that each buffer sees the direnv mode for its project directory.

I've found this to be a great compromise between automatic behavior on the one hand and transparency + control on the other—I get the right environment loaded automatically very consistently and, if something goes wrong, I can open a shell and poke around to see what's going on (is my nix shell messed up? is the right tool not loaded via direnv? etc). The only time I need to do anything manually is if I make a change to the environment and need to update Emacs about it, in which case I just run M-x direnv-update-environment.

Once I got this set up, I can just rely on executable-find to check for (and find) exactly the right tool on a per-project basis—no more worrying about global or seeing the wrong version of a tool. This also made it easy to do stuff like only run formatting if the corresponding tool is available: I add hooks to various programming language modes that only turn on lsp/formatting/etc if executable-find sees the corresponding executable.

Compared to the hassle I've had to go through helping my colleagues debug VSCode not seeing the right conda environment, virtualenv or the right version of various tools, Emacs + direnv has been a far nicer and more consistent experience.

[1]: https://direnv.net/

[2]: https://github.com/wbolster/emacs-direnv

Alternatively from what /u/hantva said, you can try using direnv and its integration with Emacs. This has a benefit of scaling better if you have more than one such project as each set of env vars is separate.

I'm using lorri and emacs-direnv together, works perfectly fine for me.

Thanks, I'll check this out if I can't get my ideal setup to work. Presume you meant this: https://github.com/wbolster/emacs-direnv ?

I first install direnv which allows me to have a different environment per directory, or in my case, a project. And there is a project that connects Emacs to this. https://github.com/wbolster/emacs-direnv

I use this to source .envrc files into my emacs environment: https://github.com/wbolster/emacs-direnv

almost. to integrate with a shell, you would indeed hook it onto the shell's prompt function. to integrate it with Emacs, you would use https://github.com/wbolster/emacs-direnv , so Emacs sees the project specific process environment too. the isolation is primarily achieved by setting up a custom PATH, PYTHON_PATH and similar vars