Skip to content



.mise.toml is a new config file that replaces asdf-style .tool-versions files with a file that has lot more flexibility. It supports functionality that is not possible with .tool-versions, such as:

  • setting arbitrary env vars while inside the directory
  • passing options to plugins like virtualenv=".venv" for python.
  • specifying custom plugin URLs

They can use any of the following file locations (in order of precedence, top is highest):

  • .mise.local.toml
  • mise.local.toml
  • .mise.$MISE_ENV.toml
  • mise.$MISE_ENV.toml
  • .mise.toml
  • .mise/config.toml
  • mise.toml
  • mise/config.toml
  • .config/mise.toml
  • .config/mise/config.toml

See Profiles for more information about .mise.$MISE_ENV.toml files. These files recurse upwards, so if you have a ~/src/work/myproj/.mise.toml file, what is defined there will override anything set in ~/src/work/.mise.toml or ~/.config/mise.toml. The config contents are merged together.


Run mise config to see what files mise has loaded along with their precedence.

Here is what an .mise.toml looks like:

# supports arbitrary env vars so mise can be used like direnv/dotenv
NODE_ENV = 'production'

# specify single or multiple versions
terraform = '1.0.0'
erlang = ['23.3', '24.0']

# supports everything you can do with .tool-versions currently
node = ['16', 'prefix:20', 'ref:master', 'path:~/.nodes/14']

# specify a custom repo url
# note this will only be used if the plugin does not already exist
python = ''

[alias.node] # project-local aliases
my_custom_node = '20'

.mise.toml files are hierarchical. The configuration in a file in the current directory will override conflicting configuration in parent directories. For example, if ~/src/myproj/.mise.toml defines the following:

node = '20'
python = '3.10'

And ~/src/myproj/backend/.mise.toml defines:

node = '18'
ruby = '3.1'

Then when inside of ~/src/myproj/backend, node will be 18, python will be 3.10, and ruby will be 3.1. You can check the active versions with mise ls --current.

You can also have environment specific config files like .mise.production.toml, see Profiles for more details.

[env] - Arbitrary Environment Variables

See environments.

[plugins] - Specify Custom Plugin Repository URLs

Use [plugins] to add/modify plugin shortnames. Note that this will only modify new plugin installations. Existing plugins can use any URL.

elixir = ""
node = "" # supports specific gitref

If you simply want to install a plugin from a specific URL once, it's better to use mise plugin install plugin <GIT_URL>. Add this section to .mise.toml if you want to share the plugin location/revision with other developers in your project.

This is similar to MISE_SHORTHANDS but doesn't require a separate file.

[aliases] - Tool version aliases

The following makes mise install node@my_custom_node install node-20.x this can also be specified in a plugin. note adding an alias will also add a symlink, in this case:

~/.local/share/mise/installs/node/20 -> ./20.x.x
my_custom_node = '20'

Global config: ~/.config/mise/config.toml

mise can be configured in ~/.config/mise/config.toml. It's like local .mise.toml files except that it is used for all directories.

# global tool versions go here
# you can set these with `mise use -g`
node = 'lts'
python = ['3.10', '3.11']

# plugins can read the versions files used by other version managers (if enabled by the plugin)
# for example, .nvmrc in the case of node's nvm
legacy_version_file = true                     # enabled by default (unlike asdf)
legacy_version_file_disable_tools = ['python'] # disable for specific tools

# configure `mise install` to always keep the downloaded archive
always_keep_download = false        # deleted after install by default
always_keep_install = false         # deleted on failure by default

# configure how frequently (in minutes) to fetch updated plugin repository changes
# this is updated whenever a new runtime is installed
# (note: this isn't currently implemented but there are plans to add it:
plugin_autoupdate_last_check_duration = '1 week' # set to 0 to disable updates

