HN Reader

mise is a great tool. One area where it doesn't work right out of the box is installing PostgreSQL via macOS brew, when I don't want to use Nix or Docker or Podman etc.

Here's the solution I use; perhaps someone here has a better idea?

    brew install gcc readline zlib curl openssl@1.1 ossp-uuid icu4c pkg-config
    PKG_CONFIG_PATH="$(brew --prefix)/lib/pkgconfig:$(brew --prefix icu4c)/lib/pkgconfig" \
    LDFLAGS="-L$(brew --prefix)/lib" \
    CPPFLAGS="-I$(brew --prefix)/include" \
    mise use postgres --verbose

Hey, was reading your post and realised that your tag pages aren't working e.g. https://blog.vbang.dk/tag/mise/ Just in case you wanted to fix them

I manage a monorepo at my workplace. Different devs with various levels of seniority are on/off boarded on the project, some on mac some on linux.

At first I offered mise as the recommended tool, and after a while I declared it's the only supported way to build the project and boom! All support requests that used to end with "oooh my XYZ's version was not matching the project's requirement" are gone now.

I like asdf but it has quirks. Mise has been a better companion for me past few years.

I also hear people say "but my node/ruby/elixir/java/foo version manager will break. My team uses that tool in our other projects, etc, etc" then I only have to show them what an amazing drop-in replacement mise is and nothing breaks; there's no going back for them.

I just hope muse stays mise, and doesn't become just[1] (whom I also install via mise)

[1]: https://github.com/casey/just

My actual usage is a mix-bag. For general tools and utilities, I often just use Nix and Home Manager. It is a pain for setting up but once you got it working, it's basically fire and forget. Whenever you need a new app, you just add that to the `home.nix` and call it a day.

Now, for language development environment, I won't use Nix and just prefer to whatever that language popular choice. For instance, in Python I use uv. For Node I use npm (or yarn or bun or whatever in fashion now), Java has mice, Rust has rustup.

It is not a one-size-fit-all solution but I am not sure if we can ever achieve that.

The nice thing about `mise` is everything is installed in `$HOME` without sudo access so the odds of it being able to run malicious code is quite low.

I'm lazy by nature so I don't like learning new tools if I don't have to. I've stuck with make, direnv, and my distros package manager instead of learning just or asdf so that I don't need to learn anything new. But mise hits that sweet spot of being a better direnv and a (mostly) better Make that it became worth the effort to try it out and I'm glad I did. It also helps that jdx (the author) really cares about the ergonomics of use and it shows; the documentation is up to date, the commands make sense, and every time I start to get annoyed some paper cut with it I discover there's already a fix for it (like `mise task run task-name` and `mise task-name` being equivalent commands so you don't have to type as much).

If you try to stick to the classic POSIX tools since they're installed everywhere, I urge you to give mise a try anyway. It and fzf are the only programs I've found that are truly worth the extra effort it takes to install them, even if it is just grabbing a binary.

This is what I have been doing to manage development environments:

Workflows now revolve around nix.

Setup a shell.nix that defines development environment (whether it’s specific version of rust or python).

Then `nix develop` will setup an isolated environment. Do some work on project. Then exit shell.

No need to pollute machines environment with 100 versions of python/pip/uv.

Add in `direnv` and it will automatically activate the nix shell upon `cd`. Plays well with gui editors too, assuming direnv plugin/tooling available.

Recently completed a switch from asdf, and can confirm, this tool is great and it's now part of my base machine setup going forward.

I have been using asdf for ~12 years, and made the switch to (what is now called) mise about ~4 years ago. This year I challenged myself to switch to nix. asdf and mise are essentially less virulent nix, after all. nix is a complete and utter phase shift for the better. However, the learning curve is steep due to atrocious documentation.

If you’re into these environment / tool managers I highly recommend giving nix a solid try for 4-6 months.

Mise is fantastic. Switched from asdf awhile ago and have not looked back.

I don't use the advanced task / env stuff, mostly just the tool management. Its been stable, fast, and gets out of the way.

So if I understand it correctly, it's a mix between GNU Make and `asdf`?

can anyone comment on what their experience of using mise is vs. other tools a a la nix home-manager/flakes?

I see this "one tool to rule them all" and instantly my senses go off that this is too good to be true to work in all the long-tail scenarios.

There always seems to be some strange edge-cases with tools of this nature.

Interesting thank you for sharing. I've been using asdf for years now but I dislike the fact that you have to install plugins. I wish it just did stuff when I called commands.

I'll try out Mise for Elixir, Erlang and NodeJS to see if it works like you describe.

Executables need to be more stable. I shouldn't have to manage versions this way at all. i.e., I should never need to downgrade a program. I think the Python 2 -> 3 fiasco broke everyone's brains.

I use and love pixi to manage python versions, venvs, and dependencies. How would mise fit into that workflow, or does it not?