Article summary
A version management tool is incredibly important for any software developer. This is especially true when developers find themselves jumping between different projects on the same device. Version managers make setting up or switching between tool sets for projects easier, which makes the decision around what version manager to use an important one. Two of the biggest competitors in the space are asdf and mise (pronounced MEEZ). If you are stuck between which of these tools to use, just use mise.
What are Version Managers?
For those who may be unaware, a version manager is a tool that allows developers to install, select, and switch between multiple versions of programming languages, runtimes, and developer tools on a per user, per project, or global basis. Version managers give developers a simple way to customize the version requirements for individual projects without affecting the tooling of other projects on your machine. As an example this means one project can be using .NET 10 without causing issues for another project on your machine that requires .NET 8.
Version managers do this by keeping installed versions of a program isolated from each other. They will then use PATH manipulation to direct the running of an executable to a shim. The shim is a tiny executable that identifies the correct version of a tool to use, and runs the binary for that version. The version of a program that should be run is usually defined within a configuration file within your project.
This allows for version managers to act like swiss army knives for configuring tools and plugins required for your project. When using such a versatile and useful tool, you want to make sure you are using the best of the best. So that begs the question, what version manager should you use?
Why I use mise.
The version manager I recommend is mise. Both asdf and mise have many similarities but across those differences mise edges out its competition. Starting with their configuration techniques, asdf uses a `.tool-versions` text file that simply lists the plugins being loaded. Mise supports this same list structure while also allowing you to create a `toml` file. These files act more as environment specs, providing a structured layout for plugins while also allowing environment variables, tasks, or profiles to be defined.
Example
# Example mise toml file
[tools]
node = "20"
[env]
NODE_ENV = "development"
Besides a more flexible configuration, out-of-the-box mise is built to be faster and more reliable. Mise does this by being a single compiled binary built in Rust. This allows for mise to do most of its work in-process, unlike asdf, which primarily manages its tasks through shell processes. Recently, asdf has been getting a rebuild in Go, which has brought up its speed compared to its Bash version. However, mise still manages to run ever so slightly faster.
More Reasons to Choose mise
While asdf’s rebuild helps it catch up in speed, it loses in features. For the time being, certain features available in older versions of asdf have not made their way into the most recent version. An example was the loss of backwards compatibility for edge cases. This happened on a project where I needed an older version of .NET to run commands for a library that did not support the version of .NET we were using.
After countless hours of digging through asdf documentation, I found I needed to load into two separate versions of .NET and then manually identify the path for the older version within the script calling the specific command. When I tried doing the same thing in mise, all I needed was one command. This is the trend for many tools within mise. Take an action that would require several commands to do in asdf, and mise will have a way to do it in one line.
On top of all this, mise has improved failure handling. Mise centralizes its error handling so that, across all its features, it has one shared error-handling pathway with consistent logging and messaging. Meanwhile, having more separation between each of its plugins allows room for vastly different levels of error-handling or assumptions related to the state of different plugins. The pros of mise’s approach compared to asdf is that it allows for more predictable behavior, an easier ability to debug with consistent error messaging, and fewer environment-specific surprises that lead to the classic “it works on my machine” issue.
Just use mise.
Version managers are foundational developer tools, and small differences in ergonomics, reliability, and predictability compound over time. While asdf helped define the category, mise reflects a more modern approach to managing development environments: richer configuration, simpler workflows, faster execution, and more predictable failure modes. For developers who regularly switch between projects, work in teams, or care about reducing friction in their tooling, mise offers a smoother and more reliable experience. If you are choosing a version manager today, there is little reason to reach for anything else. Just use mise.