# config files with these prefixes will be trusted by default
trusted_config_paths = [

verbose = false     # set to true to see full installation output, see `MISE_VERBOSE`
asdf_compat = false # set to true to ensure .tool-versions will be compatible with asdf, see `MISE_ASDF_COMPAT`
http_timeout = 30   # set the timeout for http requests in seconds, see `MISE_HTTP_TIMEOUT`
jobs = 4            # number of plugins or runtimes to install in parallel. The default is `4`.
raw = false         # set to true to directly pipe plugins to stdin/stdout/stderr
yes = false         # set to true to automatically answer yes to all prompts

not_found_auto_install = true # see MISE_NOT_FOUND_AUTO_INSTALL
task_output = "prefix" # see Tasks Runner for more information
paranoid = false       # see MISE_PARANOID

shorthands_file = '~/.config/mise/shorthands.toml' # path to the shorthands file, see `MISE_SHORTHANDS_FILE`
disable_default_shorthands = false # disable the default shorthands, see `MISE_DISABLE_DEFAULT_SHORTHANDS`
disable_tools = ['node']           # disable specific tools, generally used to turn off core tools

env_file = '.env' # load env vars from a dotenv file, see `MISE_ENV_FILE`

experimental = true # enable experimental features

# configure messages displayed when entering directories with config files
status = { missing_tools = "if_other_versions_installed", show_env = false, show_tools = false }

System config: /etc/mise/config.toml

Similar to ~/.config/mise/config.toml but for all users on the system. This is useful for setting defaults for all users.


The .tool-versions file is asdf's config file and it can be used in mise just like .mise.toml. It isn't as flexible so it's recommended to use .mise.toml instead. It can be useful if you already have a lot of .tool-versions files or work on a team that uses asdf.

Here is an example with all the supported syntax:

node        20.0.0       # comments are allowed
ruby        3            # can be fuzzy version
shellcheck  latest       # also supports "latest"
jq          1.6
erlang      ref:master   # compile from vcs ref
go          prefix:1.19  # uses the latest 1.19.x version—needed in case "1.19" is an exact match
shfmt       path:./shfmt # use a custom runtime
node        lts          # use lts version of node (not supported by all plugins)

node        sub-2:lts      # install 2 versions behind the latest lts (e.g.: 18 if lts is 20)
python      sub-0.1:latest # install python-3.10 if the latest is 3.11

See the asdf docs for more info on this file format.


Both .mise.toml and .tool-versions support "scopes" which modify the behavior of the version:

  • ref:<SHA> - compile from a vcs (usually git) ref
  • prefix:<PREFIX> - use the latest version that matches the prefix. Useful for Go since 1.20 would only match 1.20 exactly but prefix:1.20 will match 1.20.1 and 1.20.2 etc.
  • path:<PATH> - use a custom compiled version at the given path. One use-case is to re-use Homebrew tools (e.g.: path:/opt/homebrew/opt/node@20).
  • sub-<PARTIAL_VERSION>:<ORIG_VERSION> - subtracts PARTIAL_VERSION from ORIG_VERSION. This can be used to express something like "2 versions behind lts" such as sub-2:lts. Or 1 minor version behind the latest version: sub-0.1:latest.

Legacy version files

mise supports "legacy version files" just like asdf. They're language-specific files like .node-version and .python-version. These are ideal for setting the runtime version of a project without forcing other developers to use a specific tool like mise/asdf.

They support aliases, which means you can have an .nvmrc file with lts/hydrogen and it will work in mise and nvm. Here are some of the supported legacy version files:

Plugin"Legacy" (Idiomatic) Files
go.go-version, go.mod, .sdkmanrc
node.nvmrc, .node-version
ruby.ruby-version, Gemfile
terraform.terraform-version, .packer-version,

In mise these are enabled by default. You can disable them with mise settings set legacy_version_file false. There is a performance cost to having these when they're parsed as it's performed by the plugin in bin/parse-version-file. However these are cached so it's not a huge deal. You may not even notice.


asdf calls these "legacy version files" so we do too. I think this is a bad name since it implies that they shouldn't be used—which is definitely not the case IMO. I prefer the term "idiomatic" version files since they're version files not specific to asdf/mise and can be used by other tools. (.nvmrc being a notable exception, which is tied to a specific tool.)


The following is a list of all of mise's settings. These can be set via mise settings set, by directly modifying ~/.config/mise/config.toml or local config, or via environment variables.

Some of them also can be set via global CLI flags.


  • Type: bool
  • Default: false

Pushes tools' bin-paths to the front of PATH instead of allowing modifications of PATH after activation to take precedence.

For example, if you have the following in your .mise.toml:

node = '20'
python = '3.12'

But you also have this in your ~/.zshrc:

eval "$(mise activate zsh)"

What will happen is /some/other/python will be used instead of the python installed by mise. This means you typically want to put mise activate at the end of your shell config so nothing overrides it.

If you want to always use the mise versions of tools despite what is in your shell config, set this to true. In that case, using this example again, /some/other/python will be after mise's python in PATH.


  • Type: bool
  • Default: false

Only output .tool-versions files in mise local|global which will be usable by asdf. This disables mise functionality that would otherwise make these files incompatible with asdf such as non-pinned versions.

This will also change the default global tool config to be ~/.tool-versions instead of ~/.config/mise/config.toml.


  • Type: string[] (comma-delimited)
  • Default: []

Disables the specified tools. Separate with ,. Generally used for core plugins but works with any tool.


  • Type: enum
  • Default: if_other_versions_installed
if_other_versions_installed [default]Show the warning only when the tool has at least 1 other version installed
alwaysAlways show the warning
neverNever show the warning

Show a warning if tools are not installed when entering a directory with a .mise.toml file.


Disable tools with disable_tools.


  • Type: bool
  • Default: false

Show configured env vars when entering a directory with a .mise.toml file.


  • Type: bool
  • Default: false

Show active tools when entering a directory with a .mise.toml file.

Environment variables

mise can also be configured via environment variables. The following options are available:


Default: ~/.local/share/mise or $XDG_DATA_HOME/mise

This is the directory where mise stores plugins and tool installs. These are not supposed to be shared across machines.


Default (Linux): ~/.cache/mise or $XDG_CACHE_HOME/mise Default (macOS): ~/Library/Caches/mise or $XDG_CACHE_HOME/mise

This is the directory where mise stores internal cache. This is not supposed to be shared across machines. It may be deleted at any time mise is not running.


Default: std::env::temp_dir() implementation in rust

This is used for temporary storage such as when installing tools.


Default: /etc/mise

This is the directory where mise stores system-wide configuration.


Default: $MISE_CONFIG_DIR/config.toml (Usually ~/.config/mise/config.toml)

This is the path to the config file.


Set to something other than ".tool-versions" to have mise look for .tool-versions files but with a different name.


Set to something other than .mise.toml to have mise look for .mise.toml config files with a different name.


Enables environment-specific config files such as .mise.development.toml. Use this for different env vars or different tool versions in development/staging/production environments. See Profiles for more on how to use this feature.


Set to a filename to read from env from a dotenv file. e.g.: MISE_ENV_FILE=.env. Uses dotenvy under the hood.


Default: true

Set to "false" to disable using mise-versions as a quick way for mise to query for new versions. This host regularly grabs all the latest versions of core and community plugins. It's faster than running a plugin's list-all command and gets around GitHub rate limiting problems when using it.

See FAQ for more information.


Set the version for a runtime. For example, MISE_NODE_VERSION=20 will use [email protected] regardless of what is set in .tool-versions/.mise.toml.


Plugins can read the versions files used by other version managers (if enabled by the plugin) for example, .nvmrc in the case of node's nvm. See legacy version files for more information.

Set to "0" to disable legacy version file parsing.


Disable legacy version file parsing for specific tools. Separate with ,.


Set to 1 to default to using .mise.toml in mise local instead of .tool-versions for configuration.

For now this is not used by mise use which will only use .mise.toml unless --path is specified.


This is a list of paths that mise will automatically mark as trusted. They can be separated with :.


These change the verbosity of mise.

You can also use MISE_DEBUG=1, MISE_TRACE=1, and MISE_QUIET=1 as well as --log-level=trace|debug|info|warn|error.


Output logs to a file.


Same as MISE_LOG_LEVEL but for the log file output level. This is useful if you want to store the logs but not have them litter your display.


Set to "1" to always keep the downloaded archive. By default it is deleted after install.


Set to "1" to always keep the install directory. By default it is deleted on failure.


This shows the installation output during mise install and mise plugin install. This should likely be merged so it behaves the same as MISE_DEBUG=1 and we don't have 2 configuration for the same thing, but for now it is its own config.

Equivalent to MISE_LOG_LEVEL=debug.


Equivalent to MISE_LOG_LEVEL=warn.


Enables extra-secure behavior. See Paranoid.


Set the timeout for http requests in seconds. The default is 30.


Set the number plugins or runtimes to install in parallel. The default is 4.


Set to "1" to directly pipe plugin scripts to stdin/stdout/stderr. By default stdin is disabled because when installing a bunch of plugins in parallel you won't see the prompt. Use this if a plugin accepts input or otherwise does not seem to be installing correctly.

Sets MISE_JOBS=1 because only 1 plugin script can be executed at a time.


Use a custom file for the shorthand aliases. This is useful if you want to share plugins within an organization.

Shorthands make it so when a user runs something like mise install elixir mise will automatically install the asdf-elixir plugin. By default, it uses the shorthands in src/

The file should be in this toml format:

elixir = ""
node = ""


Disables the shorthand aliases for installing plugins. You will have to specify full URLs when installing plugins, e.g.: mise plugin install node


This will automatically answer yes or no to prompts. This is useful for scripting.


Set to false to disable the "command not found" handler to autoinstall missing tool versions. Disable this if experiencing strange behavior in your shell when a command is not found—but please submit a ticket to help diagnose problems.


This controls the output of mise run. It can be one of:

  • prefix - (default if jobs > 1) print by line with the prefix of the task name
  • interleave - (default if jobs == 1) display stdout/stderr as it comes in


Enables experimental features. I generally will publish new features under this config which needs to be enabled to use them. While a feature is marked as "experimental" its behavior may change or even disappear in any release.

The idea is experimental features can be iterated on this way so we can get the behavior right, but once that label goes away you shouldn't expect things to change without a proper deprecation—and even then it's unlikely.

Also, I very often will use experimental as a beta flag as well. New functionality that I want to test with a smaller subset of users I will often push out under experimental mode even if it's not related to an experimental feature.

If you'd like to help me out, consider enabling it even if you don't have a particular feature you'd like to try. Also, if something isn't working right, try disabling it if you can.


Default: false unless running NixOS or Alpine (let me know if others should be added)

Do not use precompiled binaries for all languages. Useful if running on a Linux distribution like Alpine that does not use glibc and therefore likely won't be able to run precompiled binaries.

Note that this needs to be setup for each language. File a ticket if you notice a language that is not working with this config.


Configures the vendor_conf.d script for fish shell to automatically activate. This file is automatically used in homebrew and potentially other installs to automatically activate mise without configuring.

Defaults to enabled, set to "0" to disable.

Licensed under the MIT License. Maintained by @jdx and friends.