Author(s): Akula Hemanth Kumar

Originally published on Towards AI.

🚀 Introducing mise: A Fast and Dev-Friendly Version Manager for Your Toolchain

The front-end to your dev env.

Managing multiple versions of programming languages, CLIs, and tooling has long been a pain point for developers. Whether you’re switching between Node.js, Python, Terraform, or Java projects, ensuring you’re using the correct version of each tool can be a headache — especially when you’re juggling multiple projects.

That’s where mise comes in: a powerful, fast, and pluggable version manager built with developer ergonomics in mind.

🧠 TL;DR

• mise is a fast, Rust-based version manager for dev tools (like Node.js, Python, Java, etc.).
• Compatible with .tool-versions (asdf-style) and supports dozens of tools via plugins.
• Offers a unified config (mise.toml), environment variable management, and a built-in task runner.
• Works globally, locally (per project), and per shell session.
• Faster and more feature-rich than tools like asdf, nvm, and pyenv.

🌟 What is mise?

mise (pronounced “miz”) is a dev tool version manager written in Rust, designed as a modern alternative to tools like:

• asdf
• nvm
• pyenv
• rbenv

With mise, you can manage versions of multiple tools using a single, unified interface — all configured via a simple .tool-versions or mise.toml file.

🔧 Why Use mise?

Here’s why mise stands out in the crowded ecosystem of version managers:

✅ 1. Super Fast

Thanks to its Rust core, mise is noticeably faster than older tools like asdf, which rely heavily on shell scripts and plugins.

✅ 2. asdf-Compatible

Already using asdf? Good news — mise supports .tool-versions out of the box, meaning you can drop it into your project with zero config changes.

✅ 3. Plugin Ecosystem

mise leverages the vast asdf plugin ecosystem, so it supports dozens of tools including:

• Node.js
• Python
• Java
• Terraform
• Ruby
• Go
• and more…

You can also create custom plugins easily.

✅ 4. Global, Local, and Environment Support

mise supports setting tool versions:

• globally (across all projects)
• locally (per-project using .tool-versions)
• per shell session (via MRTX_ environment variables)

✅ 5. Environment Variables & Shims

mise ensures seamless version switching using lightweight shims, so your shell always runs the correct tool version.

Beyond the Basics: Advanced Functionalities

While mise excels at simple tool version management, its real power lies in its advanced features that streamline the entire development workflow.

1. Integrated Task Runner

Mise includes a powerful and lightweight task runner, which can serve as a direct replacement for make, npm scripts, or other similar tools. Tasks are defined in the [tasks] section of your mise.toml file.

The primary benefit is that any task you run will automatically inherit the correct tool versions and environment variables defined for that project. This eliminates the common issue of a script failing because it was run in the wrong environment.

A basic task definition looks like this:

[tasks.build]
description = "Build the project"
run = "cargo build --release"

[tasks.test]
description = "Run all unit tests"
run = "cargo test"

You can then run these tasks with a simple command: mise run build or the shorthand mise build. For multi-step tasks, you can even define dependencies so that mise runs them in the correct order, in parallel where possible.

2. Hierarchical Configuration and Merging

Mise’s configuration system is a key differentiator. It uses a hierarchical approach, allowing you to have multiple mise.toml files in different directories. mise automatically merges these configurations, with the most specific file taking precedence.

For example, a global configuration at ~/.config/mise/config.toml can set default tool versions and environment variables. A project-level mise.toml in your repository can then override those settings for that specific project. This lets you manage system-wide defaults while still providing per-project overrides effortlessly.

3. Advanced Tool Version Scopes

Mise provides sophisticated ways to specify tool versions beyond simple numbers. These “version scopes” offer fine-grained control:

• prefix:<VERSION>: Use the latest available version that matches a given prefix. For example, python = "prefix:3.11" will automatically use 3.11.8 if it's the newest 3.11 version available.
• ref:<SHA>: Install a tool directly from a specific commit reference in a Git repository. This is perfect for bleeding-edge or pre-release testing.
• path:<PATH>: Use a tool that is already installed at a custom path on your system. This is useful for integrating with system-level package managers like Homebrew.
• sub-<PARTIAL_VERSION>:<ORIG_VERSION>: A powerful way to manage versions relative to a release, such as sub-1:latest to always use the version right before the most recent one.

4. Direnv Integration and Replacement

Mise is an effective alternative to direnv for managing environment variables. You can define variables in the [env] section of your mise.toml.

[env]
NODE_ENV = "development"
API_URL = "http://localhost:3000"

Mise will automatically set these variables when you enter the project directory and unset them when you leave. For projects that still use direnv or .env files, mise can seamlessly work with them, ensuring a smooth transition or coexistence.

📦 Installation

curl https://mise.run | sh

Or install via Homebrew (macOS/Linux):

brew install jdx/mise/mise

Add it to your shell config (.zshrc, .bashrc, etc.):

eval "$(mise activate bash)" # or zsh/fish

⚔️ mise vs Other Version Managers

📂 Project Setup Example

To get started, you’ll install mise and then set up a mise.toml file in your project directory. This file will declare the required versions for your tools, such as:

[tools]
nodejs = "22"
python = "3.11"

[env]
DATABASE_URL = "postgres://..."

This simple configuration ensures that anyone working on the project will automatically use the specified versions and environment variables, eliminating “it works on my machine” issues.

Run:

mise install

And just like that – Node.js and Python are installed with the right versions and ready to go.

⚙️ Bonus: mise use and mise ls

Some helpful commands:

mise use nodejs@20 # use nodejs v20 for current project
mise ls python # list installed versions of python
mise x node npx # run `npx` from specified node version

🚀 Final Thoughts

mise is the spiritual (and technical) successor to asdf, designed with performance and simplicity in mind. Whether you’re managing a Node.js monorepo, deploying Python-based Lambda functions, or juggling Terraform projects, mise keeps your toolchain sane and reproducible.

If you’re tired of sluggish version managers or managing multiple CLIs by hand — give mise a try!

👉 GitHub: github.com/jdx/mise

Join thousands of data leaders on the AI newsletter. Join over 80,000 subscribers and keep up to date with the latest developments in AI. From research to projects and ideas. If you are building an AI startup, an AI-related product, or a service, we invite you to consider becoming a sponsor.

Published via Towards AI