# https://mise.jdx.dev llms-full.txt

<|firecrawl-page-1-lllmstxt|>
## Dev Environment Management
[Skip to content](https://mise.jdx.dev/#VPContent)

# mise-en-place

The front-end to your dev env
Pronounced "MEEZ ahn plahs"

[Getting Started](https://mise.jdx.dev/getting-started.html)

[Demo](https://mise.jdx.dev/demo.html)

[About](https://mise.jdx.dev/about.html)

[🛠️\\
\\
**Dev Tools** \\
\\
mise is a polyglot tool version manager. It replaces tools like asdf, nvm, pyenv, rbenv, etc.](https://mise.jdx.dev/dev-tools/)

[⚙\\
\\
**Environments** \\
\\
mise allows you to switch sets of env vars in different project directories. It can replace direnv.](https://mise.jdx.dev/environments/)

[⚡\\
\\
**Tasks** \\
\\
mise is a task runner that can replace make, or npm scripts.](https://mise.jdx.dev/tasks/)

<|firecrawl-page-2-lllmstxt|>
## Getting Started with mise
[Skip to content](https://mise.jdx.dev/getting-started.html#VPContent)

On this page

# Getting Started [​](https://mise.jdx.dev/getting-started.html\#getting-started)

This will show you how to install mise and get started with it. This is a suitable way when using an interactive shell like `bash`, `zsh`, or `fish`.

## 1\. Install `mise` CLI [​](https://mise.jdx.dev/getting-started.html\#installing-mise-cli)

See [installing mise](https://mise.jdx.dev/installing-mise.html) for other ways to install mise ( `macport`, `apt`, `yum`, `nix`, etc.).

Linux/macOSBrewWindowsDebian/Ubuntu (apt)Fedora 41+, RHEL/CentOS Stream 9+ (dnf)

shell

```
curl https://mise.run | sh
```

By default, mise will be installed to `~/.local/bin` (this is simply a suggestion. `mise` can be installed anywhere). You can verify the installation by running:

shell

```
~/.local/bin/mise --version
# mise 2024.x.x
```

- `~/.local/bin` does not need to be in `PATH`. mise will automatically add its own directory to `PATH` when [activated](https://mise.jdx.dev/getting-started.html#activate-mise).

`mise` respects [`MISE_DATA_DIR`](https://mise.jdx.dev/configuration.html) and [`XDG_DATA_HOME`](https://mise.jdx.dev/configuration.html) if you'd like to change these locations.

## 2\. mise `exec` and `run` [​](https://mise.jdx.dev/getting-started.html\#mise-exec-run)

Once `mise` is installed, you can immediately start using it. `mise` can be used to install and run [tools](https://mise.jdx.dev/dev-tools/), launch [tasks](https://mise.jdx.dev/tasks/), and manage [environment variables](https://mise.jdx.dev/environments/).

The most essential feature `mise` provides is the ability to run [tools](https://mise.jdx.dev/dev-tools/) with specific versions. A simple way to run a shell command with a given tool is to use [`mise x|exec`](https://mise.jdx.dev/cli/exec.html). For example, here is how you can start a Python 3 interactive shell (REPL):

> _In the examples below, use `~/.local/bin/mise` (or the absolute path to `mise`) if `mise` is not already on `PATH`_

sh

```
mise exec python@3 -- python
# this will download and install Python if it is not already installed
# Python 3.13.2
# >>> ...
```

or run node 22:

sh

```
mise exec node@22 -- node -v
# v22.x.x
```

[`mise x|exec`](https://mise.jdx.dev/cli/exec.html) is a powerful way to load the current `mise` context (tools & environment variables) without modifying your shell session or running ad-hoc commands with mise tools set. Installing [`tools`](https://mise.jdx.dev/dev-tools/) is as simple as running [`mise u|use`](https://mise.jdx.dev/cli/use.html).

shell

```
mise use --global node@22 # install node 22 and set it as the global default
mise exec -- node my-script.js
# run my-script.js with node 22...
```

Another useful command is [`mise r|run`](https://mise.jdx.dev/cli/run.html) which allows you to run a [`mise task`](https://mise.jdx.dev/tasks/) or a script with the `mise` context.

TIP

You can set a shell alias in your shell's rc file like `alias x="mise x --"` to save some keystrokes.

## 3\. Activate `mise` optional [​](https://mise.jdx.dev/getting-started.html\#activate-mise)

While using [`mise x|exec`](https://mise.jdx.dev/cli/exec.html) is useful, for interactive shells, you might prefer to activate `mise` to automatically load the `mise` context ( `tools` and `environment variables`) in your shell session. Another option is to use [shims](https://mise.jdx.dev/dev-tools/shims.html).

- [`mise activate`](https://mise.jdx.dev/cli/activate.html) method updates your environment variable and `PATH` every time your prompt is run to ensure you use the correct versions.
- [Shims](https://mise.jdx.dev/dev-tools/shims.html) are symlinks to the `mise` binary that intercept commands and load the appropriate environment. Note that [**shims do not support all the features of `mise activate`**](https://mise.jdx.dev/dev-tools/shims.html#shims-vs-path).

For interactive shells, `mise activate` is recommended. In non-interactive sessions, like CI/CD, IDEs, and scripts, using `shims` might work best. You can also not use any and call `mise exec/run` directly instead. See [this guide](https://mise.jdx.dev/dev-tools/shims.html) for more information.

Here is how you can activate `mise` depending on your shell and the installation method:

https://mise.runBrewWindowsOther package managers

bashzshfish

sh

```
echo 'eval "$(~/.local/bin/mise activate bash)"' >> ~/.bashrc
```

sh

```
echo 'eval "$(~/.local/bin/mise activate zsh)"' >> ~/.zshrc
```

sh

```
echo '~/.local/bin/mise activate fish | source' >> ~/.config/fish/config.fish
```

Make sure you restart your shell session after modifying your rc file in order for it to take effect. You can run [`mise dr|doctor`](https://mise.jdx.dev/cli/doctor.html) to verify that mise is correctly installed and activated.

Now that `mise` is activated or its shims have been added to `PATH`, `node` is also available directly! (without using `mise exec`):

sh

```
mise use --global node@22
node -v
# v22.x.x
```

Note that when you ran `mise use --global node@22`, `mise` updated the global `mise` configuration.

~/.config/mise/config.toml

toml

```
[tools]
node = "22"
```

## 4\. Next steps [​](https://mise.jdx.dev/getting-started.html\#next-steps)

Follow the [walkthrough](https://mise.jdx.dev/walkthrough.html) for more examples on how to use mise.

### Set up the autocompletion [​](https://mise.jdx.dev/getting-started.html\#autocompletion)

See [autocompletion](https://mise.jdx.dev/installing-mise.html#autocompletion) to learn how to set up autocompletion for your shell.

### GitHub API rate limiting [​](https://mise.jdx.dev/getting-started.html\#github-api-rate-limiting)

WARNING

Many tools in mise require the use of the GitHub API. Unauthenticated requests to the GitHub API are often rate limited. If you see 4xx errors while using mise, you can set `MISE_GITHUB_TOKEN` or `GITHUB_TOKEN` to a token [generated from here](https://github.com/settings/tokens/new?description=MISE_GITHUB_TOKEN) which will likely fix the issue. The token does not require any scopes.

<|firecrawl-page-3-lllmstxt|>
## TOML Task Configuration
[Skip to content](https://mise.jdx.dev/tasks/toml-tasks.html#VPContent)

On this page

# TOML-based Tasks [​](https://mise.jdx.dev/tasks/toml-tasks.html\#toml-based-tasks)

Tasks can be defined in `mise.toml` files in different ways. Trivial tasks can be written into a `[tasks]` section, while more detailed tasks each get their own section.

## Trivial task examples [​](https://mise.jdx.dev/tasks/toml-tasks.html\#trivial-task-examples)

mise.toml

toml

```
build = "cargo build"
test = "cargo test"
lint = "cargo clippy"
```

## Detailed task examples [​](https://mise.jdx.dev/tasks/toml-tasks.html\#detailed-task-examples)

mise.toml

toml

```
[tasks.cleancache]
run = "rm -rf .cache"
hide = true # hide this task from the list

[tasks.clean]
depends = ['cleancache']
run = "cargo clean" # runs as a shell command

[tasks.build]
description = 'Build the CLI'
run = "cargo build"
alias = 'b' # `mise run b`

[tasks.test]
description = 'Run automated tests'
# multiple commands are run in series
run = [\
    'cargo test',\
    './scripts/test-e2e.sh',\
]
dir = "{{cwd}}" # run in user's cwd, default is the project's base directory

[tasks.lint]
description = 'Lint with clippy'
env = { RUST_BACKTRACE = '1' } # env vars for the script
# you can specify a multiline script instead of individual commands
run = """
#!/usr/bin/env bash
cargo clippy
"""

[tasks.ci] # only dependencies to be run
description = 'Run CI tasks'
depends = ['build', 'lint', 'test']

[tasks.release]
confirm = 'Are you sure you want to cut a new release?'
description = 'Cut a new release'
file = 'scripts/release.sh' # execute an external script
```

You can use [environment variables](https://mise.jdx.dev/environments/) or [`vars`](https://mise.jdx.dev/tasks/task-configuration.html#vars-options) to define common arguments:

mise.toml

toml

```
[env]
VERBOSE_ARGS = '--verbose'

# Vars can be shared between tasks like environment variables,
# but they are not passed as environment variables to the scripts
[vars]
e2e_args = '--headless'

[tasks.test]
run = './scripts/test-e2e.sh {{vars.e2e_args}} $VERBOSE_ARGS'
```

## Adding tasks [​](https://mise.jdx.dev/tasks/toml-tasks.html\#adding-tasks)

You can edit the `mise.toml` file directly or using [`mise tasks add`](https://mise.jdx.dev/cli/tasks/add.html)

shell

```
mise task add pre-commit --depends "test" --depends "render" -- echo pre-commit
```

will add the following to `mise.toml`:

shell

```
[tasks.pre-commit]
depends = ["test", "render"]
run = "echo pre-commit"
```

## Common options [​](https://mise.jdx.dev/tasks/toml-tasks.html\#common-options)

For an exhaustive list, see [task configuration](https://mise.jdx.dev/tasks/task-configuration.html).

### Run command [​](https://mise.jdx.dev/tasks/toml-tasks.html\#run-command)

Provide the script to run. Can be a single command or an array of commands:

toml

```
[tasks.test]
run = 'cargo test'
```

Commands are run in series. If a command fails, the task will stop and the remaining commands will not run.

toml

```
[tasks.test]
run = [\
    'cargo test',\
    './scripts/test-e2e.sh',\
]
```

You can specify an alternate command to run on Windows by using the `run_windows` key:

toml

```
[tasks.test]
run = 'cargo test'
run_windows = 'cargo test --features windows'
```

### Specifying which directory to use [​](https://mise.jdx.dev/tasks/toml-tasks.html\#specifying-which-directory-to-use)

The [`dir`](https://mise.jdx.dev/tasks/task-configuration.html#dir) property determines the `cwd` in which the task is executed. You can use the directory from where the task was run with `dir = "{{cwd}}"`:

toml

```
[tasks.test]
run = 'cargo test'
dir = "{{cwd}}"
```

Also, `MISE_ORIGINAL_CWD` is set to the original working directory and will be passed to the task.

### Adding a description and alias [​](https://mise.jdx.dev/tasks/toml-tasks.html\#adding-a-description-and-alias)

You can add a description to a task and alias for a task.

toml

```
[tasks.build]
description = 'Build the CLI'
run = "cargo build"
alias = 'b' # `mise run b`
```

- This alias can be used to run the task
- The description will be displayed when running [`mise tasks ls`](https://mise.jdx.dev/cli/tasks/ls.html) or [`mise run`](https://mise.jdx.dev/cli/run.html) with no arguments.

shell

```
❯ mise run
Tasks
# Select a tasks to run
# > build  Build the CLI
#   test   Run the tests
```

### Dependencies [​](https://mise.jdx.dev/tasks/toml-tasks.html\#dependencies)

You can specify dependencies for a task. Dependencies are run before the task itself. If a dependency fails, the task will not run.

toml

```
[tasks.build]
run = 'cargo build'

[tasks.test]
depends = ['build']
```

There are other ways to specify dependencies, see [wait\_for](https://mise.jdx.dev/tasks/task-configuration.html#wait-for) and [depends\_post](https://mise.jdx.dev/tasks/task-configuration.html#depends-post)

### Environment variables [​](https://mise.jdx.dev/tasks/toml-tasks.html\#environment-variables)

You can specify environment variables for a task:

toml

```
[tasks.lint]
description = 'Lint with clippy'
env = { RUST_BACKTRACE = '1' } # env vars for the script
# you can specify a multiline script instead of individual commands
run = """
#!/usr/bin/env bash
cargo clippy
"""
```

### Sources / Outputs [​](https://mise.jdx.dev/tasks/toml-tasks.html\#sources-outputs)

If you want to skip executing a task if certain files haven't changed (up-to-date), you should specify `sources` and `outputs`:

toml

```
[tasks.build]
description = 'Build the CLI'
run = "cargo build"
sources = ['Cargo.toml', 'src/**/*.rs'] # skip running if these files haven't changed
outputs = ['target/debug/mycli']
```

You can use `sources` alone if with [`mise watch`](https://mise.jdx.dev/cli/watch.html) to run the task when the sources change.

### Confirmation [​](https://mise.jdx.dev/tasks/toml-tasks.html\#confirmation)

A message to show before running the task. The user will be prompted to confirm before the task is run.

toml

```
[tasks.release]
confirm = 'Are you sure you want to cut a new release?'
description = 'Cut a new release'
file = 'scripts/release.sh'
```

## Specifying a shell or an interpreter [​](https://mise.jdx.dev/tasks/toml-tasks.html\#shell-shebang)

Tasks are executed with `set -e` ( `set -o erropt`) if the shell is `sh`, `bash`, or `zsh`. This means that the script will exit if any command fails. You can disable this by running `set +e` in the script.

toml

```
[tasks.echo]
run = '''
set +e
cd /nonexistent
echo "This will not fail the task"
'''
```

You can specify a `shell` command to run the script with (default is [`sh -c`](https://mise.jdx.dev/configuration/settings.html#unix_default_inline_shell_args) or [`cmd /c`](https://mise.jdx.dev/configuration/settings.html#windows_default_inline_shell_args)):

toml

```
[tasks.lint]
shell = 'bash -c'
run = "cargo clippy"
```

or use a shebang:

toml

```
[tasks.lint]
run = """
#!/usr/bin/env bash
cargo clippy
"""
```

By using a `shebang` (or `shell`), you can run tasks in different languages (e.g., Python, Node.js, Ruby, etc.):

pythonpython + uvnodebundenoruby

toml

```
[tools]
python = 'latest'

[tasks.python_task]
run = '''
#!/usr/bin/env python
for i in range(10):
    print(i)
'''
```

toml

```
[tools]
uv = 'latest'

[tasks.python_uv_task]
run = """
#!/usr/bin/env -S uv run --script
# /// script
# dependencies = ["requests<3", "rich"]
# ///

import requests
from rich.pretty import pprint

resp = requests.get("https://peps.python.org/api/peps.json")
data = resp.json()
pprint([(k, v["title"]) for k, v in data.items()][:10])
"""
```

toml

```
[tools]
node = 'lts'

[tasks.node_task]
shell = 'node -e'
run = [\
  "console.log('First line')",\
  "console.log('Second line')",\
]
```

toml

```
[tools]
bun = 'latest'

[tasks.bun_shell]
description = "https://bun.sh/docs/runtime/shell"
run = """
#!/usr/bin/env bun

import { $ } from "bun";
const response = await fetch("https://example.com");
await $`cat < ${response} | wc -c`; // 1256
"""
```

toml

```
[tools]
deno = 'latest'

[tasks.deno_task]
description = "A more complex task using Deno imports"
run = '''
#!/usr/bin/env -S deno run
import ProgressBar from "jsr:@deno-library/progress";
import { delay } from "jsr:@std/async";

if (!confirm('Start download?')) {
    Deno.exit(1);
}

const progress = new ProgressBar({ title:  "downloading:", total: 100 });
let completed = 0;
async function download() {
  while (completed <= 100) {
    await progress.render(completed++);
    await delay(10);
  }
}
await download();
'''
# ❯ mise run deno_task
# [download_task] $ import ProgressBar from "jsr:@deno-library/progress";
# Start download? [y/N] y
# downloading: ...
```

toml

```
[tools]
ruby = 'latest'

[tasks.ruby_task]
run = """
#!/usr/bin/env ruby
puts 'Hello, ruby!'
"""
```

What's a shebang? What's the difference between `#!/usr/bin/env` and `#!/usr/bin/env -S`

A shebang is the character sequence `#!` at the beginning of a script file that tells the system which program should be used to interpret/execute the script. The [env command](https://manpages.ubuntu.com/manpages/jammy/man1/env.1.html) comes from GNU Coreutils. `mise` does not use `env` but will behave similarly.

For example, `#!/usr/bin/env python` will run the script with the Python interpreter found in the `PATH`.

The `-S` flag allows passing multiple arguments to the interpreter. It treats the rest of the line as a single argument string to be split.

This is useful when you need to specify interpreter flags or options. Example: `#!/usr/bin/env -S python -u` will run Python with unbuffered output.

## Using a file or remote script [​](https://mise.jdx.dev/tasks/toml-tasks.html\#using-a-file-or-remote-script)

You can specify a file to run as a task:

toml

```
[tasks.release]
description = 'Cut a new release'
file = 'scripts/release.sh' # execute an external script
```

### Remote tasks [​](https://mise.jdx.dev/tasks/toml-tasks.html\#remote-tasks)

Task files can be fetched remotely with multiple protocols:

#### HTTP [​](https://mise.jdx.dev/tasks/toml-tasks.html\#http)

toml

```
[tasks.build]
file = "https://example.com/build.sh"
```

Please note that the file will be downloaded and executed. Make sure you trust the source.

#### Git experimental [​](https://mise.jdx.dev/tasks/toml-tasks.html\#git)

sshhttps

toml

```
[tasks.build]
file = "git::ssh://git@github.com/myorg/example.git//myfile?ref=v1.0.0"
```

toml

```
[tasks.build]
file = "git::https://github.com/myorg/example.git//myfile?ref=v1.0.0"
```

Url format must follow these patterns `git::<protocol>://<url>//<path>?<ref>`

Required fields:

- `protocol`: The git repository URL.
- `url`: The git repository URL.
- `path`: The path to the file in the repository.

Optional fields:

- `ref`: The git reference (branch, tag, commit).

#### Cache [​](https://mise.jdx.dev/tasks/toml-tasks.html\#cache)

Each task file is cached in the `MISE_CACHE_DIR` directory. If the file is updated, it will not be re-downloaded unless the cache is cleared.

TIP

You can reset the cache by running `mise cache clear`.

You can use the `MISE_TASK_REMOTE_NO_CACHE` environment variable to disable caching of remote tasks.

## Arguments [​](https://mise.jdx.dev/tasks/toml-tasks.html\#arguments)

By default, arguments are passed to the last script in the `run` array. So if a task was defined as:

toml

```
[tasks.test]
run = ['cargo test', './scripts/test-e2e.sh']
```

Then running `mise run test foo bar` will pass `foo bar` to `./scripts/test-e2e.sh` but not to `cargo test`.

You can also define arguments using templates:

toml

```
[tasks.test]
run = [\
    'cargo test {{arg(name="cargo_test_args", var=true)}}',\
    './scripts/test-e2e.sh {{option(name="e2e_args")}}',\
]
```

Then running `mise run test foo bar` will pass `foo bar` to `cargo test`. `mise run test --e2e-args baz` will pass `baz` to `./scripts/test-e2e.sh`. If any arguments are defined with templates then mise will not pass the arguments to the last script in the `run` array.

TIP

Using templates to define arguments will make them work with completion and help messages.

### Positional Arguments [​](https://mise.jdx.dev/tasks/toml-tasks.html\#positional-arguments)

These are defined in scripts with `{{arg()}}`. They are used for positional arguments where the order matters.

Example:

toml

```
[tasks.test]
run = 'cargo test {{arg(name="file")}}'
# execute: mise run test my-test-file
# runs: cargo test my-test-file
```

- `i`: The index of the argument. This can be used to specify the order of arguments. Defaults to the order they're defined in the scripts.
- `name`: The name of the argument. This is used for help/error messages.
- `var`: If `true`, multiple arguments can be passed.
- `default`: The default value if the argument is not provided.

### Options [​](https://mise.jdx.dev/tasks/toml-tasks.html\#options)

These are defined in scripts with `{{option()}}`. They are used for named arguments where the order doesn't matter.

Example:

toml

```
[tasks.test]
run = 'cargo test {{option(name="file")}}'
# execute: mise run test --file my-test-file
# runs: cargo test my-test-file
```

- `name`: The name of the argument. This is used for help/error messages.
- `var`: If `true`, multiple values can be passed.
- `default`: The default value if the option is not provided.

### Flags [​](https://mise.jdx.dev/tasks/toml-tasks.html\#flags)

Flags are like options except they don't take values. They are defined in scripts with `{{flag()}}`.

Examples:

toml

```
[tasks.echo]
run = 'echo {{flag(name="myflag")}}'
# execute: mise run echo --myflag
# runs: echo true
```

toml

```
[tasks.maybeClean]
run = """
if [ '{{flag(name='clean')}}' = 'true' ]; then
  echo 'cleaning'
fi
"""
# execute: mise run maybeClean --clean
# runs: echo cleaning
```

- `name`: The name of the flag. This is used for help/error messages.

The value will be `true` if the flag is passed, and `false` otherwise.

### Usage spec [​](https://mise.jdx.dev/tasks/toml-tasks.html\#usage-spec)

More advanced usage specs can be added to the task's `usage` field:

toml

```
[tasks.add-user]
description = "Add a user"
usage = '''
arg "<user>" default="unknown"
complete "user" run="mise run list-users-completion"
'''
run = 'echo {{arg(name="user")}}'

[tasks.list-users-completion]
hide = true
quiet = true # this is mandatory to make completion work (makes the mise command just print "alice bob charlie")
description = "List users"
run = 'echo "alice\nbob\ncharlie"'
```

Arguments and flags defined in the usage spec are also set in the environment before running each script defined in the `run` field. The name of each variable is prepended with `usage_` keyword.

toml

```
[tasks.usage-env-example]
usage = '''
arg "myarg" "myarg description" default="foo"
'''
run = 'echo myarg=$usage_myarg'

# execute: mise run usage-env-example
# outputs: myarg=foo

# execute: mise run usage-env-example bar
# outputs: myarg=bar
```

toml

```
[tasks.usage-env-example]
usage = '''
flag "-m --myflag <myflag>" default="false"
'''
run = [\
'echo "Command 1: $usage_myflag"',\
'echo "Command 2: {{flag(name="myflag", default="false")}} $usage_myflag"',\
]

# execute: mise run usage-env-example
# outputs:
# Command 1: false
# Command 2: false false

# execute: mise run usage-env-example --myflag true
# outputs:
# Command 1: true
# Command 2: true true
```

<|firecrawl-page-4-lllmstxt|>
## Mise Tool Registry
[Skip to content](https://mise.jdx.dev/registry.html#VPContent)

On this page

# Registry [​](https://mise.jdx.dev/registry.html\#registry)

List of all [tools](https://mise.jdx.dev/registry.html#tools) aliased by default in `mise`.

You can use these shorthands with `mise use`. This allows you to use a tool without needing to know the full name. For example, to use the `aws-cli` tool, you can do the following:

shell

```
mise use aws-cli
```

instead of

shell

```
mise use aqua:aws/aws-cli
```

If a tool is not available in the registry, you can install it by its full name. [ubi](https://mise.jdx.dev/dev-tools/backends/ubi.html) and [aqua](https://mise.jdx.dev/dev-tools/backends/aqua.html) give you for example access to almost all programs available on GitHub.

## Backends [​](https://mise.jdx.dev/registry.html\#backends)

In addition to built-in [core tools](https://mise.jdx.dev/core-tools.html), `mise` supports a variety of [backends](https://mise.jdx.dev/dev-tools/backends/) to install tools.

In general, the preferred [backend](https://mise.jdx.dev/dev-tools/backends/) to use for new tools is the following:

- [aqua](https://mise.jdx.dev/dev-tools/backends/aqua.html) \- offers the most features and security while not requiring plugins
- [ubi](https://mise.jdx.dev/dev-tools/backends/ubi.html) \- Universal Binary Installer, offers a simple way to install tools from any GitHub/GitLab repo
- [pipx](https://mise.jdx.dev/dev-tools/backends/pipx.html) \- only for python tools, requires python to be installed but this generally would always be the case for python tools
- [npm](https://mise.jdx.dev/dev-tools/backends/npm.html) \- only for node tools, requires node to be installed but this generally would always be the case for node tools
- [vfox](https://mise.jdx.dev/dev-tools/backends/vfox.html) \- only for tools that have unique installation requirements or need to modify env vars
- [asdf](https://mise.jdx.dev/dev-tools/backends/asdf.html) \- only for tools that have unique installation requirements or need to modify env vars, doesn't support windows
- [go](https://mise.jdx.dev/dev-tools/backends/go.html) \- only for go tools, requires go to be installed to compile. Because go tools can be distributed as a single binary, aqua/ubi are definitely preferred.
- [cargo](https://mise.jdx.dev/dev-tools/backends/cargo.html) \- only for rust tools, requires rust to be installed to compile. Because rust tools can be distributed as a single binary, aqua/ubi are definitely preferred.
- [dotnet](https://mise.jdx.dev/dev-tools/backends/dotnet.html) \- only for dotnet tools, requires dotnet to be installed to compile. Because dotnet tools can be distributed as a single binary, aqua/ubi are definitely preferred.

### Backends Priority [​](https://mise.jdx.dev/registry.html\#backends-priority)

Each tool can define its own priority if it has more than one backend it supports. If you would like to disable a backend, you can do so with the following command:

shell

```
mise settings disable_backends=asdf
```

This will disable the [asdf](https://mise.jdx.dev/dev-tools/backends/asdf.html) backend. See [Aliases](https://mise.jdx.dev/dev-tools/aliases.html) for a way to set a default backend for a tool. Note that the `asdf` backend is disabled by default on Windows.

You can also specify the full name for a tool using `mise use aqua:1password/cli` if you want to use a specific backend.

Source: [https://github.com/jdx/mise/blob/main/registry.toml](https://github.com/jdx/mise/blob/main/registry.toml)

## Tools [​](https://mise.jdx.dev/registry.html\#tools)

Note that [`mise registry`](https://mise.jdx.dev/cli/registry.html) can be used to list all tools in the registry. [`mise use`](https://mise.jdx.dev/cli/use.html) without any arguments will show a `tui` to select a tool to install.

| Short | Full | OS |
| --- | --- | --- |
| 1password | [aqua:1password/cli](https://github.com/1password/cli)<br>[asdf:mise-plugins/mise-1password-cli](https://github.com/mise-plugins/mise-1password-cli) |  |
| aapt2 | [asdf:mise-plugins/mise-aapt2](https://github.com/mise-plugins/mise-aapt2) |  |
| act | [aqua:nektos/act](https://github.com/nektos/act)<br>[ubi:nektos/act](https://github.com/nektos/act)<br>[asdf:gr1m0h/asdf-act](https://github.com/gr1m0h/asdf-act) |  |
| action-validator | [aqua:mpalmer/action-validator](https://github.com/mpalmer/action-validator)<br>[ubi:mpalmer/action-validator](https://github.com/mpalmer/action-validator)<br>[asdf:mpalmer/action-validator](https://github.com/mpalmer/action-validator) | linux, macos |
| actionlint | [aqua:rhysd/actionlint](https://github.com/rhysd/actionlint)<br>[ubi:rhysd/actionlint](https://github.com/rhysd/actionlint)<br>[asdf:crazy-matt/asdf-actionlint](https://github.com/crazy-matt/asdf-actionlint)<br>[go:github.com/rhysd/actionlint/cmd/actionlint](https://pkg.go.dev/github.com/rhysd/actionlint/cmd/actionlint) |  |
| adr-tools | [aqua:npryce/adr-tools](https://github.com/npryce/adr-tools)<br>[asdf:https://gitlab.com/td7x/asdf/adr-tools](https://gitlab.com/td7x/asdf/adr-tools) |  |
| ag | [asdf:mise-plugins/mise-ag](https://github.com/mise-plugins/mise-ag) |  |
| age | [aqua:FiloSottile/age](https://github.com/FiloSottile/age)<br>[asdf:threkk/asdf-age](https://github.com/threkk/asdf-age) |  |
| age-plugin-yubikey | [ubi:str4d/age-plugin-yubikey](https://github.com/str4d/age-plugin-yubikey)<br>[asdf:joke/asdf-age-plugin-yubikey](https://github.com/joke/asdf-age-plugin-yubikey) |  |
| agebox | [aqua:slok/agebox](https://github.com/slok/agebox)<br>[ubi:slok/agebox](https://github.com/slok/agebox)<br>[asdf:slok/asdf-agebox](https://github.com/slok/asdf-agebox) |  |
| aichat | [aqua:sigoden/aichat](https://github.com/sigoden/aichat) |  |
| air | [aqua:air-verse/air](https://github.com/air-verse/air)<br>[asdf:pdemagny/asdf-air](https://github.com/pdemagny/asdf-air) |  |
| aks-engine | [aqua:Azure/aks-engine](https://github.com/Azure/aks-engine)<br>[asdf:robsonpeixoto/asdf-aks-engine](https://github.com/robsonpeixoto/asdf-aks-engine) |  |
| allure | [asdf:mise-plugins/mise-allure](https://github.com/mise-plugins/mise-allure) |  |
| allurectl | [ubi:allure-framework/allurectl](https://github.com/allure-framework/allurectl) |  |
| alp | [aqua:tkuchiki/alp](https://github.com/tkuchiki/alp)<br>[asdf:asdf-community/asdf-alp](https://github.com/asdf-community/asdf-alp) |  |
| amass | [ubi:owasp-amass/amass](https://github.com/owasp-amass/amass)<br>[asdf:dhoeric/asdf-amass](https://github.com/dhoeric/asdf-amass) |  |
| amazon-ecr-credential-helper | [aqua:awslabs/amazon-ecr-credential-helper](https://github.com/awslabs/amazon-ecr-credential-helper)<br>[asdf:dex4er/asdf-amazon-ecr-credential-helper](https://github.com/dex4er/asdf-amazon-ecr-credential-helper) |  |
| amp | [npm:@sourcegraph/amp](https://www.npmjs.com/package/@sourcegraph/amp) |  |
| android-sdk | [asdf:mise-plugins/mise-android-sdk](https://github.com/mise-plugins/mise-android-sdk) |  |
| ansible | [pipx:ansible](https://pypi.org/project/ansible) |  |
| ansible-core | [pipx:ansible-core](https://pypi.org/project/ansible-core) |  |
| ant | [asdf:mise-plugins/mise-ant](https://github.com/mise-plugins/mise-ant) |  |
| apko | [aqua:chainguard-dev/apko](https://github.com/chainguard-dev/apko)<br>[ubi:chainguard-dev/apko](https://github.com/chainguard-dev/apko)<br>[asdf:omissis/asdf-apko](https://github.com/omissis/asdf-apko) |  |
| apollo-ios | [asdf:mise-plugins/mise-apollo-ios-cli](https://github.com/mise-plugins/mise-apollo-ios-cli) |  |
| apollo-router | [ubi:apollographql/router](https://github.com/apollographql/router)<br>[asdf:safx/asdf-apollo-router](https://github.com/safx/asdf-apollo-router) |  |
| apollo-rover | [ubi:apollographql/rover](https://github.com/apollographql/rover) |  |
| aqua | [ubi:aquaproj/aqua](https://github.com/aquaproj/aqua) |  |
| arduino | [aqua:arduino/arduino-cli](https://github.com/arduino/arduino-cli)<br>[asdf:egnor/asdf-arduino-cli](https://github.com/egnor/asdf-arduino-cli) |  |
| argc | [ubi:sigoden/argc](https://github.com/sigoden/argc) |  |
| argo | [aqua:argoproj/argo-workflows](https://github.com/argoproj/argo-workflows)<br>[asdf:sudermanjr/asdf-argo](https://github.com/sudermanjr/asdf-argo) |  |
| argo-rollouts | [aqua:argoproj/argo-rollouts](https://github.com/argoproj/argo-rollouts)<br>[asdf:abatilo/asdf-argo-rollouts](https://github.com/abatilo/asdf-argo-rollouts) |  |
| argocd | [aqua:argoproj/argo-cd](https://github.com/argoproj/argo-cd)<br>[ubi:argoproj/argo-cd](https://github.com/argoproj/argo-cd)<br>[asdf:beardix/asdf-argocd](https://github.com/beardix/asdf-argocd) |  |
| asciidoctorj | [asdf:mise-plugins/mise-asciidoctorj](https://github.com/mise-plugins/mise-asciidoctorj) |  |
| assh | [ubi:moul/assh](https://github.com/moul/assh)<br>[asdf:mise-plugins/mise-assh](https://github.com/mise-plugins/mise-assh) |  |
| ast-grep | [aqua:ast-grep/ast-grep](https://github.com/ast-grep/ast-grep)<br>[cargo:ast-grep](https://crates.io/crates/ast-grep)<br>[npm:@ast-grep/cli](https://www.npmjs.com/package/@ast-grep/cli)<br>[pipx:ast-grep-cli](https://pypi.org/project/ast-grep-cli) |  |
| astro | [ubi:astronomer/astro-cli](https://github.com/astronomer/astro-cli) |  |
| atlas | [aqua:ariga/atlas](https://github.com/ariga/atlas)<br>[asdf:komi1230/asdf-atlas](https://github.com/komi1230/asdf-atlas) |  |
| atmos | [aqua:cloudposse/atmos](https://github.com/cloudposse/atmos)<br>[asdf:cloudposse/asdf-atmos](https://github.com/cloudposse/asdf-atmos) |  |
| atuin | [aqua:atuinsh/atuin](https://github.com/atuinsh/atuin)<br>[ubi:atuinsh/atuin](https://github.com/atuinsh/atuin) |  |
| auto-doc | [ubi:tj-actions/auto-doc](https://github.com/tj-actions/auto-doc)<br>[asdf:mise-plugins/mise-auto-doc](https://github.com/mise-plugins/mise-auto-doc) |  |
| aws-amplify | [ubi:aws-amplify/amplify-cli](https://github.com/aws-amplify/amplify-cli)<br>[asdf:LozanoMatheus/asdf-aws-amplify-cli](https://github.com/LozanoMatheus/asdf-aws-amplify-cli) |  |
| aws-cli | [aqua:aws/aws-cli](https://github.com/aws/aws-cli)<br>[asdf:MetricMike/asdf-awscli](https://github.com/MetricMike/asdf-awscli) | linux, macos |
| aws-copilot | [aqua:aws/copilot-cli](https://github.com/aws/copilot-cli)<br>[asdf:NeoHsu/asdf-copilot](https://github.com/NeoHsu/asdf-copilot) |  |
| aws-iam-authenticator | [aqua:kubernetes-sigs/aws-iam-authenticator](https://github.com/kubernetes-sigs/aws-iam-authenticator)<br>[asdf:zekker6/asdf-aws-iam-authenticator](https://github.com/zekker6/asdf-aws-iam-authenticator) |  |
| aws-nuke | [aqua:ekristen/aws-nuke](https://github.com/ekristen/aws-nuke)<br>[asdf:bersalazar/asdf-aws-nuke](https://github.com/bersalazar/asdf-aws-nuke) |  |
| aws-sam | [aqua:aws/aws-sam-cli](https://github.com/aws/aws-sam-cli)<br>[pipx:aws-sam-cli](https://pypi.org/project/aws-sam-cli)<br>[asdf:mise-plugins/mise-pyapp](https://github.com/mise-plugins/mise-pyapp) |  |
| aws-sso | [aqua:synfinatic/aws-sso-cli](https://github.com/synfinatic/aws-sso-cli)<br>[asdf:adamcrews/asdf-aws-sso-cli](https://github.com/adamcrews/asdf-aws-sso-cli) |  |
| aws-vault | [aqua:99designs/aws-vault](https://github.com/99designs/aws-vault)<br>[asdf:karancode/asdf-aws-vault](https://github.com/karancode/asdf-aws-vault) |  |
| awscli-local | [asdf:mise-plugins/mise-awscli-local](https://github.com/mise-plugins/mise-awscli-local) |  |
| awsebcli | [pipx:awsebcli](https://pypi.org/project/awsebcli)<br>[asdf:mise-plugins/mise-pyapp](https://github.com/mise-plugins/mise-pyapp) |  |
| awsls | [ubi:jckuester/awsls](https://github.com/jckuester/awsls)<br>[asdf:chessmango/asdf-awsls](https://github.com/chessmango/asdf-awsls) |  |
| awsrm | [ubi:jckuester/awsrm](https://github.com/jckuester/awsrm)<br>[asdf:chessmango/asdf-awsrm](https://github.com/chessmango/asdf-awsrm) |  |
| awsweeper | [ubi:jckuester/awsweeper](https://github.com/jckuester/awsweeper)<br>[asdf:chessmango/asdf-awsweeper](https://github.com/chessmango/asdf-awsweeper) |  |
| azure | [asdf:mise-plugins/mise-azure-cli](https://github.com/mise-plugins/mise-azure-cli) |  |
| azure-functions-core-tools | [asdf:mise-plugins/mise-azure-functions-core-tools](https://github.com/mise-plugins/mise-azure-functions-core-tools) |  |
| azure-kubelogin | [aqua:Azure/kubelogin](https://github.com/Azure/kubelogin)<br>[asdf:sechmann/asdf-kubelogin](https://github.com/sechmann/asdf-kubelogin) |  |
| babashka | [ubi:babashka/babashka](https://github.com/babashka/babashka)<br>[asdf:pitch-io/asdf-babashka](https://github.com/pitch-io/asdf-babashka) |  |
| balena | [ubi:balena-io/balena-cli](https://github.com/balena-io/balena-cli)<br>[asdf:jaredallard/asdf-balena-cli](https://github.com/jaredallard/asdf-balena-cli) |  |
| bashbot | [aqua:mathew-fleisch/bashbot](https://github.com/mathew-fleisch/bashbot)<br>[asdf:mathew-fleisch/asdf-bashbot](https://github.com/mathew-fleisch/asdf-bashbot) |  |
| bashly | [asdf:mise-plugins/mise-bashly](https://github.com/mise-plugins/mise-bashly) |  |
| bat | [aqua:sharkdp/bat](https://github.com/sharkdp/bat)<br>[ubi:sharkdp/bat](https://github.com/sharkdp/bat)<br>[cargo:bat](https://crates.io/crates/bat)<br>[asdf:https://gitlab.com/wt0f/asdf-bat](https://gitlab.com/wt0f/asdf-bat) |  |
| bat-extras | [asdf:mise-plugins/mise-bat-extras](https://github.com/mise-plugins/mise-bat-extras) |  |
| bats | [aqua:bats-core/bats-core](https://github.com/bats-core/bats-core)<br>[asdf:timgluz/asdf-bats](https://github.com/timgluz/asdf-bats) | linux, macos |
| bazel | [aqua:bazelbuild/bazel](https://github.com/bazelbuild/bazel)<br>[ubi:bazelbuild/bazel](https://github.com/bazelbuild/bazel)<br>[asdf:rajatvig/asdf-bazel](https://github.com/rajatvig/asdf-bazel) |  |
| bazel-watcher | [aqua:bazelbuild/bazel-watcher](https://github.com/bazelbuild/bazel-watcher) |  |
| bazelisk | [aqua:bazelbuild/bazelisk](https://github.com/bazelbuild/bazelisk)<br>[asdf:josephtate/asdf-bazelisk](https://github.com/josephtate/asdf-bazelisk) |  |
| bbr-s3-config-validator | [asdf:mise-plugins/tanzu-plug-in-for-asdf](https://github.com/mise-plugins/tanzu-plug-in-for-asdf) |  |
| benthos | [aqua:benthosdev/benthos](https://github.com/benthosdev/benthos)<br>[asdf:benthosdev/benthos-asdf](https://github.com/benthosdev/benthos-asdf) |  |
| bfs | [asdf:mise-plugins/mise-bfs](https://github.com/mise-plugins/mise-bfs) |  |
| binnacle | [aqua:Traackr/binnacle](https://github.com/Traackr/binnacle)<br>[asdf:Traackr/asdf-binnacle](https://github.com/Traackr/asdf-binnacle) |  |
| biome | [aqua:biomejs/biome](https://github.com/biomejs/biome)<br>[ubi:biomejs/biome](https://github.com/biomejs/biome)<br>[npm:@biomejs/biome](https://www.npmjs.com/package/@biomejs/biome) |  |
| bitwarden | [aqua:bitwarden/clients](https://github.com/bitwarden/clients)<br>[asdf:vixus0/asdf-bitwarden](https://github.com/vixus0/asdf-bitwarden) |  |
| bitwarden-secrets-manager | [ubi:bitwarden/sdk](https://github.com/bitwarden/sdk)<br>[asdf:asdf-community/asdf-bitwarden-secrets-manager](https://github.com/asdf-community/asdf-bitwarden-secrets-manager) |  |
| black | [aqua:psf/black](https://github.com/psf/black) |  |
| bob | [ubi:MordechaiHadad/bob](https://github.com/MordechaiHadad/bob)<br>[cargo:bob-nvim](https://crates.io/crates/bob-nvim) |  |
| boilerplate | [aqua:gruntwork-io/boilerplate](https://github.com/gruntwork-io/boilerplate) |  |
| bombardier | [aqua:codesenberg/bombardier](https://github.com/codesenberg/bombardier)<br>[asdf:NeoHsu/asdf-bombardier](https://github.com/NeoHsu/asdf-bombardier) |  |
| borg | [aqua:borgbackup/borg](https://github.com/borgbackup/borg)<br>[asdf:lwiechec/asdf-borg](https://github.com/lwiechec/asdf-borg) |  |
| bosh | [aqua:cloudfoundry/bosh-cli](https://github.com/cloudfoundry/bosh-cli)<br>[asdf:mise-plugins/tanzu-plug-in-for-asdf](https://github.com/mise-plugins/tanzu-plug-in-for-asdf) |  |
| bosh-backup-and-restore | [ubi:cloudfoundry-incubator/bosh-backup-and-restore](https://github.com/cloudfoundry-incubator/bosh-backup-and-restore)<br>[asdf:mise-plugins/tanzu-plug-in-for-asdf](https://github.com/mise-plugins/tanzu-plug-in-for-asdf) | linux, macos |
| bottom | [aqua:ClementTsang/bottom](https://github.com/ClementTsang/bottom)<br>[asdf:carbonteq/asdf-btm](https://github.com/carbonteq/asdf-btm) |  |
| boundary | [aqua:hashicorp/boundary](https://github.com/hashicorp/boundary)<br>[asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| bpkg | [asdf:mise-plugins/mise-bpkg](https://github.com/mise-plugins/mise-bpkg) |  |
| brig | [aqua:brigadecore/brigade](https://github.com/brigadecore/brigade)<br>[asdf:Ibotta/asdf-brig](https://github.com/Ibotta/asdf-brig) |  |
| btop | [aqua:aristocratos/btop](https://github.com/aristocratos/btop)<br>[ubi:aristocratos/btop](https://github.com/aristocratos/btop) |  |
| btrace | [asdf:mise-plugins/mise-btrace](https://github.com/mise-plugins/mise-btrace) |  |
| buf | [aqua:bufbuild/buf](https://github.com/bufbuild/buf)<br>[ubi:bufbuild/buf](https://github.com/bufbuild/buf)<br>[asdf:truepay/asdf-buf](https://github.com/truepay/asdf-buf) |  |
| buildifier | [aqua:bazelbuild/buildtools/buildifier](https://github.com/bazelbuild/buildtools) |  |
| buildpack | [aqua:buildpacks/pack](https://github.com/buildpacks/pack)<br>[asdf:johnlayton/asdf-buildpack](https://github.com/johnlayton/asdf-buildpack) |  |
| bun | [core:bun](https://mise.jdx.dev/lang/bun.html) |  |
| cabal | [aqua:haskell/cabal/cabal-install](https://github.com/haskell/cabal) |  |
| caddy | [aqua:caddyserver/caddy](https://github.com/caddyserver/caddy)<br>[asdf:salasrod/asdf-caddy](https://github.com/salasrod/asdf-caddy) |  |
| calendarsync | [aqua:inovex/CalendarSync](https://github.com/inovex/CalendarSync)<br>[ubi:inovex/CalendarSync](https://github.com/inovex/CalendarSync)<br>[asdf:FeryET/asdf-calendarsync](https://github.com/FeryET/asdf-calendarsync) |  |
| calicoctl | [aqua:projectcalico/calico/calicoctl](https://github.com/projectcalico/calico)<br>[asdf:TheCubicleJockey/asdf-calicoctl](https://github.com/TheCubicleJockey/asdf-calicoctl) |  |
| carapace | [aqua:carapace-sh/carapace-bin](https://github.com/carapace-sh/carapace-bin) |  |
| cargo-binstall | [aqua:cargo-bins/cargo-binstall](https://github.com/cargo-bins/cargo-binstall)<br>[ubi:cargo-bins/cargo-binstall](https://github.com/cargo-bins/cargo-binstall)<br>[cargo:cargo-binstall](https://crates.io/crates/cargo-binstall) |  |
| cargo-insta | [aqua:mitsuhiko/insta](https://github.com/mitsuhiko/insta)<br>[ubi:mitsuhiko/insta](https://github.com/mitsuhiko/insta) |  |
| cargo-make | [aqua:sagiegurari/cargo-make](https://github.com/sagiegurari/cargo-make)<br>[ubi:sagiegurari/cargo-make](https://github.com/sagiegurari/cargo-make)<br>[asdf:mise-plugins/asdf-cargo-make](https://github.com/mise-plugins/asdf-cargo-make) |  |
| carp | [ubi:carp-lang/Carp](https://github.com/carp-lang/Carp)<br>[asdf:susurri/asdf-carp](https://github.com/susurri/asdf-carp) |  |
| carthage | [asdf:mise-plugins/mise-carthage](https://github.com/mise-plugins/mise-carthage) |  |
| ccache | [ubi:ccache/ccache](https://github.com/ccache/ccache)<br>[asdf:asdf-community/asdf-ccache](https://github.com/asdf-community/asdf-ccache) |  |
| certstrap | [ubi:square/certstrap](https://github.com/square/certstrap)<br>[asdf:carnei-ro/asdf-certstrap](https://github.com/carnei-ro/asdf-certstrap) |  |
| cf | [asdf:mise-plugins/mise-cf](https://github.com/mise-plugins/mise-cf) |  |
| cfn-lint | [pipx:cfn-lint](https://pypi.org/project/cfn-lint) |  |
| cfssl | [aqua:cloudflare/cfssl/cfssl](https://github.com/cloudflare/cfssl)<br>[asdf:mathew-fleisch/asdf-cfssl](https://github.com/mathew-fleisch/asdf-cfssl) |  |
| chamber | [aqua:segmentio/chamber](https://github.com/segmentio/chamber)<br>[ubi:segmentio/chamber](https://github.com/segmentio/chamber)<br>[asdf:mintel/asdf-chamber](https://github.com/mintel/asdf-chamber) |  |
| changie | [aqua:miniscruff/changie](https://github.com/miniscruff/changie)<br>[ubi:miniscruff/changie](https://github.com/miniscruff/changie)<br>[asdf:pdemagny/asdf-changie](https://github.com/pdemagny/asdf-changie) |  |
| cheat | [aqua:cheat/cheat](https://github.com/cheat/cheat)<br>[asdf:jmoratilla/asdf-cheat-plugin](https://github.com/jmoratilla/asdf-cheat-plugin) |  |
| checkmake | [aqua:mrtazz/checkmake](https://github.com/mrtazz/checkmake) |  |
| checkov | [aqua:bridgecrewio/checkov](https://github.com/bridgecrewio/checkov)<br>[ubi:bridgecrewio/checkov](https://github.com/bridgecrewio/checkov)<br>[asdf:bosmak/asdf-checkov](https://github.com/bosmak/asdf-checkov) |  |
| chezmoi | [aqua:twpayne/chezmoi](https://github.com/twpayne/chezmoi)<br>[ubi:twpayne/chezmoi](https://github.com/twpayne/chezmoi)<br>[asdf:joke/asdf-chezmoi](https://github.com/joke/asdf-chezmoi) |  |
| chezscheme | [asdf:mise-plugins/mise-chezscheme](https://github.com/mise-plugins/mise-chezscheme) |  |
| chicken | [asdf:mise-plugins/mise-chicken](https://github.com/mise-plugins/mise-chicken) |  |
| chisel | [aqua:jpillora/chisel](https://github.com/jpillora/chisel)<br>[ubi:jpillora/chisel](https://github.com/jpillora/chisel)<br>[go:github.com/jpillora/chisel](https://pkg.go.dev/github.com/jpillora/chisel)<br>[asdf:lwiechec/asdf-chisel](https://github.com/lwiechec/asdf-chisel) |  |
| choose | [aqua:theryangeary/choose](https://github.com/theryangeary/choose)<br>[ubi:theryangeary/choose](https://github.com/theryangeary/choose)<br>[cargo:choose](https://crates.io/crates/choose)<br>[asdf:carbonteq/asdf-choose](https://github.com/carbonteq/asdf-choose) |  |
| chromedriver | [asdf:mise-plugins/mise-chromedriver](https://github.com/mise-plugins/mise-chromedriver) |  |
| cidr-merger | [ubi:zhanhb/cidr-merger](https://github.com/zhanhb/cidr-merger)<br>[asdf:ORCID/asdf-cidr-merger](https://github.com/ORCID/asdf-cidr-merger) |  |
| cidrchk | [ubi:mhausenblas/cidrchk](https://github.com/mhausenblas/cidrchk)<br>[asdf:ORCID/asdf-cidrchk](https://github.com/ORCID/asdf-cidrchk) |  |
| cilium-cli | [aqua:cilium/cilium-cli](https://github.com/cilium/cilium-cli)<br>[ubi:cilium/cilium-cli](https://github.com/cilium/cilium-cli)<br>[asdf:carnei-ro/asdf-cilium-cli](https://github.com/carnei-ro/asdf-cilium-cli) |  |
| cilium-hubble | [ubi:cilium/hubble](https://github.com/cilium/hubble)<br>[asdf:NitriKx/asdf-cilium-hubble](https://github.com/NitriKx/asdf-cilium-hubble) |  |
| circleci | [aqua:CircleCI-Public/circleci-cli](https://github.com/CircleCI-Public/circleci-cli)<br>[ubi:CircleCI-Public/circleci-cli](https://github.com/CircleCI-Public/circleci-cli)<br>[asdf:ucpr/asdf-circleci-cli](https://github.com/ucpr/asdf-circleci-cli) |  |
| clang | [asdf:mise-plugins/mise-llvm](https://github.com/mise-plugins/mise-llvm)<br>[vfox:mise-plugins/vfox-clang](https://github.com/mise-plugins/vfox-clang) |  |
| clang-format | [asdf:mise-plugins/mise-llvm](https://github.com/mise-plugins/mise-llvm) |  |
| clangd | [asdf:mise-plugins/mise-llvm](https://github.com/mise-plugins/mise-llvm) |  |
| clarinet | [ubi:hirosystems/clarinet](https://github.com/hirosystems/clarinet)<br>[asdf:alexgo-io/asdf-clarinet](https://github.com/alexgo-io/asdf-clarinet) | linux, macos |
| claude | [npm:@anthropic-ai/claude-code](https://www.npmjs.com/package/@anthropic-ai/claude-code) |  |
| cli53 | [aqua:barnybug/cli53](https://github.com/barnybug/cli53) |  |
| clickhouse | [asdf:mise-plugins/mise-clickhouse](https://github.com/mise-plugins/mise-clickhouse) |  |
| clj-kondo | [ubi:clj-kondo/clj-kondo](https://github.com/clj-kondo/clj-kondo)<br>[asdf:rynkowsg/asdf-clj-kondo](https://github.com/rynkowsg/asdf-clj-kondo) |  |
| cljstyle | [ubi:greglook/cljstyle](https://github.com/greglook/cljstyle)<br>[asdf:abogoyavlensky/asdf-cljstyle](https://github.com/abogoyavlensky/asdf-cljstyle) | linux, macos |
| clojure | [asdf:mise-plugins/mise-clojure](https://github.com/mise-plugins/mise-clojure) |  |
| cloud-sql-proxy | [aqua:GoogleCloudPlatform/cloud-sql-proxy](https://github.com/GoogleCloudPlatform/cloud-sql-proxy)<br>[asdf:pbr0ck3r/asdf-cloud-sql-proxy](https://github.com/pbr0ck3r/asdf-cloud-sql-proxy) |  |
| cloudflared | [aqua:cloudflare/cloudflared](https://github.com/cloudflare/cloudflared)<br>[asdf:threkk/asdf-cloudflared](https://github.com/threkk/asdf-cloudflared) |  |
| clusterawsadm | [ubi:kubernetes-sigs/cluster-api-provider-aws](https://github.com/kubernetes-sigs/cluster-api-provider-aws)<br>[asdf:kahun/asdf-clusterawsadm](https://github.com/kahun/asdf-clusterawsadm) |  |
| clusterctl | [aqua:kubernetes-sigs/cluster-api](https://github.com/kubernetes-sigs/cluster-api)<br>[asdf:pfnet-research/asdf-clusterctl](https://github.com/pfnet-research/asdf-clusterctl) |  |
| cmake | [asdf:mise-plugins/mise-cmake](https://github.com/mise-plugins/mise-cmake)<br>[vfox:mise-plugins/vfox-cmake](https://github.com/mise-plugins/vfox-cmake) |  |
| cmctl | [aqua:cert-manager/cmctl](https://github.com/cert-manager/cmctl)<br>[asdf:asdf-community/asdf-cmctl](https://github.com/asdf-community/asdf-cmctl) |  |
| cmdx | [aqua:suzuki-shunsuke/cmdx](https://github.com/suzuki-shunsuke/cmdx)<br>[ubi:suzuki-shunsuke/cmdx](https://github.com/suzuki-shunsuke/cmdx) |  |
| cockroach | [aqua:cockroachdb/cockroach](https://github.com/cockroachdb/cockroach)<br>[asdf:salasrod/asdf-cockroach](https://github.com/salasrod/asdf-cockroach) |  |
| cocoapods | [asdf:mise-plugins/mise-cocoapods](https://github.com/mise-plugins/mise-cocoapods) |  |
| cocogitto | [aqua:cocogitto/cocogitto](https://github.com/cocogitto/cocogitto) |  |
| codebuff | [npm:codebuff](https://www.npmjs.com/package/codebuff) |  |
| codefresh | [ubi:codefresh-io/cli](https://github.com/codefresh-io/cli)<br>[asdf:gurukulkarni/asdf-codefresh](https://github.com/gurukulkarni/asdf-codefresh) |  |
| codeql | [asdf:mise-plugins/mise-codeql](https://github.com/mise-plugins/mise-codeql) |  |
| coder | [aqua:coder/coder](https://github.com/coder/coder)<br>[asdf:mise-plugins/asdf-coder](https://github.com/mise-plugins/asdf-coder) |  |
| colima | [aqua:abiosoft/colima](https://github.com/abiosoft/colima)<br>[ubi:abiosoft/colima](https://github.com/abiosoft/colima)<br>[asdf:CrouchingMuppet/asdf-colima](https://github.com/CrouchingMuppet/asdf-colima) |  |
| committed | [aqua:crate-ci/committed](https://github.com/crate-ci/committed) |  |
| conan | [pipx:conan](https://pypi.org/project/conan)<br>[asdf:mise-plugins/mise-pyapp](https://github.com/mise-plugins/mise-pyapp) |  |
| concourse | [aqua:concourse/concourse/concourse](https://github.com/concourse/concourse)<br>[asdf:mattysweeps/asdf-concourse](https://github.com/mattysweeps/asdf-concourse) |  |
| conduit | [ubi:ConduitIO/conduit](https://github.com/ConduitIO/conduit)<br>[asdf:gmcabrita/asdf-conduit](https://github.com/gmcabrita/asdf-conduit) |  |
| conform | [aqua:siderolabs/conform](https://github.com/siderolabs/conform)<br>[asdf:skyzyx/asdf-conform](https://github.com/skyzyx/asdf-conform) | linux, macos |
| conftest | [aqua:open-policy-agent/conftest](https://github.com/open-policy-agent/conftest)<br>[asdf:looztra/asdf-conftest](https://github.com/looztra/asdf-conftest) |  |
| consul | [aqua:hashicorp/consul](https://github.com/hashicorp/consul)<br>[asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| container | [aqua:apple/container](https://github.com/apple/container)<br>[ubi:apple/container](https://github.com/apple/container) | macos |
| container-structure-test | [aqua:GoogleContainerTools/container-structure-test](https://github.com/GoogleContainerTools/container-structure-test)<br>[asdf:FeryET/asdf-container-structure-test](https://github.com/FeryET/asdf-container-structure-test) |  |
| cookiecutter | [pipx:cookiecutter](https://pypi.org/project/cookiecutter)<br>[asdf:shawon-crosen/asdf-cookiecutter](https://github.com/shawon-crosen/asdf-cookiecutter) |  |
| copier | [pipx:copier](https://pypi.org/project/copier)<br>[asdf:looztra/asdf-copier](https://github.com/looztra/asdf-copier) |  |
| copper | [aqua:cloud66-oss/copper](https://github.com/cloud66-oss/copper)<br>[ubi:cloud66-oss/copper](https://github.com/cloud66-oss/copper)<br>[asdf:vladlosev/asdf-copper](https://github.com/vladlosev/asdf-copper) | linux, macos |
| coq | [asdf:mise-plugins/mise-coq](https://github.com/mise-plugins/mise-coq) |  |
| coredns | [ubi:coredns/coredns](https://github.com/coredns/coredns)<br>[asdf:s3than/asdf-coredns](https://github.com/s3than/asdf-coredns) |  |
| coreutils | [aqua:uutils/coreutils](https://github.com/uutils/coreutils)<br>[ubi:uutils/coreutils](https://github.com/uutils/coreutils) |  |
| cosign | [aqua:sigstore/cosign](https://github.com/sigstore/cosign)<br>[asdf:https://gitlab.com/wt0f/asdf-cosign](https://gitlab.com/wt0f/asdf-cosign) |  |
| coursier | [ubi:coursier/coursier](https://github.com/coursier/coursier)<br>[asdf:jiahuili430/asdf-coursier](https://github.com/jiahuili430/asdf-coursier) |  |
| cowsay | [npm:cowsay](https://www.npmjs.com/package/cowsay) |  |
| crane | [aqua:google/go-containerregistry](https://github.com/google/go-containerregistry)<br>[ubi:google/go-containerregistry](https://github.com/google/go-containerregistry)<br>[asdf:dmpe/asdf-crane](https://github.com/dmpe/asdf-crane) |  |
| crc | [asdf:mise-plugins/mise-crc](https://github.com/mise-plugins/mise-crc) |  |
| credhub | [aqua:cloudfoundry/credhub-cli](https://github.com/cloudfoundry/credhub-cli)<br>[asdf:mise-plugins/tanzu-plug-in-for-asdf](https://github.com/mise-plugins/tanzu-plug-in-for-asdf) |  |
| crictl | [aqua:kubernetes-sigs/cri-tools/crictl](https://github.com/kubernetes-sigs/cri-tools)<br>[asdf:FairwindsOps/asdf-crictl](https://github.com/FairwindsOps/asdf-crictl) |  |
| crossplane | [aqua:crossplane/crossplane](https://github.com/crossplane/crossplane)<br>[asdf:joke/asdf-crossplane-cli](https://github.com/joke/asdf-crossplane-cli) |  |
| crystal | [asdf:mise-plugins/mise-crystal](https://github.com/mise-plugins/mise-crystal)<br>[vfox:mise-plugins/vfox-crystal](https://github.com/mise-plugins/vfox-crystal) |  |
| cspell | [npm:cspell](https://www.npmjs.com/package/cspell) |  |
| ctlptl | [aqua:tilt-dev/ctlptl](https://github.com/tilt-dev/ctlptl)<br>[asdf:ezcater/asdf-ctlptl](https://github.com/ezcater/asdf-ctlptl) |  |
| ctop | [aqua:bcicen/ctop](https://github.com/bcicen/ctop)<br>[ubi:bcicen/ctop](https://github.com/bcicen/ctop)<br>[asdf:NeoHsu/asdf-ctop](https://github.com/NeoHsu/asdf-ctop) |  |
| cue | [aqua:cue-lang/cue](https://github.com/cue-lang/cue)<br>[asdf:asdf-community/asdf-cue](https://github.com/asdf-community/asdf-cue) |  |
| curlie | [aqua:rs/curlie](https://github.com/rs/curlie) |  |
| cyclonedx | [aqua:CycloneDX/cyclonedx-cli](https://github.com/CycloneDX/cyclonedx-cli)<br>[asdf:xeedio/asdf-cyclonedx](https://github.com/xeedio/asdf-cyclonedx) |  |
| dagger | [aqua:dagger/dagger](https://github.com/dagger/dagger)<br>[asdf:virtualstaticvoid/asdf-dagger](https://github.com/virtualstaticvoid/asdf-dagger) |  |
| dagu | [aqua:dagu-org/dagu](https://github.com/dagu-org/dagu)<br>[ubi:dagu-org/dagu](https://github.com/dagu-org/dagu) |  |
| danger-js | [asdf:mise-plugins/mise-danger-js](https://github.com/mise-plugins/mise-danger-js) |  |
| danger-swift | [spm:danger/swift](https://mise.jdx.dev/registry.html) |  |
| dapr | [aqua:dapr/cli](https://github.com/dapr/cli)<br>[asdf:asdf-community/asdf-dapr-cli](https://github.com/asdf-community/asdf-dapr-cli) |  |
| dart | [asdf:mise-plugins/mise-dart](https://github.com/mise-plugins/mise-dart)<br>[vfox:mise-plugins/vfox-dart](https://github.com/mise-plugins/vfox-dart) |  |
| dasel | [aqua:TomWright/dasel](https://github.com/TomWright/dasel)<br>[asdf:asdf-community/asdf-dasel](https://github.com/asdf-community/asdf-dasel) |  |
| databricks-cli | [ubi:databricks/cli](https://github.com/databricks/cli) |  |
| datree | [aqua:datreeio/datree](https://github.com/datreeio/datree)<br>[asdf:lukeab/asdf-datree](https://github.com/lukeab/asdf-datree) |  |
| daytona | [asdf:mise-plugins/mise-daytona](https://github.com/mise-plugins/mise-daytona) |  |
| dbmate | [aqua:amacneil/dbmate](https://github.com/amacneil/dbmate)<br>[asdf:juusujanar/asdf-dbmate](https://github.com/juusujanar/asdf-dbmate) |  |
| deck | [aqua:Kong/deck](https://github.com/Kong/deck)<br>[asdf:nutellinoit/asdf-deck](https://github.com/nutellinoit/asdf-deck) |  |
| delta | [aqua:dandavison/delta](https://github.com/dandavison/delta)<br>[ubi:dandavison/delta](https://github.com/dandavison/delta)<br>[asdf:andweeb/asdf-delta](https://github.com/andweeb/asdf-delta)<br>[cargo:git-delta](https://crates.io/crates/git-delta) |  |
| deno | [core:deno](https://mise.jdx.dev/lang/deno.html) |  |
| depot | [ubi:depot/cli](https://github.com/depot/cli)<br>[asdf:depot/asdf-depot](https://github.com/depot/asdf-depot) |  |
| desk | [aqua:jamesob/desk](https://github.com/jamesob/desk)<br>[asdf:endorama/asdf-desk](https://github.com/endorama/asdf-desk) | linux, macos |
| devspace | [aqua:devspace-sh/devspace](https://github.com/devspace-sh/devspace)<br>[asdf:NeoHsu/asdf-devspace](https://github.com/NeoHsu/asdf-devspace) |  |
| dhall | [asdf:mise-plugins/mise-dhall](https://github.com/mise-plugins/mise-dhall) |  |
| diffoci | [aqua:reproducible-containers/diffoci](https://github.com/reproducible-containers/diffoci) |  |
| difftastic | [aqua:Wilfred/difftastic](https://github.com/Wilfred/difftastic)<br>[ubi:Wilfred/difftastic](https://github.com/Wilfred/difftastic)<br>[asdf:volf52/asdf-difftastic](https://github.com/volf52/asdf-difftastic) |  |
| digdag | [asdf:mise-plugins/mise-digdag](https://github.com/mise-plugins/mise-digdag) |  |
| direnv | [aqua:direnv/direnv](https://github.com/direnv/direnv)<br>[asdf:asdf-community/asdf-direnv](https://github.com/asdf-community/asdf-direnv) |  |
| dive | [aqua:wagoodman/dive](https://github.com/wagoodman/dive)<br>[ubi:wagoodman/dive](https://github.com/wagoodman/dive)<br>[asdf:looztra/asdf-dive](https://github.com/looztra/asdf-dive) |  |
| djinni | [ubi:cross-language-cpp/djinni-generator](https://github.com/cross-language-cpp/djinni-generator)<br>[asdf:cross-language-cpp/asdf-djinni](https://github.com/cross-language-cpp/asdf-djinni) |  |
| dmd | [asdf:mise-plugins/mise-dmd](https://github.com/mise-plugins/mise-dmd) |  |
| docker-cli | [aqua:docker/cli](https://github.com/docker/cli) |  |
| docker-compose | [aqua:docker/compose](https://github.com/docker/compose) |  |
| docker-slim | [aqua:mintoolkit/mint](https://github.com/mintoolkit/mint)<br>[ubi:mintoolkit/mint](https://github.com/mintoolkit/mint)<br>[asdf:xataz/asdf-docker-slim](https://github.com/xataz/asdf-docker-slim) | linux, macos |
| dockle | [aqua:goodwithtech/dockle](https://github.com/goodwithtech/dockle)<br>[asdf:mathew-fleisch/asdf-dockle](https://github.com/mathew-fleisch/asdf-dockle) |  |
| doctl | [aqua:digitalocean/doctl](https://github.com/digitalocean/doctl)<br>[ubi:digitalocean/doctl](https://github.com/digitalocean/doctl)<br>[asdf:maristgeek/asdf-doctl](https://github.com/maristgeek/asdf-doctl) |  |
| doctoolchain | [asdf:mise-plugins/mise-doctoolchain](https://github.com/mise-plugins/mise-doctoolchain) |  |
| docuum | [aqua:stepchowfun/docuum](https://github.com/stepchowfun/docuum)<br>[ubi:stepchowfun/docuum](https://github.com/stepchowfun/docuum)<br>[cargo:docuum](https://crates.io/crates/docuum)<br>[asdf:bradym/asdf-docuum](https://github.com/bradym/asdf-docuum) |  |
| doggo | [aqua:mr-karan/doggo](https://github.com/mr-karan/doggo)<br>[ubi:mr-karan/doggo](https://github.com/mr-karan/doggo) |  |
| dome | [asdf:mise-plugins/mise-dome](https://github.com/mise-plugins/mise-dome) |  |
| doppler | [ubi:DopplerHQ/cli](https://github.com/DopplerHQ/cli)<br>[asdf:takutakahashi/asdf-doppler](https://github.com/takutakahashi/asdf-doppler) |  |
| dotenv-linter | [aqua:dotenv-linter/dotenv-linter](https://github.com/dotenv-linter/dotenv-linter)<br>[ubi:dotenv-linter/dotenv-linter](https://github.com/dotenv-linter/dotenv-linter)<br>[asdf:wesleimp/asdf-dotenv-linter](https://github.com/wesleimp/asdf-dotenv-linter) |  |
| dotenvx | [aqua:dotenvx/dotenvx](https://github.com/dotenvx/dotenvx)<br>[ubi:dotenvx/dotenvx](https://github.com/dotenvx/dotenvx) |  |
| dotnet | [asdf:mise-plugins/mise-dotnet](https://github.com/mise-plugins/mise-dotnet)<br>[vfox:mise-plugins/vfox-dotnet](https://github.com/mise-plugins/vfox-dotnet) |  |
| dotnet-core | [asdf:mise-plugins/mise-dotnet-core](https://github.com/mise-plugins/mise-dotnet-core) |  |
| dotslash | [ubi:facebook/dotslash](https://github.com/facebook/dotslash) |  |
| dotty | [asdf:mise-plugins/mise-dotty](https://github.com/mise-plugins/mise-dotty) |  |
| dprint | [aqua:dprint/dprint](https://github.com/dprint/dprint)<br>[asdf:asdf-community/asdf-dprint](https://github.com/asdf-community/asdf-dprint) |  |
| draft | [aqua:Azure/draft](https://github.com/Azure/draft)<br>[asdf:kristoflemmens/asdf-draft](https://github.com/kristoflemmens/asdf-draft) |  |
| driftctl | [aqua:snyk/driftctl](https://github.com/snyk/driftctl)<br>[asdf:nlamirault/asdf-driftctl](https://github.com/nlamirault/asdf-driftctl) |  |
| drone | [aqua:harness/drone-cli](https://github.com/harness/drone-cli)<br>[ubi:harness/drone-cli](https://github.com/harness/drone-cli)<br>[asdf:virtualstaticvoid/asdf-drone](https://github.com/virtualstaticvoid/asdf-drone) |  |
| dt | [aqua:so-dang-cool/dt](https://github.com/so-dang-cool/dt)<br>[asdf:so-dang-cool/asdf-dt](https://github.com/so-dang-cool/asdf-dt) |  |
| dtm | [ubi:devstream-io/devstream](https://github.com/devstream-io/devstream)<br>[asdf:zhenyuanlau/asdf-dtm](https://github.com/zhenyuanlau/asdf-dtm) |  |
| dua | [aqua:Byron/dua-cli](https://github.com/Byron/dua-cli)<br>[ubi:Byron/dua-cli](https://github.com/Byron/dua-cli) |  |
| duckdb | [aqua:duckdb/duckdb](https://github.com/duckdb/duckdb)<br>[ubi:duckdb/duckdb](https://github.com/duckdb/duckdb) |  |
| duf | [aqua:muesli/duf](https://github.com/muesli/duf)<br>[asdf:NeoHsu/asdf-duf](https://github.com/NeoHsu/asdf-duf) |  |
| dust | [aqua:bootandy/dust](https://github.com/bootandy/dust)<br>[ubi:bootandy/dust](https://github.com/bootandy/dust)<br>[asdf:looztra/asdf-dust](https://github.com/looztra/asdf-dust) |  |
| dvc | [asdf:mise-plugins/mise-dvc](https://github.com/mise-plugins/mise-dvc) |  |
| dyff | [aqua:homeport/dyff](https://github.com/homeport/dyff)<br>[asdf:https://gitlab.com/wt0f/asdf-dyff](https://gitlab.com/wt0f/asdf-dyff) |  |
| dynatrace-monaco | [ubi:Dynatrace/dynatrace-configuration-as-code](https://github.com/Dynatrace/dynatrace-configuration-as-code)<br>[asdf:nsaputro/asdf-monaco](https://github.com/nsaputro/asdf-monaco) |  |
| e1s | [asdf:tbobm/asdf-e1s](https://github.com/tbobm/asdf-e1s) |  |
| earthly | [aqua:earthly/earthly](https://github.com/earthly/earthly)<br>[asdf:YR-ZR0/asdf-earthly](https://github.com/YR-ZR0/asdf-earthly) |  |
| ecspresso | [aqua:kayac/ecspresso](https://github.com/kayac/ecspresso)<br>[asdf:kayac/asdf-ecspresso](https://github.com/kayac/asdf-ecspresso) |  |
| edit | [aqua:microsoft/edit](https://github.com/microsoft/edit) |  |
| editorconfig-checker | [aqua:editorconfig-checker/editorconfig-checker](https://github.com/editorconfig-checker/editorconfig-checker)<br>[ubi:editorconfig-checker/editorconfig-checker](https://github.com/editorconfig-checker/editorconfig-checker)<br>[asdf:gabitchov/asdf-editorconfig-checker](https://github.com/gabitchov/asdf-editorconfig-checker) |  |
| ejson | [aqua:Shopify/ejson](https://github.com/Shopify/ejson)<br>[asdf:cipherstash/asdf-ejson](https://github.com/cipherstash/asdf-ejson) |  |
| eksctl | [aqua:eksctl-io/eksctl](https://github.com/eksctl-io/eksctl)<br>[asdf:elementalvoid/asdf-eksctl](https://github.com/elementalvoid/asdf-eksctl) |  |
| elasticsearch | [asdf:mise-plugins/mise-elasticsearch](https://github.com/mise-plugins/mise-elasticsearch) |  |
| elixir | [core:elixir](https://mise.jdx.dev/lang/elixir.html) |  |
| elixir-ls | [asdf:mise-plugins/mise-elixir-ls](https://github.com/mise-plugins/mise-elixir-ls) |  |
| elm | [ubi:elm/compiler](https://github.com/elm/compiler)<br>[asdf:asdf-community/asdf-elm](https://github.com/asdf-community/asdf-elm) |  |
| emsdk | [asdf:mise-plugins/mise-emsdk](https://github.com/mise-plugins/mise-emsdk) |  |
| envcli | [aqua:EnvCLI/EnvCLI](https://github.com/EnvCLI/EnvCLI)<br>[ubi:EnvCLI/EnvCLI](https://github.com/EnvCLI/EnvCLI)<br>[asdf:zekker6/asdf-envcli](https://github.com/zekker6/asdf-envcli) |  |
| envsubst | [aqua:a8m/envsubst](https://github.com/a8m/envsubst)<br>[asdf:dex4er/asdf-envsubst](https://github.com/dex4er/asdf-envsubst) |  |
| ephemeral-postgres | [asdf:mise-plugins/mise-ephemeral-postgres](https://github.com/mise-plugins/mise-ephemeral-postgres) |  |
| erlang | [core:erlang](https://mise.jdx.dev/lang/erlang.html) |  |
| esc | [aqua:pulumi/esc](https://github.com/pulumi/esc)<br>[ubi:pulumi/esc](https://github.com/pulumi/esc)<br>[asdf:fxsalazar/asdf-esc](https://github.com/fxsalazar/asdf-esc) |  |
| esy | [asdf:mise-plugins/mise-esy](https://github.com/mise-plugins/mise-esy) |  |
| etcd | [aqua:etcd-io/etcd](https://github.com/etcd-io/etcd)<br>[asdf:particledecay/asdf-etcd](https://github.com/particledecay/asdf-etcd)<br>[vfox:mise-plugins/vfox-etcd](https://github.com/mise-plugins/vfox-etcd) |  |
| evans | [aqua:ktr0731/evans](https://github.com/ktr0731/evans)<br>[asdf:goki90210/asdf-evans](https://github.com/goki90210/asdf-evans) |  |
| eza | [aqua:eza-community/eza](https://github.com/eza-community/eza)<br>[asdf:mise-plugins/mise-eza](https://github.com/mise-plugins/mise-eza)<br>[cargo:eza](https://crates.io/crates/eza) |  |
| fastfetch | [aqua:fastfetch-cli/fastfetch](https://github.com/fastfetch-cli/fastfetch) |  |
| fd | [aqua:sharkdp/fd](https://github.com/sharkdp/fd)<br>[ubi:sharkdp/fd](https://github.com/sharkdp/fd)<br>[asdf:https://gitlab.com/wt0f/asdf-fd](https://gitlab.com/wt0f/asdf-fd)<br>[cargo:fd-find](https://crates.io/crates/fd-find) |  |
| ffmpeg | [asdf:mise-plugins/mise-ffmpeg](https://github.com/mise-plugins/mise-ffmpeg) |  |
| figma-export | [ubi:RedMadRobot/figma-export](https://github.com/RedMadRobot/figma-export)<br>[asdf:younke/asdf-figma-export](https://github.com/younke/asdf-figma-export) |  |
| fillin | [aqua:itchyny/fillin](https://github.com/itchyny/fillin)<br>[asdf:ouest/asdf-fillin](https://github.com/ouest/asdf-fillin) |  |
| firebase | [aqua:firebase/firebase-tools](https://github.com/firebase/firebase-tools)<br>[asdf:jthegedus/asdf-firebase](https://github.com/jthegedus/asdf-firebase) |  |
| fission | [aqua:fission/fission](https://github.com/fission/fission)<br>[asdf:virtualstaticvoid/asdf-fission](https://github.com/virtualstaticvoid/asdf-fission) |  |
| flamingo | [ubi:flux-subsystem-argo/flamingo](https://github.com/flux-subsystem-argo/flamingo)<br>[asdf:log2/asdf-flamingo](https://github.com/log2/asdf-flamingo) |  |
| flarectl | [ubi:cloudflare/cloudflare-go](https://github.com/cloudflare/cloudflare-go)<br>[asdf:mise-plugins/asdf-flarectl](https://github.com/mise-plugins/asdf-flarectl) |  |
| flatc | [ubi:google/flatbuffers](https://github.com/google/flatbuffers)<br>[asdf:TheOpenDictionary/asdf-flatc](https://github.com/TheOpenDictionary/asdf-flatc) |  |
| flutter | [asdf:mise-plugins/mise-flutter](https://github.com/mise-plugins/mise-flutter)<br>[vfox:mise-plugins/vfox-flutter](https://github.com/mise-plugins/vfox-flutter) |  |
| fluttergen | [ubi:FlutterGen/flutter\_gen](https://github.com/FlutterGen/flutter_gen)<br>[asdf:FlutterGen/asdf-fluttergen](https://github.com/FlutterGen/asdf-fluttergen) | linux, macos |
| flux2 | [aqua:fluxcd/flux2](https://github.com/fluxcd/flux2)<br>[asdf:tablexi/asdf-flux2](https://github.com/tablexi/asdf-flux2) |  |
| fly | [aqua:concourse/concourse/fly](https://github.com/concourse/concourse)<br>[asdf:mise-plugins/tanzu-plug-in-for-asdf](https://github.com/mise-plugins/tanzu-plug-in-for-asdf) |  |
| flyctl | [aqua:superfly/flyctl](https://github.com/superfly/flyctl)<br>[ubi:superfly/flyctl](https://github.com/superfly/flyctl)<br>[asdf:chessmango/asdf-flyctl](https://github.com/chessmango/asdf-flyctl) |  |
| flyway | [asdf:mise-plugins/mise-flyway](https://github.com/mise-plugins/mise-flyway) |  |
| foundry | [aqua:foundry-rs/foundry](https://github.com/foundry-rs/foundry)<br>[ubi:foundry-rs/foundry](https://github.com/foundry-rs/foundry) |  |
| func-e | [ubi:tetratelabs/func-e](https://github.com/tetratelabs/func-e)<br>[asdf:mise-plugins/mise-func-e](https://github.com/mise-plugins/mise-func-e) |  |
| furyctl | [ubi:sighupio/furyctl](https://github.com/sighupio/furyctl)<br>[asdf:sighupio/asdf-furyctl](https://github.com/sighupio/asdf-furyctl) | linux, macos |
| fx | [aqua:antonmedv/fx](https://github.com/antonmedv/fx)<br>[asdf:https://gitlab.com/wt0f/asdf-fx](https://gitlab.com/wt0f/asdf-fx) |  |
| fzf | [aqua:junegunn/fzf](https://github.com/junegunn/fzf)<br>[ubi:junegunn/fzf](https://github.com/junegunn/fzf)<br>[asdf:kompiro/asdf-fzf](https://github.com/kompiro/asdf-fzf) |  |
| gallery-dl | [asdf:mise-plugins/mise-gallery-dl](https://github.com/mise-plugins/mise-gallery-dl) |  |
| gam | [ubi:GAM-team/GAM](https://github.com/GAM-team/GAM)<br>[asdf:offbyone/asdf-gam](https://github.com/offbyone/asdf-gam) |  |
| gator | [aqua:open-policy-agent/gatekeeper](https://github.com/open-policy-agent/gatekeeper)<br>[ubi:open-policy-agent/gatekeeper](https://github.com/open-policy-agent/gatekeeper)<br>[asdf:MxNxPx/asdf-gator](https://github.com/MxNxPx/asdf-gator) |  |
| gauche | [asdf:mise-plugins/mise-gauche](https://github.com/mise-plugins/mise-gauche) |  |
| gcc-arm-none-eabi | [asdf:mise-plugins/mise-gcc-arm-none-eabi](https://github.com/mise-plugins/mise-gcc-arm-none-eabi) |  |
| gcloud | [asdf:mise-plugins/mise-gcloud](https://github.com/mise-plugins/mise-gcloud) |  |
| gdu | [aqua:dundee/gdu](https://github.com/dundee/gdu) |  |
| gemini-cli | [npm:@google/gemini-cli](https://www.npmjs.com/package/@google/gemini-cli) |  |
| getenvoy | [ubi:tetratelabs-attic/getenvoy](https://github.com/tetratelabs-attic/getenvoy)<br>[asdf:mise-plugins/mise-getenvoy](https://github.com/mise-plugins/mise-getenvoy) |  |
| ghalint | [aqua:suzuki-shunsuke/ghalint](https://github.com/suzuki-shunsuke/ghalint)<br>[ubi:suzuki-shunsuke/ghalint](https://github.com/suzuki-shunsuke/ghalint) |  |
| ghc | [asdf:mise-plugins/mise-ghcup](https://github.com/mise-plugins/mise-ghcup) |  |
| ghcup | [aqua:haskell/ghcup-hs](https://github.com/haskell/ghcup-hs)<br>[ubi:haskell/ghcup-hs](https://github.com/haskell/ghcup-hs)<br>[asdf:mise-plugins/mise-ghcup](https://github.com/mise-plugins/mise-ghcup) | linux, macos |
| ghidra | [asdf:mise-plugins/mise-ghidra](https://github.com/mise-plugins/mise-ghidra) |  |
| ghorg | [aqua:gabrie30/ghorg](https://github.com/gabrie30/ghorg)<br>[asdf:gbloquel/asdf-ghorg](https://github.com/gbloquel/asdf-ghorg) |  |
| ghq | [aqua:x-motemen/ghq](https://github.com/x-motemen/ghq)<br>[asdf:kajisha/asdf-ghq](https://github.com/kajisha/asdf-ghq) |  |
| ginkgo | [go:github.com/onsi/ginkgo/v2/ginkgo](https://pkg.go.dev/github.com/onsi/ginkgo/v2/ginkgo)<br>[asdf:mise-plugins/mise-ginkgo](https://github.com/mise-plugins/mise-ginkgo) |  |
| git-chglog | [aqua:git-chglog/git-chglog](https://github.com/git-chglog/git-chglog)<br>[asdf:GoodwayGroup/asdf-git-chglog](https://github.com/GoodwayGroup/asdf-git-chglog) |  |
| git-cliff | [aqua:orhun/git-cliff](https://github.com/orhun/git-cliff)<br>[asdf:jylenhof/asdf-git-cliff](https://github.com/jylenhof/asdf-git-cliff) |  |
| git-lfs | [aqua:git-lfs/git-lfs](https://github.com/git-lfs/git-lfs)<br>[ubi:git-lfs/git-lfs](https://github.com/git-lfs/git-lfs) |  |
| gitconfig | [ubi:0ghny/gitconfig](https://github.com/0ghny/gitconfig)<br>[asdf:0ghny/asdf-gitconfig](https://github.com/0ghny/asdf-gitconfig) |  |
| github-cli | [aqua:cli/cli](https://github.com/cli/cli)<br>[ubi:cli/cli](https://github.com/cli/cli)<br>[asdf:bartlomiejdanek/asdf-github-cli](https://github.com/bartlomiejdanek/asdf-github-cli) |  |
| github-markdown-toc | [aqua:ekalinin/github-markdown-toc](https://github.com/ekalinin/github-markdown-toc)<br>[asdf:skyzyx/asdf-github-markdown-toc](https://github.com/skyzyx/asdf-github-markdown-toc) |  |
| gitleaks | [aqua:gitleaks/gitleaks](https://github.com/gitleaks/gitleaks)<br>[asdf:jmcvetta/asdf-gitleaks](https://github.com/jmcvetta/asdf-gitleaks) |  |
| gitsign | [aqua:sigstore/gitsign](https://github.com/sigstore/gitsign)<br>[asdf:spencergilbert/asdf-gitsign](https://github.com/spencergilbert/asdf-gitsign) | linux, macos |
| gitu | [ubi:altsem/gitu](https://github.com/altsem/gitu)<br>[cargo:gitu](https://crates.io/crates/gitu) |  |
| gitui | [aqua:extrawurst/gitui](https://github.com/extrawurst/gitui)<br>[asdf:looztra/asdf-gitui](https://github.com/looztra/asdf-gitui) |  |
| gitversion | [aqua:gittools/gitversion](https://github.com/gittools/gitversion)<br>[ubi:gittools/gitversion](https://github.com/gittools/gitversion) |  |
| glab | [ubi:gitlab-org/cli](https://gitlab.com/gitlab-org/cli)<br>[ubi:gitlab-org/cli](https://gitlab.com/gitlab-org/cli)<br>[asdf:mise-plugins/mise-glab](https://github.com/mise-plugins/mise-glab) |  |
| gleam | [aqua:gleam-lang/gleam](https://github.com/gleam-lang/gleam)<br>[asdf:asdf-community/asdf-gleam](https://github.com/asdf-community/asdf-gleam) |  |
| glen | [ubi:lingrino/glen](https://github.com/lingrino/glen)<br>[asdf:bradym/asdf-glen](https://github.com/bradym/asdf-glen) |  |
| glooctl | [ubi:solo-io/gloo](https://github.com/solo-io/gloo)<br>[asdf:halilkaya/asdf-glooctl](https://github.com/halilkaya/asdf-glooctl) |  |
| glow | [aqua:charmbracelet/glow](https://github.com/charmbracelet/glow)<br>[asdf:mise-plugins/asdf-glow](https://github.com/mise-plugins/asdf-glow) |  |
| go | [core:go](https://mise.jdx.dev/lang/go.html) |  |
| go-containerregistry | [aqua:google/go-containerregistry](https://github.com/google/go-containerregistry)<br>[asdf:dex4er/asdf-go-containerregistry](https://github.com/dex4er/asdf-go-containerregistry) |  |
| go-getter | [aqua:hashicorp/go-getter](https://github.com/hashicorp/go-getter)<br>[asdf:mise-plugins/mise-go-getter](https://github.com/mise-plugins/mise-go-getter) |  |
| go-jira | [aqua:go-jira/jira](https://github.com/go-jira/jira)<br>[asdf:dguihal/asdf-go-jira](https://github.com/dguihal/asdf-go-jira) |  |
| go-jsonnet | [aqua:google/go-jsonnet](https://github.com/google/go-jsonnet)<br>[asdf:https://gitlab.com/craigfurman/asdf-go-jsonnet](https://gitlab.com/craigfurman/asdf-go-jsonnet) |  |
| go-junit-report | [aqua:jstemmer/go-junit-report](https://github.com/jstemmer/go-junit-report)<br>[ubi:jstemmer/go-junit-report](https://github.com/jstemmer/go-junit-report)<br>[asdf:jwillker/asdf-go-junit-report](https://github.com/jwillker/asdf-go-junit-report) |  |
| go-sdk | [asdf:mise-plugins/mise-go-sdk](https://github.com/mise-plugins/mise-go-sdk) |  |
| go-swagger | [aqua:go-swagger/go-swagger](https://github.com/go-swagger/go-swagger)<br>[asdf:jfreeland/asdf-go-swagger](https://github.com/jfreeland/asdf-go-swagger) | linux, macos |
| goconvey | [go:github.com/smartystreets/goconvey](https://pkg.go.dev/github.com/smartystreets/goconvey)<br>[asdf:mise-plugins/mise-goconvey](https://github.com/mise-plugins/mise-goconvey) |  |
| gocryptfs | [aqua:rfjakob/gocryptfs](https://github.com/rfjakob/gocryptfs)<br>[ubi:rfjakob/gocryptfs](https://github.com/rfjakob/gocryptfs) |  |
| gofumpt | [aqua:mvdan/gofumpt](https://github.com/mvdan/gofumpt)<br>[ubi:mvdan/gofumpt](https://github.com/mvdan/gofumpt)<br>[asdf:looztra/asdf-gofumpt](https://github.com/looztra/asdf-gofumpt) |  |
| gojq | [aqua:itchyny/gojq](https://github.com/itchyny/gojq)<br>[ubi:itchyny/gojq](https://github.com/itchyny/gojq)<br>[asdf:jimmidyson/asdf-gojq](https://github.com/jimmidyson/asdf-gojq)<br>[go:github.com/itchyny/gojq/cmd/gojq](https://pkg.go.dev/github.com/itchyny/gojq/cmd/gojq) |  |
| gokey | [aqua:cloudflare/gokey](https://github.com/cloudflare/gokey)<br>[ubi:cloudflare/gokey](https://github.com/cloudflare/gokey) |  |
| golangci-lint | [aqua:golangci/golangci-lint](https://github.com/golangci/golangci-lint)<br>[ubi:golangci/golangci-lint](https://github.com/golangci/golangci-lint)<br>[asdf:hypnoglow/asdf-golangci-lint](https://github.com/hypnoglow/asdf-golangci-lint) |  |
| golangci-lint-langserver | [aqua:nametake/golangci-lint-langserver](https://github.com/nametake/golangci-lint-langserver)<br>[ubi:nametake/golangci-lint-langserver](https://github.com/nametake/golangci-lint-langserver)<br>[go:github.com/nametake/golangci-lint-langserver](https://pkg.go.dev/github.com/nametake/golangci-lint-langserver) |  |
| golines | [aqua:segmentio/golines](https://github.com/segmentio/golines)<br>[ubi:segmentio/golines](https://github.com/segmentio/golines)<br>[go:github.com/segmentio/golines](https://pkg.go.dev/github.com/segmentio/golines) |  |
| gomigrate | [aqua:golang-migrate/migrate](https://github.com/golang-migrate/migrate)<br>[asdf:joschi/asdf-gomigrate](https://github.com/joschi/asdf-gomigrate) |  |
| gomplate | [aqua:hairyhenderson/gomplate](https://github.com/hairyhenderson/gomplate)<br>[asdf:sneakybeaky/asdf-gomplate](https://github.com/sneakybeaky/asdf-gomplate) |  |
| gopass | [aqua:gopasspw/gopass](https://github.com/gopasspw/gopass)<br>[asdf:trallnag/asdf-gopass](https://github.com/trallnag/asdf-gopass) |  |
| goreleaser | [aqua:goreleaser/goreleaser](https://github.com/goreleaser/goreleaser)<br>[ubi:goreleaser/goreleaser](https://github.com/goreleaser/goreleaser)<br>[asdf:kforsthoevel/asdf-goreleaser](https://github.com/kforsthoevel/asdf-goreleaser) |  |
| goss | [aqua:goss-org/goss](https://github.com/goss-org/goss)<br>[asdf:raimon49/asdf-goss](https://github.com/raimon49/asdf-goss) |  |
| gotestsum | [aqua:gotestyourself/gotestsum](https://github.com/gotestyourself/gotestsum)<br>[asdf:pmalek/mise-gotestsum](https://github.com/pmalek/mise-gotestsum) |  |
| graalvm | [asdf:mise-plugins/mise-graalvm](https://github.com/mise-plugins/mise-graalvm) |  |
| gradle | [aqua:gradle/gradle](https://github.com/gradle/gradle)<br>[vfox:mise-plugins/vfox-gradle](https://github.com/mise-plugins/vfox-gradle) |  |
| gradle-profiler | [asdf:mise-plugins/mise-gradle-profiler](https://github.com/mise-plugins/mise-gradle-profiler) |  |
| grails | [asdf:mise-plugins/mise-grails](https://github.com/mise-plugins/mise-grails) |  |
| grain | [ubi:grain-lang/grain](https://github.com/grain-lang/grain)<br>[asdf:mise-plugins/mise-grain](https://github.com/mise-plugins/mise-grain) |  |
| granted | [aqua:common-fate/granted](https://github.com/common-fate/granted)<br>[asdf:dex4er/asdf-granted](https://github.com/dex4er/asdf-granted) |  |
| graphite | [npm:@withgraphite/graphite-cli](https://www.npmjs.com/package/@withgraphite/graphite-cli) |  |
| grex | [aqua:pemistahl/grex](https://github.com/pemistahl/grex)<br>[asdf:ouest/asdf-grex](https://github.com/ouest/asdf-grex) |  |
| gron | [aqua:tomnomnom/gron](https://github.com/tomnomnom/gron)<br>[ubi:tomnomnom/gron](https://github.com/tomnomnom/gron) |  |
| groovy | [asdf:mise-plugins/mise-groovy](https://github.com/mise-plugins/mise-groovy)<br>[vfox:mise-plugins/vfox-groovy](https://github.com/mise-plugins/vfox-groovy) |  |
| grpc-health-probe | [aqua:grpc-ecosystem/grpc-health-probe](https://github.com/grpc-ecosystem/grpc-health-probe)<br>[asdf:zufardhiyaulhaq/asdf-grpc-health-probe](https://github.com/zufardhiyaulhaq/asdf-grpc-health-probe) | linux, macos |
| grpcurl | [aqua:fullstorydev/grpcurl](https://github.com/fullstorydev/grpcurl)<br>[asdf:asdf-community/asdf-grpcurl](https://github.com/asdf-community/asdf-grpcurl) |  |
| grype | [aqua:anchore/grype](https://github.com/anchore/grype)<br>[ubi:anchore/grype](https://github.com/anchore/grype)<br>[asdf:poikilotherm/asdf-grype](https://github.com/poikilotherm/asdf-grype) |  |
| guile | [asdf:mise-plugins/mise-guile](https://github.com/mise-plugins/mise-guile) |  |
| gum | [aqua:charmbracelet/gum](https://github.com/charmbracelet/gum)<br>[asdf:lwiechec/asdf-gum](https://github.com/lwiechec/asdf-gum) |  |
| gup | [aqua:nao1215/gup](https://github.com/nao1215/gup) |  |
| gwvault | [aqua:GoodwayGroup/gwvault](https://github.com/GoodwayGroup/gwvault)<br>[asdf:GoodwayGroup/asdf-gwvault](https://github.com/GoodwayGroup/asdf-gwvault) |  |
| hadolint | [aqua:hadolint/hadolint](https://github.com/hadolint/hadolint)<br>[ubi:hadolint/hadolint](https://github.com/hadolint/hadolint)<br>[asdf:devlincashman/asdf-hadolint](https://github.com/devlincashman/asdf-hadolint) |  |
| hamler | [asdf:mise-plugins/mise-hamler](https://github.com/mise-plugins/mise-hamler) |  |
| harper-cli | [aqua:Automattic/harper/harper-cli](https://github.com/Automattic/harper) |  |
| harper-ls | [aqua:Automattic/harper/harper-ls](https://github.com/Automattic/harper) |  |
| has | [aqua:kdabir/has](https://github.com/kdabir/has)<br>[asdf:sylvainmetayer/asdf-has](https://github.com/sylvainmetayer/asdf-has) | linux, macos |
| haskell | [asdf:mise-plugins/mise-haskell](https://github.com/mise-plugins/mise-haskell) |  |
| hasura-cli | [aqua:hasura/graphql-engine](https://github.com/hasura/graphql-engine)<br>[asdf:gurukulkarni/asdf-hasura](https://github.com/gurukulkarni/asdf-hasura) |  |
| hatch | [pipx:hatch](https://pypi.org/project/hatch) |  |
| haxe | [ubi:HaxeFoundation/haxe](https://github.com/HaxeFoundation/haxe)<br>[asdf:mise-plugins/mise-haxe](https://github.com/mise-plugins/mise-haxe) |  |
| hcl2json | [aqua:tmccombs/hcl2json](https://github.com/tmccombs/hcl2json)<br>[asdf:dex4er/asdf-hcl2json](https://github.com/dex4er/asdf-hcl2json) |  |
| hcloud | [aqua:hetznercloud/cli](https://github.com/hetznercloud/cli)<br>[asdf:chessmango/asdf-hcloud](https://github.com/chessmango/asdf-hcloud) |  |
| helix | [aqua:helix-editor/helix](https://github.com/helix-editor/helix)<br>[ubi:helix-editor/helix](https://github.com/helix-editor/helix) |  |
| helm | [aqua:helm/helm](https://github.com/helm/helm)<br>[asdf:Antiarchitect/asdf-helm](https://github.com/Antiarchitect/asdf-helm) |  |
| helm-cr | [aqua:helm/chart-releaser](https://github.com/helm/chart-releaser)<br>[asdf:Antiarchitect/asdf-helm-cr](https://github.com/Antiarchitect/asdf-helm-cr) |  |
| helm-ct | [aqua:helm/chart-testing](https://github.com/helm/chart-testing)<br>[asdf:tablexi/asdf-helm-ct](https://github.com/tablexi/asdf-helm-ct) |  |
| helm-diff | [ubi:databus23/helm-diff](https://github.com/databus23/helm-diff)<br>[asdf:mise-plugins/mise-helm-diff](https://github.com/mise-plugins/mise-helm-diff) |  |
| helm-docs | [aqua:norwoodj/helm-docs](https://github.com/norwoodj/helm-docs)<br>[asdf:sudermanjr/asdf-helm-docs](https://github.com/sudermanjr/asdf-helm-docs) |  |
| helmfile | [aqua:helmfile/helmfile](https://github.com/helmfile/helmfile)<br>[ubi:helmfile/helmfile](https://github.com/helmfile/helmfile)<br>[asdf:feniix/asdf-helmfile](https://github.com/feniix/asdf-helmfile) |  |
| helmsman | [ubi:Praqma/helmsman](https://github.com/Praqma/helmsman)<br>[asdf:luisdavim/asdf-helmsman](https://github.com/luisdavim/asdf-helmsman) |  |
| helmwave | [aqua:helmwave/helmwave](https://github.com/helmwave/helmwave)<br>[ubi:helmwave/helmwave](https://github.com/helmwave/helmwave) |  |
| heroku | [asdf:mise-plugins/mise-heroku-cli](https://github.com/mise-plugins/mise-heroku-cli) |  |
| hexyl | [aqua:sharkdp/hexyl](https://github.com/sharkdp/hexyl)<br>[ubi:sharkdp/hexyl](https://github.com/sharkdp/hexyl) |  |
| hey | [asdf:mise-plugins/mise-hey](https://github.com/mise-plugins/mise-hey) |  |
| hishtory | [ubi:ddworken/hishtory](https://github.com/ddworken/hishtory)<br>[asdf:asdf-community/asdf-hishtory](https://github.com/asdf-community/asdf-hishtory) |  |
| hivemind | [ubi:DarthSim/hivemind](https://github.com/DarthSim/hivemind)<br>[go:github.com/DarthSim/hivemind](https://pkg.go.dev/github.com/DarthSim/hivemind) |  |
| hk | [aqua:jdx/hk](https://github.com/jdx/hk)<br>[ubi:jdx/hk](https://github.com/jdx/hk) |  |
| hledger | [ubi:simonmichael/hledger](https://github.com/simonmichael/hledger)<br>[asdf:airtonix/asdf-hledger](https://github.com/airtonix/asdf-hledger) |  |
| hledger-flow | [ubi:apauley/hledger-flow](https://github.com/apauley/hledger-flow)<br>[asdf:airtonix/asdf-hledger-flow](https://github.com/airtonix/asdf-hledger-flow) |  |
| hls | [asdf:mise-plugins/mise-ghcup](https://github.com/mise-plugins/mise-ghcup) |  |
| hostctl | [aqua:guumaster/hostctl](https://github.com/guumaster/hostctl)<br>[asdf:svenluijten/asdf-hostctl](https://github.com/svenluijten/asdf-hostctl) |  |
| htmlq | [aqua:mgdm/htmlq](https://github.com/mgdm/htmlq)<br>[ubi:mgdm/htmlq](https://github.com/mgdm/htmlq) |  |
| httpie-go | [aqua:nojima/httpie-go](https://github.com/nojima/httpie-go)<br>[asdf:abatilo/asdf-httpie-go](https://github.com/abatilo/asdf-httpie-go) | linux, macos |
| hub | [aqua:mislav/hub](https://github.com/mislav/hub)<br>[asdf:mise-plugins/asdf-hub](https://github.com/mise-plugins/asdf-hub) |  |
| hugo | [aqua:gohugoio/hugo](https://github.com/gohugoio/hugo)<br>[ubi:gohugoio/hugo](https://github.com/gohugoio/hugo)<br>[asdf:NeoHsu/asdf-hugo](https://github.com/NeoHsu/asdf-hugo)<br>[asdf:nklmilojevic/asdf-hugo](https://github.com/nklmilojevic/asdf-hugo) |  |
| hugo-extended | [aqua:gohugoio/hugo/hugo-extended](https://github.com/gohugoio/hugo) |  |
| hurl | [aqua:Orange-OpenSource/hurl](https://github.com/Orange-OpenSource/hurl)<br>[asdf:raimon49/asdf-hurl](https://github.com/raimon49/asdf-hurl) |  |
| hwatch | [aqua:blacknon/hwatch](https://github.com/blacknon/hwatch)<br>[ubi:blacknon/hwatch](https://github.com/blacknon/hwatch)<br>[asdf:chessmango/asdf-hwatch](https://github.com/chessmango/asdf-hwatch) |  |
| hygen | [ubi:jondot/hygen](https://github.com/jondot/hygen)<br>[asdf:brentjanderson/asdf-hygen](https://github.com/brentjanderson/asdf-hygen) |  |
| hyperfine | [aqua:sharkdp/hyperfine](https://github.com/sharkdp/hyperfine)<br>[ubi:sharkdp/hyperfine](https://github.com/sharkdp/hyperfine)<br>[asdf:volf52/asdf-hyperfine](https://github.com/volf52/asdf-hyperfine) |  |
| iam-policy-json-to-terraform | [aqua:flosell/iam-policy-json-to-terraform](https://github.com/flosell/iam-policy-json-to-terraform)<br>[asdf:carlduevel/asdf-iam-policy-json-to-terraform](https://github.com/carlduevel/asdf-iam-policy-json-to-terraform) |  |
| iamlive | [aqua:iann0036/iamlive](https://github.com/iann0036/iamlive)<br>[asdf:chessmango/asdf-iamlive](https://github.com/chessmango/asdf-iamlive) |  |
| ibmcloud | [asdf:mise-plugins/mise-ibmcloud](https://github.com/mise-plugins/mise-ibmcloud) |  |
| idris | [asdf:mise-plugins/mise-idris](https://github.com/mise-plugins/mise-idris) |  |
| idris2 | [asdf:mise-plugins/mise-idris2](https://github.com/mise-plugins/mise-idris2) |  |
| imagemagick | [asdf:mise-plugins/mise-imagemagick](https://github.com/mise-plugins/mise-imagemagick) |  |
| imgpkg | [aqua:carvel-dev/imgpkg](https://github.com/carvel-dev/imgpkg)<br>[asdf:vmware-tanzu/asdf-carvel](https://github.com/vmware-tanzu/asdf-carvel) |  |
| infracost | [aqua:infracost/infracost](https://github.com/infracost/infracost)<br>[asdf:dex4er/asdf-infracost](https://github.com/dex4er/asdf-infracost) |  |
| inlets | [aqua:inlets/inletsctl](https://github.com/inlets/inletsctl)<br>[asdf:nlamirault/asdf-inlets](https://github.com/nlamirault/asdf-inlets) |  |
| io | [asdf:mise-plugins/mise-io](https://github.com/mise-plugins/mise-io) |  |
| istioctl | [aqua:istio/istio/istioctl](https://github.com/istio/istio)<br>[asdf:virtualstaticvoid/asdf-istioctl](https://github.com/virtualstaticvoid/asdf-istioctl) |  |
| janet | [asdf:mise-plugins/mise-janet](https://github.com/mise-plugins/mise-janet) |  |
| java | [core:java](https://mise.jdx.dev/lang/java.html) |  |
| jbang | [asdf:mise-plugins/jbang-asdf](https://github.com/mise-plugins/jbang-asdf) |  |
| jc | [aqua:kellyjonbrazil/jc](https://github.com/kellyjonbrazil/jc)<br>[ubi:kellyjonbrazil/jc](https://github.com/kellyjonbrazil/jc)<br>[pipx:jc](https://pypi.org/project/jc) |  |
| jd | [aqua:josephburnett/jd](https://github.com/josephburnett/jd)<br>[ubi:josephburnett/jd](https://github.com/josephburnett/jd)<br>[go:github.com/josephburnett/jd](https://pkg.go.dev/github.com/josephburnett/jd) |  |
| jfrog-cli | [asdf:mise-plugins/mise-jfrog-cli](https://github.com/mise-plugins/mise-jfrog-cli) |  |
| jib | [asdf:mise-plugins/mise-jib](https://github.com/mise-plugins/mise-jib) |  |
| jiq | [aqua:fiatjaf/jiq](https://github.com/fiatjaf/jiq)<br>[asdf:chessmango/asdf-jiq](https://github.com/chessmango/asdf-jiq) |  |
| jj | [aqua:jj-vcs/jj](https://github.com/jj-vcs/jj)<br>[ubi:jj-vcs/jj](https://github.com/jj-vcs/jj) |  |
| jjui | [aqua:idursun/jjui](https://github.com/idursun/jjui)<br>[ubi:idursun/jjui](https://github.com/idursun/jjui) |  |
| jless | [aqua:PaulJuliusMartinez/jless](https://github.com/PaulJuliusMartinez/jless)<br>[asdf:jc00ke/asdf-jless](https://github.com/jc00ke/asdf-jless) |  |
| jmespath | [aqua:jmespath/jp](https://github.com/jmespath/jp)<br>[asdf:skyzyx/asdf-jmespath](https://github.com/skyzyx/asdf-jmespath) |  |
| jmeter | [asdf:mise-plugins/mise-jmeter](https://github.com/mise-plugins/mise-jmeter) |  |
| jnv | [aqua:ynqa/jnv](https://github.com/ynqa/jnv)<br>[asdf:raimon49/asdf-jnv](https://github.com/raimon49/asdf-jnv) |  |
| jq | [aqua:jqlang/jq](https://github.com/jqlang/jq)<br>[ubi:jqlang/jq](https://github.com/jqlang/jq)<br>[asdf:mise-plugins/asdf-jq](https://github.com/mise-plugins/asdf-jq) |  |
| jqp | [aqua:noahgorstein/jqp](https://github.com/noahgorstein/jqp)<br>[asdf:https://gitlab.com/wt0f/asdf-jqp](https://gitlab.com/wt0f/asdf-jqp) |  |
| jreleaser | [aqua:jreleaser/jreleaser](https://github.com/jreleaser/jreleaser)<br>[asdf:joschi/asdf-jreleaser](https://github.com/joschi/asdf-jreleaser) |  |
| json5 | [npm:json5](https://www.npmjs.com/package/json5) |  |
| jsonnet-bundler | [aqua:jsonnet-bundler/jsonnet-bundler](https://github.com/jsonnet-bundler/jsonnet-bundler)<br>[asdf:beardix/asdf-jb](https://github.com/beardix/asdf-jb) |  |
| jsonschema | [aqua:sourcemeta/jsonschema](https://github.com/sourcemeta/jsonschema)<br>[ubi:sourcemeta/jsonschema](https://github.com/sourcemeta/jsonschema) |  |
| julia | [asdf:mise-plugins/mise-julia](https://github.com/mise-plugins/mise-julia) |  |
| just | [aqua:casey/just](https://github.com/casey/just)<br>[ubi:casey/just](https://github.com/casey/just)<br>[asdf:olofvndrhr/asdf-just](https://github.com/olofvndrhr/asdf-just) |  |
| jwt | [aqua:mike-engel/jwt-cli](https://github.com/mike-engel/jwt-cli)<br>[ubi:mike-engel/jwt-cli](https://github.com/mike-engel/jwt-cli)<br>[cargo:jwt-cli](https://crates.io/crates/jwt-cli) |  |
| jwtui | [ubi:jwt-rs/jwt-ui](https://github.com/jwt-rs/jwt-ui)<br>[cargo:jwt-ui](https://crates.io/crates/jwt-ui) |  |
| jx | [aqua:jenkins-x/jx](https://github.com/jenkins-x/jx)<br>[ubi:jenkins-x/jx](https://github.com/jenkins-x/jx)<br>[asdf:vbehar/asdf-jx](https://github.com/vbehar/asdf-jx) |  |
| k0sctl | [aqua:k0sproject/k0sctl](https://github.com/k0sproject/k0sctl)<br>[ubi:k0sproject/k0sctl](https://github.com/k0sproject/k0sctl)<br>[asdf:Its-Alex/asdf-plugin-k0sctl](https://github.com/Its-Alex/asdf-plugin-k0sctl) |  |
| k2tf | [aqua:sl1pm4t/k2tf](https://github.com/sl1pm4t/k2tf)<br>[ubi:sl1pm4t/k2tf](https://github.com/sl1pm4t/k2tf)<br>[asdf:carlduevel/asdf-k2tf](https://github.com/carlduevel/asdf-k2tf) |  |
| k3d | [aqua:k3d-io/k3d](https://github.com/k3d-io/k3d)<br>[ubi:k3d-io/k3d](https://github.com/k3d-io/k3d)<br>[asdf:spencergilbert/asdf-k3d](https://github.com/spencergilbert/asdf-k3d) |  |
| k3kcli | [ubi:rancher/k3k](https://github.com/rancher/k3k)<br>[asdf:xanmanning/asdf-k3kcli](https://github.com/xanmanning/asdf-k3kcli) |  |
| k3s | [asdf:mise-plugins/mise-k3s](https://github.com/mise-plugins/mise-k3s) |  |
| k3sup | [aqua:alexellis/k3sup](https://github.com/alexellis/k3sup)<br>[asdf:cgroschupp/asdf-k3sup](https://github.com/cgroschupp/asdf-k3sup) |  |
| k6 | [aqua:grafana/k6](https://github.com/grafana/k6)<br>[ubi:grafana/k6](https://github.com/grafana/k6)<br>[asdf:gr1m0h/asdf-k6](https://github.com/gr1m0h/asdf-k6) |  |
| k9s | [aqua:derailed/k9s](https://github.com/derailed/k9s)<br>[ubi:derailed/k9s](https://github.com/derailed/k9s)<br>[asdf:looztra/asdf-k9s](https://github.com/looztra/asdf-k9s) |  |
| kafka | [asdf:mise-plugins/mise-kafka](https://github.com/mise-plugins/mise-kafka) |  |
| kafkactl | [aqua:deviceinsight/kafkactl](https://github.com/deviceinsight/kafkactl)<br>[asdf:anweber/asdf-kafkactl](https://github.com/anweber/asdf-kafkactl) |  |
| kapp | [aqua:carvel-dev/kapp](https://github.com/carvel-dev/kapp)<br>[asdf:vmware-tanzu/asdf-carvel](https://github.com/vmware-tanzu/asdf-carvel) |  |
| kbld | [aqua:carvel-dev/kbld](https://github.com/carvel-dev/kbld)<br>[asdf:vmware-tanzu/asdf-carvel](https://github.com/vmware-tanzu/asdf-carvel) |  |
| kcat | [asdf:mise-plugins/mise-kcat](https://github.com/mise-plugins/mise-kcat) |  |
| kcctl | [ubi:kcctl/kcctl](https://github.com/kcctl/kcctl)<br>[asdf:joschi/asdf-kcctl](https://github.com/joschi/asdf-kcctl) |  |
| kcl | [aqua:kcl-lang/cli](https://github.com/kcl-lang/cli)<br>[asdf:mise-plugins/mise-kcl](https://github.com/mise-plugins/mise-kcl) |  |
| kconf | [aqua:particledecay/kconf](https://github.com/particledecay/kconf)<br>[asdf:particledecay/asdf-kconf](https://github.com/particledecay/asdf-kconf) |  |
| ki | [aqua:Kotlin/kotlin-interactive-shell](https://github.com/Kotlin/kotlin-interactive-shell)<br>[ubi:Kotlin/kotlin-interactive-shell](https://github.com/Kotlin/kotlin-interactive-shell)<br>[asdf:comdotlinux/asdf-ki](https://github.com/comdotlinux/asdf-ki) |  |
| killport | [aqua:jkfran/killport](https://github.com/jkfran/killport)<br>[ubi:jkfran/killport](https://github.com/jkfran/killport) |  |
| kind | [aqua:kubernetes-sigs/kind](https://github.com/kubernetes-sigs/kind)<br>[ubi:kubernetes-sigs/kind](https://github.com/kubernetes-sigs/kind)<br>[asdf:johnlayton/asdf-kind](https://github.com/johnlayton/asdf-kind) |  |
| kiota | [aqua:microsoft/kiota](https://github.com/microsoft/kiota)<br>[asdf:asdf-community/asdf-kiota](https://github.com/asdf-community/asdf-kiota) |  |
| kn | [aqua:knative/client](https://github.com/knative/client)<br>[asdf:joke/asdf-kn](https://github.com/joke/asdf-kn) |  |
| ko | [aqua:ko-build/ko](https://github.com/ko-build/ko)<br>[asdf:zasdaym/asdf-ko](https://github.com/zasdaym/asdf-ko) |  |
| koka | [ubi:koka-lang/koka](https://github.com/koka-lang/koka)<br>[asdf:susurri/asdf-koka](https://github.com/susurri/asdf-koka) |  |
| kompose | [aqua:kubernetes/kompose](https://github.com/kubernetes/kompose)<br>[ubi:kubernetes/kompose](https://github.com/kubernetes/kompose)<br>[asdf:technikhil314/asdf-kompose](https://github.com/technikhil314/asdf-kompose) |  |
| kops | [aqua:kubernetes/kops](https://github.com/kubernetes/kops)<br>[asdf:Antiarchitect/asdf-kops](https://github.com/Antiarchitect/asdf-kops) |  |
| kotlin | [asdf:mise-plugins/mise-kotlin](https://github.com/mise-plugins/mise-kotlin)<br>[vfox:mise-plugins/vfox-kotlin](https://github.com/mise-plugins/vfox-kotlin) |  |
| kpack | [ubi:vmware-tanzu/kpack-cli](https://github.com/vmware-tanzu/kpack-cli)<br>[asdf:asdf-community/asdf-kpack-cli](https://github.com/asdf-community/asdf-kpack-cli) |  |
| kpt | [aqua:kptdev/kpt](https://github.com/kptdev/kpt)<br>[asdf:nlamirault/asdf-kpt](https://github.com/nlamirault/asdf-kpt) | linux, macos |
| krab | [aqua:ohkrab/krab](https://github.com/ohkrab/krab)<br>[ubi:ohkrab/krab](https://github.com/ohkrab/krab)<br>[asdf:ohkrab/asdf-krab](https://github.com/ohkrab/asdf-krab) |  |
| krew | [aqua:kubernetes-sigs/krew](https://github.com/kubernetes-sigs/krew)<br>[asdf:bjw-s/asdf-krew](https://github.com/bjw-s/asdf-krew) |  |
| kscript | [ubi:kscripting/kscript](https://github.com/kscripting/kscript)<br>[asdf:edgelevel/asdf-kscript](https://github.com/edgelevel/asdf-kscript) |  |
| ksops | [aqua:viaduct-ai/kustomize-sops](https://github.com/viaduct-ai/kustomize-sops)<br>[ubi:viaduct-ai/kustomize-sops](https://github.com/viaduct-ai/kustomize-sops)<br>[asdf:janpieper/asdf-ksops](https://github.com/janpieper/asdf-ksops) |  |
| ktlint | [aqua:pinterest/ktlint](https://github.com/pinterest/ktlint)<br>[asdf:mise-plugins/mise-ktlint](https://github.com/mise-plugins/mise-ktlint) |  |
| kube-capacity | [aqua:robscott/kube-capacity](https://github.com/robscott/kube-capacity)<br>[asdf:looztra/asdf-kube-capacity](https://github.com/looztra/asdf-kube-capacity) |  |
| kube-code-generator | [asdf:mise-plugins/mise-kube-code-generator](https://github.com/mise-plugins/mise-kube-code-generator) |  |
| kube-controller-tools | [ubi:kubernetes-sigs/controller-tools](https://github.com/kubernetes-sigs/controller-tools)<br>[asdf:jimmidyson/asdf-kube-controller-tools](https://github.com/jimmidyson/asdf-kube-controller-tools) |  |
| kube-credential-cache | [aqua:ryodocx/kube-credential-cache](https://github.com/ryodocx/kube-credential-cache)<br>[asdf:ryodocx/kube-credential-cache](https://github.com/ryodocx/kube-credential-cache) |  |
| kube-linter | [aqua:stackrox/kube-linter](https://github.com/stackrox/kube-linter)<br>[asdf:devlincashman/asdf-kube-linter](https://github.com/devlincashman/asdf-kube-linter) |  |
| kube-score | [aqua:zegl/kube-score](https://github.com/zegl/kube-score)<br>[asdf:bageljp/asdf-kube-score](https://github.com/bageljp/asdf-kube-score) |  |
| kubebuilder | [aqua:kubernetes-sigs/kubebuilder](https://github.com/kubernetes-sigs/kubebuilder)<br>[asdf:virtualstaticvoid/asdf-kubebuilder](https://github.com/virtualstaticvoid/asdf-kubebuilder) |  |
| kubecm | [aqua:sunny0826/kubecm](https://github.com/sunny0826/kubecm)<br>[asdf:samhvw8/asdf-kubecm](https://github.com/samhvw8/asdf-kubecm) |  |
| kubecolor | [aqua:kubecolor/kubecolor](https://github.com/kubecolor/kubecolor)<br>[asdf:dex4er/asdf-kubecolor](https://github.com/dex4er/asdf-kubecolor) |  |
| kubeconform | [aqua:yannh/kubeconform](https://github.com/yannh/kubeconform)<br>[asdf:lirlia/asdf-kubeconform](https://github.com/lirlia/asdf-kubeconform) |  |
| kubectl | [aqua:kubernetes/kubectl](https://github.com/kubernetes/kubectl)<br>[asdf:asdf-community/asdf-kubectl](https://github.com/asdf-community/asdf-kubectl) |  |
| kubectl-convert | [aqua:kubernetes/kubernetes/kubectl-convert](https://github.com/kubernetes/kubernetes)<br>[asdf:iul1an/asdf-kubectl-convert](https://github.com/iul1an/asdf-kubectl-convert) |  |
| kubectl-kots | [aqua:replicatedhq/kots](https://github.com/replicatedhq/kots)<br>[asdf:ganta/asdf-kubectl-kots](https://github.com/ganta/asdf-kubectl-kots) |  |
| kubectl-kuttl | [aqua:kudobuilder/kuttl](https://github.com/kudobuilder/kuttl)<br>[asdf:jimmidyson/asdf-kuttl](https://github.com/jimmidyson/asdf-kuttl) | linux, macos |
| kubectl-rolesum | [aqua:Ladicle/kubectl-rolesum](https://github.com/Ladicle/kubectl-rolesum)<br>[asdf:looztra/asdf-kubectl-bindrole](https://github.com/looztra/asdf-kubectl-bindrole) |  |
| kubectx | [aqua:ahmetb/kubectx](https://github.com/ahmetb/kubectx)<br>[asdf:https://gitlab.com/wt0f/asdf-kubectx](https://gitlab.com/wt0f/asdf-kubectx) |  |
| kubefedctl | [aqua:kubernetes-retired/kubefed](https://github.com/kubernetes-retired/kubefed)<br>[asdf:kvokka/asdf-kubefedctl](https://github.com/kvokka/asdf-kubefedctl) |  |
| kubefirst | [ubi:konstructio/kubefirst](https://github.com/konstructio/kubefirst)<br>[asdf:Claywd/asdf-kubefirst](https://github.com/Claywd/asdf-kubefirst) |  |
| kubelogin | [aqua:int128/kubelogin](https://github.com/int128/kubelogin) |  |
| kubemqctl | [aqua:kubemq-io/kubemqctl](https://github.com/kubemq-io/kubemqctl)<br>[asdf:johnlayton/asdf-kubemqctl](https://github.com/johnlayton/asdf-kubemqctl) |  |
| kubens | [aqua:ahmetb/kubectx/kubens](https://github.com/ahmetb/kubectx) |  |
| kubent | [aqua:doitintl/kube-no-trouble](https://github.com/doitintl/kube-no-trouble)<br>[asdf:virtualstaticvoid/asdf-kubent](https://github.com/virtualstaticvoid/asdf-kubent) |  |
| kubeone | [aqua:kubermatic/kubeone](https://github.com/kubermatic/kubeone)<br>[aqua:kubermatic/kubeone](https://github.com/kubermatic/kubeone) |  |
| kubergrunt | [aqua:gruntwork-io/kubergrunt](https://github.com/gruntwork-io/kubergrunt)<br>[asdf:NeoHsu/asdf-kubergrunt](https://github.com/NeoHsu/asdf-kubergrunt) |  |
| kubeseal | [aqua:bitnami-labs/sealed-secrets](https://github.com/bitnami-labs/sealed-secrets)<br>[asdf:stefansedich/asdf-kubeseal](https://github.com/stefansedich/asdf-kubeseal) |  |
| kubesec | [aqua:controlplaneio/kubesec](https://github.com/controlplaneio/kubesec)<br>[asdf:vitalis/asdf-kubesec](https://github.com/vitalis/asdf-kubesec) |  |
| kubeshark | [aqua:kubeshark/kubeshark](https://github.com/kubeshark/kubeshark)<br>[asdf:carnei-ro/asdf-kubeshark](https://github.com/carnei-ro/asdf-kubeshark) |  |
| kubespy | [aqua:pulumi/kubespy](https://github.com/pulumi/kubespy)<br>[asdf:jfreeland/asdf-kubespy](https://github.com/jfreeland/asdf-kubespy) |  |
| kubeval | [aqua:instrumenta/kubeval](https://github.com/instrumenta/kubeval)<br>[asdf:stefansedich/asdf-kubeval](https://github.com/stefansedich/asdf-kubeval) |  |
| kubevela | [aqua:kubevela/kubevela](https://github.com/kubevela/kubevela)<br>[asdf:gustavclausen/asdf-kubevela](https://github.com/gustavclausen/asdf-kubevela) |  |
| kubie | [aqua:sbstp/kubie](https://github.com/sbstp/kubie)<br>[asdf:johnhamelink/asdf-kubie](https://github.com/johnhamelink/asdf-kubie) |  |
| kustomize | [aqua:kubernetes-sigs/kustomize](https://github.com/kubernetes-sigs/kustomize)<br>[asdf:Banno/asdf-kustomize](https://github.com/Banno/asdf-kustomize) |  |
| kwokctl | [aqua:kubernetes-sigs/kwok/kwokctl](https://github.com/kubernetes-sigs/kwok) |  |
| kwt | [aqua:carvel-dev/kwt](https://github.com/carvel-dev/kwt)<br>[asdf:vmware-tanzu/asdf-carvel](https://github.com/vmware-tanzu/asdf-carvel) |  |
| kyverno | [aqua:kyverno/kyverno](https://github.com/kyverno/kyverno)<br>[asdf:https://github.com/hobaen/asdf-kyverno-cli.git](https://github.com/hobaen/asdf-kyverno-cli.git) |  |
| lab | [aqua:zaquestion/lab](https://github.com/zaquestion/lab)<br>[asdf:particledecay/asdf-lab](https://github.com/particledecay/asdf-lab) |  |
| lane | [ubi:CodeReaper/lane](https://github.com/CodeReaper/lane)<br>[asdf:CodeReaper/asdf-lane](https://github.com/CodeReaper/asdf-lane) |  |
| lazydocker | [aqua:jesseduffield/lazydocker](https://github.com/jesseduffield/lazydocker)<br>[ubi:jesseduffield/lazydocker](https://github.com/jesseduffield/lazydocker) |  |
| lazygit | [aqua:jesseduffield/lazygit](https://github.com/jesseduffield/lazygit)<br>[asdf:nklmilojevic/asdf-lazygit](https://github.com/nklmilojevic/asdf-lazygit) |  |
| lazyjournal | [aqua:Lifailon/lazyjournal](https://github.com/Lifailon/lazyjournal)<br>[ubi:Lifailon/lazyjournal](https://github.com/Lifailon/lazyjournal) |  |
| lean | [asdf:mise-plugins/mise-lean](https://github.com/mise-plugins/mise-lean) |  |
| lefthook | [aqua:evilmartians/lefthook](https://github.com/evilmartians/lefthook)<br>[ubi:evilmartians/lefthook](https://github.com/evilmartians/lefthook)<br>[npm:lefthook](https://www.npmjs.com/package/lefthook)<br>[asdf:jtzero/asdf-lefthook](https://github.com/jtzero/asdf-lefthook)<br>[go:github.com/evilmartians/lefthook](https://pkg.go.dev/github.com/evilmartians/lefthook) |  |
| leiningen | [asdf:mise-plugins/mise-lein](https://github.com/mise-plugins/mise-lein) |  |
| levant | [aqua:hashicorp/levant](https://github.com/hashicorp/levant)<br>[asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| lfe | [asdf:mise-plugins/mise-lfe](https://github.com/mise-plugins/mise-lfe) |  |
| libsql-server | [ubi:tursodatabase/libsql](https://github.com/tursodatabase/libsql)<br>[asdf:jonasb/asdf-libsql-server](https://github.com/jonasb/asdf-libsql-server) |  |
| license-plist | [aqua:mono0926/LicensePlist](https://github.com/mono0926/LicensePlist)<br>[ubi:mono0926/LicensePlist](https://github.com/mono0926/LicensePlist)<br>[asdf:MacPaw/asdf-license-plist](https://github.com/MacPaw/asdf-license-plist) | macos |
| lima | [aqua:lima-vm/lima](https://github.com/lima-vm/lima)<br>[asdf:CrouchingMuppet/asdf-lima](https://github.com/CrouchingMuppet/asdf-lima) |  |
| linkerd | [aqua:linkerd/linkerd2](https://github.com/linkerd/linkerd2)<br>[asdf:kforsthoevel/asdf-linkerd](https://github.com/kforsthoevel/asdf-linkerd) |  |
| liqoctl | [aqua:liqotech/liqo](https://github.com/liqotech/liqo)<br>[asdf:pdemagny/asdf-liqoctl](https://github.com/pdemagny/asdf-liqoctl) |  |
| liquibase | [asdf:mise-plugins/mise-liquibase](https://github.com/mise-plugins/mise-liquibase) |  |
| litestream | [aqua:benbjohnson/litestream](https://github.com/benbjohnson/litestream)<br>[asdf:threkk/asdf-litestream](https://github.com/threkk/asdf-litestream) |  |
| llvm-objcopy | [asdf:mise-plugins/mise-llvm](https://github.com/mise-plugins/mise-llvm) |  |
| llvm-objdump | [asdf:mise-plugins/mise-llvm](https://github.com/mise-plugins/mise-llvm) |  |
| lnav | [aqua:tstack/lnav](https://github.com/tstack/lnav)<br>[ubi:tstack/lnav](https://github.com/tstack/lnav) |  |
| localstack | [ubi:localstack/localstack-cli](https://github.com/localstack/localstack-cli) |  |
| logtalk | [asdf:mise-plugins/mise-logtalk](https://github.com/mise-plugins/mise-logtalk) |  |
| loki-logcli | [aqua:grafana/loki/logcli](https://github.com/grafana/loki)<br>[asdf:comdotlinux/asdf-loki-logcli](https://github.com/comdotlinux/asdf-loki-logcli) |  |
| ls-lint | [aqua:loeffel-io/ls-lint](https://github.com/loeffel-io/ls-lint)<br>[ubi:loeffel-io/ls-lint](https://github.com/loeffel-io/ls-lint)<br>[npm:@ls-lint/ls-lint](https://www.npmjs.com/package/@ls-lint/ls-lint)<br>[asdf:Ameausoone/asdf-ls-lint](https://github.com/Ameausoone/asdf-ls-lint) |  |
| lsd | [aqua:lsd-rs/lsd](https://github.com/lsd-rs/lsd)<br>[asdf:mise-plugins/asdf-lsd](https://github.com/mise-plugins/asdf-lsd) |  |
| lua | [asdf:mise-plugins/mise-lua](https://github.com/mise-plugins/mise-lua) |  |
| lua-language-server | [aqua:LuaLS/lua-language-server](https://github.com/LuaLS/lua-language-server)<br>[asdf:bellini666/asdf-lua-language-server](https://github.com/bellini666/asdf-lua-language-server) |  |
| luajit | [asdf:mise-plugins/mise-luaJIT](https://github.com/mise-plugins/mise-luaJIT) |  |
| luau | [aqua:luau-lang/luau](https://github.com/luau-lang/luau) |  |
| lychee | [aqua:lycheeverse/lychee](https://github.com/lycheeverse/lychee)<br>[ubi:lycheeverse/lychee](https://github.com/lycheeverse/lychee)<br>[cargo:lychee](https://crates.io/crates/lychee) |  |
| maestro | [ubi:mobile-dev-inc/maestro](https://github.com/mobile-dev-inc/maestro)<br>[asdf:dotanuki-labs/asdf-maestro](https://github.com/dotanuki-labs/asdf-maestro) |  |
| mage | [aqua:magefile/mage](https://github.com/magefile/mage)<br>[asdf:mathew-fleisch/asdf-mage](https://github.com/mathew-fleisch/asdf-mage) |  |
| make | [asdf:mise-plugins/mise-make](https://github.com/mise-plugins/mise-make) |  |
| mani | [aqua:alajmo/mani](https://github.com/alajmo/mani)<br>[ubi:alajmo/mani](https://github.com/alajmo/mani)<br>[asdf:anweber/asdf-mani](https://github.com/anweber/asdf-mani) |  |
| mark | [ubi:kovetskiy/mark](https://github.com/kovetskiy/mark)<br>[asdf:jfreeland/asdf-mark](https://github.com/jfreeland/asdf-mark) |  |
| markdownlint-cli2 | [npm:markdownlint-cli2](https://www.npmjs.com/package/markdownlint-cli2)<br>[asdf:paulo-ferraz-oliveira/asdf-markdownlint-cli2](https://github.com/paulo-ferraz-oliveira/asdf-markdownlint-cli2) |  |
| marksman | [aqua:artempyanykh/marksman](https://github.com/artempyanykh/marksman) |  |
| marp-cli | [aqua:marp-team/marp-cli](https://github.com/marp-team/marp-cli)<br>[asdf:xataz/asdf-marp-cli](https://github.com/xataz/asdf-marp-cli) |  |
| mask | [aqua:jacobdeichert/mask](https://github.com/jacobdeichert/mask)<br>[asdf:aaaaninja/asdf-mask](https://github.com/aaaaninja/asdf-mask) |  |
| maven | [aqua:apache/maven](https://github.com/apache/maven)<br>[asdf:mise-plugins/mise-maven](https://github.com/mise-plugins/mise-maven)<br>[vfox:mise-plugins/vfox-maven](https://github.com/mise-plugins/vfox-maven) |  |
| mc | [asdf:mise-plugins/mise-mc](https://github.com/mise-plugins/mise-mc) |  |
| mdbook | [aqua:rust-lang/mdBook](https://github.com/rust-lang/mdBook)<br>[asdf:cipherstash/asdf-mdbook](https://github.com/cipherstash/asdf-mdbook) |  |
| mdbook-linkcheck | [ubi:Michael-F-Bryan/mdbook-linkcheck](https://github.com/Michael-F-Bryan/mdbook-linkcheck)<br>[asdf:mise-plugins/mise-mdbook-linkcheck](https://github.com/mise-plugins/mise-mdbook-linkcheck) |  |
| melange | [aqua:chainguard-dev/melange](https://github.com/chainguard-dev/melange)<br>[asdf:omissis/asdf-melange](https://github.com/omissis/asdf-melange) | linux, macos |
| melt | [ubi:charmbracelet/melt](https://github.com/charmbracelet/melt)<br>[asdf:chessmango/asdf-melt](https://github.com/chessmango/asdf-melt) |  |
| memcached | [asdf:mise-plugins/mise-memcached](https://github.com/mise-plugins/mise-memcached) |  |
| mercury | [asdf:mise-plugins/mise-mercury](https://github.com/mise-plugins/mise-mercury) |  |
| meson | [asdf:mise-plugins/mise-meson](https://github.com/mise-plugins/mise-meson) |  |
| micronaut | [asdf:mise-plugins/mise-micronaut](https://github.com/mise-plugins/mise-micronaut) |  |
| mill | [asdf:mise-plugins/mise-mill](https://github.com/mise-plugins/mise-mill) |  |
| mimirtool | [aqua:grafana/mimir/mimirtool](https://github.com/grafana/mimir)<br>[asdf:asdf-community/asdf-mimirtool](https://github.com/asdf-community/asdf-mimirtool) | linux, macos |
| minify | [aqua:tdewolff/minify](https://github.com/tdewolff/minify)<br>[asdf:axilleas/asdf-minify](https://github.com/axilleas/asdf-minify) |  |
| minikube | [aqua:kubernetes/minikube](https://github.com/kubernetes/minikube)<br>[asdf:alvarobp/asdf-minikube](https://github.com/alvarobp/asdf-minikube) |  |
| minio | [asdf:mise-plugins/mise-minio](https://github.com/mise-plugins/mise-minio) |  |
| minishift | [aqua:minishift/minishift](https://github.com/minishift/minishift)<br>[asdf:sqtran/asdf-minishift](https://github.com/sqtran/asdf-minishift) |  |
| minisign | [aqua:jedisct1/minisign](https://github.com/jedisct1/minisign) |  |
| mint | [ubi:mint-lang/mint](https://github.com/mint-lang/mint)<br>[asdf:mint-lang/asdf-mint](https://github.com/mint-lang/asdf-mint) |  |
| mirrord | [ubi:metalbear-co/mirrord](https://github.com/metalbear-co/mirrord)<br>[asdf:metalbear-co/asdf-mirrord](https://github.com/metalbear-co/asdf-mirrord) |  |
| mitmproxy | [asdf:mise-plugins/mise-mitmproxy](https://github.com/mise-plugins/mise-mitmproxy) |  |
| mkcert | [aqua:FiloSottile/mkcert](https://github.com/FiloSottile/mkcert)<br>[ubi:FiloSottile/mkcert](https://github.com/FiloSottile/mkcert)<br>[asdf:salasrod/asdf-mkcert](https://github.com/salasrod/asdf-mkcert) |  |
| mlton | [asdf:mise-plugins/mise-mlton](https://github.com/mise-plugins/mise-mlton) |  |
| mockery | [aqua:vektra/mockery](https://github.com/vektra/mockery)<br>[asdf:cabify/asdf-mockery](https://github.com/cabify/asdf-mockery) |  |
| mockolo | [ubi:uber/mockolo](https://github.com/uber/mockolo)<br>[asdf:mise-plugins/mise-mockolo](https://github.com/mise-plugins/mise-mockolo) |  |
| mold | [aqua:rui314/mold](https://github.com/rui314/mold)<br>[ubi:rui314/mold](https://github.com/rui314/mold) |  |
| monarch | [asdf:mise-plugins/mise-monarch](https://github.com/mise-plugins/mise-monarch) |  |
| mongodb | [asdf:mise-plugins/mise-mongodb](https://github.com/mise-plugins/mise-mongodb) |  |
| mongosh | [ubi:mongodb-js/mongosh](https://github.com/mongodb-js/mongosh)<br>[asdf:itspngu/asdf-mongosh](https://github.com/itspngu/asdf-mongosh) |  |
| mprocs | [aqua:pvolok/mprocs](https://github.com/pvolok/mprocs)<br>[ubi:pvolok/mprocs](https://github.com/pvolok/mprocs) |  |
| mssqldef | [aqua:sqldef/sqldef/mssqldef](https://github.com/sqldef/sqldef) |  |
| mutanus | [asdf:mise-plugins/mise-mutanus](https://github.com/mise-plugins/mise-mutanus) |  |
| mvnd | [aqua:apache/maven-mvnd](https://github.com/apache/maven-mvnd)<br>[asdf:joschi/asdf-mvnd](https://github.com/joschi/asdf-mvnd) |  |
| mysql | [asdf:mise-plugins/mise-mysql](https://github.com/mise-plugins/mise-mysql) |  |
| mysqldef | [aqua:sqldef/sqldef/mysqldef](https://github.com/sqldef/sqldef) |  |
| nancy | [aqua:sonatype-nexus-community/nancy](https://github.com/sonatype-nexus-community/nancy)<br>[asdf:iilyak/asdf-nancy](https://github.com/iilyak/asdf-nancy) |  |
| nano | [asdf:mise-plugins/mise-nano](https://github.com/mise-plugins/mise-nano) |  |
| nasm | [asdf:mise-plugins/mise-nasm](https://github.com/mise-plugins/mise-nasm) |  |
| navi | [aqua:denisidoro/navi](https://github.com/denisidoro/navi)<br>[ubi:denisidoro/navi](https://github.com/denisidoro/navi) |  |
| neko | [ubi:HaxeFoundation/neko](https://github.com/HaxeFoundation/neko)<br>[asdf:asdf-community/asdf-neko](https://github.com/asdf-community/asdf-neko) |  |
| neonctl | [aqua:neondatabase/neonctl](https://github.com/neondatabase/neonctl)<br>[ubi:neondatabase/neonctl](https://github.com/neondatabase/neonctl) |  |
| neovim | [aqua:neovim/neovim](https://github.com/neovim/neovim)<br>[asdf:richin13/asdf-neovim](https://github.com/richin13/asdf-neovim) |  |
| nerdctl | [aqua:containerd/nerdctl](https://github.com/containerd/nerdctl)<br>[asdf:dmpe/asdf-nerdctl](https://github.com/dmpe/asdf-nerdctl) |  |
| newrelic | [aqua:newrelic/newrelic-cli](https://github.com/newrelic/newrelic-cli)<br>[ubi:newrelic/newrelic-cli](https://github.com/newrelic/newrelic-cli)<br>[asdf:NeoHsu/asdf-newrelic-cli](https://github.com/NeoHsu/asdf-newrelic-cli) |  |
| nfpm | [aqua:goreleaser/nfpm](https://github.com/goreleaser/nfpm)<br>[ubi:goreleaser/nfpm](https://github.com/goreleaser/nfpm)<br>[asdf:ORCID/asdf-nfpm](https://github.com/ORCID/asdf-nfpm) |  |
| ni | [npm:@antfu/ni](https://www.npmjs.com/package/@antfu/ni) |  |
| nim | [asdf:mise-plugins/mise-nim](https://github.com/mise-plugins/mise-nim) |  |
| ninja | [aqua:ninja-build/ninja](https://github.com/ninja-build/ninja)<br>[asdf:asdf-community/asdf-ninja](https://github.com/asdf-community/asdf-ninja) |  |
| node | [core:node](https://mise.jdx.dev/lang/node.html) |  |
| nomad | [aqua:hashicorp/nomad](https://github.com/hashicorp/nomad)<br>[asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| nomad-pack | [asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| notation | [aqua:notaryproject/notation](https://github.com/notaryproject/notation)<br>[asdf:bodgit/asdf-notation](https://github.com/bodgit/asdf-notation) |  |
| nova | [aqua:FairwindsOps/nova](https://github.com/FairwindsOps/nova)<br>[asdf:elementalvoid/asdf-nova](https://github.com/elementalvoid/asdf-nova) |  |
| nsc | [ubi:nats-io/nsc](https://github.com/nats-io/nsc)<br>[asdf:dex4er/asdf-nsc](https://github.com/dex4er/asdf-nsc) |  |
| numbat | [aqua:sharkdp/numbat](https://github.com/sharkdp/numbat)<br>[ubi:sharkdp/numbat](https://github.com/sharkdp/numbat) |  |
| oapi-codegen | [go:github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen](https://pkg.go.dev/github.com/oapi-codegen/oapi-codegen/v2/cmd/oapi-codegen)<br>[asdf:dylanrayboss/asdf-oapi-codegen](https://github.com/dylanrayboss/asdf-oapi-codegen) |  |
| oauth2c | [aqua:cloudentity/oauth2c](https://github.com/cloudentity/oauth2c)<br>[ubi:cloudentity/oauth2c](https://github.com/cloudentity/oauth2c) |  |
| oc | [asdf:mise-plugins/mise-oc](https://github.com/mise-plugins/mise-oc) |  |
| ocaml | [asdf:mise-plugins/mise-ocaml](https://github.com/mise-plugins/mise-ocaml) |  |
| oci | [asdf:mise-plugins/mise-oci](https://github.com/mise-plugins/mise-oci) |  |
| octosql | [ubi:cube2222/octosql](https://github.com/cube2222/octosql) |  |
| odin | [ubi:odin-lang/Odin](https://github.com/odin-lang/Odin)<br>[asdf:jtakakura/asdf-odin](https://github.com/jtakakura/asdf-odin) |  |
| odo | [aqua:redhat-developer/odo](https://github.com/redhat-developer/odo)<br>[asdf:rm3l/asdf-odo](https://github.com/rm3l/asdf-odo) |  |
| okta-aws | [aqua:okta/okta-aws-cli](https://github.com/okta/okta-aws-cli)<br>[asdf:bennythejudge/asdf-plugin-okta-aws-cli](https://github.com/bennythejudge/asdf-plugin-okta-aws-cli) |  |
| okteto | [aqua:okteto/okteto](https://github.com/okteto/okteto)<br>[asdf:BradenM/asdf-okteto](https://github.com/BradenM/asdf-okteto) |  |
| ollama | [aqua:ollama/ollama](https://github.com/ollama/ollama)<br>[asdf:virtualstaticvoid/asdf-ollama](https://github.com/virtualstaticvoid/asdf-ollama) |  |
| om | [aqua:pivotal-cf/om](https://github.com/pivotal-cf/om)<br>[asdf:mise-plugins/tanzu-plug-in-for-asdf](https://github.com/mise-plugins/tanzu-plug-in-for-asdf) |  |
| onyx | [ubi:onyx-lang/onyx](https://github.com/onyx-lang/onyx)<br>[asdf:jtakakura/asdf-onyx](https://github.com/jtakakura/asdf-onyx) |  |
| opa | [aqua:open-policy-agent/opa](https://github.com/open-policy-agent/opa)<br>[asdf:tochukwuvictor/asdf-opa](https://github.com/tochukwuvictor/asdf-opa) |  |
| opam | [ubi:ocaml/opam](https://github.com/ocaml/opam)<br>[asdf:asdf-community/asdf-opam](https://github.com/asdf-community/asdf-opam) |  |
| openbao | [ubi:openbao/openbao](https://github.com/openbao/openbao) |  |
| opencode | [aqua:sst/opencode](https://github.com/sst/opencode)<br>[ubi:sst/opencode](https://github.com/sst/opencode) |  |
| openfaas-cli | [aqua:openfaas/faas-cli](https://github.com/openfaas/faas-cli)<br>[asdf:zekker6/asdf-faas-cli](https://github.com/zekker6/asdf-faas-cli) |  |
| openresty | [asdf:mise-plugins/mise-openresty](https://github.com/mise-plugins/mise-openresty) |  |
| opensearch | [asdf:mise-plugins/mise-opensearch](https://github.com/mise-plugins/mise-opensearch) |  |
| opensearch-cli | [ubi:opensearch-project/opensearch-cli](https://github.com/opensearch-project/opensearch-cli)<br>[asdf:mise-plugins/mise-opensearch-cli](https://github.com/mise-plugins/mise-opensearch-cli) |  |
| openshift-install | [asdf:mise-plugins/mise-openshift-install](https://github.com/mise-plugins/mise-openshift-install) |  |
| opentofu | [aqua:opentofu/opentofu](https://github.com/opentofu/opentofu)<br>[ubi:opentofu/opentofu](https://github.com/opentofu/opentofu)<br>[asdf:virtualroot/asdf-opentofu](https://github.com/virtualroot/asdf-opentofu) |  |
| operator-sdk | [aqua:operator-framework/operator-sdk](https://github.com/operator-framework/operator-sdk)<br>[asdf:Medium/asdf-operator-sdk](https://github.com/Medium/asdf-operator-sdk) |  |
| opsgenie-lamp | [ubi:opsgenie/opsgenie-lamp](https://github.com/opsgenie/opsgenie-lamp)<br>[asdf:mise-plugins/mise-opsgenie-lamp](https://github.com/mise-plugins/mise-opsgenie-lamp) |  |
| oras | [aqua:oras-project/oras](https://github.com/oras-project/oras)<br>[asdf:bodgit/asdf-oras](https://github.com/bodgit/asdf-oras) |  |
| osqueryi | [asdf:mise-plugins/mise-osqueryi](https://github.com/mise-plugins/mise-osqueryi) |  |
| osv-scanner | [aqua:google/osv-scanner](https://github.com/google/osv-scanner) |  |
| overmind | [ubi:DarthSim/overmind](https://github.com/DarthSim/overmind)<br>[go:github.com/DarthSim/overmind/v2](https://pkg.go.dev/github.com/DarthSim/overmind/v2) |  |
| oxipng | [aqua:shssoichiro/oxipng](https://github.com/shssoichiro/oxipng) |  |
| oxker | [aqua:mrjackwills/oxker](https://github.com/mrjackwills/oxker)<br>[ubi:mrjackwills/oxker](https://github.com/mrjackwills/oxker)<br>[cargo:oxker](https://crates.io/crates/oxker) |  |
| oxlint | [aqua:oxc-project/oxc/oxlint](https://github.com/oxc-project/oxc)<br>[ubi:oxc-project/oxc](https://github.com/oxc-project/oxc)<br>[npm:oxlint](https://www.npmjs.com/package/oxlint) |  |
| pachctl | [aqua:pachyderm/pachyderm](https://github.com/pachyderm/pachyderm)<br>[asdf:abatilo/asdf-pachctl](https://github.com/abatilo/asdf-pachctl) |  |
| packer | [aqua:hashicorp/packer](https://github.com/hashicorp/packer)<br>[asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| pandoc | [ubi:jgm/pandoc](https://github.com/jgm/pandoc)<br>[asdf:Fbrisset/asdf-pandoc](https://github.com/Fbrisset/asdf-pandoc) |  |
| patat | [ubi:jaspervdj/patat](https://github.com/jaspervdj/patat)<br>[asdf:airtonix/asdf-patat](https://github.com/airtonix/asdf-patat) |  |
| pdm | [pipx:pdm](https://pypi.org/project/pdm)<br>[asdf:1oglop1/asdf-pdm](https://github.com/1oglop1/asdf-pdm) |  |
| peco | [aqua:peco/peco](https://github.com/peco/peco)<br>[asdf:asdf-community/asdf-peco](https://github.com/asdf-community/asdf-peco) |  |
| periphery | [aqua:peripheryapp/periphery](https://github.com/peripheryapp/periphery)<br>[asdf:mise-plugins/mise-periphery](https://github.com/mise-plugins/mise-periphery) |  |
| perl | [aqua:skaji/relocatable-perl](https://github.com/skaji/relocatable-perl)<br>[asdf:ouest/asdf-perl](https://github.com/ouest/asdf-perl) |  |
| php | [asdf:mise-plugins/asdf-php](https://github.com/mise-plugins/asdf-php)<br>[vfox:mise-plugins/vfox-php](https://github.com/mise-plugins/vfox-php) |  |
| pinact | [aqua:suzuki-shunsuke/pinact](https://github.com/suzuki-shunsuke/pinact)<br>[ubi:suzuki-shunsuke/pinact](https://github.com/suzuki-shunsuke/pinact) |  |
| pint | [aqua:cloudflare/pint](https://github.com/cloudflare/pint)<br>[asdf:sam-burrell/asdf-pint](https://github.com/sam-burrell/asdf-pint) |  |
| pipectl | [aqua:pipe-cd/pipecd/pipectl](https://github.com/pipe-cd/pipecd)<br>[asdf:pipe-cd/asdf-pipectl](https://github.com/pipe-cd/asdf-pipectl) | linux, macos |
| pipelight | [asdf:mise-plugins/mise-pipelight](https://github.com/mise-plugins/mise-pipelight) |  |
| pipenv | [asdf:mise-plugins/mise-pipenv](https://github.com/mise-plugins/mise-pipenv) |  |
| pipx | [asdf:mise-plugins/mise-pipx](https://github.com/mise-plugins/mise-pipx) |  |
| pitchfork | [aqua:jdx/pitchfork](https://github.com/jdx/pitchfork)<br>[ubi:jdx/pitchfork](https://github.com/jdx/pitchfork) |  |
| pivnet | [aqua:pivotal-cf/pivnet-cli](https://github.com/pivotal-cf/pivnet-cli)<br>[asdf:mise-plugins/tanzu-plug-in-for-asdf](https://github.com/mise-plugins/tanzu-plug-in-for-asdf) |  |
| pixi | [ubi:prefix-dev/pixi](https://github.com/prefix-dev/pixi) |  |
| pkl | [aqua:apple/pkl](https://github.com/apple/pkl)<br>[ubi:apple/pkl](https://github.com/apple/pkl)<br>[asdf:mise-plugins/asdf-pkl](https://github.com/mise-plugins/asdf-pkl) |  |
| please | [aqua:thought-machine/please](https://github.com/thought-machine/please)<br>[asdf:asdf-community/asdf-please](https://github.com/asdf-community/asdf-please) |  |
| pluto | [aqua:FairwindsOps/pluto](https://github.com/FairwindsOps/pluto)<br>[ubi:FairwindsOps/pluto](https://github.com/FairwindsOps/pluto)<br>[asdf:FairwindsOps/asdf-pluto](https://github.com/FairwindsOps/asdf-pluto) |  |
| pnpm | [aqua:pnpm/pnpm](https://github.com/pnpm/pnpm)<br>[ubi:pnpm/pnpm](https://github.com/pnpm/pnpm)<br>[npm:pnpm](https://www.npmjs.com/package/pnpm)<br>[asdf:jonathanmorley/asdf-pnpm](https://github.com/jonathanmorley/asdf-pnpm) |  |
| podman | [ubi:containers/podman](https://github.com/containers/podman)<br>[asdf:tvon/asdf-podman](https://github.com/tvon/asdf-podman) |  |
| poetry | [asdf:mise-plugins/mise-poetry](https://github.com/mise-plugins/mise-poetry) |  |
| polaris | [aqua:FairwindsOps/polaris](https://github.com/FairwindsOps/polaris)<br>[asdf:particledecay/asdf-polaris](https://github.com/particledecay/asdf-polaris) |  |
| popeye | [aqua:derailed/popeye](https://github.com/derailed/popeye)<br>[asdf:nlamirault/asdf-popeye](https://github.com/nlamirault/asdf-popeye) |  |
| postgis | [asdf:mise-plugins/mise-postgis](https://github.com/mise-plugins/mise-postgis) |  |
| postgres | [asdf:mise-plugins/mise-postgres](https://github.com/mise-plugins/mise-postgres) |  |
| powerline-go | [aqua:justjanne/powerline-go](https://github.com/justjanne/powerline-go)<br>[ubi:justjanne/powerline-go](https://github.com/justjanne/powerline-go)<br>[asdf:dex4er/asdf-powerline-go](https://github.com/dex4er/asdf-powerline-go) |  |
| powerpipe | [aqua:turbot/powerpipe](https://github.com/turbot/powerpipe)<br>[asdf:jc00ke/asdf-powerpipe](https://github.com/jc00ke/asdf-powerpipe) |  |
| powershell-core | [aqua:PowerShell/PowerShell](https://github.com/PowerShell/PowerShell)<br>[asdf:daveneeley/asdf-powershell-core](https://github.com/daveneeley/asdf-powershell-core) |  |
| pre-commit | [aqua:pre-commit/pre-commit](https://github.com/pre-commit/pre-commit)<br>[ubi:pre-commit/pre-commit](https://github.com/pre-commit/pre-commit)<br>[asdf:jonathanmorley/asdf-pre-commit](https://github.com/jonathanmorley/asdf-pre-commit)<br>[pipx:pre-commit](https://pypi.org/project/pre-commit) |  |
| prettier | [npm:prettier](https://www.npmjs.com/package/prettier) |  |
| process-compose | [ubi:F1bonacc1/process-compose](https://github.com/F1bonacc1/process-compose) |  |
| promtool | [aqua:prometheus/prometheus](https://github.com/prometheus/prometheus)<br>[asdf:asdf-community/asdf-promtool](https://github.com/asdf-community/asdf-promtool) |  |
| protoc | [aqua:protocolbuffers/protobuf/protoc](https://github.com/protocolbuffers/protobuf)<br>[asdf:paxosglobal/asdf-protoc](https://github.com/paxosglobal/asdf-protoc) |  |
| protoc-gen-connect-go | [go:connectrpc.com/connect/cmd/protoc-gen-connect-go](https://pkg.go.dev/connectrpc.com/connect/cmd/protoc-gen-connect-go)<br>[asdf:dylanrayboss/asdf-protoc-gen-connect-go](https://github.com/dylanrayboss/asdf-protoc-gen-connect-go) |  |
| protoc-gen-go | [aqua:protocolbuffers/protobuf-go/protoc-gen-go](https://github.com/protocolbuffers/protobuf-go)<br>[asdf:pbr0ck3r/asdf-protoc-gen-go](https://github.com/pbr0ck3r/asdf-protoc-gen-go) |  |
| protoc-gen-go-grpc | [aqua:grpc/grpc-go/protoc-gen-go-grpc](https://github.com/grpc/grpc-go)<br>[asdf:pbr0ck3r/asdf-protoc-gen-go-grpc](https://github.com/pbr0ck3r/asdf-protoc-gen-go-grpc) |  |
| protoc-gen-grpc-web | [asdf:mise-plugins/mise-protoc-gen-grpc-web](https://github.com/mise-plugins/mise-protoc-gen-grpc-web) |  |
| protoc-gen-js | [ubi:protocolbuffers/protobuf-javascript](https://github.com/protocolbuffers/protobuf-javascript)<br>[asdf:pbr0ck3r/asdf-protoc-gen-js](https://github.com/pbr0ck3r/asdf-protoc-gen-js) |  |
| protoc-gen-validate | [aqua:bufbuild/protoc-gen-validate](https://github.com/bufbuild/protoc-gen-validate)<br>[go:github.com/envoyproxy/protoc-gen-validate](https://pkg.go.dev/github.com/envoyproxy/protoc-gen-validate) |  |
| protolint | [aqua:yoheimuta/protolint](https://github.com/yoheimuta/protolint)<br>[asdf:spencergilbert/asdf-protolint](https://github.com/spencergilbert/asdf-protolint) |  |
| protonge | [asdf:mise-plugins/mise-protonge](https://github.com/mise-plugins/mise-protonge) |  |
| psc-package | [ubi:purescript/psc-package](https://github.com/purescript/psc-package)<br>[asdf:nsaunders/asdf-psc-package](https://github.com/nsaunders/asdf-psc-package) |  |
| psqldef | [aqua:sqldef/sqldef/psqldef](https://github.com/sqldef/sqldef) |  |
| pulumi | [aqua:pulumi/pulumi](https://github.com/pulumi/pulumi)<br>[asdf:canha/asdf-pulumi](https://github.com/canha/asdf-pulumi) |  |
| purerl | [ubi:purerl/purerl](https://github.com/purerl/purerl)<br>[asdf:GoNZooo/asdf-purerl](https://github.com/GoNZooo/asdf-purerl) |  |
| purescript | [ubi:purescript/purescript](https://github.com/purescript/purescript)<br>[asdf:jrrom/asdf-purescript](https://github.com/jrrom/asdf-purescript) |  |
| purty | [asdf:mise-plugins/mise-purty](https://github.com/mise-plugins/mise-purty) |  |
| python | [core:python](https://mise.jdx.dev/lang/python.html) |  |
| qdns | [ubi:natesales/q](https://github.com/natesales/q)<br>[asdf:moritz-makandra/asdf-plugin-qdns](https://github.com/moritz-makandra/asdf-plugin-qdns) |  |
| qsv | [ubi:dathere/qsv](https://github.com/dathere/qsv)<br>[asdf:vjda/asdf-qsv](https://github.com/vjda/asdf-qsv) |  |
| quarkus | [asdf:mise-plugins/mise-quarkus](https://github.com/mise-plugins/mise-quarkus) |  |
| r | [asdf:mise-plugins/mise-r](https://github.com/mise-plugins/mise-r) |  |
| rabbitmq | [asdf:mise-plugins/asdf-rabbitmq](https://github.com/mise-plugins/asdf-rabbitmq) |  |
| racket | [asdf:mise-plugins/mise-racket](https://github.com/mise-plugins/mise-racket) |  |
| railway | [ubi:railwayapp/cli](https://github.com/railwayapp/cli) |  |
| raku | [asdf:mise-plugins/mise-raku](https://github.com/mise-plugins/mise-raku) |  |
| rancher | [aqua:rancher/cli](https://github.com/rancher/cli)<br>[asdf:abinet/asdf-rancher](https://github.com/abinet/asdf-rancher) |  |
| rbac-lookup | [aqua:FairwindsOps/rbac-lookup](https://github.com/FairwindsOps/rbac-lookup)<br>[asdf:looztra/asdf-rbac-lookup](https://github.com/looztra/asdf-rbac-lookup) |  |
| rclone | [aqua:rclone/rclone](https://github.com/rclone/rclone)<br>[ubi:rclone/rclone](https://github.com/rclone/rclone)<br>[asdf:johnlayton/asdf-rclone](https://github.com/johnlayton/asdf-rclone) |  |
| rebar | [asdf:mise-plugins/mise-rebar](https://github.com/mise-plugins/mise-rebar) |  |
| reckoner | [ubi:FairwindsOps/reckoner](https://github.com/FairwindsOps/reckoner)<br>[asdf:FairwindsOps/asdf-reckoner](https://github.com/FairwindsOps/asdf-reckoner) |  |
| redis | [asdf:mise-plugins/mise-redis](https://github.com/mise-plugins/mise-redis) |  |
| redis-cli | [asdf:mise-plugins/mise-redis-cli](https://github.com/mise-plugins/mise-redis-cli) |  |
| redo | [aqua:barthr/redo](https://github.com/barthr/redo)<br>[ubi:barthr/redo](https://github.com/barthr/redo)<br>[asdf:chessmango/asdf-redo](https://github.com/chessmango/asdf-redo) |  |
| reg | [aqua:genuinetools/reg](https://github.com/genuinetools/reg)<br>[asdf:looztra/asdf-reg](https://github.com/looztra/asdf-reg) |  |
| regal | [aqua:StyraInc/regal](https://github.com/StyraInc/regal)<br>[asdf:mise-plugins/mise-regal](https://github.com/mise-plugins/mise-regal) |  |
| regctl | [aqua:regclient/regclient/regctl](https://github.com/regclient/regclient)<br>[asdf:ORCID/asdf-regctl](https://github.com/ORCID/asdf-regctl) |  |
| regsync | [aqua:regclient/regclient/regsync](https://github.com/regclient/regclient)<br>[asdf:rsrchboy/asdf-regsync](https://github.com/rsrchboy/asdf-regsync) |  |
| restic | [aqua:restic/restic](https://github.com/restic/restic)<br>[asdf:xataz/asdf-restic](https://github.com/xataz/asdf-restic) |  |
| restish | [ubi:danielgtaylor/restish](https://github.com/danielgtaylor/restish)<br>[go:github.com/danielgtaylor/restish](https://pkg.go.dev/github.com/danielgtaylor/restish) |  |
| resvg | [aqua:linebender/resvg](https://github.com/linebender/resvg) |  |
| revive | [aqua:mgechev/revive](https://github.com/mgechev/revive)<br>[asdf:bjw-s/asdf-revive](https://github.com/bjw-s/asdf-revive) |  |
| richgo | [aqua:kyoh86/richgo](https://github.com/kyoh86/richgo)<br>[asdf:paxosglobal/asdf-richgo](https://github.com/paxosglobal/asdf-richgo) |  |
| ripgrep | [aqua:BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)<br>[ubi:BurntSushi/ripgrep](https://github.com/BurntSushi/ripgrep)<br>[asdf:https://gitlab.com/wt0f/asdf-ripgrep](https://gitlab.com/wt0f/asdf-ripgrep)<br>[cargo:ripgrep](https://crates.io/crates/ripgrep) |  |
| ripgrep-all | [aqua:phiresky/ripgrep-all](https://github.com/phiresky/ripgrep-all)<br>[ubi:phiresky/ripgrep-all](https://github.com/phiresky/ripgrep-all)<br>[cargo:ripgrep\_all](https://crates.io/crates/ripgrep_all) |  |
| ripsecrets | [aqua:sirwart/ripsecrets](https://github.com/sirwart/ripsecrets)<br>[asdf:https://github.com/boris-smidt-klarrio/asdf-ripsecrets](https://github.com/boris-smidt-klarrio/asdf-ripsecrets) |  |
| rke | [aqua:rancher/rke](https://github.com/rancher/rke)<br>[asdf:particledecay/asdf-rke](https://github.com/particledecay/asdf-rke) |  |
| rlwrap | [asdf:mise-plugins/mise-rlwrap](https://github.com/mise-plugins/mise-rlwrap) |  |
| ruby | [core:ruby](https://mise.jdx.dev/lang/ruby.html) |  |
| ruff | [aqua:astral-sh/ruff](https://github.com/astral-sh/ruff)<br>[ubi:astral-sh/ruff](https://github.com/astral-sh/ruff)<br>[asdf:simhem/asdf-ruff](https://github.com/simhem/asdf-ruff) |  |
| rust | [core:rust](https://mise.jdx.dev/lang/rust.html)<br>[asdf:code-lever/asdf-rust](https://github.com/code-lever/asdf-rust) |  |
| rust-analyzer | [aqua:rust-lang/rust-analyzer](https://github.com/rust-lang/rust-analyzer)<br>[asdf:Xyven1/asdf-rust-analyzer](https://github.com/Xyven1/asdf-rust-analyzer) |  |
| rustic | [aqua:rustic-rs/rustic](https://github.com/rustic-rs/rustic)<br>[ubi:rustic-rs/rustic](https://github.com/rustic-rs/rustic) |  |
| rye | [aqua:astral-sh/rye](https://github.com/astral-sh/rye)<br>[asdf:Azuki-bar/asdf-rye](https://github.com/Azuki-bar/asdf-rye) |  |
| saml2aws | [aqua:Versent/saml2aws](https://github.com/Versent/saml2aws)<br>[asdf:elementalvoid/asdf-saml2aws](https://github.com/elementalvoid/asdf-saml2aws) |  |
| sampler | [aqua:sqshq/sampler](https://github.com/sqshq/sampler)<br>[ubi:sqshq/sampler](https://github.com/sqshq/sampler) |  |
| sbcl | [asdf:mise-plugins/mise-sbcl](https://github.com/mise-plugins/mise-sbcl) |  |
| sbt | [asdf:mise-plugins/mise-sbt](https://github.com/mise-plugins/mise-sbt) |  |
| scala | [asdf:mise-plugins/mise-scala](https://github.com/mise-plugins/mise-scala)<br>[vfox:mise-plugins/vfox-scala](https://github.com/mise-plugins/vfox-scala) |  |
| scala-cli | [ubi:VirtusLab/scala-cli](https://github.com/VirtusLab/scala-cli)<br>[asdf:mise-plugins/mise-scala-cli](https://github.com/mise-plugins/mise-scala-cli) |  |
| scaleway | [aqua:scaleway/scaleway-cli](https://github.com/scaleway/scaleway-cli)<br>[asdf:albarralnunez/asdf-plugin-scaleway-cli](https://github.com/albarralnunez/asdf-plugin-scaleway-cli) |  |
| scalingo-cli | [aqua:Scalingo/cli](https://github.com/Scalingo/cli)<br>[asdf:brandon-welsch/asdf-scalingo-cli](https://github.com/brandon-welsch/asdf-scalingo-cli) |  |
| scarb | [ubi:software-mansion/scarb](https://github.com/software-mansion/scarb)<br>[asdf:software-mansion/asdf-scarb](https://github.com/software-mansion/asdf-scarb) |  |
| sccache | [aqua:mozilla/sccache](https://github.com/mozilla/sccache)<br>[ubi:mozilla/sccache](https://github.com/mozilla/sccache)<br>[asdf:emersonmx/asdf-sccache](https://github.com/emersonmx/asdf-sccache) |  |
| schemacrawler | [asdf:mise-plugins/mise-schemacrawler](https://github.com/mise-plugins/mise-schemacrawler) |  |
| scie-pants | [ubi:pantsbuild/scie-pants](https://github.com/pantsbuild/scie-pants)<br>[asdf:robzr/asdf-scie-pants](https://github.com/robzr/asdf-scie-pants) |  |
| scorecard | [aqua:ossf/scorecard](https://github.com/ossf/scorecard) |  |
| sd | [aqua:chmln/sd](https://github.com/chmln/sd)<br>[ubi:chmln/sd](https://github.com/chmln/sd)<br>[cargo:sd](https://crates.io/crates/sd) |  |
| seed7 | [asdf:mise-plugins/mise-seed7](https://github.com/mise-plugins/mise-seed7) |  |
| semgrep | [pipx:semgrep](https://pypi.org/project/semgrep)<br>[asdf:mise-plugins/mise-semgrep](https://github.com/mise-plugins/mise-semgrep) |  |
| semtag | [asdf:mise-plugins/mise-semtag](https://github.com/mise-plugins/mise-semtag) |  |
| semver | [aqua:fsaintjacques/semver-tool](https://github.com/fsaintjacques/semver-tool)<br>[asdf:mathew-fleisch/asdf-semver](https://github.com/mathew-fleisch/asdf-semver) |  |
| sentinel | [asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| sentry | [aqua:getsentry/sentry-cli](https://github.com/getsentry/sentry-cli)<br>[ubi:getsentry/sentry-cli](https://github.com/getsentry/sentry-cli) |  |
| serf | [asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| serverless | [asdf:mise-plugins/mise-serverless](https://github.com/mise-plugins/mise-serverless) |  |
| setup-envtest | [asdf:mise-plugins/mise-setup-envtest](https://github.com/mise-plugins/mise-setup-envtest) |  |
| shell2http | [aqua:msoap/shell2http](https://github.com/msoap/shell2http)<br>[asdf:ORCID/asdf-shell2http](https://github.com/ORCID/asdf-shell2http) |  |
| shellcheck | [aqua:koalaman/shellcheck](https://github.com/koalaman/shellcheck)<br>[ubi:koalaman/shellcheck](https://github.com/koalaman/shellcheck)<br>[asdf:luizm/asdf-shellcheck](https://github.com/luizm/asdf-shellcheck) | linux, macos |
| shellspec | [aqua:shellspec/shellspec](https://github.com/shellspec/shellspec)<br>[asdf:poikilotherm/asdf-shellspec](https://github.com/poikilotherm/asdf-shellspec) |  |
| shfmt | [aqua:mvdan/sh](https://github.com/mvdan/sh)<br>[ubi:mvdan/sh](https://github.com/mvdan/sh)<br>[asdf:luizm/asdf-shfmt](https://github.com/luizm/asdf-shfmt)<br>[go:mvdan.cc/sh/v3/cmd/shfmt](https://pkg.go.dev/mvdan.cc/sh/v3/cmd/shfmt) | linux, macos |
| shorebird | [asdf:mise-plugins/mise-shorebird](https://github.com/mise-plugins/mise-shorebird) |  |
| signadot | [ubi:signadot/cli](https://github.com/signadot/cli) |  |
| sinker | [aqua:plexsystems/sinker](https://github.com/plexsystems/sinker)<br>[asdf:elementalvoid/asdf-sinker](https://github.com/elementalvoid/asdf-sinker) |  |
| skaffold | [aqua:GoogleContainerTools/skaffold](https://github.com/GoogleContainerTools/skaffold)<br>[asdf:nklmilojevic/asdf-skaffold](https://github.com/nklmilojevic/asdf-skaffold) |  |
| skate | [aqua:charmbracelet/skate](https://github.com/charmbracelet/skate)<br>[asdf:chessmango/asdf-skate](https://github.com/chessmango/asdf-skate) |  |
| skeema | [aqua:skeema/skeema](https://github.com/skeema/skeema)<br>[ubi:skeema/skeema](https://github.com/skeema/skeema) |  |
| sloth | [aqua:slok/sloth](https://github.com/slok/sloth)<br>[asdf:slok/asdf-sloth](https://github.com/slok/asdf-sloth) |  |
| slsa-verifier | [ubi:slsa-framework/slsa-verifier](https://github.com/slsa-framework/slsa-verifier) |  |
| smithy | [asdf:mise-plugins/mise-smithy](https://github.com/mise-plugins/mise-smithy) |  |
| smlnj | [asdf:mise-plugins/mise-smlnj](https://github.com/mise-plugins/mise-smlnj) |  |
| snyk | [aqua:snyk/cli](https://github.com/snyk/cli)<br>[asdf:nirfuchs/asdf-snyk](https://github.com/nirfuchs/asdf-snyk) |  |
| soft-serve | [ubi:charmbracelet/soft-serve](https://github.com/charmbracelet/soft-serve)<br>[asdf:chessmango/asdf-soft-serve](https://github.com/chessmango/asdf-soft-serve) |  |
| solidity | [ubi:ethereum/solidity](https://github.com/ethereum/solidity)<br>[asdf:diegodorado/asdf-solidity](https://github.com/diegodorado/asdf-solidity) |  |
| sonobuoy | [ubi:vmware-tanzu/sonobuoy](https://github.com/vmware-tanzu/sonobuoy)<br>[asdf:Nick-Triller/asdf-sonobuoy](https://github.com/Nick-Triller/asdf-sonobuoy) |  |
| sops | [aqua:getsops/sops](https://github.com/getsops/sops)<br>[ubi:getsops/sops](https://github.com/getsops/sops)<br>[asdf:mise-plugins/mise-sops](https://github.com/mise-plugins/mise-sops) |  |
| sopstool | [aqua:ibotta/sopstool](https://github.com/ibotta/sopstool)<br>[asdf:elementalvoid/asdf-sopstool](https://github.com/elementalvoid/asdf-sopstool) |  |
| soracom | [ubi:soracom/soracom-cli](https://github.com/soracom/soracom-cli)<br>[asdf:gr1m0h/asdf-soracom](https://github.com/gr1m0h/asdf-soracom) |  |
| sourcery | [asdf:mise-plugins/mise-sourcery](https://github.com/mise-plugins/mise-sourcery) |  |
| spacectl | [aqua:spacelift-io/spacectl](https://github.com/spacelift-io/spacectl)<br>[asdf:bodgit/asdf-spacectl](https://github.com/bodgit/asdf-spacectl) |  |
| spago | [ubi:purescript/spago](https://github.com/purescript/spago)<br>[asdf:jrrom/asdf-spago](https://github.com/jrrom/asdf-spago) |  |
| spark | [aqua:apache/spark](https://github.com/apache/spark)<br>[asdf:mise-plugins/mise-spark](https://github.com/mise-plugins/mise-spark) |  |
| specstory | [aqua:specstoryai/getspecstory](https://github.com/specstoryai/getspecstory)<br>[ubi:specstoryai/getspecstory](https://github.com/specstoryai/getspecstory) | linux, macos |
| spectral | [aqua:stoplightio/spectral](https://github.com/stoplightio/spectral)<br>[asdf:vbyrd/asdf-spectral](https://github.com/vbyrd/asdf-spectral) |  |
| spin | [aqua:spinnaker/spin](https://github.com/spinnaker/spin)<br>[asdf:pavloos/asdf-spin](https://github.com/pavloos/asdf-spin) |  |
| spring-boot | [asdf:mise-plugins/mise-spring-boot](https://github.com/mise-plugins/mise-spring-boot) |  |
| spruce | [aqua:geofffranks/spruce](https://github.com/geofffranks/spruce)<br>[asdf:woneill/asdf-spruce](https://github.com/woneill/asdf-spruce) |  |
| sqlite | [asdf:mise-plugins/mise-sqlite](https://github.com/mise-plugins/mise-sqlite) |  |
| sqlite3def | [aqua:sqldef/sqldef/sqlite3def](https://github.com/sqldef/sqldef) |  |
| sshi | [aqua:aakso/ssh-inscribe/sshi](https://github.com/aakso/ssh-inscribe) |  |
| sshuttle | [asdf:mise-plugins/mise-sshuttle](https://github.com/mise-plugins/mise-sshuttle) |  |
| sst | [ubi:sst/sst](https://github.com/sst/sst) |  |
| stack | [aqua:commercialhaskell/stack](https://github.com/commercialhaskell/stack)<br>[asdf:mise-plugins/mise-ghcup](https://github.com/mise-plugins/mise-ghcup) |  |
| starboard | [aqua:aquasecurity/starboard](https://github.com/aquasecurity/starboard)<br>[asdf:zufardhiyaulhaq/asdf-starboard](https://github.com/zufardhiyaulhaq/asdf-starboard) |  |
| starknet-foundry | [ubi:foundry-rs/starknet-foundry](https://github.com/foundry-rs/starknet-foundry) |  |
| starknet-foundry-sncast | [ubi:foundry-rs/starknet-foundry](https://github.com/foundry-rs/starknet-foundry) |  |
| starship | [aqua:starship/starship](https://github.com/starship/starship)<br>[ubi:starship/starship](https://github.com/starship/starship)<br>[asdf:gr1m0h/asdf-starship](https://github.com/gr1m0h/asdf-starship) |  |
| staticcheck | [aqua:dominikh/go-tools/staticcheck](https://github.com/dominikh/go-tools)<br>[asdf:pbr0ck3r/asdf-staticcheck](https://github.com/pbr0ck3r/asdf-staticcheck) |  |
| steampipe | [aqua:turbot/steampipe](https://github.com/turbot/steampipe)<br>[asdf:carnei-ro/asdf-steampipe](https://github.com/carnei-ro/asdf-steampipe) |  |
| step | [aqua:smallstep/cli](https://github.com/smallstep/cli)<br>[asdf:log2/asdf-step](https://github.com/log2/asdf-step) |  |
| stern | [aqua:stern/stern](https://github.com/stern/stern)<br>[asdf:looztra/asdf-stern](https://github.com/looztra/asdf-stern) |  |
| stripe | [aqua:stripe/stripe-cli](https://github.com/stripe/stripe-cli)<br>[asdf:offbyone/asdf-stripe](https://github.com/offbyone/asdf-stripe) |  |
| stylua | [aqua:JohnnyMorganz/StyLua](https://github.com/JohnnyMorganz/StyLua)<br>[asdf:jc00ke/asdf-stylua](https://github.com/jc00ke/asdf-stylua) |  |
| sui | [ubi:MystenLabs/sui](https://github.com/MystenLabs/sui)<br>[asdf:placeholder-soft/asdf-sui](https://github.com/placeholder-soft/asdf-sui) |  |
| superfile | [aqua:yorukot/superfile](https://github.com/yorukot/superfile) |  |
| sver | [aqua:mitoma/sver](https://github.com/mitoma/sver)<br>[asdf:robzr/asdf-sver](https://github.com/robzr/asdf-sver) |  |
| svu | [aqua:caarlos0/svu](https://github.com/caarlos0/svu)<br>[asdf:asdf-community/asdf-svu](https://github.com/asdf-community/asdf-svu) |  |
| swag | [aqua:swaggo/swag](https://github.com/swaggo/swag)<br>[asdf:behoof4mind/asdf-swag](https://github.com/behoof4mind/asdf-swag) |  |
| swift | [core:swift](https://mise.jdx.dev/lang/swift.html) | linux, macos |
| swift-package-list | [asdf:mise-plugins/mise-swift-package-list](https://github.com/mise-plugins/mise-swift-package-list) |  |
| swiftformat | [asdf:mise-plugins/mise-swiftformat](https://github.com/mise-plugins/mise-swiftformat) |  |
| swiftgen | [asdf:mise-plugins/mise-swiftgen](https://github.com/mise-plugins/mise-swiftgen) |  |
| swiftlint | [aqua:realm/SwiftLint](https://github.com/realm/SwiftLint)<br>[asdf:mise-plugins/mise-swiftlint](https://github.com/mise-plugins/mise-swiftlint) |  |
| swiprolog | [asdf:mise-plugins/mise-swiprolog](https://github.com/mise-plugins/mise-swiprolog) |  |
| syft | [aqua:anchore/syft](https://github.com/anchore/syft)<br>[asdf:davidgp1701/asdf-syft](https://github.com/davidgp1701/asdf-syft) |  |
| tailpipe | [aqua:turbot/tailpipe](https://github.com/turbot/tailpipe) |  |
| talhelper | [aqua:budimanjojo/talhelper](https://github.com/budimanjojo/talhelper)<br>[asdf:bjw-s/asdf-talhelper](https://github.com/bjw-s/asdf-talhelper) |  |
| talosctl | [aqua:siderolabs/talos](https://github.com/siderolabs/talos)<br>[ubi:siderolabs/talos](https://github.com/siderolabs/talos) |  |
| tanka | [aqua:grafana/tanka](https://github.com/grafana/tanka)<br>[asdf:trotttrotttrott/asdf-tanka](https://github.com/trotttrotttrott/asdf-tanka) |  |
| tanzu | [asdf:mise-plugins/tanzu-plug-in-for-asdf](https://github.com/mise-plugins/tanzu-plug-in-for-asdf) |  |
| taplo | [aqua:tamasfe/taplo](https://github.com/tamasfe/taplo)<br>[ubi:tamasfe/taplo](https://github.com/tamasfe/taplo)<br>[cargo:taplo-cli](https://crates.io/crates/taplo-cli) |  |
| task | [aqua:go-task/task](https://github.com/go-task/task)<br>[ubi:go-task/task](https://github.com/go-task/task)<br>[asdf:particledecay/asdf-task](https://github.com/particledecay/asdf-task) |  |
| tctl | [aqua:temporalio/tctl](https://github.com/temporalio/tctl)<br>[asdf:eko/asdf-tctl](https://github.com/eko/asdf-tctl) |  |
| tekton | [aqua:tektoncd/cli](https://github.com/tektoncd/cli)<br>[asdf:johnhamelink/asdf-tekton-cli](https://github.com/johnhamelink/asdf-tekton-cli) |  |
| teleport-community | [asdf:mise-plugins/mise-teleport-community](https://github.com/mise-plugins/mise-teleport-community) |  |
| teleport-ent | [asdf:mise-plugins/mise-teleport-ent](https://github.com/mise-plugins/mise-teleport-ent) |  |
| telepresence | [aqua:telepresenceio/telepresence](https://github.com/telepresenceio/telepresence)<br>[asdf:pirackr/asdf-telepresence](https://github.com/pirackr/asdf-telepresence) |  |
| television | [aqua:alexpasmantier/television](https://github.com/alexpasmantier/television) |  |
| teller | [aqua:tellerops/teller](https://github.com/tellerops/teller)<br>[asdf:pdemagny/asdf-teller](https://github.com/pdemagny/asdf-teller) |  |
| temporal | [aqua:temporalio/temporal](https://github.com/temporalio/temporal)<br>[asdf:asdf-community/asdf-temporal](https://github.com/asdf-community/asdf-temporal) |  |
| terradozer | [aqua:jckuester/terradozer](https://github.com/jckuester/terradozer)<br>[asdf:chessmango/asdf-terradozer](https://github.com/chessmango/asdf-terradozer) |  |
| terraform | [aqua:hashicorp/terraform](https://github.com/hashicorp/terraform)<br>[asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp)<br>[vfox:mise-plugins/vfox-terraform](https://github.com/mise-plugins/vfox-terraform) |  |
| terraform-docs | [aqua:terraform-docs/terraform-docs](https://github.com/terraform-docs/terraform-docs)<br>[asdf:looztra/asdf-terraform-docs](https://github.com/looztra/asdf-terraform-docs) |  |
| terraform-ls | [aqua:hashicorp/terraform-ls](https://github.com/hashicorp/terraform-ls)<br>[asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| terraform-lsp | [aqua:juliosueiras/terraform-lsp](https://github.com/juliosueiras/terraform-lsp)<br>[asdf:bartlomiejdanek/asdf-terraform-lsp](https://github.com/bartlomiejdanek/asdf-terraform-lsp) |  |
| terraform-validator | [aqua:thazelart/terraform-validator](https://github.com/thazelart/terraform-validator)<br>[asdf:looztra/asdf-terraform-validator](https://github.com/looztra/asdf-terraform-validator) |  |
| terraformer | [aqua:GoogleCloudPlatform/terraformer](https://github.com/GoogleCloudPlatform/terraformer)<br>[asdf:gr1m0h/asdf-terraformer](https://github.com/gr1m0h/asdf-terraformer) |  |
| terragrunt | [aqua:gruntwork-io/terragrunt](https://github.com/gruntwork-io/terragrunt)<br>[asdf:gruntwork-io/asdf-terragrunt](https://github.com/gruntwork-io/asdf-terragrunt) |  |
| terramate | [aqua:terramate-io/terramate](https://github.com/terramate-io/terramate)<br>[asdf:martinlindner/asdf-terramate](https://github.com/martinlindner/asdf-terramate) |  |
| terrascan | [aqua:tenable/terrascan](https://github.com/tenable/terrascan)<br>[asdf:hpdobrica/asdf-terrascan](https://github.com/hpdobrica/asdf-terrascan) |  |
| tf-summarize | [aqua:dineshba/tf-summarize](https://github.com/dineshba/tf-summarize)<br>[asdf:adamcrews/asdf-tf-summarize](https://github.com/adamcrews/asdf-tf-summarize) |  |
| tfc-agent | [asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| tfctl | [aqua:flux-iac/tofu-controller/tfctl](https://github.com/flux-iac/tofu-controller)<br>[asdf:deas/asdf-tfctl](https://github.com/deas/asdf-tfctl) |  |
| tfenv | [aqua:tfutils/tfenv](https://github.com/tfutils/tfenv)<br>[asdf:carlduevel/asdf-tfenv](https://github.com/carlduevel/asdf-tfenv) |  |
| tflint | [aqua:terraform-linters/tflint](https://github.com/terraform-linters/tflint)<br>[ubi:terraform-linters/tflint](https://github.com/terraform-linters/tflint)<br>[asdf:skyzyx/asdf-tflint](https://github.com/skyzyx/asdf-tflint) |  |
| tfmigrate | [aqua:minamijoyo/tfmigrate](https://github.com/minamijoyo/tfmigrate)<br>[asdf:dex4er/asdf-tfmigrate](https://github.com/dex4er/asdf-tfmigrate) |  |
| tfnotify | [aqua:mercari/tfnotify](https://github.com/mercari/tfnotify)<br>[asdf:jnavarrof/asdf-tfnotify](https://github.com/jnavarrof/asdf-tfnotify) |  |
| tfsec | [aqua:aquasecurity/tfsec](https://github.com/aquasecurity/tfsec)<br>[asdf:woneill/asdf-tfsec](https://github.com/woneill/asdf-tfsec) |  |
| tfstate-lookup | [aqua:fujiwara/tfstate-lookup](https://github.com/fujiwara/tfstate-lookup)<br>[asdf:carnei-ro/asdf-tfstate-lookup](https://github.com/carnei-ro/asdf-tfstate-lookup) |  |
| tfswitch | [ubi:warrensbox/terraform-switcher](https://github.com/warrensbox/terraform-switcher)<br>[asdf:iul1an/asdf-tfswitch](https://github.com/iul1an/asdf-tfswitch) |  |
| tfupdate | [aqua:minamijoyo/tfupdate](https://github.com/minamijoyo/tfupdate)<br>[asdf:yuokada/asdf-tfupdate](https://github.com/yuokada/asdf-tfupdate) |  |
| thrift | [asdf:mise-plugins/mise-thrift](https://github.com/mise-plugins/mise-thrift) |  |
| tilt | [aqua:tilt-dev/tilt](https://github.com/tilt-dev/tilt)<br>[asdf:eaceaser/asdf-tilt](https://github.com/eaceaser/asdf-tilt) |  |
| timoni | [aqua:stefanprodan/timoni](https://github.com/stefanprodan/timoni)<br>[asdf:Smana/asdf-timoni](https://github.com/Smana/asdf-timoni) |  |
| tiny | [asdf:mise-plugins/mise-tiny](https://github.com/mise-plugins/mise-tiny) |  |
| tinytex | [asdf:mise-plugins/mise-tinytex](https://github.com/mise-plugins/mise-tinytex) |  |
| titan | [ubi:titan-data/titan](https://github.com/titan-data/titan)<br>[asdf:gabitchov/asdf-titan](https://github.com/gabitchov/asdf-titan) |  |
| tlrc | [aqua:tldr-pages/tlrc](https://github.com/tldr-pages/tlrc)<br>[ubi:tldr-pages/tlrc](https://github.com/tldr-pages/tlrc)<br>[cargo:tlrc](https://crates.io/crates/tlrc) |  |
| tmux | [asdf:mise-plugins/mise-tmux](https://github.com/mise-plugins/mise-tmux) |  |
| tokei | [aqua:XAMPPRocky/tokei](https://github.com/XAMPPRocky/tokei)<br>[ubi:XAMPPRocky/tokei](https://github.com/XAMPPRocky/tokei)<br>[asdf:gasuketsu/asdf-tokei](https://github.com/gasuketsu/asdf-tokei) |  |
| tomcat | [asdf:mise-plugins/mise-tomcat](https://github.com/mise-plugins/mise-tomcat) |  |
| tonnage | [ubi:elementalvoid/tonnage](https://github.com/elementalvoid/tonnage)<br>[asdf:elementalvoid/asdf-tonnage](https://github.com/elementalvoid/asdf-tonnage) |  |
| traefik | [ubi:traefik/traefik](https://github.com/traefik/traefik)<br>[asdf:Dabolus/asdf-traefik](https://github.com/Dabolus/asdf-traefik) |  |
| transifex | [ubi:transifex/cli](https://github.com/transifex/cli)<br>[asdf:ORCID/asdf-transifex](https://github.com/ORCID/asdf-transifex) |  |
| trdsql | [aqua:noborus/trdsql](https://github.com/noborus/trdsql)<br>[asdf:johnlayton/asdf-trdsql](https://github.com/johnlayton/asdf-trdsql) |  |
| tree-sitter | [aqua:tree-sitter/tree-sitter](https://github.com/tree-sitter/tree-sitter)<br>[asdf:ivanvc/asdf-tree-sitter](https://github.com/ivanvc/asdf-tree-sitter) |  |
| tridentctl | [aqua:NetApp/trident/tridentctl](https://github.com/NetApp/trident)<br>[asdf:asdf-community/asdf-tridentctl](https://github.com/asdf-community/asdf-tridentctl) |  |
| trivy | [aqua:aquasecurity/trivy](https://github.com/aquasecurity/trivy)<br>[asdf:zufardhiyaulhaq/asdf-trivy](https://github.com/zufardhiyaulhaq/asdf-trivy) |  |
| trunk | [npm:@trunkio/launcher](https://www.npmjs.com/package/@trunkio/launcher) |  |
| trzsz-ssh | [aqua:trzsz/trzsz-ssh](https://github.com/trzsz/trzsz-ssh)<br>[ubi:trzsz/trzsz-ssh](https://github.com/trzsz/trzsz-ssh)<br>[go:github.com/trzsz/trzsz-ssh/cmd/tssh](https://pkg.go.dev/github.com/trzsz/trzsz-ssh/cmd/tssh) |  |
| tsuru | [ubi:tsuru/tsuru-client](https://github.com/tsuru/tsuru-client)<br>[asdf:virtualstaticvoid/asdf-tsuru](https://github.com/virtualstaticvoid/asdf-tsuru) |  |
| ttyd | [aqua:tsl0922/ttyd](https://github.com/tsl0922/ttyd)<br>[asdf:ivanvc/asdf-ttyd](https://github.com/ivanvc/asdf-ttyd) |  |
| tuist | [asdf:mise-plugins/mise-tuist](https://github.com/mise-plugins/mise-tuist) | macos |
| tusd | [ubi:tus/tusd](https://github.com/tus/tusd) |  |
| typos | [aqua:crate-ci/typos](https://github.com/crate-ci/typos)<br>[ubi:crate-ci/typos](https://github.com/crate-ci/typos)<br>[asdf:aschiavon91/asdf-typos](https://github.com/aschiavon91/asdf-typos)<br>[cargo:typos-cli](https://crates.io/crates/typos-cli) |  |
| typst | [aqua:typst/typst](https://github.com/typst/typst)<br>[ubi:typst/typst](https://github.com/typst/typst)<br>[asdf:stephane-klein/asdf-typst](https://github.com/stephane-klein/asdf-typst)<br>[cargo:typst-cli](https://crates.io/crates/typst-cli) |  |
| typstyle | [aqua:Enter-tainer/typstyle](https://github.com/Enter-tainer/typstyle)<br>[ubi:Enter-tainer/typstyle](https://github.com/Enter-tainer/typstyle)<br>[cargo:typstyle](https://crates.io/crates/typstyle) |  |
| uaa | [aqua:cloudfoundry/uaa-cli](https://github.com/cloudfoundry/uaa-cli)<br>[ubi:cloudfoundry/uaa-cli](https://github.com/cloudfoundry/uaa-cli)<br>[asdf:mise-plugins/tanzu-plug-in-for-asdf](https://github.com/mise-plugins/tanzu-plug-in-for-asdf) |  |
| ubi | [aqua:houseabsolute/ubi](https://github.com/houseabsolute/ubi)<br>[ubi:houseabsolute/ubi](https://github.com/houseabsolute/ubi) |  |
| unison | [ubi:unisonweb/unison](https://github.com/unisonweb/unison)<br>[asdf:susurri/asdf-unison](https://github.com/susurri/asdf-unison) |  |
| upctl | [aqua:UpCloudLtd/upcloud-cli](https://github.com/UpCloudLtd/upcloud-cli) |  |
| updatecli | [aqua:updatecli/updatecli](https://github.com/updatecli/updatecli)<br>[asdf:updatecli/asdf-updatecli](https://github.com/updatecli/asdf-updatecli) |  |
| upt | [ubi:sigoden/upt](https://github.com/sigoden/upt)<br>[asdf:ORCID/asdf-upt](https://github.com/ORCID/asdf-upt) |  |
| upx | [aqua:upx/upx](https://github.com/upx/upx)<br>[asdf:jimmidyson/asdf-upx](https://github.com/jimmidyson/asdf-upx) |  |
| usage | [aqua:jdx/usage](https://github.com/jdx/usage)<br>[ubi:jdx/usage](https://github.com/jdx/usage)<br>[asdf:jdx/mise-usage](https://github.com/jdx/mise-usage)<br>[cargo:usage-cli](https://crates.io/crates/usage-cli) | linux, macos |
| usql | [aqua:xo/usql](https://github.com/xo/usql)<br>[asdf:itspngu/asdf-usql](https://github.com/itspngu/asdf-usql) |  |
| uv | [aqua:astral-sh/uv](https://github.com/astral-sh/uv)<br>[ubi:astral-sh/uv](https://github.com/astral-sh/uv)<br>[asdf:asdf-community/asdf-uv](https://github.com/asdf-community/asdf-uv)<br>[pipx:uv](https://pypi.org/project/uv) |  |
| v | [asdf:mise-plugins/mise-v](https://github.com/mise-plugins/mise-v) |  |
| vacuum | [aqua:daveshanley/vacuum](https://github.com/daveshanley/vacuum) |  |
| vale | [aqua:errata-ai/vale](https://github.com/errata-ai/vale)<br>[asdf:pdemagny/asdf-vale](https://github.com/pdemagny/asdf-vale) |  |
| vals | [aqua:helmfile/vals](https://github.com/helmfile/vals)<br>[asdf:dex4er/asdf-vals](https://github.com/dex4er/asdf-vals) |  |
| vault | [aqua:hashicorp/vault](https://github.com/hashicorp/vault)<br>[asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| vcluster | [aqua:loft-sh/vcluster](https://github.com/loft-sh/vcluster)<br>[asdf:https://gitlab.com/wt0f/asdf-vcluster](https://gitlab.com/wt0f/asdf-vcluster) |  |
| velad | [ubi:kubevela/velad](https://github.com/kubevela/velad)<br>[asdf:mise-plugins/mise-velad](https://github.com/mise-plugins/mise-velad) |  |
| velero | [aqua:vmware-tanzu/velero](https://github.com/vmware-tanzu/velero)<br>[asdf:looztra/asdf-velero](https://github.com/looztra/asdf-velero) |  |
| vendir | [aqua:carvel-dev/vendir](https://github.com/carvel-dev/vendir)<br>[asdf:vmware-tanzu/asdf-carvel](https://github.com/vmware-tanzu/asdf-carvel) |  |
| venom | [aqua:ovh/venom](https://github.com/ovh/venom)<br>[asdf:aabouzaid/asdf-venom](https://github.com/aabouzaid/asdf-venom) |  |
| vfox | [aqua:version-fox/vfox](https://github.com/version-fox/vfox)<br>[ubi:version-fox/vfox](https://github.com/version-fox/vfox) |  |
| vhs | [aqua:charmbracelet/vhs](https://github.com/charmbracelet/vhs)<br>[asdf:chessmango/asdf-vhs](https://github.com/chessmango/asdf-vhs) |  |
| victoria-metrics | [aqua:VictoriaMetrics/VictoriaMetrics/victoria-metrics](https://github.com/VictoriaMetrics/VictoriaMetrics) |  |
| viddy | [aqua:sachaos/viddy](https://github.com/sachaos/viddy)<br>[asdf:ryodocx/asdf-viddy](https://github.com/ryodocx/asdf-viddy) |  |
| vim | [asdf:mise-plugins/mise-vim](https://github.com/mise-plugins/mise-vim) |  |
| virtualos | [asdf:mise-plugins/mise-virtualos](https://github.com/mise-plugins/mise-virtualos) |  |
| vivid | [aqua:sharkdp/vivid](https://github.com/sharkdp/vivid)<br>[ubi:sharkdp/vivid](https://github.com/sharkdp/vivid) |  |
| vlang | [vfox:mise-plugins/vfox-vlang](https://github.com/mise-plugins/vfox-vlang) |  |
| vlt | [asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| vultr | [ubi:vultr/vultr-cli](https://github.com/vultr/vultr-cli)<br>[asdf:ikuradon/asdf-vultr-cli](https://github.com/ikuradon/asdf-vultr-cli) |  |
| wait-for-gh-rate-limit | [ubi:jdx/wait-for-gh-rate-limit](https://github.com/jdx/wait-for-gh-rate-limit) |  |
| wash | [aqua:wasmCloud/wasmCloud/wash](https://github.com/wasmCloud/wasmCloud) |  |
| wasi-sdk | [asdf:mise-plugins/mise-wasi-sdk](https://github.com/mise-plugins/mise-wasi-sdk) |  |
| wasm3 | [asdf:mise-plugins/mise-wasm3](https://github.com/mise-plugins/mise-wasm3) |  |
| wasm4 | [aqua:aduros/wasm4](https://github.com/aduros/wasm4)<br>[ubi:aduros/wasm4](https://github.com/aduros/wasm4)<br>[asdf:jtakakura/asdf-wasm4](https://github.com/jtakakura/asdf-wasm4) |  |
| wasmer | [aqua:wasmerio/wasmer](https://github.com/wasmerio/wasmer)<br>[asdf:tachyonicbytes/asdf-wasmer](https://github.com/tachyonicbytes/asdf-wasmer) |  |
| wasmtime | [aqua:bytecodealliance/wasmtime](https://github.com/bytecodealliance/wasmtime)<br>[asdf:tachyonicbytes/asdf-wasmtime](https://github.com/tachyonicbytes/asdf-wasmtime) |  |
| watchexec | [aqua:watchexec/watchexec](https://github.com/watchexec/watchexec)<br>[ubi:watchexec/watchexec](https://github.com/watchexec/watchexec)<br>[asdf:nyrst/asdf-watchexec](https://github.com/nyrst/asdf-watchexec)<br>[cargo:watchexec-cli](https://crates.io/crates/watchexec-cli) |  |
| waypoint | [aqua:hashicorp/waypoint](https://github.com/hashicorp/waypoint)<br>[asdf:mise-plugins/mise-hashicorp](https://github.com/mise-plugins/mise-hashicorp) |  |
| weave-gitops | [ubi:weaveworks/weave-gitops](https://github.com/weaveworks/weave-gitops)<br>[asdf:deas/asdf-weave-gitops](https://github.com/deas/asdf-weave-gitops) |  |
| websocat | [aqua:vi/websocat](https://github.com/vi/websocat)<br>[asdf:bdellegrazie/asdf-websocat](https://github.com/bdellegrazie/asdf-websocat) |  |
| wren | [aqua:wren-lang/wren-cli](https://github.com/wren-lang/wren-cli)<br>[ubi:wren-lang/wren-cli](https://github.com/wren-lang/wren-cli)<br>[asdf:jtakakura/asdf-wren-cli](https://github.com/jtakakura/asdf-wren-cli) |  |
| wrk | [asdf:mise-plugins/mise-wrk](https://github.com/mise-plugins/mise-wrk) |  |
| wtfutil | [aqua:wtfutil/wtf](https://github.com/wtfutil/wtf)<br>[asdf:NeoHsu/asdf-wtfutil](https://github.com/NeoHsu/asdf-wtfutil) |  |
| xc | [aqua:joerdav/xc](https://github.com/joerdav/xc)<br>[asdf:airtonix/asdf-xc](https://github.com/airtonix/asdf-xc) |  |
| xcbeautify | [aqua:cpisciotta/xcbeautify](https://github.com/cpisciotta/xcbeautify)<br>[ubi:cpisciotta/xcbeautify](https://github.com/cpisciotta/xcbeautify)<br>[asdf:mise-plugins/asdf-xcbeautify](https://github.com/mise-plugins/asdf-xcbeautify) |  |
| xchtmlreport | [asdf:mise-plugins/mise-xchtmlreport](https://github.com/mise-plugins/mise-xchtmlreport) |  |
| xcodegen | [asdf:mise-plugins/mise-xcodegen](https://github.com/mise-plugins/mise-xcodegen) |  |
| xcodes | [aqua:XcodesOrg/xcodes](https://github.com/XcodesOrg/xcodes) | macos |
| xcresultparser | [asdf:mise-plugins/mise-xcresultparser](https://github.com/mise-plugins/mise-xcresultparser) |  |
| xh | [aqua:ducaale/xh](https://github.com/ducaale/xh)<br>[ubi:ducaale/xh](https://github.com/ducaale/xh)<br>[asdf:NeoHsu/asdf-xh](https://github.com/NeoHsu/asdf-xh)<br>[cargo:xh](https://crates.io/crates/xh) |  |
| yadm | [asdf:mise-plugins/mise-yadm](https://github.com/mise-plugins/mise-yadm) |  |
| yamlfmt | [aqua:google/yamlfmt](https://github.com/google/yamlfmt)<br>[ubi:google/yamlfmt](https://github.com/google/yamlfmt)<br>[asdf:mise-plugins/asdf-yamlfmt](https://github.com/mise-plugins/asdf-yamlfmt)<br>[go:github.com/google/yamlfmt/cmd/yamlfmt](https://pkg.go.dev/github.com/google/yamlfmt/cmd/yamlfmt) |  |
| yamllint | [pipx:yamllint](https://pypi.org/project/yamllint)<br>[asdf:ericcornelissen/asdf-yamllint](https://github.com/ericcornelissen/asdf-yamllint) |  |
| yamlscript | [aqua:yaml/yamlscript](https://github.com/yaml/yamlscript)<br>[ubi:yaml/yamlscript](https://github.com/yaml/yamlscript)<br>[asdf:mise-plugins/mise-yamlscript](https://github.com/mise-plugins/mise-yamlscript) |  |
| yarn | [aqua:yarnpkg/berry](https://github.com/yarnpkg/berry)<br>[npm:@yarnpkg/cli-dist](https://www.npmjs.com/package/@yarnpkg/cli-dist)<br>[asdf:mise-plugins/mise-yarn](https://github.com/mise-plugins/mise-yarn) |  |
| yay | [asdf:mise-plugins/mise-yay](https://github.com/mise-plugins/mise-yay) |  |
| yazi | [aqua:sxyazi/yazi](https://github.com/sxyazi/yazi) |  |
| yj | [aqua:sclevine/yj](https://github.com/sclevine/yj)<br>[ubi:sclevine/yj](https://github.com/sclevine/yj)<br>[asdf:ryodocx/asdf-yj](https://github.com/ryodocx/asdf-yj) |  |
| yor | [aqua:bridgecrewio/yor](https://github.com/bridgecrewio/yor)<br>[asdf:ordinaryexperts/asdf-yor](https://github.com/ordinaryexperts/asdf-yor) |  |
| youtube-dl | [aqua:ytdl-org/ytdl-nightly](https://github.com/ytdl-org/ytdl-nightly)<br>[ubi:ytdl-org/ytdl-nightly](https://github.com/ytdl-org/ytdl-nightly)<br>[asdf:mise-plugins/mise-youtube-dl](https://github.com/mise-plugins/mise-youtube-dl) |  |
| yq | [aqua:mikefarah/yq](https://github.com/mikefarah/yq)<br>[ubi:mikefarah/yq](https://github.com/mikefarah/yq)<br>[asdf:sudermanjr/asdf-yq](https://github.com/sudermanjr/asdf-yq)<br>[go:github.com/mikefarah/yq/v4](https://pkg.go.dev/github.com/mikefarah/yq/v4) |  |
| yt-dlp | [ubi:yt-dlp/yt-dlp](https://github.com/yt-dlp/yt-dlp)<br>[asdf:duhow/asdf-yt-dlp](https://github.com/duhow/asdf-yt-dlp) |  |
| ytt | [aqua:carvel-dev/ytt](https://github.com/carvel-dev/ytt)<br>[asdf:vmware-tanzu/asdf-carvel](https://github.com/vmware-tanzu/asdf-carvel) |  |
| zbctl | [asdf:mise-plugins/mise-zbctl](https://github.com/mise-plugins/mise-zbctl) |  |
| zellij | [aqua:zellij-org/zellij](https://github.com/zellij-org/zellij)<br>[ubi:zellij-org/zellij](https://github.com/zellij-org/zellij)<br>[asdf:chessmango/asdf-zellij](https://github.com/chessmango/asdf-zellij) |  |
| zephyr | [aqua:MaybeJustJames/zephyr](https://github.com/MaybeJustJames/zephyr)<br>[ubi:MaybeJustJames/zephyr](https://github.com/MaybeJustJames/zephyr)<br>[asdf:nsaunders/asdf-zephyr](https://github.com/nsaunders/asdf-zephyr) |  |
| zig | [core:zig](https://mise.jdx.dev/lang/zig.html) |  |
| zigmod | [ubi:nektro/zigmod](https://github.com/nektro/zigmod)<br>[asdf:mise-plugins/asdf-zigmod](https://github.com/mise-plugins/asdf-zigmod) |  |
| zizmor | [aqua:zizmorcore/zizmor](https://github.com/zizmorcore/zizmor)<br>[ubi:zizmorcore/zizmor](https://github.com/zizmorcore/zizmor)<br>[cargo:zizmor](https://crates.io/crates/zizmor) |  |
| zls | [aqua:zigtools/zls](https://github.com/zigtools/zls)<br>[ubi:zigtools/zls](https://github.com/zigtools/zls) |  |
| zola | [aqua:getzola/zola](https://github.com/getzola/zola)<br>[ubi:getzola/zola](https://github.com/getzola/zola)<br>[asdf:salasrod/asdf-zola](https://github.com/salasrod/asdf-zola) |  |
| zoxide | [aqua:ajeetdsouza/zoxide](https://github.com/ajeetdsouza/zoxide)<br>[ubi:ajeetdsouza/zoxide](https://github.com/ajeetdsouza/zoxide)<br>[asdf:nyrst/asdf-zoxide](https://github.com/nyrst/asdf-zoxide) |  |
| zprint | [asdf:mise-plugins/mise-zprint](https://github.com/mise-plugins/mise-zprint) |  |

<|firecrawl-page-5-lllmstxt|>
## Mise Configuration Guide
[Skip to content](https://mise.jdx.dev/configuration.html#VPContent)

On this page

# Configuration [​](https://mise.jdx.dev/configuration.html\#configuration)

## `mise.toml` [​](https://mise.jdx.dev/configuration.html\#mise-toml)

`mise.toml` is the config file for mise. They can be at any of the following file paths (in order of precedence, top overrides configuration of lower paths):

- `mise.local.toml` \- used for local config, this should not be committed to source control
- `mise.toml`
- `mise/config.toml`
- `.config/mise.toml` \- use this in order to group config files into a common directory
- `.config/mise/config.toml`
- `.config/mise/conf.d/*.toml` \- all files in this directory will be loaded in alphabetical order

TIP

Run [`mise cfg`](https://mise.jdx.dev/cli/config.html) to figure out what order mise is loading files on your particular setup. This is often a lot easier than figuring out mise's rules.

Notes:

- Paths which start with `mise` can be dotfiles, e.g.: `.mise.toml` or `.mise/config.toml`.
- This list doesn't include [Configuration Environments](https://mise.jdx.dev/configuration/environments.html) which allow for environment-specific config files like `mise.development.toml`—set with `MISE_ENV=development`.
- See [`LOCAL_CONFIG_FILENAMES` in `src/config/mod.rs`](https://github.com/jdx/mise/blob/main/src/config/mod.rs) for the actual code for these paths and their precedence. Some legacy paths are not listed here for brevity.

## Configuration Hierarchy [​](https://mise.jdx.dev/configuration.html\#configuration-hierarchy)

mise uses a sophisticated hierarchical configuration system that merges settings from multiple sources. Understanding this hierarchy helps you organize your development environments effectively.

### How Configuration Merging Works [​](https://mise.jdx.dev/configuration.html\#how-configuration-merging-works)

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.

### Configuration Resolution Process [​](https://mise.jdx.dev/configuration.html\#configuration-resolution-process)

When mise needs configuration, it follows this process:

1. **Walks up the directory tree** from your current location to the root
2. **Collects all config files** it finds along the way
3. **Merges them in order** with more specific (closer to your current directory) settings overriding broader ones
4. **Applies environment-specific configs** like `mise.dev.toml` if `MISE_ENV` is set

### Visual Configuration Hierarchy [​](https://mise.jdx.dev/configuration.html\#visual-configuration-hierarchy)

```
/
├── etc/mise/config.toml              # System-wide config (highest precedence)
└── home/user/
    ├── .config/mise/config.toml      # Global user config
    └── work/
        ├── mise.toml                 # Work-wide settings
        └── myproject/
            ├── mise.local.toml       # Local overrides (git-ignored)
            ├── mise.toml             # Project config
            └── backend/
                └── mise.toml         # Service-specific config (lowest precedence)
```

### Merge Behavior by Section [​](https://mise.jdx.dev/configuration.html\#merge-behavior-by-section)

Different configuration sections merge in different ways:

**Tools** ( `[tools]`): Additive with overrides

toml

```
# Global: node@18, python@3.11
# Project: node@20, go@1.21
# Result: node@20, python@3.11, go@1.21
```

**Environment Variables** ( `[env]`): Additive with overrides

toml

```
# Global: NODE_ENV=development
# Project: NODE_ENV=production, API_URL=localhost
# Result: NODE_ENV=production, API_URL=localhost
```

**Tasks** ( `[tasks]`): Completely replaced per task

toml

```
# Global: [tasks.test] = "npm test"
# Project: [tasks.test] = "yarn test"
# Result: "yarn test" (completely replaces global)
```

**Settings** ( `[settings]`): Additive with overrides

toml

```
# Global: experimental = true
# Project: jobs = 4
# Result: experimental = true, jobs = 4
```

TIP

Run `mise config` to see what files mise has loaded in order of precedence.

Here is what a `mise.toml` looks like:

toml

```
[env]
NODE_ENV = 'production'

[tools]
terraform = '1.0.0'
erlang = '24.0'

[tasks.build]
run = 'echo "running build tasks"'
```

`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:

toml

```
[tools]
node = '20'
python = '3.10'
```

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

toml

```
[tools]
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 [Configuration Environments](https://mise.jdx.dev/configuration/environments.html) for more details.

### `[tools]` \- Dev tools [​](https://mise.jdx.dev/configuration.html\#tools-dev-tools)

See [Tools](https://mise.jdx.dev/dev-tools/).

### `[env]` \- Arbitrary Environment Variables [​](https://mise.jdx.dev/configuration.html\#env-arbitrary-environment-variables)

See [environments](https://mise.jdx.dev/environments/).

### `[tasks.*]` \- Run files or shell scripts [​](https://mise.jdx.dev/configuration.html\#tasks-run-files-or-shell-scripts)

See [Tasks](https://mise.jdx.dev/tasks/).

### `[settings]` \- Mise Settings [​](https://mise.jdx.dev/configuration.html\#settings-mise-settings)

See [Settings](https://mise.jdx.dev/configuration/settings.html) for the full list of settings.

### `[plugins]` \- Specify Custom Plugin Repository URLs [​](https://mise.jdx.dev/configuration.html\#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.

toml

```
[plugins]
elixir = "https://github.com/my-org/mise-elixir.git"
node = "https://github.com/my-org/mise-node.git#DEADBEEF" # 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`](https://github.com/jdx/mise#mise_shorthands_fileconfigmiseshorthandstoml) but doesn't require a separate file.

### `[alias]` \- Tool version aliases [​](https://mise.jdx.dev/configuration.html\#alias-tool-version-aliases)

The following makes `mise install node@my_custom_node` install node-20.x this can also be specified in a [plugin](https://mise.jdx.dev/dev-tools/aliases.html). note adding an alias will also add a symlink, in this case:

sh

```
~/.local/share/mise/installs/node/20 -> ./20.x.x
```

toml

```
my_custom_node = '20'
```

### Minimum mise version [​](https://mise.jdx.dev/configuration.html\#minimum-mise-version)

Specify the minimum supported version of mise required for the configuration file. If the configuration file specifies a version of mise that is higher than the currently installed version, mise will error out.

toml

```
min_version = '2024.11.1'
```

### `mise.toml` schema [​](https://mise.jdx.dev/configuration.html\#mise-toml-schema)

- You can find the JSON schema for `mise.toml` in [schema/mise.json](https://github.com/jdx/mise/blob/main/schema/mise.json) or at [https://mise.jdx.dev/schema/mise.json](https://mise.jdx.dev/schema/mise.json).
- Some editors can load it automatically to provide autocompletion and validation for when editing a `mise.toml` file ( [VSCode](https://code.visualstudio.com/docs/languages/json#_json-schemas-and-settings), [IntelliJ](https://www.jetbrains.com/help/idea/json.html#ws_json_using_schemas), [neovim](https://github.com/b0o/SchemaStore.nvim), etc.). It is also available in the [JSON schema store](https://www.schemastore.org/json/).
- Note that for `included tasks` (see [task configuration](https://mise.jdx.dev/tasks/task-configuration.html), there is another schema: [https://mise.jdx.dev/schema/mise-task.json](https://mise.jdx.dev/schema/mise-task.json))

## Global config: `~/.config/mise/config.toml` [​](https://mise.jdx.dev/configuration.html\#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.

~/.config/mise/config.toml

toml

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

[settings]
# tools can read the versions files used by other version managers
# for example, .nvmrc in the case of node's nvm
idiomatic_version_file_enable_tools = ['node']

# 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: https://github.com/jdx/mise/issues/128)
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 = [\
    '~/work/my-trusted-projects',\
]

verbose = false       # set to true to see full installation output, see `MISE_VERBOSE`
http_timeout = "30s"  # set the timeout for http requests as duration string, 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 }

# "_" is a special key for information you'd like to put into mise.toml that mise will never parse
[_]
foo = "bar"
```

## System config: `/etc/mise/config.toml` [​](https://mise.jdx.dev/configuration.html\#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.

## `.tool-versions` [​](https://mise.jdx.dev/configuration.html\#tool-versions)

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:

text

```
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](https://asdf-vm.com/manage/configuration.html#tool-versions) for more info on this file format.

## Scopes [​](https://mise.jdx.dev/configuration.html\#scopes)

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`.

## Idiomatic version files [​](https://mise.jdx.dev/configuration.html\#idiomatic-version-files)

mise supports "idiomatic 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 or 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 idiomatic version files:

| Plugin | Idiomatic Files |
| --- | --- |
| crystal | `.crystal-version` |
| elixir | `.exenv-version` |
| go | `.go-version` |
| java | `.java-version`, `.sdkmanrc` |
| node | `.nvmrc`, `.node-version` |
| packer | `.packer-version` |
| python | `.python-version`, `.python-versions` |
| ruby | `.ruby-version`, `Gemfile` |
| terragrunt | `.terragrunt-version` |
| terraform | `.terraform-version`, `main.tf` |
| yarn | `.yvmrc` |

In mise, these are enabled by default. However, in 2025.10.0 they will default to disabled (see [https://github.com/jdx/mise/discussions/4345](https://github.com/jdx/mise/discussions/4345)).

- `mise settings add idiomatic_version_file_enable_tools python` for a specific tool such as Python ( [docs](https://mise.jdx.dev/configuration/settings.html#idiomatic_version_file_enable_tools))

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](https://mise.jdx.dev/cache-behavior.html) so it's not a huge deal. You may not even notice.

INFO

asdf called these "legacy version files". I think this was 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 are 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.)

## Settings [​](https://mise.jdx.dev/configuration.html\#settings)

See [Settings](https://mise.jdx.dev/configuration/settings.html) for the full list of settings.

## Tasks [​](https://mise.jdx.dev/configuration.html\#tasks)

See [Tasks](https://mise.jdx.dev/tasks/) for the full list of configuration options.

## Environment variables [​](https://mise.jdx.dev/configuration.html\#environment-variables)

TIP

Normally environment variables in mise are used to set [settings](https://mise.jdx.dev/configuration/settings.html) so most environment variables are in that doc. The following are environment variables that are not settings.

A setting in mise is generally something that can be configured either as an environment variable or set in a config file.

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

### `MISE_DATA_DIR` [​](https://mise.jdx.dev/configuration.html\#mise-data-dir)

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.

### `MISE_CACHE_DIR` [​](https://mise.jdx.dev/configuration.html\#mise-cache-dir)

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.

### `MISE_TMP_DIR` [​](https://mise.jdx.dev/configuration.html\#mise-tmp-dir)

Default: [`std::env::temp_dir()`](https://doc.rust-lang.org/std/env/fn.temp_dir.html) implementation in rust

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

### `MISE_SYSTEM_DIR` [​](https://mise.jdx.dev/configuration.html\#mise-system-dir)

Default: `/etc/mise`

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

### `MISE_GLOBAL_CONFIG_FILE` [​](https://mise.jdx.dev/configuration.html\#mise-global-config-file)

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

This is the path to the config file.

### `MISE_GLOBAL_CONFIG_ROOT` [​](https://mise.jdx.dev/configuration.html\#mise-global-config-root)

Default: `$HOME`

This is the path which is used as `{{config_root}}` for the global config file.

### `MISE_ENV_FILE` [​](https://mise.jdx.dev/configuration.html\#mise-env-file)

Set to a filename to read from env from a dotenv file. e.g.: `MISE_ENV_FILE=.env`. Uses [dotenvy](https://crates.io/crates/dotenvy) under the hood.

### `MISE_${PLUGIN}_VERSION` [​](https://mise.jdx.dev/configuration.html\#mise-plugin-version)

Set the version for a runtime. For example, `MISE_NODE_VERSION=20` will use [node@20.x](mailto:node@20.x) regardless of what is set in `mise.toml`/ `.tool-versions`.

### `MISE_TRUSTED_CONFIG_PATHS` [​](https://mise.jdx.dev/configuration.html\#mise-trusted-config-paths)

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

### `MISE_LOG_LEVEL=trace|debug|info|warn|error` [​](https://mise.jdx.dev/configuration.html\#mise-log-level-trace-debug-info-warn-error)

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`.

### `MISE_LOG_FILE=~/mise.log` [​](https://mise.jdx.dev/configuration.html\#mise-log-file-mise-log)

Output logs to a file.

### `MISE_LOG_FILE_LEVEL=trace|debug|info|warn|error` [​](https://mise.jdx.dev/configuration.html\#mise-log-file-level-trace-debug-info-warn-error)

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.

### `MISE_LOG_HTTP=1` [​](https://mise.jdx.dev/configuration.html\#mise-log-http-1)

Display HTTP requests/responses in the logs.

### `MISE_QUIET=1` [​](https://mise.jdx.dev/configuration.html\#mise-quiet-1)

Equivalent to `MISE_LOG_LEVEL=warn`.

### `MISE_HTTP_TIMEOUT` [​](https://mise.jdx.dev/configuration.html\#mise-http-timeout)

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

### `MISE_RAW=1` [​](https://mise.jdx.dev/configuration.html\#mise-raw-1)

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.

### `MISE_FISH_AUTO_ACTIVATE=1` [​](https://mise.jdx.dev/configuration.html\#mise-fish-auto-activate-1)

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.

<|firecrawl-page-6-lllmstxt|>
## 404 Error - Not Found
# Error 404

### Object not found

This object does not exist or is not publicly accessible at this
URL. Check the URL of the object that you're looking for or contact
the owner to enable Public access.


Is this your bucket?

Learn how to enable
[Public Access](https://developers.cloudflare.com/r2/data-access/public-buckets/)

<|firecrawl-page-7-lllmstxt|>
## Page Not Found
# Error 404

### Object not found

This object does not exist or is not publicly accessible at this
URL. Check the URL of the object that you're looking for or contact
the owner to enable Public access.


Is this your bucket?

Learn how to enable
[Public Access](https://developers.cloudflare.com/r2/data-access/public-buckets/)

<|firecrawl-page-8-lllmstxt|>
## Pipx Backend Overview
[Skip to content](https://mise.jdx.dev/dev-tools/backends/pipx.html#VPContent)

On this page

# pipx Backend [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#pipx-backend)

pipx is a tool for running Python CLIs in isolated virtualenvs. This is necessary for Python CLIs because it prevents conflicting dependencies between CLIs or between a CLI and Python projects. In essence, this backend lets you add Python CLIs to mise.

To be clear, pipx is not pip and it's not used to manage Python dependencies generally. mise is a tool manager, not a dependency manager like pip, uv, or poetry. You can, however, use mise to install said package managers. You'd want to use the pipx backend to install a CLI like "black", not a library like "NumPy" or "requests".

Somewhat confusingly, the pipx backend will actually default to using [`uvx`](https://docs.astral.sh/uv/guides/tools/) (the equivalent of pipx for uv) if uv is installed. This should just mean that it installs much faster, but see below to disable or configure since occasionally tools don't work with uvx.

The pipx backend supports the following sources:

- PyPI
- Git
- GitHub
- Http

The code for this is inside of the mise repository at [`./src/backend/pipx.rs`](https://github.com/jdx/mise/blob/main/src/backend/pipx.rs).

## Dependencies [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#dependencies)

This relies on having `pipx` installed. You can install it with or without mise. Here is how to install `pipx` with mise:

sh

```
mise use -g python
pip install --user pipx
```

[Other installation instructions](https://pipx.pypa.io/latest/installation/)

## Usage [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#usage)

The following installs the latest version of [black](https://github.com/psf/black) and sets it as the active version on PATH:

sh

```
$ mise use -g pipx:psf/black
$ black --version
black, 24.3.0
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"pipx:psf/black" = "latest"
```

## Python upgrades [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#python-upgrades)

If the python version used by a pipx package changes, (by mise or system python), you may need to reinstall the package. This can be done with:

sh

```
mise install -f pipx:psf/black
```

Or you can reinstall all pipx packages with:

sh

```
mise install -f "pipx:*"
```

mise _should_ do this automatically when using `mise up python`.

### Supported Pipx Syntax [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#supported-pipx-syntax)

| Description | Usage |
| --- | --- |
| PyPI shorthand latest version | `pipx:black` |
| PyPI shorthand for specific version | `pipx:black@24.3.0` |
| GitHub shorthand for latest version | `pipx:psf/black` |
| GitHub shorthand for specific version | `pipx:psf/black@24.3.0` |
| Git syntax for latest version | `pipx:git+https://github.com/psf/black.git` |
| Git syntax for a branch | `pipx:git+https://github.com/psf/black.git@main` |
| Https with zipfile | `pipx:https://github.com/psf/black/archive/18.9b0.zip` |

Other syntax may work but is unsupported and untested.

## Settings [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#settings)

Set these with `mise settings set [VARIABLE] [VALUE]` or by setting the environment variable listed.

### `pipx.registry_url`

- Type: `string`
- Env: `MISE_PIPX_REGISTRY_URL`
- Default: `https://pypi.org/pypi/{}/json`

URL to use for pipx registry.

This is used to fetch the latest version of a package from the pypi registry.

The default is `https://pypi.org/pypi/{}/json` which is the JSON endpoint for the pypi
registry.

You can also use the HTML endpoint by setting this to `https://pypi.org/simple/{}/`.

### `pipx.uvx`

- Type: `Bool`
- Env: `MISE_PIPX_UVX`
- Default: `true`

If true, mise will use `uvx` instead of `pipx` if
[`uv`](https://docs.astral.sh/uv/) is installed and on PATH.
This makes installing CLIs _much_ faster by using `uv` as the package manager.

You can install it with mise:

```sh
mise use -g uv

```

## Tool Options [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `pipx` backend—these go in `[tools]` in `mise.toml`.

### `extras` [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#extras)

Install additional components.

toml

```
[tools]
"pipx:harlequin" = { version = "latest", extras = "postgres,s3" }
```

### `pipx_args` [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#pipx-args)

Additional arguments to pass to `pipx` when installing the package.

toml

```
[tools]
"pipx:black" = { version = "latest", pipx_args = "--preinstall" }
```

### `uvx` [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#uvx)

Set to `false` to always disable uv for this tool.

toml

```
[tools]
"pipx:ansible" = { version = "latest", uvx = "false", pipx_args = "--include-deps" }
```

### `uvx_args` [​](https://mise.jdx.dev/dev-tools/backends/pipx.html\#uvx-args)

Additional arguments to pass to `uvx` when installing the package.

toml

```
[tools]
"pipx:ansible-core" = { version = "latest", uvx_args = "--with ansible" }
```

<|firecrawl-page-9-lllmstxt|>
## Mise Documentation Site
[Skip to content](https://mise.jdx.dev/README.html#VPContent)

Return to top

# mise-docs [​](https://mise.jdx.dev/README.html\#mise-docs)

This repository contains the documentation website for the runtime executor [mise](https://github.com/jdx/mise). The website is powered by [VitePress](https://vitepress.dev/).

<|firecrawl-page-10-lllmstxt|>
## About mise Development Tool
[Skip to content](https://mise.jdx.dev/about.html#VPContent)

On this page

# About [​](https://mise.jdx.dev/about.html\#about)

`mise` (pronounced "meez") or "mise-en-place" is a development environment setup tool. The name refers to a French culinary phrase that roughly translates to "setup" or "put in place". The idea is that before one begins cooking, they should have all their utensils and ingredients ready to go in their place.

`mise` does the same for your projects. Using its `mise.toml` config file, you'll have a consistent way to setup and interact with your projects no matter what language they're written in.

Its functionality is grouped into 3 categories described below.

`mise` installs and manages dev tools/runtimes like node, python, or terraform both simplifying installing these tools and allowing you to specify which version of these tools to use in different projects. `mise` supports [hundreds](https://mise.jdx.dev/plugins.html) of dev tools.

`mise` manages environment variables letting you specify configuration like `AWS_ACCESS_KEY_ID` that may differ between projects. It can also be used to automatically activate a [Python virtualenv](https://mise.jdx.dev/lang/python.html) when entering projects too.

`mise` is a task runner that can be used to share common tasks within a project among developers and make things like running tasks on file changes easy.

## Contact [​](https://mise.jdx.dev/about.html\#contact)

`mise` was initially created by [Jeff Dickey](https://jdx.dev/). The goal is to make local development of software easy and consistent across languages. Jeff has spent many years building dev tools and thinking about the problems that `mise` addresses.

This project is simply a labor of love. Jeff created it because he wanted to make your life as a developer easier. We hope you find it useful. Feedback is a massive driver for us. If you have anything positive or negative to say-even if it's just to say hi-please reach out to me either on [Twitter](https://twitter.com/jdxcode), [Mastodon](https://fosstodon.org/@jdx), [Discord](https://discord.gg/UBa7pJUN7Z), or `jdx at this domain`.

<|firecrawl-page-11-lllmstxt|>
## Mise Architecture Overview
[Skip to content](https://mise.jdx.dev/architecture.html#VPContent)

Return to top

# mise Architecture [​](https://mise.jdx.dev/architecture.html\#mise-architecture)

This document provides a comprehensive overview of mise's architecture, designed primarily for contributors and those interested in understanding how mise works internally.

For practical development guidance, see the [Contributing Guide](https://mise.jdx.dev/contributing.html).

## System Overview [​](https://mise.jdx.dev/architecture.html\#system-overview)

mise is a Rust-based tool with a modular architecture centered around three core concepts:

1. **Tool Version Management** \- Installing and managing different versions of [development tools](https://mise.jdx.dev/dev-tools/)
2. **Environment Management** \- Setting up [environment variables](https://mise.jdx.dev/environments/) and project contexts
3. **Task Running** \- Executing [project tasks](https://mise.jdx.dev/tasks/) with dependency management

These three pillars work together to provide a unified development environment management experience.

## Core Architecture Components [​](https://mise.jdx.dev/architecture.html\#core-architecture-components)

### Command Layer ( [`src/cli/`](https://github.com/jdx/mise/tree/main/src/cli/)) [​](https://mise.jdx.dev/architecture.html\#command-layer-src-cli)

The CLI layer provides the user interface and delegates to core functionality:

- **Modular Commands**: Each command is a separate module ( [`install.rs`](https://github.com/jdx/mise/blob/main/src/cli/install.rs), [`use.rs`](https://github.com/jdx/mise/blob/main/src/cli/use.rs), [`run.rs`](https://github.com/jdx/mise/blob/main/src/cli/run.rs), etc.)
- **Argument Parsing**: Leverages [`clap`](https://clap.rs/) for robust CLI parsing and validation
- **Async Command Execution**: All commands support concurrent operations
- **Unified Error Handling**: Consistent error reporting across all commands

**Key Commands Architecture:**

- [`install`](https://mise.jdx.dev/cli/install.html) \- Tool installation coordination
- [`use`](https://mise.jdx.dev/cli/use.html) \- Tool activation and configuration management
- [`run`](https://mise.jdx.dev/cli/run.html) \- Task execution with dependency resolution
- [`env`](https://mise.jdx.dev/cli/env.html) \- Environment variable management
- [`shell`](https://mise.jdx.dev/cli/shell.html) \- Shell integration and activation

### Backend System ( [`src/backend/`](https://github.com/jdx/mise/tree/main/src/backend/)) [​](https://mise.jdx.dev/architecture.html\#backend-system-src-backend)

The backend system is mise's core abstraction for tool management, implementing a trait-based architecture:

rust

```
pub trait Backend: Debug + Send + Sync {
    async fn list_remote_versions(&self) -> Result<Vec<String>>;
    async fn install_version(&self, ctx: &InstallContext, tv: &ToolVersion) -> Result<()>;
    async fn uninstall_version(&self, tv: &ToolVersion) -> Result<()>;
    // ... additional methods for lifecycle management
}
```

**Backend Categories:**

- **Core Backends**: Native Rust implementations for maximum performance
- **Language Package Managers**: npm, pipx, cargo, gem, go modules
- **Universal Installers**: ubi (GitHub releases), aqua (comprehensive package management)
- **Plugin Systems**: [backend plugins](https://mise.jdx.dev/backend-plugin-development.html) (enhanced methods), [tool plugins](https://mise.jdx.dev/tool-plugin-development.html) (hook-based), [asdf plugins](https://mise.jdx.dev/asdf-legacy-plugins.html) (legacy)

For guidance on implementing new backends, see the [Contributing Guide](https://mise.jdx.dev/contributing.html#adding-backends). For detailed backend system design, see [Backend Architecture](https://mise.jdx.dev/dev-tools/backend_architecture.html).

### Configuration System ( [`src/config/`](https://github.com/jdx/mise/tree/main/src/config/)) [​](https://mise.jdx.dev/architecture.html\#configuration-system-src-config)

A hierarchical configuration system that merges settings from multiple config files:

**Config Trait Architecture:**

rust

```
pub trait ConfigFile: Debug + Send + Sync {
    fn get_path(&self) -> &Path;
    fn to_tool_request_set(&self) -> Result<ToolRequestSet>;
    fn env_entries(&self) -> Result<Vec<EnvDirective>>;
    fn tasks(&self) -> Vec<&Task>;
    // ... additional configuration methods
}
```

**Concrete Implementations:**

- `MiseToml` \- Primary configuration format with full feature support
- `ToolVersions` \- asdf compatibility layer
- `IdiomaticVersion` \- Language-specific version files ( `.node-version`, etc.)

**Configuration Hierarchy:** See [Configuration Documentation](https://mise.jdx.dev/configuration.html) for the complete hierarchy and precedence rules.

### Toolset Management ( [`src/toolset/`](https://github.com/jdx/mise/tree/main/src/toolset/)) [​](https://mise.jdx.dev/architecture.html\#toolset-management-src-toolset)

Coordinates tool resolution, installation, and environment setup:

**Core Components:**

- `Toolset` \- Immutable collection of resolved tools for a context
- `ToolVersion` \- Represents a specific, resolved tool version (e.g., `node@latest` becomes `node@18.17.0`)
- `ToolRequest` \- User's tool specification (e.g., `node@18`, `python@latest`)
- `ToolsetBuilder` \- Constructs toolsets from configuration with dependency resolution

**Tool Resolution Pipeline:**

1. **Configuration Parsing**: Extract tool requirements from config files
2. **Version Resolution**: Resolve version specifications ( `latest`, `~1.2.0`, etc.) to concrete versions
3. **Backend Selection**: Choose appropriate backend for each tool
4. **Dependency Analysis**: Resolve tool dependencies (e.g., npm requires Node.js)
5. **Installation Coordination**: Install missing tools in dependency order
6. **Environment Configuration**: Set up PATH and environment variables

### Task System ( [`src/task/`](https://github.com/jdx/mise/tree/main/src/task/)) [​](https://mise.jdx.dev/architecture.html\#task-system-src-task)

Sophisticated task execution with dependency graph management:

**Architecture Components:**

- `Task` \- Task definition with metadata, dependencies, and execution configuration
- `Deps` \- Dependency graph manager using `petgraph` for DAG operations
- `TaskFileProvider` \- Discovers tasks from files and configuration
- Parallel execution engine with configurable concurrency

**Task Discovery:**

1. [File-based tasks](https://mise.jdx.dev/tasks/file-tasks.html) from configured directories
2. [TOML-defined tasks](https://mise.jdx.dev/tasks/toml-tasks.html) in configuration files
3. Inherited tasks from parent directories

**Dependency Resolution:**

- Uses directed acyclic graph (DAG) for dependency modeling
- Supports multiple dependency types: `depends`, `depends_post`, `wait_for`
- Parallel execution within dependency constraints
- Circular dependency detection and prevention

See the [Task Documentation](https://mise.jdx.dev/tasks/) for complete usage details and configuration options, and [Task Architecture](https://mise.jdx.dev/tasks/architecture.html) for detailed system design.

### Plugin System ( [`src/plugins/`](https://github.com/jdx/mise/tree/main/src/plugins/)) [​](https://mise.jdx.dev/architecture.html\#plugin-system-src-plugins)

Extensibility layer supporting multiple plugin architectures:

**Plugin Trait:**

rust

```
pub trait Plugin: Debug + Send {
    fn name(&self) -> &str;
    fn path(&self) -> PathBuf;
    async fn install(&self, config: &Arc<Config>, pr: &Box<dyn SingleReport>) -> Result<()>;
    async fn update(&self, pr: &Box<dyn SingleReport>, gitref: Option<String>) -> Result<()>;
    // ... lifecycle management methods
}
```

**Plugin Types:**

- **Backend Plugins**: Enhanced plugins with backend methods for managing multiple tools
- **Tool Plugins**: Hook-based plugins using the traditional vfox format
- **asdf Plugins**: Legacy plugins compatible with the asdf plugin ecosystem (Linux/macOS only)

For complete plugin documentation, see [Plugin Guide](https://mise.jdx.dev/plugins.html).

### Shell Integration ( [`src/shell/`](https://github.com/jdx/mise/tree/main/src/shell/)) [​](https://mise.jdx.dev/architecture.html\#shell-integration-src-shell)

Shell-specific code generation that abstracts commands like `mise env` and contains all shell differences in one place:

**Shell Trait:**

rust

```
pub trait Shell {
    fn activate(&self, opts: ActivateOptions) -> String;
    fn set_env(&self, k: &str, v: &str) -> String;
    fn unset_env(&self, k: &str) -> String;
    // ... shell-specific methods
}
```

**Supported Shells:** See [`mise activate`](https://mise.jdx.dev/cli/activate.html) documentation for the complete list **Shell Abstractions:** Environment variable setting, PATH modification, command execution

### Environment Management ( [`src/env*.rs`](https://github.com/jdx/mise/tree/main/src/)) [​](https://mise.jdx.dev/architecture.html\#environment-management-src-env-rs)

Helpers for working with environment variables:

- `EnvDiff` \- Tracks and applies environment changes
- `EnvDirective` \- Configuration-based environment variable management
- `PathEnv` \- Intelligent PATH manipulation with precedence rules
- Context-aware resolution with inheritance

For environment setup and configuration, see [Environment Documentation](https://mise.jdx.dev/environments/).

### Caching System ( [`src/cache.rs`](https://github.com/jdx/mise/blob/main/src/cache.rs)) [​](https://mise.jdx.dev/architecture.html\#caching-system-src-cache-rs)

Generic caching backed by files, using msgpack serialization with zstd compression:

- `CacheManager<T>` \- Generic caching with TTL support
- Data serialized with msgpack and compressed with zstd for efficient storage
- Automatic cache invalidation based on file timestamps
- Per-backend cache isolation for data integrity

## Test Architecture [​](https://mise.jdx.dev/architecture.html\#test-architecture)

mise employs a multi-layered testing strategy that combines different testing approaches for thorough validation across its complex feature set.

**Testing Strategy Overview:**

1. **Unit Tests** \- Rust `#[test]` functions embedded in source files
2. **End-to-End (E2E) Tests** \- Bash-based integration tests with complete environment isolation
3. **Snapshot Tests** \- Using `insta` crate for complex output validation

Testing Philosophy

**Most tests in mise are end-to-end tests, and this is generally the preferred approach** for new functionality. E2E tests provide thorough validation of real-world usage scenarios and catch integration issues that unit tests might miss. However, **E2E tests can be challenging to run locally** due to environment dependencies and setup complexity. For development and CI purposes, it's often easier to run tests on GitHub Actions where the environment is consistent and properly configured.

See the [Contributing Guide](https://mise.jdx.dev/contributing.html#testing) for detailed testing setup and guidelines.

### Unit Tests ( [`src/` modules](https://github.com/jdx/mise/tree/main/src/)) [​](https://mise.jdx.dev/architecture.html\#unit-tests-src-modules)

**Structure and Characteristics:**

- **Location**: Embedded within source files using `mod tests` blocks
- **Test Runner**: Standard Rust `cargo test`
- **Dependencies**: `pretty_assertions`, `insta`, `test-log`, `ctor`
- **Coverage**: ~50+ test modules covering all major functionality

rust

```
mod tests {
    use insta::assert_snapshot;
    use pretty_assertions::assert_eq;
    use crate::config::Config;
    use super::*;

    #[tokio::test]
    async fn test_hash_to_str() {
        let _config = Config::get().await.unwrap();
        assert_eq!(hash_to_str(&"foo"), "e1b19adfb2e348a2");
    }
}
```

**Test Environment Setup:**

- **Global Setup**: Uses `ctor::ctor` in [`src/test.rs`](https://github.com/jdx/mise/blob/main/src/test.rs) for test environment initialization
- **Isolated Environment**: Each test gets a clean environment with custom `HOME`, cache, and config directories
- **Async Support**: Extensive use of `#[tokio::test]` for async testing

### End-to-End Tests ( [`e2e/`](https://github.com/jdx/mise/tree/main/e2e/)) [​](https://mise.jdx.dev/architecture.html\#end-to-end-tests-e2e)

**Architecture:**

```
e2e/
├── run_test          # Single test executor with environment isolation
├── run_all_tests     # Test orchestrator with parallel execution
├── assert.sh         # Rich assertion library
├── cli/              # CLI command tests
│   ├── test_use      # Testing tool activation and configuration
│   ├── test_install  # Testing tool installation
│   ├── test_upgrade  # Testing tool upgrades
│   ├── test_uninstall # Testing tool removal
│   └── test_version  # Testing version commands
├── backend/          # Backend-specific tests
│   ├── test_aqua     # Testing aqua package manager
│   ├── test_asdf     # Testing asdf plugin compatibility
│   └── test_npm      # Testing npm backend
├── tasks/            # Task system tests
│   ├── test_task_deps # Testing task dependencies
│   ├── test_task_run_depends # Testing task execution order
│   ├── test_task_ls  # Testing task listing
│   └── test_task_info # Testing task metadata
├── config/           # Configuration tests
│   ├── test_config_ls # Testing configuration listing
│   └── test_config_set # Testing configuration updates
└── [other domains]/  # Additional test categories
```

**Environment Isolation System:**

Each test runs in complete isolation with temporary directories:

bash

```
setup_isolated_env() {
  TEST_ISOLATED_DIR="$(mktemp --tmpdir --directory "$(basename "$TEST").XXXXXX")"
  TEST_HOME="$TEST_ISOLATED_DIR/home"
  MISE_DATA_DIR="$TEST_HOME/.local/share/mise"
  MISE_CACHE_DIR="$TEST_HOME/.cache/mise"
  # ... complete environment isolation
}
```

**Rich Assertion Framework:**

The [`assert.sh`](https://github.com/jdx/mise/blob/main/e2e/assert.sh) provides rich test utilities:

bash

```
# Basic assertions
assert "command" "expected_output"
assert_contains "command" "substring"
assert_fail "command" "error_message"

# JSON testing
assert_json "command" '{"key": "value"}'
assert_json_partial_object "command" "field1,field2" '{"field1": "value1"}'

# File system assertions
assert_directory_exists "path"
assert_directory_empty "path"
```

**Test Categories:**

- **CLI Tests**: Validate all command-line interfaces and argument parsing
- **Backend Tests**: Test tool installation, version resolution, and backend integration
- **Task Tests**: Validate task execution, dependency resolution, and parallel execution
- **Configuration Tests**: Test configuration parsing, hierarchy, and environment variable handling

### Windows Testing [​](https://mise.jdx.dev/architecture.html\#windows-testing)

**Windows-Specific Tests ( [`e2e-win/`](https://github.com/jdx/mise/tree/main/e2e-win/)):**

- **Language**: PowerShell scripts ( `.ps1`)
- **Focus**: Windows-specific functionality and cross-platform compatibility
- **Coverage**: Core tools like Go, Java, Node.js, Python, Rust

powershell

```
Describe "go" {
    It "installs go" {
        mise install go@latest
        go version | Should -Match "go version"
    }
}
```

### Snapshot Testing ( [`src/snapshots/`](https://github.com/jdx/mise/tree/main/src/snapshots/)) [​](https://mise.jdx.dev/architecture.html\#snapshot-testing-src-snapshots)

**Implementation:**

- **Crate**: Uses `insta` for snapshot testing with 11 snapshot files
- **Format**: Stores expected outputs as `.snap` files
- **Coverage**: Complex outputs like directory listings, configuration parsing, environment diffs

rust

```
#[tokio::test]
async fn test_parse() {
    let diff = DirenvDiff::parse(input).unwrap();
    assert_snapshot!(diff);  // Creates/validates snapshot
}
```

### Test Infrastructure Features [​](https://mise.jdx.dev/architecture.html\#test-infrastructure-features)

**Performance and Utility Tests ( [`xtasks/test/`](https://github.com/jdx/mise/tree/main/xtasks/test/)):**

- **Performance Testing**: `perf` script for benchmarking
- **Coverage Testing**: `coverage` script for test coverage analysis
- **E2E Runner**: `e2e` script with filtering capabilities

**Test Data Management ( [`test/`](https://github.com/jdx/mise/tree/main/test/)):**

```
test/
├── fixtures/          # Sample configuration files
├── config/           # Test-specific configs
├── data/             # Test plugins and mock data
└── state/            # Test state directory
```

**Test Execution Modes:**

- **Fast Tests**: Regular tests that run in CI
- **Slow Tests**: Marked with `_slow` suffix, skipped unless `TEST_ALL=1`
- **Tranche Support**: Tests can be split across parallel runners using `TEST_TRANCHE_COUNT`

**Developer Experience Features:**

- **Environment Safety**: Complete isolation prevents tests from affecting user's actual mise installation
- **Parallel Execution**: E2E tests support parallel execution with proper isolation
- **Rich Reporting**: Detailed test timing, environment preservation on failure for debugging
- **Cross-Platform Validation**: Automated testing on multiple operating systems

**Running Tests:**

bash

```
# Run all unit tests
cargo test

# Run all E2E tests
./e2e/run_all_tests

# Run specific E2E test
./e2e/run_test test_install

# Run with coverage
./xtasks/test/coverage

# Performance testing
./xtasks/test/perf
```

For complete development setup and testing procedures, see the [Contributing Guide](https://mise.jdx.dev/contributing.html).

This robust test architecture ensures mise's reliability across its complex feature set, including tool management, environment configuration, task execution, and multi-platform support.

## Related Architecture Documentation [​](https://mise.jdx.dev/architecture.html\#related-architecture-documentation)

For deeper understanding of specific subsystems:

- **[Task Architecture](https://mise.jdx.dev/tasks/architecture.html)** \- Detailed design of the task dependency system, parallel execution engine, and task discovery mechanisms
- **[Backend Architecture](https://mise.jdx.dev/dev-tools/backend_architecture.html)** \- In-depth guide to backend types, the trait system, and how different installation methods work

<|firecrawl-page-12-lllmstxt|>
## Legacy asdf Plugins Overview
[Skip to content](https://mise.jdx.dev/asdf-legacy-plugins.html#VPContent)

Return to top

# asdf (Legacy) Plugins [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#asdf-legacy-plugins)

mise maintains compatibility with the asdf plugin ecosystem through its asdf backend. These plugins are considered legacy because they have limitations compared to mise's modern plugin system.

## What are asdf (Legacy) Plugins? [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#what-are-asdf-legacy-plugins)

asdf plugins are shell script-based plugins that follow the asdf plugin specification. They were the original way to extend tool management in the asdf ecosystem and are now supported by mise for backward compatibility.

## Limitations [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#limitations)

asdf plugins have several limitations compared to mise's modern plugin system:

- **Platform Support**: Only work on Linux and macOS (no Windows support)
- **Performance**: Shell script execution is slower than mise's native backends
- **Features**: Limited compared to modern backends like aqua, ubi, or tool/backend plugins
- **Maintenance**: Harder to maintain and debug
- **Security**: Less secure than sandboxed modern backends

## When to Use asdf (Legacy) Plugins [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#when-to-use-asdf-legacy-plugins)

Only use asdf plugins when:

- The tool is not available through modern backends (aqua, ubi, etc.)
- You need compatibility with existing asdf workflows
- The tool requires complex shell-based installation logic that can't be handled by modern backends

**For new tools, consider these alternatives first:**

1. [aqua backend](https://mise.jdx.dev/dev-tools/backends/aqua.html) \- Preferred for GitHub releases
2. [ubi backend](https://mise.jdx.dev/dev-tools/backends/ubi.html) \- Simple GitHub/GitLab releases
3. [Language package managers](https://mise.jdx.dev/dev-tools/backends/) \- npm, pipx, cargo, gem, etc.
4. [backend plugins](https://mise.jdx.dev/backend-plugin-development.html) \- Enhanced plugins with backend methods
5. [tool plugins](https://mise.jdx.dev/tool-plugin-development.html) \- Hook-based cross-platform plugins

## Installing asdf (Legacy) Plugins [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#installing-asdf-legacy-plugins)

### From the Registry [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#from-the-registry)

Most popular asdf plugins are available through mise's registry:

bash

```
# Install from registry shorthand
mise use postgres@15

# This is equivalent to
mise use asdf:mise-plugins/mise-postgres@15
```

### From Git Repository [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#from-git-repository)

bash

```
# Install plugin directly from repository
mise plugin install <plugin-name> <git-url>

# Example: PostgreSQL plugin
mise plugin install postgres https://github.com/mise-plugins/mise-postgres
```

### Manual Installation [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#manual-installation)

bash

```
# Add plugin manually
mise plugin add postgres https://github.com/mise-plugins/mise-postgres

# Install tool version
mise install postgres@15.0.0

# Use the tool
mise use postgres@15.0.0
```

## Plugin Structure [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#plugin-structure)

asdf plugins follow this directory structure:

```
plugin-name/
├── bin/
│   ├── list-all          # List all available versions
│   ├── download          # Download source code/binary
│   ├── install           # Install the tool
│   ├── latest-stable     # Get latest stable version [optional]
│   ├── help.overview     # Plugin description [optional]
│   ├── help.deps         # Plugin dependencies [optional]
│   ├── help.config       # Plugin configuration [optional]
│   ├── help.links        # Plugin links [optional]
│   ├── list-legacy-filenames  # Legacy version files [optional]
│   ├── parse-legacy-file # Parse legacy version files [optional]
│   ├── post-plugin-add   # Post plugin addition hook [optional]
│   ├── post-plugin-update # Post plugin update hook [optional]
│   ├── pre-plugin-remove # Pre plugin removal hook [optional]
│   └── exec-env          # Set execution environment [optional]
├── lib/                  # Shared library code [optional]
└── README.md
```

## Required Scripts [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#required-scripts)

### bin/list-all [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#bin-list-all)

Lists all available versions of the tool:

bash

```
#!/usr/bin/env bash
# List all available versions
curl -s https://api.github.com/repos/owner/repo/releases |
  grep '"tag_name":' |
  sed -E 's/.*"([^"]+)".*/\1/' |
  sort -V
```

### bin/download [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#bin-download)

Downloads the tool source/binary:

bash

```
#!/usr/bin/env bash
set -e

# Input variables from mise
# ASDF_INSTALL_TYPE (version or ref)
# ASDF_INSTALL_VERSION (version number or git ref)
# ASDF_INSTALL_PATH (where to install)
# ASDF_DOWNLOAD_PATH (where to download)

version="$ASDF_INSTALL_VERSION"
download_path="$ASDF_DOWNLOAD_PATH"

# Download logic here
curl -Lo "$download_path/archive.tar.gz" \
  "https://github.com/owner/repo/archive/v${version}.tar.gz"
```

### bin/install [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#bin-install)

Installs the tool:

bash

```
#!/usr/bin/env bash
set -e

# Input variables from mise
# ASDF_INSTALL_TYPE (version or ref)
# ASDF_INSTALL_VERSION (version number or git ref)
# ASDF_INSTALL_PATH (where to install)
# ASDF_DOWNLOAD_PATH (where source is downloaded)

install_path="$ASDF_INSTALL_PATH"
download_path="$ASDF_DOWNLOAD_PATH"

# Extract and install
cd "$download_path"
tar -xzf archive.tar.gz --strip-components=1
make install PREFIX="$install_path"
```

## Optional Scripts [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#optional-scripts)

### bin/exec-env [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#bin-exec-env)

Set environment variables when executing tools:

bash

```
#!/usr/bin/env bash

# Set environment variables
export TOOL_HOME="$ASDF_INSTALL_PATH"
export PATH="$ASDF_INSTALL_PATH/bin:$PATH"
```

### bin/latest-stable [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#bin-latest-stable)

Get the latest stable version:

bash

```
#!/usr/bin/env bash
curl -s https://api.github.com/repos/owner/repo/releases/latest |
  grep '"tag_name":' |
  sed -E 's/.*"([^"]+)".*/\1/'
```

### bin/list-legacy-filenames [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#bin-list-legacy-filenames)

List legacy version file names:

bash

```
#!/usr/bin/env bash
echo ".tool-version"
echo ".tool-versions"
```

### bin/parse-legacy-file [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#bin-parse-legacy-file)

Parse legacy version files:

bash

```
#!/usr/bin/env bash
cat "$1" | head -n 1
```

## Environment Variables [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#environment-variables)

asdf plugins have access to these environment variables:

- `ASDF_INSTALL_TYPE` \- `version` or `ref`
- `ASDF_INSTALL_VERSION` \- Version number or git ref
- `ASDF_INSTALL_PATH` \- Installation directory
- `ASDF_DOWNLOAD_PATH` \- Download directory
- `ASDF_PLUGIN_PATH` \- Plugin directory
- `ASDF_PLUGIN_PREV_REF` \- Previous git ref (for updates)
- `ASDF_PLUGIN_POST_REF` \- New git ref (for updates)
- `ASDF_CMD_FILE` \- Path to executable being run

## Best Practices [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#best-practices)

### Error Handling [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#error-handling)

bash

```
#!/usr/bin/env bash
set -euo pipefail  # Exit on error, undefined vars, pipe failures

# Check dependencies
command -v curl >/dev/null 2>&1 || {
  echo "Error: curl is required" >&2
  exit 1
}
```

### Cross-Platform Compatibility [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#cross-platform-compatibility)

bash

```
#!/usr/bin/env bash

# Detect platform
case "$(uname -s)" in
  Darwin*) platform="darwin" ;;
  Linux*)  platform="linux" ;;
  *)       echo "Unsupported platform" >&2; exit 1 ;;
esac

case "$(uname -m)" in
  x86_64) arch="amd64" ;;
  arm64)  arch="arm64" ;;
  *)      echo "Unsupported architecture" >&2; exit 1 ;;
esac
```

### Version Parsing [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#version-parsing)

bash

```
#!/usr/bin/env bash

# Parse semantic version
parse_version() {
  local version="$1"
  # Remove 'v' prefix if present
  version="${version#v}"
  echo "$version"
}
```

## Testing Plugins [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#testing-plugins)

### Local Development [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#local-development)

bash

```
# Link plugin for development
mise plugin add my-plugin /path/to/local/plugin

# Test basic functionality
mise list-all my-plugin
mise install my-plugin@1.0.0
mise which my-plugin
```

### Debugging [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#debugging)

bash

```
# Enable debug mode
export MISE_DEBUG=1

# Or use --verbose flag
mise install --verbose my-plugin@1.0.0
```

## Example Plugin [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#example-plugin)

Here's a minimal example for a fictional tool:

bash

```
#!/usr/bin/env bash
# bin/list-all
curl -s "https://api.github.com/repos/example/tool/releases" |
  grep '"tag_name":' |
  sed -E 's/.*"v([^"]+)".*/\1/' |
  sort -V
```

bash

```
#!/usr/bin/env bash
# bin/download
set -e
version="$ASDF_INSTALL_VERSION"
platform=$(uname -s | tr '[:upper:]' '[:lower:]')
arch=$(uname -m)

url="https://github.com/example/tool/releases/download/v${version}/tool-${platform}-${arch}.tar.gz"
curl -fSL "$url" -o "$ASDF_DOWNLOAD_PATH/tool.tar.gz"
```

bash

```
#!/usr/bin/env bash
# bin/install
set -e
cd "$ASDF_DOWNLOAD_PATH"
tar -xzf tool.tar.gz
cp tool "$ASDF_INSTALL_PATH/bin/"
chmod +x "$ASDF_INSTALL_PATH/bin/tool"
```

## Migration Path [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#migration-path)

Consider migrating from asdf plugins to modern alternatives:

1. **Check if tool is available in [aqua registry](https://aquaproj.github.io/aqua-registry/)**
2. **Use [ubi backend](https://mise.jdx.dev/dev-tools/backends/ubi.html) for simple GitHub releases**
3. **Create a [mise plugin](https://mise.jdx.dev/tool-plugin-development.html) for complex tools**
4. **Use language-specific package managers** (npm, pipx, cargo, gem)

## Community Resources [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#community-resources)

- **[asdf Plugin List](https://github.com/asdf-vm/asdf-plugins)** \- Official asdf plugin registry
- **[mise-plugins Organization](https://github.com/mise-plugins)** \- Community-maintained plugins
- **[Plugin Template](https://github.com/asdf-vm/asdf-plugin-template)** \- Template for creating new plugins

## Security Considerations [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#security-considerations)

asdf plugins execute arbitrary shell scripts, which poses security risks:

- **Only install plugins from trusted sources**
- **Review plugin code before installation**
- **Avoid plugins with complex installation scripts when possible**
- **Consider using modern backends for better security**

## Next Steps [​](https://mise.jdx.dev/asdf-legacy-plugins.html\#next-steps)

- [Explore modern backends](https://mise.jdx.dev/dev-tools/backends/) for better alternatives
- [Learn about backend plugins](https://mise.jdx.dev/backend-plugin-development.html) for enhanced functionality
- [Learn about tool plugins](https://mise.jdx.dev/tool-plugin-development.html) for cross-platform support
- [Check the registry](https://mise.jdx.dev/registry.html) for available tools

<|firecrawl-page-13-lllmstxt|>
## Backend Plugin Development
[Skip to content](https://mise.jdx.dev/backend-plugin-development.html#VPContent)

Return to top

# Backend Plugin Development [​](https://mise.jdx.dev/backend-plugin-development.html\#backend-plugin-development)

Backend plugins in mise use enhanced backend methods to manage multiple tools using the `plugin:tool` format. These plugins are perfect for package managers, tool families, and custom installations that need to manage multiple related tools.

## What are Backend Plugins? [​](https://mise.jdx.dev/backend-plugin-development.html\#what-are-backend-plugins)

Backend plugins extend the standard vfox plugin system with enhanced backend methods. They support:

- **Multiple Tools**: One plugin can manage multiple tools. For example, `vfox-npm` is the plugin which could install different types of tools like `prettier`, `eslint`, and other npm packages
- **Cross-Platform Support**: Works on Windows, macOS, and Linux
- **Flexible Architecture**: Modern plugin system with dedicated backend methods for enhanced functionality

## Plugin Architecture [​](https://mise.jdx.dev/backend-plugin-development.html\#plugin-architecture)

Backend plugins are generally a git repository but can also be a directory (via `mise link`). They use three main backend methods implemented as individual files:

- `hooks/backend_list_versions.lua` \- Lists available versions for a tool
- `hooks/backend_install.lua` \- Installs a specific version of a tool
- `hooks/backend_exec_env.lua` \- Sets up environment variables for a tool

## Backend Methods [​](https://mise.jdx.dev/backend-plugin-development.html\#backend-methods)

### BackendListVersions [​](https://mise.jdx.dev/backend-plugin-development.html\#backendlistversions)

Lists available versions for a tool:

lua

```
function PLUGIN:BackendListVersions(ctx)
    local tool = ctx.tool
    local versions = {}

    -- Your logic to fetch versions for the tool
    -- Example: query an API, parse a registry, etc.

    return {versions = versions}
end
```

### BackendInstall [​](https://mise.jdx.dev/backend-plugin-development.html\#backendinstall)

Installs a specific version of a tool:

lua

```
function PLUGIN:BackendInstall(ctx)
    local tool = ctx.tool
    local version = ctx.version
    local install_path = ctx.install_path

    -- Your logic to install the tool
    -- Example: download files, extract archives, etc.

    return {}
end
```

### BackendExecEnv [​](https://mise.jdx.dev/backend-plugin-development.html\#backendexecenv)

Sets up environment variables for a tool:

lua

```
function PLUGIN:BackendExecEnv(ctx)
    local install_path = ctx.install_path

    -- Your logic to set up environment variables
    -- Example: add bin directories to PATH

    return {
        env_vars = {
            {key = "PATH", value = install_path .. "/bin"}
        }
    }
end
```

## Creating a Backend Plugin [​](https://mise.jdx.dev/backend-plugin-development.html\#creating-a-backend-plugin)

### 1\. Plugin Structure [​](https://mise.jdx.dev/backend-plugin-development.html\#_1-plugin-structure)

Create a directory with this structure:

```
vfox-npm/
├── metadata.lua                    # Plugin metadata
├── hooks/
│   ├── backend_list_versions.lua   # BackendListVersions hook
│   ├── backend_install.lua         # BackendInstall hook
│   └── backend_exec_env.lua        # BackendExecEnv hook
└── Injection.lua                   # Runtime injection (auto-generated)
```

### 2\. Basic metadata.lua [​](https://mise.jdx.dev/backend-plugin-development.html\#_2-basic-metadata-lua)

lua

```
PLUGIN = {
    name = "vfox-npm",
    version = "1.0.0",
    description = "Backend plugin for npm packages",
    author = "Your Name"
}
```

## Real-World Example: vfox-npm [​](https://mise.jdx.dev/backend-plugin-development.html\#real-world-example-vfox-npm)

Here's the complete implementation of the vfox-npm plugin that manages npm packages:

### metadata.lua [​](https://mise.jdx.dev/backend-plugin-development.html\#metadata-lua)

lua

```
PLUGIN = {
    name = "vfox-npm",
    version = "1.0.0",
    description = "Backend plugin for npm packages",
    author = "jdx"
}
```

### hooks/backend\_list\_versions.lua [​](https://mise.jdx.dev/backend-plugin-development.html\#hooks-backend-list-versions-lua)

lua

```
function PLUGIN:BackendListVersions(ctx)
    local cmd = require("cmd")
    local json = require("json")

    local result = cmd.exec("npm view " .. ctx.tool .. " versions --json")
    local versions = json.decode(result)

    return {versions = versions}
end
```

### hooks/backend\_install.lua [​](https://mise.jdx.dev/backend-plugin-development.html\#hooks-backend-install-lua)

lua

```
function PLUGIN:BackendInstall(ctx)
    local tool = ctx.tool
    local version = ctx.version
    local install_path = ctx.install_path

    -- Install the package directly using npm install
    local cmd = require("cmd")
    local npm_cmd = "npm install " .. tool .. "@" .. version .. " --no-package-lock --no-save --silent"
    local result = cmd.exec(npm_cmd, {cwd = install_path})

    -- If we get here, the command succeeded
    return {}
end
```

### hooks/backend\_exec\_env.lua [​](https://mise.jdx.dev/backend-plugin-development.html\#hooks-backend-exec-env-lua)

lua

```
function PLUGIN:BackendExecEnv(ctx)
    local file = require("file")
    return {
        env_vars = {
            {key = "PATH", value = file.join_path(ctx.install_path, "node_modules", ".bin")}
        }
    }
end
```

## Usage Example [​](https://mise.jdx.dev/backend-plugin-development.html\#usage-example)

The plugin name doesn't have to match the repository name. The backend prefix will match whatever name the backend plugin was installed as.

bash

```
# Install the plugin
mise plugin install vfox-npm https://github.com/jdx/vfox-npm

# List available versions
mise ls-remote vfox-npm:prettier

# Install a specific version
mise install vfox-npm:prettier@3.0.0

# Use in a project
mise use vfox-npm:prettier@latest

# Execute the tool
mise exec -- prettier --help
```

> **Tip**: This naming flexibility could potentially be used to have a very complex plugin backend that would behave differently based on what it was named. For example, you could install the same plugin with different names to configure different behaviors or access different tool registries.

## Context Variables [​](https://mise.jdx.dev/backend-plugin-development.html\#context-variables)

Backend plugins receive context through the `ctx` parameter passed to each hook function:

### BackendListVersions Context [​](https://mise.jdx.dev/backend-plugin-development.html\#backendlistversions-context)

| Variable | Description | Example |
| --- | --- | --- |
| `ctx.tool` | The tool name | `"prettier"` |

### BackendInstall and BackendExecEnv Context [​](https://mise.jdx.dev/backend-plugin-development.html\#backendinstall-and-backendexecenv-context)

| Variable | Description | Example |
| --- | --- | --- |
| `ctx.tool` | The tool name | `"prettier"` |
| `ctx.version` | The requested version | `"3.0.0"` |
| `ctx.install_path` | Installation directory | `"/home/user/.local/share/mise/installs/vfox-npm/prettier/3.0.0"` |

## Testing Your Plugin [​](https://mise.jdx.dev/backend-plugin-development.html\#testing-your-plugin)

### Local Development [​](https://mise.jdx.dev/backend-plugin-development.html\#local-development)

bash

```
# Link your plugin for development
mise plugin link my-plugin /path/to/my-plugin

# Test listing versions
mise ls-remote my-plugin:some-tool

# Test installation
mise use my-plugin:some-tool@1.0.0

# Test execution
mise exec -- some-tool --version
```

### Debug Mode [​](https://mise.jdx.dev/backend-plugin-development.html\#debug-mode)

Use debug mode to see detailed plugin execution:

bash

```
mise --debug install my-plugin:some-tool@1.0.0
```

## Best Practices [​](https://mise.jdx.dev/backend-plugin-development.html\#best-practices)

### Error Handling [​](https://mise.jdx.dev/backend-plugin-development.html\#error-handling)

Provide more meaningful error messages:

lua

```
function PLUGIN:BackendListVersions(ctx)
    local tool = ctx.tool

    -- Validate tool name
    if not tool or tool == "" then
        error("Tool name cannot be empty")
    end

    -- Execute command with error checking
    local cmd = require("cmd")
    local result = cmd.exec("npm view " .. tool .. " versions --json 2>/dev/null")
    if not result or result:match("npm ERR!") then
        error("Failed to fetch versions for " .. tool .. ": " .. (result or "no output"))
    end

    -- Parse JSON response
    local json = require("json")
    local success, npm_versions = pcall(json.decode, result)
    if not success or not npm_versions then
        error("Failed to parse versions for " .. tool)
    end

    -- Return versions or error if none found
    local versions = {}
    if type(npm_versions) == "table" then
        for i = #npm_versions, 1, -1 do
            table.insert(versions, npm_versions[i])
        end
    end

    if #versions == 0 then
        error("No versions found for " .. tool)
    end

    return {versions = versions}
end
```

### Regex Parsing [​](https://mise.jdx.dev/backend-plugin-development.html\#regex-parsing)

Parse versions with regex:

lua

```
local function parse_version(version_string)
    -- Remove prefixes like 'v' or 'release-'
    return version_string:gsub("^v", ""):gsub("^release%-", "")
end
```

### Path Handling [​](https://mise.jdx.dev/backend-plugin-development.html\#path-handling)

Use cross-platform path handling:

lua

```
local function join_path(...)
    local sep = package.config:sub(1,1) -- Get OS path separator
    return table.concat({...}, sep)
end

local bin_path = join_path(install_path, "bin")
```

### Cross-Platform Commands [​](https://mise.jdx.dev/backend-plugin-development.html\#cross-platform-commands)

Handle different operating systems:

lua

```
local function create_dir(path)
    local cmd = RUNTIME.osType == "Windows" and "mkdir" or "mkdir -p"
    os.execute(cmd .. " " .. path)
end
```

## Advanced Features [​](https://mise.jdx.dev/backend-plugin-development.html\#advanced-features)

### Conditional Installation [​](https://mise.jdx.dev/backend-plugin-development.html\#conditional-installation)

Different installation logic based on tool or version:

lua

```
function PLUGIN:BackendInstall(ctx)
    local tool = ctx.tool
    local version = ctx.version
    local install_path = ctx.install_path

    -- Create install directory
    os.execute("mkdir -p " .. install_path)

    if tool == "special-tool" then
        -- Special installation logic
        local cmd = require("cmd")
        local npm_cmd = "cd " .. install_path .. " && npm install " .. tool .. "@" .. version .. " --no-package-lock --no-save --silent 2>/dev/null"
        local result = cmd.exec(npm_cmd)
        if result:match("npm ERR!") then
            error("Failed to install " .. tool .. "@" .. version)
        end
    else
        -- Default installation logic
        local cmd = require("cmd")
        local npm_cmd = "cd " .. install_path .. " && npm install " .. tool .. "@" .. version .. " --no-package-lock --no-save --silent 2>/dev/null"
        local result = cmd.exec(npm_cmd)
        if result:match("npm ERR!") then
            error("Failed to install " .. tool .. "@" .. version)
        end
    end

    return {}
end
```

### Environment Detection [​](https://mise.jdx.dev/backend-plugin-development.html\#environment-detection)

vfox automatically injects runtime information into your plugin:

lua

```
function PLUGIN:BackendInstall(ctx)
    -- Platform-specific installation using injected RUNTIME object
    if RUNTIME.osType == "Darwin" then
        -- macOS installation logic
    elseif RUNTIME.osType == "Linux" then
        -- Linux installation logic
    elseif RUNTIME.osType == "Windows" then
        -- Windows installation logic
    end

    return {}
end
```

The `RUNTIME` object provides:

- `RUNTIME.osType`: Operating system type (Windows, Linux, Darwin)
- `RUNTIME.archType`: Architecture (amd64, arm64, etc.)
- `RUNTIME.version`: vfox runtime version
- `RUNTIME.pluginDirPath`: Plugin directory path

### Multiple Environment Variables [​](https://mise.jdx.dev/backend-plugin-development.html\#multiple-environment-variables)

Set multiple environment variables:

lua

```
function PLUGIN:BackendExecEnv(ctx)
    -- Add node_modules/.bin to PATH for npm-installed binaries
    local bin_path = ctx.install_path .. "/node_modules/.bin"
    return {
        env_vars = {
            {key = "PATH", value = bin_path},
            {key = ctx.tool:upper() .. "_HOME", value = ctx.install_path},
            {key = ctx.tool:upper() .. "_VERSION", value = ctx.version}
        }
    }
end
```

## Performance Optimization [​](https://mise.jdx.dev/backend-plugin-development.html\#performance-optimization)

### Caching [​](https://mise.jdx.dev/backend-plugin-development.html\#caching)

TODO: We need caching support for [Shared Lua modules](https://mise.jdx.dev/plugin-lua-modules.html).

## Next Steps [​](https://mise.jdx.dev/backend-plugin-development.html\#next-steps)

- [Learn about Tool Plugin Development](https://mise.jdx.dev/tool-plugin-development.html)
- [Explore available Lua modules](https://mise.jdx.dev/plugin-lua-modules.html)
- [Publishing your plugin](https://mise.jdx.dev/plugin-publishing.html)
- [View the vfox-npm plugin source](https://github.com/jdx/vfox-npm)

<|firecrawl-page-14-lllmstxt|>
## Cache Behavior Overview
[Skip to content](https://mise.jdx.dev/cache-behavior.html#VPContent)

Return to top

# Cache Behavior [​](https://mise.jdx.dev/cache-behavior.html\#cache-behavior)

mise makes use of caching in many places in order to be efficient. The details about how long to keep cache for should eventually all be configurable. There may be gaps in the current behavior where things are hardcoded, but I'm happy to add more settings to cover whatever config is needed.

Below I explain the behavior it uses around caching. If you're seeing behavior where things don't appear to be updating, this is a good place to start.

## Plugin/Runtime Cache [​](https://mise.jdx.dev/cache-behavior.html\#plugin-runtime-cache)

Each plugin has a cache that's stored in `~/$MISE_CACHE_DIR/<PLUGIN>`. It stores the list of versions available for that plugin ( `mise ls-remote <PLUGIN>`), the idiomatic filenames (see below), the list of aliases, the bin directories within each runtime installation, and the result of running `exec-env` after the runtime was installed.

Remote versions are updated daily by default. The file is zlib messagepack, if you want to view it you can run the following (requires [msgpack-cli](https://github.com/msgpack/msgpack-cli)).

sh

```
cat ~/$MISE_CACHE_DIR/node/remote_versions.msgpack.z | perl -e 'use Compress::Raw::Zlib;my $d=new Compress::Raw::Zlib::Inflate();my $o;undef $/;$d->inflate(<>,$o);print $o;' | msgpack-cli decode
```

Note that the caching of `exec-env` may be problematic if the script isn't simply exporting static values. The vast majority of `exec-env` scripts only export static values, but if you're working with a plugin that has a dynamic `exec-env` submit a ticket and we can try to figure out what to do.

Caching `exec-env` massively improved the performance of mise since it requires calling bash every time mise is initialized. Ideally, we can keep this behavior.

## Cache auto-pruning [​](https://mise.jdx.dev/cache-behavior.html\#cache-auto-pruning)

mise will automatically delete old files in its cache directory (configured with [`cache_prune_age`](https://mise.jdx.dev/configuration/settings.html#cache_prune_age)). Much of the contents are also ignored by mise if they are >24 hours old or a few days. For this reason, it's likely wasteful to store this directory in CI jobs.

<|firecrawl-page-15-lllmstxt|>
## Mise CLI Activation
[Skip to content](https://mise.jdx.dev/cli/activate.html#VPContent)

Return to top

# `mise activate` [​](https://mise.jdx.dev/cli/activate.html\#mise-activate)

- **Usage**: `mise activate [FLAGS] [SHELL_TYPE]`
- **Source code**: [`src/cli/activate.rs`](https://github.com/jdx/mise/blob/main/src/cli/activate.rs)

Initializes mise in the current shell session

This should go into your shell's rc file or login shell. Otherwise, it will only take effect in the current session. (e.g. ~/.zshrc, ~/.zprofile, ~/.zshenv, ~/.bashrc, ~/.bash\_profile, ~/.profile, ~/.config/fish/config.fish, or $PROFILE for powershell)

Typically, this can be added with something like the following:

```
echo 'eval "$(mise activate zsh)"' >> ~/.zshrc
```

However, this requires that "mise" is in your PATH. If it is not, you need to specify the full path like this:

```
echo 'eval "$(/path/to/mise activate zsh)"' >> ~/.zshrc
```

Customize status output with `status` settings.

## Arguments [​](https://mise.jdx.dev/cli/activate.html\#arguments)

### `[SHELL_TYPE]` [​](https://mise.jdx.dev/cli/activate.html\#shell-type)

Shell type to generate the script for

**Choices:**

- `bash`
- `elvish`
- `fish`
- `nu`
- `xonsh`
- `zsh`
- `pwsh`

## Flags [​](https://mise.jdx.dev/cli/activate.html\#flags)

### `--shims` [​](https://mise.jdx.dev/cli/activate.html\#shims)

Use shims instead of modifying PATH Effectively the same as:

```
PATH="$HOME/.local/share/mise/shims:$PATH"
```

`mise activate --shims` does not support all the features of `mise activate`. See [https://mise.jdx.dev/dev-tools/shims.html#shims-vs-path](https://mise.jdx.dev/dev-tools/shims.html#shims-vs-path) for more information

### `-q --quiet` [​](https://mise.jdx.dev/cli/activate.html\#q-quiet)

Suppress non-error messages

### `--no-hook-env` [​](https://mise.jdx.dev/cli/activate.html\#no-hook-env)

Do not automatically call hook-env

This can be helpful for debugging mise. If you run `eval "$(mise activate --no-hook-env)"`, then you can call `mise hook-env` manually which will output the env vars to stdout without actually modifying the environment. That way you can do things like `mise hook-env --trace` to get more information or just see the values that hook-env is outputting.

Examples:

```
eval "$(mise activate bash)"
eval "$(mise activate zsh)"
mise activate fish | source
execx($(mise activate xonsh))
(&mise activate pwsh) | Out-String | Invoke-Expression
```

<|firecrawl-page-16-lllmstxt|>
## Manage Version Aliases
[Skip to content](https://mise.jdx.dev/cli/alias.html#VPContent)

Return to top

# `mise alias` [​](https://mise.jdx.dev/cli/alias.html\#mise-alias)

- **Usage**: `mise alias [-p --plugin <PLUGIN>] [--no-header] <SUBCOMMAND>`
- **Aliases**: `a`
- **Source code**: [`src/cli/alias/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/alias/mod.rs)

Manage version aliases.

## Flags [​](https://mise.jdx.dev/cli/alias.html\#flags)

### `-p --plugin <PLUGIN>` [​](https://mise.jdx.dev/cli/alias.html\#p-plugin-plugin)

filter aliases by plugin

### `--no-header` [​](https://mise.jdx.dev/cli/alias.html\#no-header)

Don't show table header

## Subcommands [​](https://mise.jdx.dev/cli/alias.html\#subcommands)

- [`mise alias get <PLUGIN> <ALIAS>`](https://mise.jdx.dev/cli/alias/get.html)
- [`mise alias ls [--no-header] [TOOL]`](https://mise.jdx.dev/cli/alias/ls.html)
- [`mise alias set <ARGS>…`](https://mise.jdx.dev/cli/alias/set.html)
- [`mise alias unset <PLUGIN> <ALIAS>`](https://mise.jdx.dev/cli/alias/unset.html)

<|firecrawl-page-17-lllmstxt|>
## Show Plugin Alias
[Skip to content](https://mise.jdx.dev/cli/alias/get.html#VPContent)

Return to top

# `mise alias get` [​](https://mise.jdx.dev/cli/alias/get.html\#mise-alias-get)

- **Usage**: `mise alias get <PLUGIN> <ALIAS>`
- **Source code**: [`src/cli/alias/get.rs`](https://github.com/jdx/mise/blob/main/src/cli/alias/get.rs)

Show an alias for a plugin

This is the contents of an alias.<PLUGIN> entry in ~/.config/mise/config.toml

## Arguments [​](https://mise.jdx.dev/cli/alias/get.html\#arguments)

### `<PLUGIN>` [​](https://mise.jdx.dev/cli/alias/get.html\#plugin)

The plugin to show the alias for

### `<ALIAS>` [​](https://mise.jdx.dev/cli/alias/get.html\#alias)

The alias to show

Examples:

```
$ mise alias get node lts-hydrogen
20.0.0
```

<|firecrawl-page-18-lllmstxt|>
## List Aliases Command
[Skip to content](https://mise.jdx.dev/cli/alias/ls.html#VPContent)

Return to top

# `mise alias ls` [​](https://mise.jdx.dev/cli/alias/ls.html\#mise-alias-ls)

- **Usage**: `mise alias ls [--no-header] [TOOL]`
- **Aliases**: `list`
- **Source code**: [`src/cli/alias/ls.rs`](https://github.com/jdx/mise/blob/main/src/cli/alias/ls.rs)

List aliases Shows the aliases that can be specified. These can come from user config or from plugins in `bin/list-aliases`.

For user config, aliases are defined like the following in `~/.config/mise/config.toml`:

```
[alias.node.versions]
lts = "22.0.0"
```

## Arguments [​](https://mise.jdx.dev/cli/alias/ls.html\#arguments)

### `[TOOL]` [​](https://mise.jdx.dev/cli/alias/ls.html\#tool)

Show aliases for <TOOL>

## Flags [​](https://mise.jdx.dev/cli/alias/ls.html\#flags)

### `--no-header` [​](https://mise.jdx.dev/cli/alias/ls.html\#no-header)

Don't show table header

Examples:

```
$ mise aliases
node  lts-jod      22
```

<|firecrawl-page-19-lllmstxt|>
## Set Plugin Alias
[Skip to content](https://mise.jdx.dev/cli/alias/set.html#VPContent)

Return to top

# `mise alias set` [​](https://mise.jdx.dev/cli/alias/set.html\#mise-alias-set)

- **Usage**: `mise alias set <ARGS>…`
- **Aliases**: `add`, `create`
- **Source code**: [`src/cli/alias/set.rs`](https://github.com/jdx/mise/blob/main/src/cli/alias/set.rs)

Add/update an alias for a plugin

This modifies the contents of ~/.config/mise/config.toml

## Arguments [​](https://mise.jdx.dev/cli/alias/set.html\#arguments)

### `<PLUGIN>` [​](https://mise.jdx.dev/cli/alias/set.html\#plugin)

The plugin to set the alias for

### `<ALIAS>` [​](https://mise.jdx.dev/cli/alias/set.html\#alias)

The alias to set

### `<VALUE>` [​](https://mise.jdx.dev/cli/alias/set.html\#value)

The value to set the alias to

Examples:

```
mise alias set node lts-jod 22.0.0
```

<|firecrawl-page-20-lllmstxt|>
## Manage Backends Command
[Skip to content](https://mise.jdx.dev/cli/backends.html#VPContent)

Return to top

# `mise backends` [​](https://mise.jdx.dev/cli/backends.html\#mise-backends)

- **Usage**: `mise backends <SUBCOMMAND>`
- **Aliases**: `b`
- **Source code**: [`src/cli/backends/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/backends/mod.rs)

Manage backends

## Subcommands [​](https://mise.jdx.dev/cli/backends.html\#subcommands)

- [`mise backends ls`](https://mise.jdx.dev/cli/backends/ls.html)

<|firecrawl-page-21-lllmstxt|>
## List Built-in Backends
[Skip to content](https://mise.jdx.dev/cli/backends/ls.html#VPContent)

Return to top

# `mise backends ls` [​](https://mise.jdx.dev/cli/backends/ls.html\#mise-backends-ls)

- **Usage**: `mise backends ls`
- **Aliases**: `list`
- **Source code**: [`src/cli/backends/ls.rs`](https://github.com/jdx/mise/blob/main/src/cli/backends/ls.rs)

List built-in backends

Examples:

```
$ mise backends ls
aqua
asdf
cargo
core
dotnet
gem
go
npm
pipx
spm
ubi
vfox
```

<|firecrawl-page-22-lllmstxt|>
## Active Runtime Bin Paths
[Skip to content](https://mise.jdx.dev/cli/bin-paths.html#VPContent)

Return to top

# `mise bin-paths` [​](https://mise.jdx.dev/cli/bin-paths.html\#mise-bin-paths)

- **Usage**: `mise bin-paths [TOOL@VERSION]…`
- **Source code**: [`src/cli/bin_paths.rs`](https://github.com/jdx/mise/blob/main/src/cli/bin_paths.rs)

List all the active runtime bin paths

## Arguments [​](https://mise.jdx.dev/cli/bin-paths.html\#arguments)

### `[TOOL@VERSION]…` [​](https://mise.jdx.dev/cli/bin-paths.html\#tool-version)

Tool(s) to look up e.g.: ruby@3

<|firecrawl-page-23-lllmstxt|>
## Mise Cache Management
[Skip to content](https://mise.jdx.dev/cli/cache.html#VPContent)

Return to top

# `mise cache` [​](https://mise.jdx.dev/cli/cache.html\#mise-cache)

- **Usage**: `mise cache <SUBCOMMAND>`
- **Source code**: [`src/cli/cache/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/cache/mod.rs)

Manage the mise cache

Run `mise cache` with no args to view the current cache directory.

## Subcommands [​](https://mise.jdx.dev/cli/cache.html\#subcommands)

- [`mise cache clear [PLUGIN]…`](https://mise.jdx.dev/cli/cache/clear.html)
- [`mise cache prune [--dry-run] [-v --verbose…] [PLUGIN]…`](https://mise.jdx.dev/cli/cache/prune.html)

<|firecrawl-page-24-lllmstxt|>
## Clear Cache Command
[Skip to content](https://mise.jdx.dev/cli/cache/clear.html#VPContent)

Return to top

# `mise cache clear` [​](https://mise.jdx.dev/cli/cache/clear.html\#mise-cache-clear)

- **Usage**: `mise cache clear [PLUGIN]…`
- **Aliases**: `c`
- **Source code**: [`src/cli/cache/clear.rs`](https://github.com/jdx/mise/blob/main/src/cli/cache/clear.rs)

Deletes all cache files in mise

## Arguments [​](https://mise.jdx.dev/cli/cache/clear.html\#arguments)

### `[PLUGIN]…` [​](https://mise.jdx.dev/cli/cache/clear.html\#plugin)

Plugin(s) to clear cache for e.g.: node, python

<|firecrawl-page-25-lllmstxt|>
## Cache Pruning Command
[Skip to content](https://mise.jdx.dev/cli/cache/prune.html#VPContent)

Return to top

# `mise cache prune` [​](https://mise.jdx.dev/cli/cache/prune.html\#mise-cache-prune)

- **Usage**: `mise cache prune [--dry-run] [-v --verbose…] [PLUGIN]…`
- **Aliases**: `p`
- **Source code**: [`src/cli/cache/prune.rs`](https://github.com/jdx/mise/blob/main/src/cli/cache/prune.rs)

Removes stale mise cache files

By default, this command will remove files that have not been accessed in 30 days. Change this with the MISE\_CACHE\_PRUNE\_AGE environment variable.

## Arguments [​](https://mise.jdx.dev/cli/cache/prune.html\#arguments)

### `[PLUGIN]…` [​](https://mise.jdx.dev/cli/cache/prune.html\#plugin)

Plugin(s) to clear cache for e.g.: node, python

## Flags [​](https://mise.jdx.dev/cli/cache/prune.html\#flags)

### `--dry-run` [​](https://mise.jdx.dev/cli/cache/prune.html\#dry-run)

Just show what would be pruned

### `-v --verbose…` [​](https://mise.jdx.dev/cli/cache/prune.html\#v-verbose)

Show pruned files

<|firecrawl-page-26-lllmstxt|>
## Shell Completion Guide
[Skip to content](https://mise.jdx.dev/cli/completion.html#VPContent)

Return to top

# `mise completion` [​](https://mise.jdx.dev/cli/completion.html\#mise-completion)

- **Usage**: `mise completion [--include-bash-completion-lib] [SHELL]`
- **Source code**: [`src/cli/completion.rs`](https://github.com/jdx/mise/blob/main/src/cli/completion.rs)

Generate shell completions

## Arguments [​](https://mise.jdx.dev/cli/completion.html\#arguments)

### `[SHELL]` [​](https://mise.jdx.dev/cli/completion.html\#shell)

Shell type to generate completions for

**Choices:**

- `bash`
- `fish`
- `zsh`

## Flags [​](https://mise.jdx.dev/cli/completion.html\#flags)

### `--include-bash-completion-lib` [​](https://mise.jdx.dev/cli/completion.html\#include-bash-completion-lib)

Include the bash completion library in the bash completion script

This is required for completions to work in bash, but it is not included by default you may source it separately or enable this flag to include it in the script.

Examples:

```
mise completion bash > ~/.local/share/bash-completion/completions/mise
mise completion zsh  > /usr/local/share/zsh/site-functions/_mise
mise completion fish > ~/.config/fish/completions/mise.fish
```

<|firecrawl-page-27-lllmstxt|>
## Mise Config Management
[Skip to content](https://mise.jdx.dev/cli/config.html#VPContent)

Return to top

# `mise config` [​](https://mise.jdx.dev/cli/config.html\#mise-config)

- **Usage**: `mise config [FLAGS] <SUBCOMMAND>`
- **Aliases**: `cfg`
- **Source code**: [`src/cli/config/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/config/mod.rs)

Manage config files

## Flags [​](https://mise.jdx.dev/cli/config.html\#flags)

### `--no-header` [​](https://mise.jdx.dev/cli/config.html\#no-header)

Do not print table header

### `--tracked-configs` [​](https://mise.jdx.dev/cli/config.html\#tracked-configs)

List all tracked config files

### `-J --json` [​](https://mise.jdx.dev/cli/config.html\#j-json)

Output in JSON format

## Subcommands [​](https://mise.jdx.dev/cli/config.html\#subcommands)

- [`mise config generate [-t --tool-versions <TOOL_VERSIONS>] [-o --output <OUTPUT>]`](https://mise.jdx.dev/cli/config/generate.html)
- [`mise config get [-f --file <FILE>] [KEY]`](https://mise.jdx.dev/cli/config/get.html)
- [`mise config ls [FLAGS]`](https://mise.jdx.dev/cli/config/ls.html)
- [`mise config set [-f --file <FILE>] [-t --type <TYPE>] <KEY> <VALUE>`](https://mise.jdx.dev/cli/config/set.html)

Examples:

```
$ mise config ls
Path                        Tools
~/.config/mise/config.toml  pitchfork
~/src/mise/mise.toml        actionlint, bun, cargo-binstall, cargo:cargo-edit, cargo:cargo-insta
```

<|firecrawl-page-28-lllmstxt|>
## Generate mise.toml File
[Skip to content](https://mise.jdx.dev/cli/config/generate.html#VPContent)

Return to top

# `mise config generate` [​](https://mise.jdx.dev/cli/config/generate.html\#mise-config-generate)

- **Usage**: `mise config generate [-t --tool-versions <TOOL_VERSIONS>] [-o --output <OUTPUT>]`
- **Aliases**: `g`
- **Source code**: [`src/cli/config/generate.rs`](https://github.com/jdx/mise/blob/main/src/cli/config/generate.rs)

\[experimental\] Generate a mise.toml file

## Flags [​](https://mise.jdx.dev/cli/config/generate.html\#flags)

### `-t --tool-versions <TOOL_VERSIONS>` [​](https://mise.jdx.dev/cli/config/generate.html\#t-tool-versions-tool-versions)

Path to a .tool-versions file to import tools from

### `-o --output <OUTPUT>` [​](https://mise.jdx.dev/cli/config/generate.html\#o-output-output)

Output to file instead of stdout

Examples:

```
mise cf generate > mise.toml
mise cf generate --output=mise.toml
```

<|firecrawl-page-29-lllmstxt|>
## Mise Config Get Command
[Skip to content](https://mise.jdx.dev/cli/config/get.html#VPContent)

Return to top

# `mise config get` [​](https://mise.jdx.dev/cli/config/get.html\#mise-config-get)

- **Usage**: `mise config get [-f --file <FILE>] [KEY]`
- **Source code**: [`src/cli/config/get.rs`](https://github.com/jdx/mise/blob/main/src/cli/config/get.rs)

Display the value of a setting in a mise.toml file

## Arguments [​](https://mise.jdx.dev/cli/config/get.html\#arguments)

### `[KEY]` [​](https://mise.jdx.dev/cli/config/get.html\#key)

The path of the config to display

## Flags [​](https://mise.jdx.dev/cli/config/get.html\#flags)

### `-f --file <FILE>` [​](https://mise.jdx.dev/cli/config/get.html\#f-file-file)

The path to the mise.toml file to edit

If not provided, the nearest mise.toml file will be used

Examples:

```
$ mise toml get tools.python
3.12
```

<|firecrawl-page-30-lllmstxt|>
## List Config Files
[Skip to content](https://mise.jdx.dev/cli/config/ls.html#VPContent)

Return to top

# `mise config ls` [​](https://mise.jdx.dev/cli/config/ls.html\#mise-config-ls)

- **Usage**: `mise config ls [FLAGS]`
- **Aliases**: `list`
- **Source code**: [`src/cli/config/ls.rs`](https://github.com/jdx/mise/blob/main/src/cli/config/ls.rs)

List config files currently in use

## Flags [​](https://mise.jdx.dev/cli/config/ls.html\#flags)

### `--no-header` [​](https://mise.jdx.dev/cli/config/ls.html\#no-header)

Do not print table header

### `--tracked-configs` [​](https://mise.jdx.dev/cli/config/ls.html\#tracked-configs)

List all tracked config files

### `-J --json` [​](https://mise.jdx.dev/cli/config/ls.html\#j-json)

Output in JSON format

Examples:

```
$ mise config ls
Path                        Tools
~/.config/mise/config.toml  pitchfork
~/src/mise/mise.toml        actionlint, bun, cargo-binstall, cargo:cargo-edit, cargo:cargo-insta
```

<|firecrawl-page-31-lllmstxt|>
## Mise Config Set Command
[Skip to content](https://mise.jdx.dev/cli/config/set.html#VPContent)

Return to top

# `mise config set` [​](https://mise.jdx.dev/cli/config/set.html\#mise-config-set)

- **Usage**: `mise config set [-f --file <FILE>] [-t --type <TYPE>] <KEY> <VALUE>`
- **Source code**: [`src/cli/config/set.rs`](https://github.com/jdx/mise/blob/main/src/cli/config/set.rs)

Set the value of a setting in a mise.toml file

## Arguments [​](https://mise.jdx.dev/cli/config/set.html\#arguments)

### `<KEY>` [​](https://mise.jdx.dev/cli/config/set.html\#key)

The path of the config to display

### `<VALUE>` [​](https://mise.jdx.dev/cli/config/set.html\#value)

The value to set the key to

## Flags [​](https://mise.jdx.dev/cli/config/set.html\#flags)

### `-f --file <FILE>` [​](https://mise.jdx.dev/cli/config/set.html\#f-file-file)

The path to the mise.toml file to edit

If not provided, the nearest mise.toml file will be used

### `-t --type <TYPE>` [​](https://mise.jdx.dev/cli/config/set.html\#t-type-type)

**Choices:**

- `infer`
- `string`
- `integer`
- `float`
- `bool`
- `list`
- `set`

Examples:

```
$ mise config set tools.python 3.12
$ mise config set settings.always_keep_download true
$ mise config set env.TEST_ENV_VAR ABC
$ mise config set settings.disable_tools --type list node,rust

# Type for `settings` is inferred
$ mise config set settings.jobs 4
```

<|firecrawl-page-32-lllmstxt|>
## Deactivate Mise Command
[Skip to content](https://mise.jdx.dev/cli/deactivate.html#VPContent)

Return to top

# `mise deactivate` [​](https://mise.jdx.dev/cli/deactivate.html\#mise-deactivate)

- **Usage**: `mise deactivate`
- **Source code**: [`src/cli/deactivate.rs`](https://github.com/jdx/mise/blob/main/src/cli/deactivate.rs)

Disable mise for current shell session

This can be used to temporarily disable mise in a shell session.

Examples:

```
mise deactivate
```

<|firecrawl-page-33-lllmstxt|>
## Mise Doctor Command
[Skip to content](https://mise.jdx.dev/cli/doctor.html#VPContent)

Return to top

# `mise doctor` [​](https://mise.jdx.dev/cli/doctor.html\#mise-doctor)

- **Usage**: `mise doctor [-J --json] <SUBCOMMAND>`
- **Aliases**: `dr`
- **Source code**: [`src/cli/doctor/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/doctor/mod.rs)

Check mise installation for possible problems

## Flags [​](https://mise.jdx.dev/cli/doctor.html\#flags)

### `-J --json` [​](https://mise.jdx.dev/cli/doctor.html\#j-json)

## Subcommands [​](https://mise.jdx.dev/cli/doctor.html\#subcommands)

- [`mise doctor path [-f --full]`](https://mise.jdx.dev/cli/doctor/path.html)

Examples:

```
$ mise doctor
[WARN] plugin node is not installed
```

<|firecrawl-page-34-lllmstxt|>
## Check PATH Entries
[Skip to content](https://mise.jdx.dev/cli/doctor/path.html#VPContent)

Return to top

# `mise doctor path` [​](https://mise.jdx.dev/cli/doctor/path.html\#mise-doctor-path)

- **Usage**: `mise doctor path [-f --full]`
- **Source code**: [`src/cli/doctor/path.rs`](https://github.com/jdx/mise/blob/main/src/cli/doctor/path.rs)

Print the current PATH entries mise is providing

## Flags [​](https://mise.jdx.dev/cli/doctor/path.html\#flags)

### `-f --full` [​](https://mise.jdx.dev/cli/doctor/path.html\#f-full)

Print all entries including those not provided by mise

Examples:

```
Get the current PATH entries mise is providing
$ mise path
/home/user/.local/share/mise/installs/node/24.0.0/bin
/home/user/.local/share/mise/installs/rust/1.90.0/bin
/home/user/.local/share/mise/installs/python/3.10.0/bin
```

<|firecrawl-page-35-lllmstxt|>
## Mise En Command Guide
[Skip to content](https://mise.jdx.dev/cli/en.html#VPContent)

Return to top

# `mise en` [​](https://mise.jdx.dev/cli/en.html\#mise-en)

- **Usage**: `mise en [-s --shell <SHELL>] [DIR]`
- **Source code**: [`src/cli/en.rs`](https://github.com/jdx/mise/blob/main/src/cli/en.rs)

\[experimental\] starts a new shell with the mise environment built from the current configuration

This is an alternative to `mise activate` that allows you to explicitly start a mise session. It will have the tools and environment variables in the configs loaded. Note that changing directories will not update the mise environment.

## Arguments [​](https://mise.jdx.dev/cli/en.html\#arguments)

### `[DIR]` [​](https://mise.jdx.dev/cli/en.html\#dir)

Directory to start the shell in

**Default:** `.`

## Flags [​](https://mise.jdx.dev/cli/en.html\#flags)

### `-s --shell <SHELL>` [​](https://mise.jdx.dev/cli/en.html\#s-shell-shell)

Shell to start

Defaults to $SHELL

Examples:

```
$ mise en .
$ node -v
v20.0.0

Skip loading bashrc:
$ mise en -s "bash --norc"

Skip loading zshrc:
$ mise en -s "zsh -f"
```

<|firecrawl-page-36-lllmstxt|>
## Mise Environment Variables
[Skip to content](https://mise.jdx.dev/cli/env.html#VPContent)

Return to top

# `mise env` [​](https://mise.jdx.dev/cli/env.html\#mise-env)

- **Usage**: `mise env [FLAGS] [TOOL@VERSION]…`
- **Aliases**: `e`
- **Source code**: [`src/cli/env.rs`](https://github.com/jdx/mise/blob/main/src/cli/env.rs)

Exports env vars to activate mise a single time

Use this if you don't want to permanently install mise. It's not necessary to use this if you have `mise activate` in your shell rc file.

## Arguments [​](https://mise.jdx.dev/cli/env.html\#arguments)

### `[TOOL@VERSION]…` [​](https://mise.jdx.dev/cli/env.html\#tool-version)

Tool(s) to use

## Flags [​](https://mise.jdx.dev/cli/env.html\#flags)

### `-J --json` [​](https://mise.jdx.dev/cli/env.html\#j-json)

Output in JSON format

### `--json-extended` [​](https://mise.jdx.dev/cli/env.html\#json-extended)

Output in JSON format with additional information (source, tool)

### `-D --dotenv` [​](https://mise.jdx.dev/cli/env.html\#d-dotenv)

Output in dotenv format

### `-s --shell <SHELL>` [​](https://mise.jdx.dev/cli/env.html\#s-shell-shell)

Shell type to generate environment variables for

**Choices:**

- `bash`
- `elvish`
- `fish`
- `nu`
- `xonsh`
- `zsh`
- `pwsh`

Examples:

```
eval "$(mise env -s bash)"
eval "$(mise env -s zsh)"
mise env -s fish | source
execx($(mise env -s xonsh))
```

<|firecrawl-page-37-lllmstxt|>
## Mise Exec Command Guide
[Skip to content](https://mise.jdx.dev/cli/exec.html#VPContent)

Return to top

# `mise exec` [​](https://mise.jdx.dev/cli/exec.html\#mise-exec)

- **Usage**: `mise exec [FLAGS] [TOOL@VERSION]… [-- COMMAND]…`
- **Aliases**: `x`
- **Source code**: [`src/cli/exec.rs`](https://github.com/jdx/mise/blob/main/src/cli/exec.rs)

Execute a command with tool(s) set

use this to avoid modifying the shell session or running ad-hoc commands with mise tools set.

Tools will be loaded from mise.toml, though they can be overridden with <RUNTIME> args Note that only the plugin specified will be overridden, so if a `mise.toml` file includes "node 20" but you run `mise exec python@3.11`; it will still load node@20.

The "--" separates runtimes from the commands to pass along to the subprocess.

## Arguments [​](https://mise.jdx.dev/cli/exec.html\#arguments)

### `[TOOL@VERSION]…` [​](https://mise.jdx.dev/cli/exec.html\#tool-version)

Tool(s) to start e.g.: node@20 python@3.10

### `[-- COMMAND]…` [​](https://mise.jdx.dev/cli/exec.html\#command)

Command string to execute (same as --command)

## Flags [​](https://mise.jdx.dev/cli/exec.html\#flags)

### `-c --command <C>` [​](https://mise.jdx.dev/cli/exec.html\#c-command-c)

Command string to execute

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/exec.html\#j-jobs-jobs)

Number of jobs to run in parallel \[default: 4\]

### `--raw` [​](https://mise.jdx.dev/cli/exec.html\#raw)

Directly pipe stdin/stdout/stderr from plugin to user Sets --jobs=1

Examples:

```
$ mise exec node@20 -- node ./app.js  # launch app.js using node-20.x
$ mise x node@20 -- node ./app.js     # shorter alias

# Specify command as a string:
$ mise exec node@20 python@3.11 --command "node -v && python -V"

# Run a command in a different directory:
$ mise x -C /path/to/project node@20 -- node ./app.js
```

<|firecrawl-page-38-lllmstxt|>
## Mise Format Command
[Skip to content](https://mise.jdx.dev/cli/fmt.html#VPContent)

Return to top

# `mise fmt` [​](https://mise.jdx.dev/cli/fmt.html\#mise-fmt)

- **Usage**: `mise fmt [FLAGS]`
- **Source code**: [`src/cli/fmt.rs`](https://github.com/jdx/mise/blob/main/src/cli/fmt.rs)

Formats mise.toml

Sorts keys and cleans up whitespace in mise.toml

## Flags [​](https://mise.jdx.dev/cli/fmt.html\#flags)

### `-a --all` [​](https://mise.jdx.dev/cli/fmt.html\#a-all)

Format all files from the current directory

### `-c --check` [​](https://mise.jdx.dev/cli/fmt.html\#c-check)

Check if the configs are formatted, no formatting is done

### `-s --stdin` [​](https://mise.jdx.dev/cli/fmt.html\#s-stdin)

Read config from stdin and write its formatted version into stdout

Examples:

```
mise fmt
```

<|firecrawl-page-39-lllmstxt|>
## Mise Generate Command
[Skip to content](https://mise.jdx.dev/cli/generate.html#VPContent)

Return to top

# `mise generate` [​](https://mise.jdx.dev/cli/generate.html\#mise-generate)

- **Usage**: `mise generate <SUBCOMMAND>`
- **Aliases**: `gen`
- **Source code**: [`src/cli/generate/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/mod.rs)

\[experimental\] Generate files for various tools/services

## Subcommands [​](https://mise.jdx.dev/cli/generate.html\#subcommands)

- [`mise generate bootstrap [FLAGS]`](https://mise.jdx.dev/cli/generate/bootstrap.html)
- [`mise generate config [-t --tool-versions <TOOL_VERSIONS>] [-o --output <OUTPUT>]`](https://mise.jdx.dev/cli/generate/config.html)
- [`mise generate devcontainer [FLAGS]`](https://mise.jdx.dev/cli/generate/devcontainer.html)
- [`mise generate git-pre-commit [FLAGS]`](https://mise.jdx.dev/cli/generate/git-pre-commit.html)
- [`mise generate github-action [FLAGS]`](https://mise.jdx.dev/cli/generate/github-action.html)
- [`mise generate task-docs [FLAGS]`](https://mise.jdx.dev/cli/generate/task-docs.html)
- [`mise generate task-stubs [-m --mise-bin <MISE_BIN>] [-d --dir <DIR>]`](https://mise.jdx.dev/cli/generate/task-stubs.html)
- [`mise generate tool-stub [FLAGS] <OUTPUT>`](https://mise.jdx.dev/cli/generate/tool-stub.html)

<|firecrawl-page-40-lllmstxt|>
## Generate Bootstrap Script
[Skip to content](https://mise.jdx.dev/cli/generate/bootstrap.html#VPContent)

Return to top

# `mise generate bootstrap` [​](https://mise.jdx.dev/cli/generate/bootstrap.html\#mise-generate-bootstrap)

- **Usage**: `mise generate bootstrap [FLAGS]`
- **Source code**: [`src/cli/generate/bootstrap.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/bootstrap.rs)

\[experimental\] Generate a script to download+execute mise

This is designed to be used in a project where contributors may not have mise installed.

## Flags [​](https://mise.jdx.dev/cli/generate/bootstrap.html\#flags)

### `-l --localize` [​](https://mise.jdx.dev/cli/generate/bootstrap.html\#l-localize)

Sandboxes mise internal directories like MISE\_DATA\_DIR and MISE\_CACHE\_DIR into a `.mise` directory in the project

This is necessary if users may use a different version of mise outside the project.

### `--localized-dir <LOCALIZED_DIR>` [​](https://mise.jdx.dev/cli/generate/bootstrap.html\#localized-dir-localized-dir)

Directory to put localized data into

### `-V --version <VERSION>` [​](https://mise.jdx.dev/cli/generate/bootstrap.html\#v-version-version)

Specify mise version to fetch

### `-w --write <WRITE>` [​](https://mise.jdx.dev/cli/generate/bootstrap.html\#w-write-write)

instead of outputting the script to stdout, write to a file and make it executable

Examples:

```
mise generate bootstrap >./bin/mise
chmod +x ./bin/mise
./bin/mise install – automatically downloads mise to .mise if not already installed
```

<|firecrawl-page-41-lllmstxt|>
## Generate Configuration File
[Skip to content](https://mise.jdx.dev/cli/generate/config.html#VPContent)

Return to top

# `mise generate config` [​](https://mise.jdx.dev/cli/generate/config.html\#mise-generate-config)

- **Usage**: `mise generate config [-t --tool-versions <TOOL_VERSIONS>] [-o --output <OUTPUT>]`
- **Aliases**: `g`
- **Source code**: [`src/cli/generate/config.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/config.rs)

\[experimental\] Generate a mise.toml file

## Flags [​](https://mise.jdx.dev/cli/generate/config.html\#flags)

### `-t --tool-versions <TOOL_VERSIONS>` [​](https://mise.jdx.dev/cli/generate/config.html\#t-tool-versions-tool-versions)

Path to a .tool-versions file to import tools from

### `-o --output <OUTPUT>` [​](https://mise.jdx.dev/cli/generate/config.html\#o-output-output)

Output to file instead of stdout

Examples:

```
mise cf generate > mise.toml
mise cf generate --output=mise.toml
```

<|firecrawl-page-42-lllmstxt|>
## Devcontainer Generation Guide
[Skip to content](https://mise.jdx.dev/cli/generate/devcontainer.html#VPContent)

Return to top

# `mise generate devcontainer` [​](https://mise.jdx.dev/cli/generate/devcontainer.html\#mise-generate-devcontainer)

- **Usage**: `mise generate devcontainer [FLAGS]`
- **Source code**: [`src/cli/generate/devcontainer.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/devcontainer.rs)

\[experimental\] Generate a devcontainer to execute mise

## Flags [​](https://mise.jdx.dev/cli/generate/devcontainer.html\#flags)

### `-n --name <NAME>` [​](https://mise.jdx.dev/cli/generate/devcontainer.html\#n-name-name)

The name of the devcontainer

### `-i --image <IMAGE>` [​](https://mise.jdx.dev/cli/generate/devcontainer.html\#i-image-image)

The image to use for the devcontainer

### `-m --mount-mise-data` [​](https://mise.jdx.dev/cli/generate/devcontainer.html\#m-mount-mise-data)

Bind the mise-data-volume to the devcontainer

### `-w --write` [​](https://mise.jdx.dev/cli/generate/devcontainer.html\#w-write)

write to .devcontainer/devcontainer.json

Examples:

```
mise generate devcontainer
```

<|firecrawl-page-43-lllmstxt|>
## Generate Git Pre-Commit Hook
[Skip to content](https://mise.jdx.dev/cli/generate/git-pre-commit.html#VPContent)

Return to top

# `mise generate git-pre-commit` [​](https://mise.jdx.dev/cli/generate/git-pre-commit.html\#mise-generate-git-pre-commit)

- **Usage**: `mise generate git-pre-commit [FLAGS]`
- **Aliases**: `pre-commit`
- **Source code**: [`src/cli/generate/git_pre_commit.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/git_pre_commit.rs)

\[experimental\] Generate a git pre-commit hook

This command generates a git pre-commit hook that runs a mise task like `mise run pre-commit` when you commit changes to your repository.

Staged files are passed to the task as `STAGED`.

For more advanced pre-commit functionality, see mise's sister project: [https://hk.jdx.dev/](https://hk.jdx.dev/)

## Flags [​](https://mise.jdx.dev/cli/generate/git-pre-commit.html\#flags)

### `--hook <HOOK>` [​](https://mise.jdx.dev/cli/generate/git-pre-commit.html\#hook-hook)

Which hook to generate (saves to .git/hooks/$hook)

### `-t --task <TASK>` [​](https://mise.jdx.dev/cli/generate/git-pre-commit.html\#t-task-task)

The task to run when the pre-commit hook is triggered

### `-w --write` [​](https://mise.jdx.dev/cli/generate/git-pre-commit.html\#w-write)

write to .git/hooks/pre-commit and make it executable

Examples:

```
mise generate git-pre-commit --write --task=pre-commit
git commit -m "feat: add new feature" # runs `mise run pre-commit`
```

<|firecrawl-page-44-lllmstxt|>
## Generate GitHub Action
[Skip to content](https://mise.jdx.dev/cli/generate/github-action.html#VPContent)

Return to top

# `mise generate github-action` [​](https://mise.jdx.dev/cli/generate/github-action.html\#mise-generate-github-action)

- **Usage**: `mise generate github-action [FLAGS]`
- **Source code**: [`src/cli/generate/github_action.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/github_action.rs)

\[experimental\] Generate a GitHub Action workflow file

This command generates a GitHub Action workflow file that runs a mise task like `mise run ci` when you push changes to your repository.

## Flags [​](https://mise.jdx.dev/cli/generate/github-action.html\#flags)

### `--name <NAME>` [​](https://mise.jdx.dev/cli/generate/github-action.html\#name-name)

the name of the workflow to generate

### `-t --task <TASK>` [​](https://mise.jdx.dev/cli/generate/github-action.html\#t-task-task)

The task to run when the workflow is triggered

### `-w --write` [​](https://mise.jdx.dev/cli/generate/github-action.html\#w-write)

write to .github/workflows/$name.yml

Examples:

```
mise generate github-action --write --task=ci
git commit -m "feat: add new feature"
git push # runs `mise run ci` on GitHub
```

<|firecrawl-page-45-lllmstxt|>
## Task Documentation Generator
[Skip to content](https://mise.jdx.dev/cli/generate/task-docs.html#VPContent)

Return to top

# `mise generate task-docs` [​](https://mise.jdx.dev/cli/generate/task-docs.html\#mise-generate-task-docs)

- **Usage**: `mise generate task-docs [FLAGS]`
- **Source code**: [`src/cli/generate/task_docs.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/task_docs.rs)

Generate documentation for tasks in a project

## Flags [​](https://mise.jdx.dev/cli/generate/task-docs.html\#flags)

### `-I --index` [​](https://mise.jdx.dev/cli/generate/task-docs.html\#i-index)

write only an index of tasks, intended for use with `--multi`

### `-i --inject` [​](https://mise.jdx.dev/cli/generate/task-docs.html\#i-inject)

inserts the documentation into an existing file

This will look for a special comment, `<!-- mise-tasks -->`, and replace it with the generated documentation. It will replace everything between the comment and the next comment, `<!-- /mise-tasks -->` so it can be run multiple times on the same file to update the documentation.

### `-m --multi` [​](https://mise.jdx.dev/cli/generate/task-docs.html\#m-multi)

render each task as a separate document, requires `--output` to be a directory

### `-o --output <OUTPUT>` [​](https://mise.jdx.dev/cli/generate/task-docs.html\#o-output-output)

writes the generated docs to a file/directory

### `-r --root <ROOT>` [​](https://mise.jdx.dev/cli/generate/task-docs.html\#r-root-root)

root directory to search for tasks

### `-s --style <STYLE>` [​](https://mise.jdx.dev/cli/generate/task-docs.html\#s-style-style)

**Choices:**

- `simple`
- `detailed`

Examples:

```
mise generate task-docs
```

<|firecrawl-page-46-lllmstxt|>
## Generate Task Stubs
[Skip to content](https://mise.jdx.dev/cli/generate/task-stubs.html#VPContent)

Return to top

# `mise generate task-stubs` [​](https://mise.jdx.dev/cli/generate/task-stubs.html\#mise-generate-task-stubs)

- **Usage**: `mise generate task-stubs [-m --mise-bin <MISE_BIN>] [-d --dir <DIR>]`
- **Source code**: [`src/cli/generate/task_stubs.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/task_stubs.rs)

\[experimental\] Generates shims to run mise tasks

By default, this will build shims like ./bin/<task>. These can be paired with `mise generate bootstrap` so contributors to a project can execute mise tasks without installing mise into their system.

## Flags [​](https://mise.jdx.dev/cli/generate/task-stubs.html\#flags)

### `-m --mise-bin <MISE_BIN>` [​](https://mise.jdx.dev/cli/generate/task-stubs.html\#m-mise-bin-mise-bin)

Path to a mise bin to use when running the task stub.

Use `--mise-bin=./bin/mise` to use a mise bin generated from `mise generate bootstrap`

### `-d --dir <DIR>` [​](https://mise.jdx.dev/cli/generate/task-stubs.html\#d-dir-dir)

Directory to create task stubs inside of

Examples:

```
$ mise task add test -- echo 'running tests'
$ mise generate task-stubs
$ ./bin/test
running tests
```

<|firecrawl-page-47-lllmstxt|>
## Tool Stub Generator
[Skip to content](https://mise.jdx.dev/cli/generate/tool-stub.html#VPContent)

Return to top

# `mise generate tool-stub` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#mise-generate-tool-stub)

- **Usage**: `mise generate tool-stub [FLAGS] <OUTPUT>`
- **Source code**: [`src/cli/generate/tool_stub.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/tool_stub.rs)

\[experimental\] Generate a tool stub for HTTP-based tools

This command generates tool stubs that can automatically download and execute tools from HTTP URLs. It can detect checksums, file sizes, and binary paths automatically by downloading and analyzing the tool.

When generating stubs with platform-specific URLs, the command will append new platforms to existing stub files rather than overwriting them. This allows you to incrementally build cross-platform tool stubs.

## Arguments [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#arguments)

### `<OUTPUT>` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#output)

Output file path for the tool stub

## Flags [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#flags)

### `--version <VERSION>` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#version-version)

Version of the tool

### `-u --url <URL>` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#u-url-url)

URL for downloading the tool

Example: [https://github.com/owner/repo/releases/download/v2.0.0/tool-linux-x64.tar.gz](https://github.com/owner/repo/releases/download/v2.0.0/tool-linux-x64.tar.gz)

### `--platform-url… <PLATFORM_URL>` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#platform-url-platform-url)

Platform-specific URLs in the format platform:url or just url (auto-detect platform)

When the output file already exists, new platforms will be appended to the existing platforms table. Existing platform URLs will be updated if specified again.

If only a URL is provided (without platform:), the platform will be automatically detected from the URL filename.

Examples: --platform-url linux-x64:https://... --platform-url [https://nodejs.org/dist/v22.17.1/node-v22.17.1-darwin-arm64.tar.gz](https://nodejs.org/dist/v22.17.1/node-v22.17.1-darwin-arm64.tar.gz)

### `--platform-bin… <PLATFORM_BIN>` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#platform-bin-platform-bin)

Platform-specific binary paths in the format platform:path

Examples: --platform-bin windows-x64:tool.exe --platform-bin linux-x64:bin/tool

### `-b --bin <BIN>` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#b-bin-bin)

Binary path within the extracted archive

If not specified and the archive is downloaded, will auto-detect the most likely binary

### `--skip-download` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#skip-download)

Skip downloading for checksum and binary path detection (faster but less informative)

### `--fetch` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#fetch)

Fetch checksums and sizes for an existing tool stub file

This reads an existing stub file and fills in any missing checksum/size fields by downloading the files. URLs must already be present in the stub.

### `--http <HTTP>` [​](https://mise.jdx.dev/cli/generate/tool-stub.html\#http-http)

HTTP backend type to use

Examples:

```
Generate a tool stub for a single URL:
$ mise generate tool-stub ./bin/gh --url "https://github.com/cli/cli/releases/download/v2.336.0/gh_2.336.0_linux_amd64.tar.gz"

Generate a tool stub with platform-specific URLs:
$ mise generate tool-stub ./bin/rg \
    --platform-url linux-x64:https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-x86_64-unknown-linux-musl.tar.gz \
    --platform-url darwin-arm64:https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-aarch64-apple-darwin.tar.gz

Append additional platforms to an existing stub:
$ mise generate tool-stub ./bin/rg \
    --platform-url linux-x64:https://example.com/rg-linux.tar.gz
$ mise generate tool-stub ./bin/rg \
    --platform-url darwin-arm64:https://example.com/rg-darwin.tar.gz
# The stub now contains both platforms

Use auto-detection for platform from URL:
$ mise generate tool-stub ./bin/node \
    --platform-url https://nodejs.org/dist/v22.17.1/node-v22.17.1-darwin-arm64.tar.gz
# Platform 'macos-arm64' will be auto-detected from the URL

Generate with platform-specific binary paths:
$ mise generate tool-stub ./bin/tool \
    --platform-url linux-x64:https://example.com/tool-linux.tar.gz \
    --platform-url windows-x64:https://example.com/tool-windows.zip \
    --platform-bin windows-x64:tool.exe

Generate without downloading (faster):
$ mise generate tool-stub ./bin/tool --url "https://example.com/tool.tar.gz" --skip-download

Fetch checksums for an existing stub:
$ mise generate tool-stub ./bin/jq --fetch
# This will read the existing stub and download files to fill in any missing checksums/sizes
```

<|firecrawl-page-48-lllmstxt|>
## Mise CLI Implode Command
[Skip to content](https://mise.jdx.dev/cli/implode.html#VPContent)

Return to top

# `mise implode` [​](https://mise.jdx.dev/cli/implode.html\#mise-implode)

- **Usage**: `mise implode [--config] [-n --dry-run]`
- **Source code**: [`src/cli/implode.rs`](https://github.com/jdx/mise/blob/main/src/cli/implode.rs)

Removes mise CLI and all related data

Skips config directory by default.

## Flags [​](https://mise.jdx.dev/cli/implode.html\#flags)

### `--config` [​](https://mise.jdx.dev/cli/implode.html\#config)

Also remove config directory

### `-n --dry-run` [​](https://mise.jdx.dev/cli/implode.html\#n-dry-run)

List directories that would be removed without actually removing them

<|firecrawl-page-49-lllmstxt|>
## Install Tool Versions
[Skip to content](https://mise.jdx.dev/cli/install-into.html#VPContent)

Return to top

# `mise install-into` [​](https://mise.jdx.dev/cli/install-into.html\#mise-install-into)

- **Usage**: `mise install-into <TOOL@VERSION> <PATH>`
- **Source code**: [`src/cli/install_into.rs`](https://github.com/jdx/mise/blob/main/src/cli/install_into.rs)

Install a tool version to a specific path

Used for building a tool to a directory for use outside of mise

## Arguments [​](https://mise.jdx.dev/cli/install-into.html\#arguments)

### `<TOOL@VERSION>` [​](https://mise.jdx.dev/cli/install-into.html\#tool-version)

Tool to install e.g.: node@20

### `<PATH>` [​](https://mise.jdx.dev/cli/install-into.html\#path)

Path to install the tool into

Examples:

```
# install node@20.0.0 into ./mynode
$ mise install-into node@20.0.0 ./mynode && ./mynode/bin/node -v
20.0.0
```

<|firecrawl-page-50-lllmstxt|>
## Mise Tool Installation Guide
[Skip to content](https://mise.jdx.dev/cli/install.html#VPContent)

Return to top

# `mise install` [​](https://mise.jdx.dev/cli/install.html\#mise-install)

- **Usage**: `mise install [FLAGS] [TOOL@VERSION]…`
- **Aliases**: `i`
- **Source code**: [`src/cli/install.rs`](https://github.com/jdx/mise/blob/main/src/cli/install.rs)

Install a tool version

Installs a tool version to `~/.local/share/mise/installs/<PLUGIN>/<VERSION>` Installing alone will not activate the tools so they won't be in PATH. To install and/or activate in one command, use `mise use` which will create a `mise.toml` file in the current directory to activate this tool when inside the directory. Alternatively, run `mise exec <TOOL>@<VERSION> -- <COMMAND>` to execute a tool without creating config files.

Tools will be installed in parallel. To disable, set `--jobs=1` or `MISE_JOBS=1`

## Arguments [​](https://mise.jdx.dev/cli/install.html\#arguments)

### `[TOOL@VERSION]…` [​](https://mise.jdx.dev/cli/install.html\#tool-version)

Tool(s) to install e.g.: node@20

## Flags [​](https://mise.jdx.dev/cli/install.html\#flags)

### `-f --force` [​](https://mise.jdx.dev/cli/install.html\#f-force)

Force reinstall even if already installed

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/install.html\#j-jobs-jobs)

Number of jobs to run in parallel \[default: 4\]

### `--raw` [​](https://mise.jdx.dev/cli/install.html\#raw)

Directly pipe stdin/stdout/stderr from plugin to user Sets --jobs=1

### `-v --verbose…` [​](https://mise.jdx.dev/cli/install.html\#v-verbose)

Show installation output

This argument will print plugin output such as download, configuration, and compilation output.

Examples:

```
mise install node@20.0.0  # install specific node version
mise install node@20      # install fuzzy node version
mise install node         # install version specified in mise.toml
mise install              # installs everything specified in mise.toml
```

<|firecrawl-page-51-lllmstxt|>
## Latest Version Checker
[Skip to content](https://mise.jdx.dev/cli/latest.html#VPContent)

Return to top

# `mise latest` [​](https://mise.jdx.dev/cli/latest.html\#mise-latest)

- **Usage**: `mise latest [-i --installed] <TOOL@VERSION>`
- **Source code**: [`src/cli/latest.rs`](https://github.com/jdx/mise/blob/main/src/cli/latest.rs)

Gets the latest available version for a plugin

Supports prefixes such as `node@20` to get the latest version of node 20.

## Arguments [​](https://mise.jdx.dev/cli/latest.html\#arguments)

### `<TOOL@VERSION>` [​](https://mise.jdx.dev/cli/latest.html\#tool-version)

Tool to get the latest version of

## Flags [​](https://mise.jdx.dev/cli/latest.html\#flags)

### `-i --installed` [​](https://mise.jdx.dev/cli/latest.html\#i-installed)

Show latest installed instead of available version

Examples:

```
$ mise latest node@20  # get the latest version of node 20
20.0.0

$ mise latest node     # get the latest stable version of node
20.0.0
```

<|firecrawl-page-52-lllmstxt|>
## Mise Link Command
[Skip to content](https://mise.jdx.dev/cli/link.html#VPContent)

Return to top

# `mise link` [​](https://mise.jdx.dev/cli/link.html\#mise-link)

- **Usage**: `mise link [-f --force] <TOOL@VERSION> <PATH>`
- **Aliases**: `ln`
- **Source code**: [`src/cli/link.rs`](https://github.com/jdx/mise/blob/main/src/cli/link.rs)

Symlinks a tool version into mise

Use this for adding installs either custom compiled outside mise or built with a different tool.

## Arguments [​](https://mise.jdx.dev/cli/link.html\#arguments)

### `<TOOL@VERSION>` [​](https://mise.jdx.dev/cli/link.html\#tool-version)

Tool name and version to create a symlink for

### `<PATH>` [​](https://mise.jdx.dev/cli/link.html\#path)

The local path to the tool version e.g.: ~/.nvm/versions/node/v20.0.0

## Flags [​](https://mise.jdx.dev/cli/link.html\#flags)

### `-f --force` [​](https://mise.jdx.dev/cli/link.html\#f-force)

Overwrite an existing tool version if it exists

Examples:

```
# build node-20.0.0 with node-build and link it into mise
$ node-build 20.0.0 ~/.nodes/20.0.0
$ mise link node@20.0.0 ~/.nodes/20.0.0

# have mise use the node version provided by Homebrew
$ brew install node
$ mise link node@brew $(brew --prefix node)
$ mise use node@brew
```

<|firecrawl-page-53-lllmstxt|>
## Mise Lock Command
[Skip to content](https://mise.jdx.dev/cli/lock.html#VPContent)

Return to top

# `mise lock` [​](https://mise.jdx.dev/cli/lock.html\#mise-lock)

- **Usage**: `mise lock [FLAGS] [TOOL]…`
- **Source code**: [`src/cli/lock.rs`](https://github.com/jdx/mise/blob/main/src/cli/lock.rs)

Update lockfile checksums and URLs for all specified platforms

Updates checksums and download URLs for all platforms already specified in the lockfile. If no lockfile exists, shows what would be created based on the current configuration. This allows you to refresh lockfile data for platforms other than the one you're currently on. Operates on the lockfile in the current config root. Use TOOL arguments to target specific tools.

## Arguments [​](https://mise.jdx.dev/cli/lock.html\#arguments)

### `[TOOL]…` [​](https://mise.jdx.dev/cli/lock.html\#tool)

Tool(s) to update in lockfile e.g.: node python If not specified, all tools in lockfile will be updated

## Flags [​](https://mise.jdx.dev/cli/lock.html\#flags)

### `-p --platform… <PLATFORM>` [​](https://mise.jdx.dev/cli/lock.html\#p-platform-platform)

Comma-separated list of platforms to target e.g.: linux-x64,macos-arm64,windows-x64 If not specified, all platforms already in lockfile will be updated

### `-f --force` [​](https://mise.jdx.dev/cli/lock.html\#f-force)

Update all tools even if lockfile data already exists

### `-n --dry-run` [​](https://mise.jdx.dev/cli/lock.html\#n-dry-run)

Show what would be updated without making changes

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/lock.html\#j-jobs-jobs)

Number of jobs to run in parallel \[default: 4\]

Examples:

$ mise lock Update lockfile in current directory for all platforms $ mise lock node python Update only node and python $ mise lock --platform linux-x64 Update only linux-x64 platform $ mise lock --dry-run Show what would be updated or created $ mise lock --force Re-download and update even if data exists

<|firecrawl-page-54-lllmstxt|>
## List Available Versions
[Skip to content](https://mise.jdx.dev/cli/ls-remote.html#VPContent)

On this page

# `mise ls-remote` [​](https://mise.jdx.dev/cli/ls-remote.html\#mise-ls-remote)

- **Usage**: `mise ls-remote [--all] [TOOL@VERSION] [PREFIX]`
- **Source code**: [`src/cli/ls_remote.rs`](https://github.com/jdx/mise/blob/main/src/cli/ls_remote.rs)

List runtime versions available for install.

Note that the results may be cached, run `mise cache clean` to clear the cache and get fresh results.

## Arguments [​](https://mise.jdx.dev/cli/ls-remote.html\#arguments)

### `[TOOL@VERSION]` [​](https://mise.jdx.dev/cli/ls-remote.html\#tool-version)

Tool to get versions for

### `[PREFIX]` [​](https://mise.jdx.dev/cli/ls-remote.html\#prefix)

The version prefix to use when querying the latest version same as the first argument after the "@"

## Flags [​](https://mise.jdx.dev/cli/ls-remote.html\#flags)

### `--all` [​](https://mise.jdx.dev/cli/ls-remote.html\#all)

Show all installed plugins and versions

Examples:

```
$ mise ls-remote node
18.0.0
20.0.0

$ mise ls-remote node@20
20.0.0
20.1.0

$ mise ls-remote node 20
20.0.0
20.1.0
```

<|firecrawl-page-55-lllmstxt|>
## List Installed Tools
[Skip to content](https://mise.jdx.dev/cli/ls.html#VPContent)

Return to top

# `mise ls` [​](https://mise.jdx.dev/cli/ls.html\#mise-ls)

- **Usage**: `mise ls [FLAGS] [INSTALLED_TOOL]…`
- **Aliases**: `list`
- **Source code**: [`src/cli/ls.rs`](https://github.com/jdx/mise/blob/main/src/cli/ls.rs)

List installed and active tool versions

This command lists tools that mise "knows about". These may be tools that are currently installed, or those that are in a config file (active) but may or may not be installed.

It's a useful command to get the current state of your tools.

## Arguments [​](https://mise.jdx.dev/cli/ls.html\#arguments)

### `[INSTALLED_TOOL]…` [​](https://mise.jdx.dev/cli/ls.html\#installed-tool)

Only show tool versions from \[TOOL\]

## Flags [​](https://mise.jdx.dev/cli/ls.html\#flags)

### `-c --current` [​](https://mise.jdx.dev/cli/ls.html\#c-current)

Only show tool versions currently specified in a mise.toml

### `-g --global` [​](https://mise.jdx.dev/cli/ls.html\#g-global)

Only show tool versions currently specified in the global mise.toml

### `-l --local` [​](https://mise.jdx.dev/cli/ls.html\#l-local)

Only show tool versions currently specified in the local mise.toml

### `-i --installed` [​](https://mise.jdx.dev/cli/ls.html\#i-installed)

Only show tool versions that are installed (Hides tools defined in mise.toml but not installed)

### `--outdated` [​](https://mise.jdx.dev/cli/ls.html\#outdated)

Display whether a version is outdated

### `-J --json` [​](https://mise.jdx.dev/cli/ls.html\#j-json)

Output in JSON format

### `-m --missing` [​](https://mise.jdx.dev/cli/ls.html\#m-missing)

Display missing tool versions

### `--prefix <PREFIX>` [​](https://mise.jdx.dev/cli/ls.html\#prefix-prefix)

Display versions matching this prefix

### `--prunable` [​](https://mise.jdx.dev/cli/ls.html\#prunable)

List only tools that can be pruned with `mise prune`

### `--no-header` [​](https://mise.jdx.dev/cli/ls.html\#no-header)

Don't display headers

Examples:

```
$ mise ls
node    20.0.0 ~/src/myapp/.tool-versions latest
python  3.11.0 ~/.tool-versions           3.10
python  3.10.0

$ mise ls --current
node    20.0.0 ~/src/myapp/.tool-versions 20
python  3.11.0 ~/.tool-versions           3.11.0

$ mise ls --json
{
  "node": [\
    {\
      "version": "20.0.0",\
      "install_path": "/Users/jdx/.mise/installs/node/20.0.0",\
      "source": {\
        "type": "mise.toml",\
        "path": "/Users/jdx/mise.toml"\
      }\
    }\
  ],
  "python": [...]
}
```

<|firecrawl-page-56-lllmstxt|>
## MCP Server Command
[Skip to content](https://mise.jdx.dev/cli/mcp.html#VPContent)

Return to top

# `mise mcp` [​](https://mise.jdx.dev/cli/mcp.html\#mise-mcp)

- **Usage**: `mise mcp`
- **Source code**: [`src/cli/mcp.rs`](https://github.com/jdx/mise/blob/main/src/cli/mcp.rs)

\[experimental\] Run Model Context Protocol (MCP) server

This command starts an MCP server that exposes mise functionality to AI assistants over stdin/stdout using JSON-RPC protocol.

The MCP server provides access to:

- Installed and available tools
- Task definitions and execution
- Environment variables
- Configuration information

Resources available:

- mise://tools - List all tools (use ?include\_inactive=true to include inactive tools)
- mise://tasks - List all tasks with their configurations
- mise://env - List all environment variables
- mise://config - Show configuration files and project root

Note: This is primarily intended for integration with AI assistants like Claude, Cursor, or other tools that support the Model Context Protocol.

Examples:

```
# Start the MCP server (typically used by AI assistant tools)
$ mise mcp

# Example integration with Claude Desktop (add to claude_desktop_config.json):
{
  "mcpServers": {
    "mise": {
      "command": "mise",
      "args": ["mcp"]
    }
  }
}

# Interactive testing with JSON-RPC commands:
$ echo '{"jsonrpc":"2.0","id":1,"method":"initialize","params":{"protocolVersion":"2024-11-05","capabilities":{},"clientInfo":{"name":"test","version":"1.0"}}}' | mise mcp

# Resources you can query:
- mise://tools - List active tools
- mise://tools?include_inactive=true - List all installed tools
- mise://tasks - List all tasks
- mise://env - List environment variables
- mise://config - Show configuration info
```

<|firecrawl-page-57-lllmstxt|>
## Check Outdated Tool Versions
[Skip to content](https://mise.jdx.dev/cli/outdated.html#VPContent)

Return to top

# `mise outdated` [​](https://mise.jdx.dev/cli/outdated.html\#mise-outdated)

- **Usage**: `mise outdated [FLAGS] [TOOL@VERSION]…`
- **Source code**: [`src/cli/outdated.rs`](https://github.com/jdx/mise/blob/main/src/cli/outdated.rs)

Shows outdated tool versions

See `mise upgrade` to upgrade these versions.

## Arguments [​](https://mise.jdx.dev/cli/outdated.html\#arguments)

### `[TOOL@VERSION]…` [​](https://mise.jdx.dev/cli/outdated.html\#tool-version)

Tool(s) to show outdated versions for e.g.: node@20 python@3.10 If not specified, all tools in global and local configs will be shown

## Flags [​](https://mise.jdx.dev/cli/outdated.html\#flags)

### `-l --bump` [​](https://mise.jdx.dev/cli/outdated.html\#l-bump)

Compares against the latest versions available, not what matches the current config

For example, if you have `node = "20"` in your config by default `mise outdated` will only show other 20.x versions, not 21.x or 22.x versions.

Using this flag, if there are 21.x or newer versions it will display those instead of 20.x.

### `-J --json` [​](https://mise.jdx.dev/cli/outdated.html\#j-json)

Output in JSON format

### `--no-header` [​](https://mise.jdx.dev/cli/outdated.html\#no-header)

Don't show table header

Examples:

```
$ mise outdated
Plugin  Requested  Current  Latest
python  3.11       3.11.0   3.11.1
node    20         20.0.0   20.1.0

$ mise outdated node
Plugin  Requested  Current  Latest
node    20         20.0.0   20.1.0

$ mise outdated --json
{"python": {"requested": "3.11", "current": "3.11.0", "latest": "3.11.1"}, ...}
```

<|firecrawl-page-58-lllmstxt|>
## Mise Plugin Management
[Skip to content](https://mise.jdx.dev/cli/plugins.html#VPContent)

Return to top

# `mise plugins` [​](https://mise.jdx.dev/cli/plugins.html\#mise-plugins)

- **Usage**: `mise plugins [FLAGS] <SUBCOMMAND>`
- **Aliases**: `p`
- **Source code**: [`src/cli/plugins/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/plugins/mod.rs)

Manage plugins

## Flags [​](https://mise.jdx.dev/cli/plugins.html\#flags)

### `-c --core` [​](https://mise.jdx.dev/cli/plugins.html\#c-core)

The built-in plugins only Normally these are not shown

### `--user` [​](https://mise.jdx.dev/cli/plugins.html\#user)

List installed plugins

This is the default behavior but can be used with --core to show core and user plugins

### `-u --urls` [​](https://mise.jdx.dev/cli/plugins.html\#u-urls)

Show the git url for each plugin e.g.: [https://github.com/asdf-vm/asdf-nodejs.git](https://github.com/asdf-vm/asdf-nodejs.git)

## Subcommands [​](https://mise.jdx.dev/cli/plugins.html\#subcommands)

- [`mise plugins install [FLAGS] [NEW_PLUGIN] [GIT_URL]`](https://mise.jdx.dev/cli/plugins/install.html)
- [`mise plugins link [-f --force] <NAME> [DIR]`](https://mise.jdx.dev/cli/plugins/link.html)
- [`mise plugins ls [-u --urls]`](https://mise.jdx.dev/cli/plugins/ls.html)
- [`mise plugins ls-remote [-u --urls] [--only-names]`](https://mise.jdx.dev/cli/plugins/ls-remote.html)
- [`mise plugins uninstall [-p --purge] [-a --all] [PLUGIN]…`](https://mise.jdx.dev/cli/plugins/uninstall.html)
- [`mise plugins update [-j --jobs <JOBS>] [PLUGIN]…`](https://mise.jdx.dev/cli/plugins/update.html)

<|firecrawl-page-59-lllmstxt|>
## Install Mise Plugins
[Skip to content](https://mise.jdx.dev/cli/plugins/install.html#VPContent)

Return to top

# `mise plugins install` [​](https://mise.jdx.dev/cli/plugins/install.html\#mise-plugins-install)

- **Usage**: `mise plugins install [FLAGS] [NEW_PLUGIN] [GIT_URL]`
- **Aliases**: `i`, `a`, `add`
- **Source code**: [`src/cli/plugins/install.rs`](https://github.com/jdx/mise/blob/main/src/cli/plugins/install.rs)

Install a plugin

note that mise automatically can install plugins when you install a tool e.g.: `mise install node@20` will autoinstall the node plugin

This behavior can be modified in ~/.config/mise/config.toml

## Arguments [​](https://mise.jdx.dev/cli/plugins/install.html\#arguments)

### `[NEW_PLUGIN]` [​](https://mise.jdx.dev/cli/plugins/install.html\#new-plugin)

The name of the plugin to install e.g.: node, ruby Can specify multiple plugins: `mise plugins install node ruby python`

### `[GIT_URL]` [​](https://mise.jdx.dev/cli/plugins/install.html\#git-url)

The git url of the plugin

## Flags [​](https://mise.jdx.dev/cli/plugins/install.html\#flags)

### `-f --force` [​](https://mise.jdx.dev/cli/plugins/install.html\#f-force)

Reinstall even if plugin exists

### `-a --all` [​](https://mise.jdx.dev/cli/plugins/install.html\#a-all)

Install all missing plugins This will only install plugins that have matching shorthands. i.e.: they don't need the full git repo url

### `-v --verbose…` [​](https://mise.jdx.dev/cli/plugins/install.html\#v-verbose)

Show installation output

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/plugins/install.html\#j-jobs-jobs)

Number of jobs to run in parallel

Examples:

```
# install the poetry via shorthand
$ mise plugins install poetry

# install the poetry plugin using a specific git url
$ mise plugins install poetry https://github.com/mise-plugins/mise-poetry.git

# install the poetry plugin using the git url only
# (poetry is inferred from the url)
$ mise plugins install https://github.com/mise-plugins/mise-poetry.git

# install the poetry plugin using a specific ref
$ mise plugins install poetry https://github.com/mise-plugins/mise-poetry.git#11d0c1e
```

<|firecrawl-page-60-lllmstxt|>
## Mise Plugin Linking
[Skip to content](https://mise.jdx.dev/cli/plugins/link.html#VPContent)

Return to top

# `mise plugins link` [​](https://mise.jdx.dev/cli/plugins/link.html\#mise-plugins-link)

- **Usage**: `mise plugins link [-f --force] <NAME> [DIR]`
- **Aliases**: `ln`
- **Source code**: [`src/cli/plugins/link.rs`](https://github.com/jdx/mise/blob/main/src/cli/plugins/link.rs)

Symlinks a plugin into mise

This is used for developing a plugin.

## Arguments [​](https://mise.jdx.dev/cli/plugins/link.html\#arguments)

### `<NAME>` [​](https://mise.jdx.dev/cli/plugins/link.html\#name)

The name of the plugin e.g.: node, ruby

### `[DIR]` [​](https://mise.jdx.dev/cli/plugins/link.html\#dir)

The local path to the plugin e.g.: ./mise-node

## Flags [​](https://mise.jdx.dev/cli/plugins/link.html\#flags)

### `-f --force` [​](https://mise.jdx.dev/cli/plugins/link.html\#f-force)

Overwrite existing plugin

Examples:

```
# essentially just `ln -s ./mise-node ~/.local/share/mise/plugins/node`
$ mise plugins link node ./mise-node

# infer plugin name as "node"
$ mise plugins link ./mise-node
```

<|firecrawl-page-61-lllmstxt|>
## List Remote Plugins
[Skip to content](https://mise.jdx.dev/cli/plugins/ls-remote.html#VPContent)

Return to top

# `mise plugins ls-remote` [​](https://mise.jdx.dev/cli/plugins/ls-remote.html\#mise-plugins-ls-remote)

- **Usage**: `mise plugins ls-remote [-u --urls] [--only-names]`
- **Aliases**: `list-remote`, `list-all`
- **Source code**: [`src/cli/plugins/ls_remote.rs`](https://github.com/jdx/mise/blob/main/src/cli/plugins/ls_remote.rs)

List all available remote plugins

The full list is here: [https://github.com/jdx/mise/blob/main/registry.toml](https://github.com/jdx/mise/blob/main/registry.toml)

Examples:

```
mise plugins ls-remote
```

## Flags [​](https://mise.jdx.dev/cli/plugins/ls-remote.html\#flags)

### `-u --urls` [​](https://mise.jdx.dev/cli/plugins/ls-remote.html\#u-urls)

Show the git url for each plugin e.g.: [https://github.com/mise-plugins/mise-poetry.git](https://github.com/mise-plugins/mise-poetry.git)

### `--only-names` [​](https://mise.jdx.dev/cli/plugins/ls-remote.html\#only-names)

Only show the name of each plugin by default it will show a "\*" next to installed plugins

<|firecrawl-page-62-lllmstxt|>
## List Installed Plugins
[Skip to content](https://mise.jdx.dev/cli/plugins/ls.html#VPContent)

Return to top

# `mise plugins ls` [​](https://mise.jdx.dev/cli/plugins/ls.html\#mise-plugins-ls)

- **Usage**: `mise plugins ls [-u --urls]`
- **Aliases**: `list`
- **Source code**: [`src/cli/plugins/ls.rs`](https://github.com/jdx/mise/blob/main/src/cli/plugins/ls.rs)

List installed plugins

Can also show remotely available plugins to install.

## Flags [​](https://mise.jdx.dev/cli/plugins/ls.html\#flags)

### `-u --urls` [​](https://mise.jdx.dev/cli/plugins/ls.html\#u-urls)

Show the git url for each plugin e.g.: [https://github.com/asdf-vm/asdf-nodejs.git](https://github.com/asdf-vm/asdf-nodejs.git)

Examples:

```
$ mise plugins ls
node
ruby

$ mise plugins ls --urls
node    https://github.com/asdf-vm/asdf-nodejs.git
ruby    https://github.com/asdf-vm/asdf-ruby.git
```

<|firecrawl-page-63-lllmstxt|>
## Uninstall Plugins Guide
[Skip to content](https://mise.jdx.dev/cli/plugins/uninstall.html#VPContent)

Return to top

# `mise plugins uninstall` [​](https://mise.jdx.dev/cli/plugins/uninstall.html\#mise-plugins-uninstall)

- **Usage**: `mise plugins uninstall [-p --purge] [-a --all] [PLUGIN]…`
- **Aliases**: `remove`, `rm`
- **Source code**: [`src/cli/plugins/uninstall.rs`](https://github.com/jdx/mise/blob/main/src/cli/plugins/uninstall.rs)

Removes a plugin

## Arguments [​](https://mise.jdx.dev/cli/plugins/uninstall.html\#arguments)

### `[PLUGIN]…` [​](https://mise.jdx.dev/cli/plugins/uninstall.html\#plugin)

Plugin(s) to remove

## Flags [​](https://mise.jdx.dev/cli/plugins/uninstall.html\#flags)

### `-p --purge` [​](https://mise.jdx.dev/cli/plugins/uninstall.html\#p-purge)

Also remove the plugin's installs, downloads, and cache

### `-a --all` [​](https://mise.jdx.dev/cli/plugins/uninstall.html\#a-all)

Remove all plugins

Examples:

```
mise uninstall node
```

<|firecrawl-page-64-lllmstxt|>
## Plugin Update Command
[Skip to content](https://mise.jdx.dev/cli/plugins/update.html#VPContent)

Return to top

# `mise plugins update` [​](https://mise.jdx.dev/cli/plugins/update.html\#mise-plugins-update)

- **Usage**: `mise plugins update [-j --jobs <JOBS>] [PLUGIN]…`
- **Aliases**: `up`, `upgrade`
- **Source code**: [`src/cli/plugins/update.rs`](https://github.com/jdx/mise/blob/main/src/cli/plugins/update.rs)

Updates a plugin to the latest version

note: this updates the plugin itself, not the runtime versions

## Arguments [​](https://mise.jdx.dev/cli/plugins/update.html\#arguments)

### `[PLUGIN]…` [​](https://mise.jdx.dev/cli/plugins/update.html\#plugin)

Plugin(s) to update

## Flags [​](https://mise.jdx.dev/cli/plugins/update.html\#flags)

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/plugins/update.html\#j-jobs-jobs)

Number of jobs to run in parallel Default: 4

Examples:

```
mise plugins update            # update all plugins
mise plugins update node       # update only node
mise plugins update node#beta  # specify a ref
```

<|firecrawl-page-65-lllmstxt|>
## Mise Prune Command
[Skip to content](https://mise.jdx.dev/cli/prune.html#VPContent)

Return to top

# `mise prune` [​](https://mise.jdx.dev/cli/prune.html\#mise-prune)

- **Usage**: `mise prune [FLAGS] [INSTALLED_TOOL]…`
- **Source code**: [`src/cli/prune.rs`](https://github.com/jdx/mise/blob/main/src/cli/prune.rs)

Delete unused versions of tools

mise tracks which config files have been used in ~/.local/state/mise/tracked-configs Versions which are no longer the latest specified in any of those configs are deleted. Versions installed only with environment variables `MISE_<PLUGIN>_VERSION` will be deleted, as will versions only referenced on the command line `mise exec <PLUGIN>@<VERSION>`.

You can list prunable tools with `mise ls --prunable`

## Arguments [​](https://mise.jdx.dev/cli/prune.html\#arguments)

### `[INSTALLED_TOOL]…` [​](https://mise.jdx.dev/cli/prune.html\#installed-tool)

Prune only these tools

## Flags [​](https://mise.jdx.dev/cli/prune.html\#flags)

### `-n --dry-run` [​](https://mise.jdx.dev/cli/prune.html\#n-dry-run)

Do not actually delete anything

### `--configs` [​](https://mise.jdx.dev/cli/prune.html\#configs)

Prune only tracked and trusted configuration links that point to non-existent configurations

### `--tools` [​](https://mise.jdx.dev/cli/prune.html\#tools)

Prune only unused versions of tools

Examples:

```
$ mise prune --dry-run
rm -rf ~/.local/share/mise/versions/node/20.0.0
rm -rf ~/.local/share/mise/versions/node/20.0.1
```

<|firecrawl-page-66-lllmstxt|>
## Mise Registry Command
[Skip to content](https://mise.jdx.dev/cli/registry.html#VPContent)

Return to top

# `mise registry` [​](https://mise.jdx.dev/cli/registry.html\#mise-registry)

- **Usage**: `mise registry [-b --backend <BACKEND>] [--hide-aliased] [NAME]`
- **Source code**: [`src/cli/registry.rs`](https://github.com/jdx/mise/blob/main/src/cli/registry.rs)

List available tools to install

This command lists the tools available in the registry as shorthand names.

For example, `poetry` is shorthand for `asdf:mise-plugins/mise-poetry`.

## Arguments [​](https://mise.jdx.dev/cli/registry.html\#arguments)

### `[NAME]` [​](https://mise.jdx.dev/cli/registry.html\#name)

Show only the specified tool's full name

## Flags [​](https://mise.jdx.dev/cli/registry.html\#flags)

### `-b --backend <BACKEND>` [​](https://mise.jdx.dev/cli/registry.html\#b-backend-backend)

Show only tools for this backend

### `--hide-aliased` [​](https://mise.jdx.dev/cli/registry.html\#hide-aliased)

Hide aliased tools

Examples:

```
$ mise registry
node    core:node
poetry  asdf:mise-plugins/mise-poetry
ubi     cargo:ubi-cli

$ mise registry poetry
asdf:mise-plugins/mise-poetry
```

<|firecrawl-page-67-lllmstxt|>
## Mise Reshim Command
[Skip to content](https://mise.jdx.dev/cli/reshim.html#VPContent)

Return to top

# `mise reshim` [​](https://mise.jdx.dev/cli/reshim.html\#mise-reshim)

- **Usage**: `mise reshim [-f --force]`
- **Source code**: [`src/cli/reshim.rs`](https://github.com/jdx/mise/blob/main/src/cli/reshim.rs)

Creates new shims based on bin paths from currently installed tools.

This creates new shims in ~/.local/share/mise/shims for CLIs that have been added. mise will try to do this automatically for commands like `npm i -g` but there are other ways to install things (like using yarn or pnpm for node) that mise does not know about and so it will be necessary to call this explicitly.

If you think mise should automatically call this for a particular command, please open an issue on the mise repo. You can also setup a shell function to reshim automatically (it's really fast so you don't need to worry about overhead):

```
npm() {
  command npm "$@"
  mise reshim
}
```

Note that this creates shims for _all_ installed tools, not just the ones that are currently active in mise.toml.

## Flags [​](https://mise.jdx.dev/cli/reshim.html\#flags)

### `-f --force` [​](https://mise.jdx.dev/cli/reshim.html\#f-force)

Removes all shims before reshimming

Examples:

```
$ mise reshim
$ ~/.local/share/mise/shims/node -v
v20.0.0
```

<|firecrawl-page-68-lllmstxt|>
## Run Tasks with Mise
[Skip to content](https://mise.jdx.dev/cli/run.html#VPContent)

Return to top

# `mise run` [​](https://mise.jdx.dev/cli/run.html\#mise-run)

- **Usage**: `mise run [FLAGS]`
- **Aliases**: `r`
- **Source code**: [`src/cli/run.rs`](https://github.com/jdx/mise/blob/main/src/cli/run.rs)

Run task(s)

This command will run a tasks, or multiple tasks in parallel. Tasks may have dependencies on other tasks or on source files. If source is configured on a tasks, it will only run if the source files have changed.

Tasks can be defined in mise.toml or as standalone scripts. In mise.toml, tasks take this form:

```
[tasks.build]
run = "npm run build"
sources = ["src/**/*.ts"]
outputs = ["dist/**/*.js"]
```

Alternatively, tasks can be defined as standalone scripts. These must be located in `mise-tasks`, `.mise-tasks`, `.mise/tasks`, `mise/tasks` or `.config/mise/tasks`. The name of the script will be the name of the tasks.

```
$ cat .mise/tasks/build&lt;&lt;EOF
#!/usr/bin/env bash
npm run build
EOF
$ mise run build
```

## Flags [​](https://mise.jdx.dev/cli/run.html\#flags)

### `-C --cd <CD>` [​](https://mise.jdx.dev/cli/run.html\#c-cd-cd)

Change to this directory before executing the command

### `-c --continue-on-error` [​](https://mise.jdx.dev/cli/run.html\#c-continue-on-error)

Continue running tasks even if one fails

### `-n --dry-run` [​](https://mise.jdx.dev/cli/run.html\#n-dry-run)

Don't actually run the tasks(s), just print them in order of execution

### `-f --force` [​](https://mise.jdx.dev/cli/run.html\#f-force)

Force the tasks to run even if outputs are up to date

### `-s --shell <SHELL>` [​](https://mise.jdx.dev/cli/run.html\#s-shell-shell)

Shell to use to run toml tasks

Defaults to `sh -c -o errexit -o pipefail` on unix, and `cmd /c` on Windows Can also be set with the setting `MISE_UNIX_DEFAULT_INLINE_SHELL_ARGS` or `MISE_WINDOWS_DEFAULT_INLINE_SHELL_ARGS` Or it can be overridden with the `shell` property on a task.

### `-t --tool… <TOOL@VERSION>` [​](https://mise.jdx.dev/cli/run.html\#t-tool-tool-version)

Tool(s) to run in addition to what is in mise.toml files e.g.: node@20 python@3.10

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/run.html\#j-jobs-jobs)

Number of tasks to run in parallel \[default: 4\] Configure with `jobs` config or `MISE_JOBS` env var

### `-r --raw` [​](https://mise.jdx.dev/cli/run.html\#r-raw)

Read/write directly to stdin/stdout/stderr instead of by line Redactions are not applied with this option Configure with `raw` config or `MISE_RAW` env var

### `--no-timings` [​](https://mise.jdx.dev/cli/run.html\#no-timings)

Hides elapsed time after each task completes

Default to always hide with `MISE_TASK_TIMINGS=0`

### `-q --quiet` [​](https://mise.jdx.dev/cli/run.html\#q-quiet)

Don't show extra output

### `-S --silent` [​](https://mise.jdx.dev/cli/run.html\#s-silent)

Don't show any output except for errors

### `-o --output <OUTPUT>` [​](https://mise.jdx.dev/cli/run.html\#o-output-output)

Change how tasks information is output when running tasks

- `prefix` \- Print stdout/stderr by line, prefixed with the task's label
- `interleave` \- Print directly to stdout/stderr instead of by line
- `replacing` \- Stdout is replaced each time, stderr is printed as is
- `timed` \- Only show stdout lines if they are displayed for more than 1 second
- `keep-order` \- Print stdout/stderr by line, prefixed with the task's label, but keep the order of the output
- `quiet` \- Don't show extra output
- `silent` \- Don't show any output including stdout and stderr from the task except for errors

### `--no-cache` [​](https://mise.jdx.dev/cli/run.html\#no-cache)

Examples:

```
# Runs the "lint" tasks. This needs to either be defined in mise.toml
# or as a standalone script. See the project README for more information.
$ mise run lint

# Forces the "build" tasks to run even if its sources are up-to-date.
$ mise run build --force

# Run "test" with stdin/stdout/stderr all connected to the current terminal.
# This forces `--jobs=1` to prevent interleaving of output.
$ mise run test --raw

# Runs the "lint", "test", and "check" tasks in parallel.
$ mise run lint ::: test ::: check

# Execute multiple tasks each with their own arguments.
$ mise tasks cmd1 arg1 arg2 ::: cmd2 arg1 arg2
```

<|firecrawl-page-69-lllmstxt|>
## Tool Search Command
[Skip to content](https://mise.jdx.dev/cli/search.html#VPContent)

Return to top

# `mise search` [​](https://mise.jdx.dev/cli/search.html\#mise-search)

- **Usage**: `mise search [FLAGS] [NAME]`
- **Source code**: [`src/cli/search.rs`](https://github.com/jdx/mise/blob/main/src/cli/search.rs)

Search for tools in the registry

This command searches a tool in the registry.

By default, it will show all tools that fuzzy match the search term. For non-fuzzy matches, use the `--match-type` flag.

## Arguments [​](https://mise.jdx.dev/cli/search.html\#arguments)

### `[NAME]` [​](https://mise.jdx.dev/cli/search.html\#name)

The tool to search for

## Flags [​](https://mise.jdx.dev/cli/search.html\#flags)

### `-i --interactive` [​](https://mise.jdx.dev/cli/search.html\#i-interactive)

Show interactive search

### `-m --match-type <MATCH_TYPE>` [​](https://mise.jdx.dev/cli/search.html\#m-match-type-match-type)

Match type: equal, contains, or fuzzy

**Choices:**

- `equal`
- `contains`
- `fuzzy`

### `--no-header` [​](https://mise.jdx.dev/cli/search.html\#no-header)

Don't display headers

Examples:

```
$ mise search jq
Tool  Description
jq    Command-line JSON processor. https://github.com/jqlang/jq
jqp   A TUI playground to experiment with jq. https://github.com/noahgorstein/jqp
jiq   jid on jq - interactive JSON query tool using jq expressions. https://github.com/fiatjaf/jiq
gojq  Pure Go implementation of jq. https://github.com/itchyny/gojq

$ mise search --interactive
Tool
Search a tool
❯ jq    Command-line JSON processor. https://github.com/jqlang/jq
  jqp   A TUI playground to experiment with jq. https://github.com/noahgorstein/jqp
  jiq   jid on jq - interactive JSON query tool using jq expressions. https://github.com/fiatjaf/jiq
  gojq  Pure Go implementation of jq. https://github.com/itchyny/gojq
/jq
esc clear filter • enter confirm
```

<|firecrawl-page-70-lllmstxt|>
## Mise Self-Update Command
[Skip to content](https://mise.jdx.dev/cli/self-update.html#VPContent)

Return to top

# `mise self-update` [​](https://mise.jdx.dev/cli/self-update.html\#mise-self-update)

- **Usage**: `mise self-update [FLAGS] [VERSION]`
- **Source code**: [`src/cli/self_update.rs`](https://github.com/jdx/mise/blob/main/src/cli/self_update.rs)

Updates mise itself.

Uses the GitHub Releases API to find the latest release and binary. By default, this will also update any installed plugins. Uses the `GITHUB_API_TOKEN` environment variable if set for higher rate limits.

This command is not available if mise is installed via a package manager.

## Arguments [​](https://mise.jdx.dev/cli/self-update.html\#arguments)

### `[VERSION]` [​](https://mise.jdx.dev/cli/self-update.html\#version)

Update to a specific version

## Flags [​](https://mise.jdx.dev/cli/self-update.html\#flags)

### `-f --force` [​](https://mise.jdx.dev/cli/self-update.html\#f-force)

Update even if already up to date

### `--no-plugins` [​](https://mise.jdx.dev/cli/self-update.html\#no-plugins)

Disable auto-updating plugins

### `-y --yes` [​](https://mise.jdx.dev/cli/self-update.html\#y-yes)

Skip confirmation prompt

<|firecrawl-page-71-lllmstxt|>
## Set Environment Variables
[Skip to content](https://mise.jdx.dev/cli/set.html#VPContent)

Return to top

# `mise set` [​](https://mise.jdx.dev/cli/set.html\#mise-set)

- **Usage**: `mise set [--file <FILE>] [-g --global] [ENV_VAR]…`
- **Source code**: [`src/cli/set.rs`](https://github.com/jdx/mise/blob/main/src/cli/set.rs)

Set environment variables in mise.toml

By default, this command modifies `mise.toml` in the current directory.

## Arguments [​](https://mise.jdx.dev/cli/set.html\#arguments)

### `[ENV_VAR]…` [​](https://mise.jdx.dev/cli/set.html\#env-var)

Environment variable(s) to set e.g.: NODE\_ENV=production

## Flags [​](https://mise.jdx.dev/cli/set.html\#flags)

### `--file <FILE>` [​](https://mise.jdx.dev/cli/set.html\#file-file)

The TOML file to update

Defaults to MISE\_DEFAULT\_CONFIG\_FILENAME environment variable, or `mise.toml`.

### `-g --global` [​](https://mise.jdx.dev/cli/set.html\#g-global)

Set the environment variable in the global config file

Examples:

```
$ mise set NODE_ENV=production

$ mise set NODE_ENV
production

$ mise set
key       value       source
NODE_ENV  production  ~/.config/mise/config.toml
```

<|firecrawl-page-72-lllmstxt|>
## Mise CLI Settings
[Skip to content](https://mise.jdx.dev/cli/settings.html#VPContent)

Return to top

# `mise settings` [​](https://mise.jdx.dev/cli/settings.html\#mise-settings)

- **Usage**: `mise settings [FLAGS] [SETTING] [VALUE] <SUBCOMMAND>`
- **Source code**: [`src/cli/settings/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/settings/mod.rs)

Show current settings

This is the contents of ~/.config/mise/config.toml

Note that aliases are also stored in this file but managed separately with `mise aliases`

## Arguments [​](https://mise.jdx.dev/cli/settings.html\#arguments)

### `[SETTING]` [​](https://mise.jdx.dev/cli/settings.html\#setting)

Name of setting

### `[VALUE]` [​](https://mise.jdx.dev/cli/settings.html\#value)

Setting value to set

## Global Flags [​](https://mise.jdx.dev/cli/settings.html\#global-flags)

### `-l --local` [​](https://mise.jdx.dev/cli/settings.html\#l-local)

Use the local config file instead of the global one

## Flags [​](https://mise.jdx.dev/cli/settings.html\#flags)

### `-a --all` [​](https://mise.jdx.dev/cli/settings.html\#a-all)

List all settings

### `-J --json` [​](https://mise.jdx.dev/cli/settings.html\#j-json)

Output in JSON format

### `--json-extended` [​](https://mise.jdx.dev/cli/settings.html\#json-extended)

Output in JSON format with sources

### `-T --toml` [​](https://mise.jdx.dev/cli/settings.html\#t-toml)

Output in TOML format

## Subcommands [​](https://mise.jdx.dev/cli/settings.html\#subcommands)

- [`mise settings add [-l --local] <SETTING> <VALUE>`](https://mise.jdx.dev/cli/settings/add.html)
- [`mise settings get [-l --local] <SETTING>`](https://mise.jdx.dev/cli/settings/get.html)
- [`mise settings ls [FLAGS] [SETTING]`](https://mise.jdx.dev/cli/settings/ls.html)
- [`mise settings set [-l --local] <SETTING> <VALUE>`](https://mise.jdx.dev/cli/settings/set.html)
- [`mise settings unset [-l --local] <KEY>`](https://mise.jdx.dev/cli/settings/unset.html)

Examples:

```
# list all settings
$ mise settings

# get the value of the setting "always_keep_download"
$ mise settings always_keep_download

# set the value of the setting "always_keep_download" to "true"
$ mise settings always_keep_download=true

# set the value of the setting "node.mirror_url" to "https://npm.taobao.org/mirrors/node"
$ mise settings node.mirror_url https://npm.taobao.org/mirrors/node
```

<|firecrawl-page-73-lllmstxt|>
## Mise Settings Get Command
[Skip to content](https://mise.jdx.dev/cli/settings/get.html#VPContent)

Return to top

# `mise settings get` [​](https://mise.jdx.dev/cli/settings/get.html\#mise-settings-get)

- **Usage**: `mise settings get [-l --local] <SETTING>`
- **Source code**: [`src/cli/settings/get.rs`](https://github.com/jdx/mise/blob/main/src/cli/settings/get.rs)

Show a current setting

This is the contents of a single entry in ~/.config/mise/config.toml

Note that aliases are also stored in this file but managed separately with `mise aliases get`

## Arguments [​](https://mise.jdx.dev/cli/settings/get.html\#arguments)

### `<SETTING>` [​](https://mise.jdx.dev/cli/settings/get.html\#setting)

The setting to show

## Flags [​](https://mise.jdx.dev/cli/settings/get.html\#flags)

### `-l --local` [​](https://mise.jdx.dev/cli/settings/get.html\#l-local)

Use the local config file instead of the global one

Examples:

```
$ mise settings get idiomatic_version_file
true
```

<|firecrawl-page-74-lllmstxt|>
## List Settings Command
[Skip to content](https://mise.jdx.dev/cli/settings/ls.html#VPContent)

Return to top

# `mise settings ls` [​](https://mise.jdx.dev/cli/settings/ls.html\#mise-settings-ls)

- **Usage**: `mise settings ls [FLAGS] [SETTING]`
- **Aliases**: `list`
- **Source code**: [`src/cli/settings/ls.rs`](https://github.com/jdx/mise/blob/main/src/cli/settings/ls.rs)

Show current settings

This is the contents of ~/.config/mise/config.toml

Note that aliases are also stored in this file but managed separately with `mise aliases`

## Arguments [​](https://mise.jdx.dev/cli/settings/ls.html\#arguments)

### `[SETTING]` [​](https://mise.jdx.dev/cli/settings/ls.html\#setting)

Name of setting

## Flags [​](https://mise.jdx.dev/cli/settings/ls.html\#flags)

### `-a --all` [​](https://mise.jdx.dev/cli/settings/ls.html\#a-all)

List all settings

### `-l --local` [​](https://mise.jdx.dev/cli/settings/ls.html\#l-local)

Use the local config file instead of the global one

### `-J --json` [​](https://mise.jdx.dev/cli/settings/ls.html\#j-json)

Output in JSON format

### `--json-extended` [​](https://mise.jdx.dev/cli/settings/ls.html\#json-extended)

Output in JSON format with sources

### `-T --toml` [​](https://mise.jdx.dev/cli/settings/ls.html\#t-toml)

Output in TOML format

Examples:

```
$ mise settings ls
idiomatic_version_file = false
...

$ mise settings ls python
default_packages_file = "~/.default-python-packages"
...
```

<|firecrawl-page-75-lllmstxt|>
## Set Mise Settings
[Skip to content](https://mise.jdx.dev/cli/settings/set.html#VPContent)

Return to top

# `mise settings set` [​](https://mise.jdx.dev/cli/settings/set.html\#mise-settings-set)

- **Usage**: `mise settings set [-l --local] <SETTING> <VALUE>`
- **Aliases**: `create`
- **Source code**: [`src/cli/settings/set.rs`](https://github.com/jdx/mise/blob/main/src/cli/settings/set.rs)

Add/update a setting

This modifies the contents of ~/.config/mise/config.toml

## Arguments [​](https://mise.jdx.dev/cli/settings/set.html\#arguments)

### `<SETTING>` [​](https://mise.jdx.dev/cli/settings/set.html\#setting)

The setting to set

### `<VALUE>` [​](https://mise.jdx.dev/cli/settings/set.html\#value)

The value to set

## Flags [​](https://mise.jdx.dev/cli/settings/set.html\#flags)

### `-l --local` [​](https://mise.jdx.dev/cli/settings/set.html\#l-local)

Use the local config file instead of the global one

Examples:

```
mise settings idiomatic_version_file=true
```

<|firecrawl-page-76-lllmstxt|>
## Unset Settings Command
[Skip to content](https://mise.jdx.dev/cli/settings/unset.html#VPContent)

Return to top

# `mise settings unset` [​](https://mise.jdx.dev/cli/settings/unset.html\#mise-settings-unset)

- **Usage**: `mise settings unset [-l --local] <KEY>`
- **Aliases**: `rm`, `remove`, `delete`, `del`
- **Source code**: [`src/cli/settings/unset.rs`](https://github.com/jdx/mise/blob/main/src/cli/settings/unset.rs)

Clears a setting

This modifies the contents of ~/.config/mise/config.toml

## Arguments [​](https://mise.jdx.dev/cli/settings/unset.html\#arguments)

### `<KEY>` [​](https://mise.jdx.dev/cli/settings/unset.html\#key)

The setting to remove

## Flags [​](https://mise.jdx.dev/cli/settings/unset.html\#flags)

### `-l --local` [​](https://mise.jdx.dev/cli/settings/unset.html\#l-local)

Use the local config file instead of the global one

Examples:

```
mise settings unset idiomatic_version_file
```

<|firecrawl-page-77-lllmstxt|>
## Mise Shell Command
[Skip to content](https://mise.jdx.dev/cli/shell.html#VPContent)

Return to top

# `mise shell` [​](https://mise.jdx.dev/cli/shell.html\#mise-shell)

- **Usage**: `mise shell [FLAGS] <TOOL@VERSION>…`
- **Aliases**: `sh`
- **Source code**: [`src/cli/shell.rs`](https://github.com/jdx/mise/blob/main/src/cli/shell.rs)

Sets a tool version for the current session.

Only works in a session where mise is already activated.

This works by setting environment variables for the current shell session such as `MISE_NODE_VERSION=20` which is "eval"ed as a shell function created by `mise activate`.

## Arguments [​](https://mise.jdx.dev/cli/shell.html\#arguments)

### `<TOOL@VERSION>…` [​](https://mise.jdx.dev/cli/shell.html\#tool-version)

Tool(s) to use

## Flags [​](https://mise.jdx.dev/cli/shell.html\#flags)

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/shell.html\#j-jobs-jobs)

Number of jobs to run in parallel \[default: 4\]

### `--raw` [​](https://mise.jdx.dev/cli/shell.html\#raw)

Directly pipe stdin/stdout/stderr from plugin to user Sets --jobs=1

### `-u --unset` [​](https://mise.jdx.dev/cli/shell.html\#u-unset)

Removes a previously set version

Examples:

```
$ mise shell node@20
$ node -v
v20.0.0
```

<|firecrawl-page-78-lllmstxt|>
## Mise Sync Commands
[Skip to content](https://mise.jdx.dev/cli/sync.html#VPContent)

Return to top

# `mise sync` [​](https://mise.jdx.dev/cli/sync.html\#mise-sync)

- **Usage**: `mise sync <SUBCOMMAND>`
- **Source code**: [`src/cli/sync/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/sync/mod.rs)

Synchronize tools from other version managers with mise

## Subcommands [​](https://mise.jdx.dev/cli/sync.html\#subcommands)

- [`mise sync node [FLAGS]`](https://mise.jdx.dev/cli/sync/node.html)
- [`mise sync python [--pyenv] [--uv]`](https://mise.jdx.dev/cli/sync/python.html)
- [`mise sync ruby [--brew]`](https://mise.jdx.dev/cli/sync/ruby.html)

<|firecrawl-page-79-lllmstxt|>
## Sync Node Versions
[Skip to content](https://mise.jdx.dev/cli/sync/node.html#VPContent)

Return to top

# `mise sync node` [​](https://mise.jdx.dev/cli/sync/node.html\#mise-sync-node)

- **Usage**: `mise sync node [FLAGS]`
- **Source code**: [`src/cli/sync/node.rs`](https://github.com/jdx/mise/blob/main/src/cli/sync/node.rs)

Symlinks all tool versions from an external tool into mise

For example, use this to import all Homebrew node installs into mise

This won't overwrite any existing installs but will overwrite any existing symlinks

## Flags [​](https://mise.jdx.dev/cli/sync/node.html\#flags)

### `--brew` [​](https://mise.jdx.dev/cli/sync/node.html\#brew)

Get tool versions from Homebrew

### `--nvm` [​](https://mise.jdx.dev/cli/sync/node.html\#nvm)

Get tool versions from nvm

### `--nodenv` [​](https://mise.jdx.dev/cli/sync/node.html\#nodenv)

Get tool versions from nodenv

Examples:

```
brew install node@18 node@20
mise sync node --brew
mise use -g node@18 - uses Homebrew-provided node
```

<|firecrawl-page-80-lllmstxt|>
## Mise Sync Python Tool
[Skip to content](https://mise.jdx.dev/cli/sync/python.html#VPContent)

Return to top

# `mise sync python` [​](https://mise.jdx.dev/cli/sync/python.html\#mise-sync-python)

- **Usage**: `mise sync python [--pyenv] [--uv]`
- **Source code**: [`src/cli/sync/python.rs`](https://github.com/jdx/mise/blob/main/src/cli/sync/python.rs)

Symlinks all tool versions from an external tool into mise

For example, use this to import all pyenv installs into mise

This won't overwrite any existing installs but will overwrite any existing symlinks

## Flags [​](https://mise.jdx.dev/cli/sync/python.html\#flags)

### `--pyenv` [​](https://mise.jdx.dev/cli/sync/python.html\#pyenv)

Get tool versions from pyenv

### `--uv` [​](https://mise.jdx.dev/cli/sync/python.html\#uv)

Sync tool versions with uv (2-way sync)

Examples:

```
pyenv install 3.11.0
mise sync python --pyenv
mise use -g python@3.11.0 - uses pyenv-provided python

uv python install 3.11.0
mise install python@3.10.0
mise sync python --uv
mise x python@3.11.0 -- python -V - uses uv-provided python
uv run -p 3.10.0 -- python -V - uses mise-provided python
```

<|firecrawl-page-81-lllmstxt|>
## Ruby Sync Command
[Skip to content](https://mise.jdx.dev/cli/sync/ruby.html#VPContent)

Return to top

# `mise sync ruby` [​](https://mise.jdx.dev/cli/sync/ruby.html\#mise-sync-ruby)

- **Usage**: `mise sync ruby [--brew]`
- **Source code**: [`src/cli/sync/ruby.rs`](https://github.com/jdx/mise/blob/main/src/cli/sync/ruby.rs)

Symlinks all ruby tool versions from an external tool into mise

## Flags [​](https://mise.jdx.dev/cli/sync/ruby.html\#flags)

### `--brew` [​](https://mise.jdx.dev/cli/sync/ruby.html\#brew)

Get tool versions from Homebrew

Examples:

```
brew install ruby
mise sync ruby --brew
mise use -g ruby - Use the latest version of Ruby installed by Homebrew
```

<|firecrawl-page-82-lllmstxt|>
## Task Management Commands
[Skip to content](https://mise.jdx.dev/cli/tasks.html#VPContent)

Return to top

# `mise tasks` [​](https://mise.jdx.dev/cli/tasks.html\#mise-tasks)

- **Usage**: `mise tasks [FLAGS] [TASK] <SUBCOMMAND>`
- **Aliases**: `t`
- **Source code**: [`src/cli/tasks/mod.rs`](https://github.com/jdx/mise/blob/main/src/cli/tasks/mod.rs)

Manage tasks

## Arguments [​](https://mise.jdx.dev/cli/tasks.html\#arguments)

### `[TASK]` [​](https://mise.jdx.dev/cli/tasks.html\#task)

Task name to get info of

## Global Flags [​](https://mise.jdx.dev/cli/tasks.html\#global-flags)

### `-x --extended` [​](https://mise.jdx.dev/cli/tasks.html\#x-extended)

Show all columns

### `--no-header` [​](https://mise.jdx.dev/cli/tasks.html\#no-header)

Do not print table header

### `--hidden` [​](https://mise.jdx.dev/cli/tasks.html\#hidden)

Show hidden tasks

### `-g --global` [​](https://mise.jdx.dev/cli/tasks.html\#g-global)

Only show global tasks

### `-J --json` [​](https://mise.jdx.dev/cli/tasks.html\#j-json)

Output in JSON format

### `-l --local` [​](https://mise.jdx.dev/cli/tasks.html\#l-local)

Only show non-global tasks

### `--sort <COLUMN>` [​](https://mise.jdx.dev/cli/tasks.html\#sort-column)

Sort by column. Default is name.

**Choices:**

- `name`
- `alias`
- `description`
- `source`

### `--sort-order <SORT_ORDER>` [​](https://mise.jdx.dev/cli/tasks.html\#sort-order-sort-order)

Sort order. Default is asc.

**Choices:**

- `asc`
- `desc`

## Subcommands [​](https://mise.jdx.dev/cli/tasks.html\#subcommands)

- [`mise tasks add [FLAGS] <TASK> [-- RUN]…`](https://mise.jdx.dev/cli/tasks/add.html)
- [`mise tasks deps [--hidden] [--dot] [TASKS]…`](https://mise.jdx.dev/cli/tasks/deps.html)
- [`mise tasks edit [-p --path] <TASK>`](https://mise.jdx.dev/cli/tasks/edit.html)
- [`mise tasks info [-J --json] <TASK>`](https://mise.jdx.dev/cli/tasks/info.html)
- [`mise tasks ls [FLAGS]`](https://mise.jdx.dev/cli/tasks/ls.html)
- [`mise tasks run [FLAGS] [TASK] [ARGS]…`](https://mise.jdx.dev/cli/tasks/run.html)

Examples:

```
mise tasks ls
```

<|firecrawl-page-83-lllmstxt|>
## Add Tasks Command
[Skip to content](https://mise.jdx.dev/cli/tasks/add.html#VPContent)

Return to top

# `mise tasks add` [​](https://mise.jdx.dev/cli/tasks/add.html\#mise-tasks-add)

- **Usage**: `mise tasks add [FLAGS] <TASK> [-- RUN]…`
- **Source code**: [`src/cli/tasks/add.rs`](https://github.com/jdx/mise/blob/main/src/cli/tasks/add.rs)

Create a new task

## Arguments [​](https://mise.jdx.dev/cli/tasks/add.html\#arguments)

### `<TASK>` [​](https://mise.jdx.dev/cli/tasks/add.html\#task)

Tasks name to add

### `[-- RUN]…` [​](https://mise.jdx.dev/cli/tasks/add.html\#run)

## Flags [​](https://mise.jdx.dev/cli/tasks/add.html\#flags)

### `--description <DESCRIPTION>` [​](https://mise.jdx.dev/cli/tasks/add.html\#description-description)

Description of the task

### `-a --alias… <ALIAS>` [​](https://mise.jdx.dev/cli/tasks/add.html\#a-alias-alias)

Other names for the task

### `--depends-post… <DEPENDS_POST>` [​](https://mise.jdx.dev/cli/tasks/add.html\#depends-post-depends-post)

Dependencies to run after the task runs

### `-w --wait-for… <WAIT_FOR>` [​](https://mise.jdx.dev/cli/tasks/add.html\#w-wait-for-wait-for)

Wait for these tasks to complete if they are to run

### `-D --dir <DIR>` [​](https://mise.jdx.dev/cli/tasks/add.html\#d-dir-dir)

Run the task in a specific directory

### `-H --hide` [​](https://mise.jdx.dev/cli/tasks/add.html\#h-hide)

Hide the task from `mise task` and completions

### `-r --raw` [​](https://mise.jdx.dev/cli/tasks/add.html\#r-raw)

Directly connect stdin/stdout/stderr

### `-s --sources… <SOURCES>` [​](https://mise.jdx.dev/cli/tasks/add.html\#s-sources-sources)

Glob patterns of files this task uses as input

### `--outputs… <OUTPUTS>` [​](https://mise.jdx.dev/cli/tasks/add.html\#outputs-outputs)

Glob patterns of files this task creates, to skip if they are not modified

### `--shell <SHELL>` [​](https://mise.jdx.dev/cli/tasks/add.html\#shell-shell)

Run the task in a specific shell

### `-q --quiet` [​](https://mise.jdx.dev/cli/tasks/add.html\#q-quiet)

Do not print the command before running

### `--silent` [​](https://mise.jdx.dev/cli/tasks/add.html\#silent)

Do not print the command or its output

### `-d --depends… <DEPENDS>` [​](https://mise.jdx.dev/cli/tasks/add.html\#d-depends-depends)

Add dependencies to the task

### `--run-windows <RUN_WINDOWS>` [​](https://mise.jdx.dev/cli/tasks/add.html\#run-windows-run-windows)

Command to run on windows

### `-f --file` [​](https://mise.jdx.dev/cli/tasks/add.html\#f-file)

Create a file task instead of a toml task

Examples:

```
mise task add pre-commit --depends "test" --depends "render" -- echo pre-commit
```

<|firecrawl-page-84-lllmstxt|>
## Dependency Graph Visualization
[Skip to content](https://mise.jdx.dev/cli/tasks/deps.html#VPContent)

Return to top

# `mise tasks deps` [​](https://mise.jdx.dev/cli/tasks/deps.html\#mise-tasks-deps)

- **Usage**: `mise tasks deps [--hidden] [--dot] [TASKS]…`
- **Source code**: [`src/cli/tasks/deps.rs`](https://github.com/jdx/mise/blob/main/src/cli/tasks/deps.rs)

Display a tree visualization of a dependency graph

## Arguments [​](https://mise.jdx.dev/cli/tasks/deps.html\#arguments)

### `[TASKS]…` [​](https://mise.jdx.dev/cli/tasks/deps.html\#tasks)

Tasks to show dependencies for Can specify multiple tasks by separating with spaces e.g.: mise tasks deps lint test check

## Flags [​](https://mise.jdx.dev/cli/tasks/deps.html\#flags)

### `--hidden` [​](https://mise.jdx.dev/cli/tasks/deps.html\#hidden)

Show hidden tasks

### `--dot` [​](https://mise.jdx.dev/cli/tasks/deps.html\#dot)

Display dependencies in DOT format

Examples:

```
# Show dependencies for all tasks
$ mise tasks deps

# Show dependencies for the "lint", "test" and "check" tasks
$ mise tasks deps lint test check

# Show dependencies in DOT format
$ mise tasks deps --dot
```

<|firecrawl-page-85-lllmstxt|>
## Edit Tasks Command
[Skip to content](https://mise.jdx.dev/cli/tasks/edit.html#VPContent)

Return to top

# `mise tasks edit` [​](https://mise.jdx.dev/cli/tasks/edit.html\#mise-tasks-edit)

- **Usage**: `mise tasks edit [-p --path] <TASK>`
- **Source code**: [`src/cli/tasks/edit.rs`](https://github.com/jdx/mise/blob/main/src/cli/tasks/edit.rs)

Edit a tasks with $EDITOR

The tasks will be created as a standalone script if it does not already exist.

## Arguments [​](https://mise.jdx.dev/cli/tasks/edit.html\#arguments)

### `<TASK>` [​](https://mise.jdx.dev/cli/tasks/edit.html\#task)

Tasks to edit

## Flags [​](https://mise.jdx.dev/cli/tasks/edit.html\#flags)

### `-p --path` [​](https://mise.jdx.dev/cli/tasks/edit.html\#p-path)

Display the path to the tasks instead of editing it

Examples:

```
mise tasks edit build
mise tasks edit test
```

<|firecrawl-page-86-lllmstxt|>
## Task Information Command
[Skip to content](https://mise.jdx.dev/cli/tasks/info.html#VPContent)

Return to top

# `mise tasks info` [​](https://mise.jdx.dev/cli/tasks/info.html\#mise-tasks-info)

- **Usage**: `mise tasks info [-J --json] <TASK>`
- **Source code**: [`src/cli/tasks/info.rs`](https://github.com/jdx/mise/blob/main/src/cli/tasks/info.rs)

Get information about a task

## Arguments [​](https://mise.jdx.dev/cli/tasks/info.html\#arguments)

### `<TASK>` [​](https://mise.jdx.dev/cli/tasks/info.html\#task)

Name of the task to get information about

## Flags [​](https://mise.jdx.dev/cli/tasks/info.html\#flags)

### `-J --json` [​](https://mise.jdx.dev/cli/tasks/info.html\#j-json)

Output in JSON format

Examples:

```
$ mise tasks info
Name: test
Aliases: t
Description: Test the application
Source: ~/src/myproj/mise.toml

$ mise tasks info test --json
{
  "name": "test",
  "aliases": "t",
  "description": "Test the application",
  "source": "~/src/myproj/mise.toml",
  "depends": [],
  "env": {},
  "dir": null,
  "hide": false,
  "raw": false,
  "sources": [],
  "outputs": [],
  "run": [\
    "echo \"testing!\""\
  ],
  "file": null,
  "usage_spec": {}
}
```

<|firecrawl-page-87-lllmstxt|>
## List Available Tasks
[Skip to content](https://mise.jdx.dev/cli/tasks/ls.html#VPContent)

Return to top

# `mise tasks ls` [​](https://mise.jdx.dev/cli/tasks/ls.html\#mise-tasks-ls)

- **Usage**: `mise tasks ls [FLAGS]`
- **Source code**: [`src/cli/tasks/ls.rs`](https://github.com/jdx/mise/blob/main/src/cli/tasks/ls.rs)

List available tasks to execute These may be included from the config file or from the project's .mise/tasks directory mise will merge all tasks from all parent directories into this list.

So if you have global tasks in `~/.config/mise/tasks/*` and project-specific tasks in ~/myproject/.mise/tasks/\*, then they'll both be available but the project-specific tasks will override the global ones if they have the same name.

## Flags [​](https://mise.jdx.dev/cli/tasks/ls.html\#flags)

### `-x --extended` [​](https://mise.jdx.dev/cli/tasks/ls.html\#x-extended)

Show all columns

### `--no-header` [​](https://mise.jdx.dev/cli/tasks/ls.html\#no-header)

Do not print table header

### `--hidden` [​](https://mise.jdx.dev/cli/tasks/ls.html\#hidden)

Show hidden tasks

### `-g --global` [​](https://mise.jdx.dev/cli/tasks/ls.html\#g-global)

Only show global tasks

### `-J --json` [​](https://mise.jdx.dev/cli/tasks/ls.html\#j-json)

Output in JSON format

### `-l --local` [​](https://mise.jdx.dev/cli/tasks/ls.html\#l-local)

Only show non-global tasks

### `--sort <COLUMN>` [​](https://mise.jdx.dev/cli/tasks/ls.html\#sort-column)

Sort by column. Default is name.

**Choices:**

- `name`
- `alias`
- `description`
- `source`

### `--sort-order <SORT_ORDER>` [​](https://mise.jdx.dev/cli/tasks/ls.html\#sort-order-sort-order)

Sort order. Default is asc.

**Choices:**

- `asc`
- `desc`

Examples:

```
mise tasks ls
```

<|firecrawl-page-88-lllmstxt|>
## Run Tasks Command
[Skip to content](https://mise.jdx.dev/cli/tasks/run.html#VPContent)

Return to top

# `mise tasks run` [​](https://mise.jdx.dev/cli/tasks/run.html\#mise-tasks-run)

- **Usage**: `mise tasks run [FLAGS] [TASK] [ARGS]…`
- **Aliases**: `r`
- **Source code**: [`src/cli/tasks/run.rs`](https://github.com/jdx/mise/blob/main/src/cli/tasks/run.rs)

Run task(s)

This command will run a tasks, or multiple tasks in parallel. Tasks may have dependencies on other tasks or on source files. If source is configured on a tasks, it will only run if the source files have changed.

Tasks can be defined in mise.toml or as standalone scripts. In mise.toml, tasks take this form:

```
[tasks.build]
run = "npm run build"
sources = ["src/**/*.ts"]
outputs = ["dist/**/*.js"]
```

Alternatively, tasks can be defined as standalone scripts. These must be located in `mise-tasks`, `.mise-tasks`, `.mise/tasks`, `mise/tasks` or `.config/mise/tasks`. The name of the script will be the name of the tasks.

```
$ cat .mise/tasks/build&lt;&lt;EOF
#!/usr/bin/env bash
npm run build
EOF
$ mise run build
```

## Arguments [​](https://mise.jdx.dev/cli/tasks/run.html\#arguments)

### `[TASK]` [​](https://mise.jdx.dev/cli/tasks/run.html\#task)

Tasks to run Can specify multiple tasks by separating with `:::` e.g.: mise run task1 arg1 arg2 ::: task2 arg1 arg2

**Default:** `default`

### `[ARGS]…` [​](https://mise.jdx.dev/cli/tasks/run.html\#args)

Arguments to pass to the tasks. Use ":::" to separate tasks

## Flags [​](https://mise.jdx.dev/cli/tasks/run.html\#flags)

### `-C --cd <CD>` [​](https://mise.jdx.dev/cli/tasks/run.html\#c-cd-cd)

Change to this directory before executing the command

### `-c --continue-on-error` [​](https://mise.jdx.dev/cli/tasks/run.html\#c-continue-on-error)

Continue running tasks even if one fails

### `-n --dry-run` [​](https://mise.jdx.dev/cli/tasks/run.html\#n-dry-run)

Don't actually run the tasks(s), just print them in order of execution

### `-f --force` [​](https://mise.jdx.dev/cli/tasks/run.html\#f-force)

Force the tasks to run even if outputs are up to date

### `-s --shell <SHELL>` [​](https://mise.jdx.dev/cli/tasks/run.html\#s-shell-shell)

Shell to use to run toml tasks

Defaults to `sh -c -o errexit -o pipefail` on unix, and `cmd /c` on Windows Can also be set with the setting `MISE_UNIX_DEFAULT_INLINE_SHELL_ARGS` or `MISE_WINDOWS_DEFAULT_INLINE_SHELL_ARGS` Or it can be overridden with the `shell` property on a task.

### `-t --tool… <TOOL@VERSION>` [​](https://mise.jdx.dev/cli/tasks/run.html\#t-tool-tool-version)

Tool(s) to run in addition to what is in mise.toml files e.g.: node@20 python@3.10

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/tasks/run.html\#j-jobs-jobs)

Number of tasks to run in parallel \[default: 4\] Configure with `jobs` config or `MISE_JOBS` env var

### `-r --raw` [​](https://mise.jdx.dev/cli/tasks/run.html\#r-raw)

Read/write directly to stdin/stdout/stderr instead of by line Redactions are not applied with this option Configure with `raw` config or `MISE_RAW` env var

### `--no-timings` [​](https://mise.jdx.dev/cli/tasks/run.html\#no-timings)

Hides elapsed time after each task completes

Default to always hide with `MISE_TASK_TIMINGS=0`

### `-q --quiet` [​](https://mise.jdx.dev/cli/tasks/run.html\#q-quiet)

Don't show extra output

### `-S --silent` [​](https://mise.jdx.dev/cli/tasks/run.html\#s-silent)

Don't show any output except for errors

### `-o --output <OUTPUT>` [​](https://mise.jdx.dev/cli/tasks/run.html\#o-output-output)

Change how tasks information is output when running tasks

- `prefix` \- Print stdout/stderr by line, prefixed with the task's label
- `interleave` \- Print directly to stdout/stderr instead of by line
- `replacing` \- Stdout is replaced each time, stderr is printed as is
- `timed` \- Only show stdout lines if they are displayed for more than 1 second
- `keep-order` \- Print stdout/stderr by line, prefixed with the task's label, but keep the order of the output
- `quiet` \- Don't show extra output
- `silent` \- Don't show any output including stdout and stderr from the task except for errors

### `--no-cache` [​](https://mise.jdx.dev/cli/tasks/run.html\#no-cache)

Examples:

```
# Runs the "lint" tasks. This needs to either be defined in mise.toml
# or as a standalone script. See the project README for more information.
$ mise run lint

# Forces the "build" tasks to run even if its sources are up-to-date.
$ mise run build --force

# Run "test" with stdin/stdout/stderr all connected to the current terminal.
# This forces `--jobs=1` to prevent interleaving of output.
$ mise run test --raw

# Runs the "lint", "test", and "check" tasks in parallel.
$ mise run lint ::: test ::: check

# Execute multiple tasks each with their own arguments.
$ mise tasks cmd1 arg1 arg2 ::: cmd2 arg1 arg2
```

<|firecrawl-page-89-lllmstxt|>
## Mise Test Tool
[Skip to content](https://mise.jdx.dev/cli/test-tool.html#VPContent)

Return to top

# `mise test-tool` [​](https://mise.jdx.dev/cli/test-tool.html\#mise-test-tool)

- **Usage**: `mise test-tool [FLAGS] [TOOLS]…`
- **Source code**: [`src/cli/test_tool.rs`](https://github.com/jdx/mise/blob/main/src/cli/test_tool.rs)

Test a tool installs and executes

## Arguments [​](https://mise.jdx.dev/cli/test-tool.html\#arguments)

### `[TOOLS]…` [​](https://mise.jdx.dev/cli/test-tool.html\#tools)

Tool(s) to test

## Flags [​](https://mise.jdx.dev/cli/test-tool.html\#flags)

### `-a --all` [​](https://mise.jdx.dev/cli/test-tool.html\#a-all)

Test every tool specified in registry.toml

### `--all-config` [​](https://mise.jdx.dev/cli/test-tool.html\#all-config)

Test all tools specified in config files

### `--include-non-defined` [​](https://mise.jdx.dev/cli/test-tool.html\#include-non-defined)

Also test tools not defined in registry.toml, guessing how to test it

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/test-tool.html\#j-jobs-jobs)

Number of jobs to run in parallel \[default: 4\]

### `--raw` [​](https://mise.jdx.dev/cli/test-tool.html\#raw)

Directly pipe stdin/stdout/stderr from plugin to user Sets --jobs=1

Examples:

```
mise test-tool ripgrep
```

<|firecrawl-page-90-lllmstxt|>
## Tool Stub Execution Guide
[Skip to content](https://mise.jdx.dev/cli/tool-stub.html#VPContent)

Return to top

# `mise tool-stub` [​](https://mise.jdx.dev/cli/tool-stub.html\#mise-tool-stub)

- **Usage**: `mise tool-stub <FILE> [ARGS]…`
- **Source code**: [`src/cli/tool_stub.rs`](https://github.com/jdx/mise/blob/main/src/cli/tool_stub.rs)

Execute a tool stub

Tool stubs are executable files containing TOML configuration that specify which tool to run and how to run it. They provide a convenient way to create portable, self-contained executables that automatically manage tool installation and execution.

A tool stub consists of: - A shebang line: #!/usr/bin/env -S mise tool-stub - TOML configuration specifying the tool, version, and options - Optional comments describing the tool's purpose

Example stub file: #!/usr/bin/env -S mise tool-stub # Node.js v20 development environment

tool = "node" version = "20.0.0" bin = "node"

The stub will automatically install the specified tool version if missing and execute it with any arguments passed to the stub.

For more information, see: [https://mise.jdx.dev/dev-tools/tool-stubs.html](https://mise.jdx.dev/dev-tools/tool-stubs.html)

## Arguments [​](https://mise.jdx.dev/cli/tool-stub.html\#arguments)

### `<FILE>` [​](https://mise.jdx.dev/cli/tool-stub.html\#file)

Path to the TOML tool stub file to execute

The stub file must contain TOML configuration specifying the tool and version to run. At minimum, it should specify a 'version' field. Other common fields include 'tool', 'bin', and backend-specific options.

### `[ARGS]…` [​](https://mise.jdx.dev/cli/tool-stub.html\#args)

Arguments to pass to the tool

All arguments after the stub file path will be forwarded to the underlying tool. Use '--' to separate mise arguments from tool arguments if needed.

<|firecrawl-page-91-lllmstxt|>
## Mise Tool Information
[Skip to content](https://mise.jdx.dev/cli/tool.html#VPContent)

Return to top

# `mise tool` [​](https://mise.jdx.dev/cli/tool.html\#mise-tool)

- **Usage**: `mise tool [FLAGS] <TOOL>`
- **Source code**: [`src/cli/tool.rs`](https://github.com/jdx/mise/blob/main/src/cli/tool.rs)

Gets information about a tool

## Arguments [​](https://mise.jdx.dev/cli/tool.html\#arguments)

### `<TOOL>` [​](https://mise.jdx.dev/cli/tool.html\#tool)

Tool name to get information about

## Flags [​](https://mise.jdx.dev/cli/tool.html\#flags)

### `-J --json` [​](https://mise.jdx.dev/cli/tool.html\#j-json)

Output in JSON format

### `--backend` [​](https://mise.jdx.dev/cli/tool.html\#backend)

Only show backend field

### `--description` [​](https://mise.jdx.dev/cli/tool.html\#description)

Only show description field

### `--installed` [​](https://mise.jdx.dev/cli/tool.html\#installed)

Only show installed versions

### `--active` [​](https://mise.jdx.dev/cli/tool.html\#active)

Only show active versions

### `--requested` [​](https://mise.jdx.dev/cli/tool.html\#requested)

Only show requested versions

### `--config-source` [​](https://mise.jdx.dev/cli/tool.html\#config-source)

Only show config source

### `--tool-options` [​](https://mise.jdx.dev/cli/tool.html\#tool-options)

Only show tool options

Examples:

```
$ mise tool node
Backend:            core
Installed Versions: 20.0.0 22.0.0
Active Version:     20.0.0
Requested Version:  20
Config Source:      ~/.config/mise/mise.toml
Tool Options:       [none]
```

<|firecrawl-page-92-lllmstxt|>
## Mise Trust Command
[Skip to content](https://mise.jdx.dev/cli/trust.html#VPContent)

Return to top

# `mise trust` [​](https://mise.jdx.dev/cli/trust.html\#mise-trust)

- **Usage**: `mise trust [FLAGS] [CONFIG_FILE]`
- **Source code**: [`src/cli/trust.rs`](https://github.com/jdx/mise/blob/main/src/cli/trust.rs)

Marks a config file as trusted

This means mise will parse the file with potentially dangerous features enabled.

This includes:

- environment variables
- templates
- `path:` plugin versions

## Arguments [​](https://mise.jdx.dev/cli/trust.html\#arguments)

### `[CONFIG_FILE]` [​](https://mise.jdx.dev/cli/trust.html\#config-file)

The config file to trust

## Flags [​](https://mise.jdx.dev/cli/trust.html\#flags)

### `-a --all` [​](https://mise.jdx.dev/cli/trust.html\#a-all)

Trust all config files in the current directory and its parents

### `--ignore` [​](https://mise.jdx.dev/cli/trust.html\#ignore)

Do not trust this config and ignore it in the future

### `--untrust` [​](https://mise.jdx.dev/cli/trust.html\#untrust)

No longer trust this config, will prompt in the future

### `--show` [​](https://mise.jdx.dev/cli/trust.html\#show)

Show the trusted status of config files from the current directory and its parents. Does not trust or untrust any files.

Examples:

```
# trusts ~/some_dir/mise.toml
$ mise trust ~/some_dir/mise.toml

# trusts mise.toml in the current or parent directory
$ mise trust
```

<|firecrawl-page-93-lllmstxt|>
## Mise Uninstall Command
[Skip to content](https://mise.jdx.dev/cli/uninstall.html#VPContent)

Return to top

# `mise uninstall` [​](https://mise.jdx.dev/cli/uninstall.html\#mise-uninstall)

- **Usage**: `mise uninstall [-a --all] [-n --dry-run] [INSTALLED_TOOL@VERSION]…`
- **Source code**: [`src/cli/uninstall.rs`](https://github.com/jdx/mise/blob/main/src/cli/uninstall.rs)

Removes installed tool versions

This only removes the installed version, it does not modify mise.toml.

## Arguments [​](https://mise.jdx.dev/cli/uninstall.html\#arguments)

### `[INSTALLED_TOOL@VERSION]…` [​](https://mise.jdx.dev/cli/uninstall.html\#installed-tool-version)

Tool(s) to remove

## Flags [​](https://mise.jdx.dev/cli/uninstall.html\#flags)

### `-a --all` [​](https://mise.jdx.dev/cli/uninstall.html\#a-all)

Delete all installed versions

### `-n --dry-run` [​](https://mise.jdx.dev/cli/uninstall.html\#n-dry-run)

Do not actually delete anything

Examples:

```
# will uninstall specific version
$ mise uninstall node@18.0.0

# will uninstall the current node version (if only one version is installed)
$ mise uninstall node

# will uninstall all installed versions of node
$ mise uninstall --all node@18.0.0 # will uninstall all node versions
```

<|firecrawl-page-94-lllmstxt|>
## Unset Environment Variables
[Skip to content](https://mise.jdx.dev/cli/unset.html#VPContent)

Return to top

# `mise unset` [​](https://mise.jdx.dev/cli/unset.html\#mise-unset)

- **Usage**: `mise unset [-f --file <FILE>] [-g --global] [ENV_KEY]…`
- **Source code**: [`src/cli/unset.rs`](https://github.com/jdx/mise/blob/main/src/cli/unset.rs)

Remove environment variable(s) from the config file.

By default, this command modifies `mise.toml` in the current directory.

## Arguments [​](https://mise.jdx.dev/cli/unset.html\#arguments)

### `[ENV_KEY]…` [​](https://mise.jdx.dev/cli/unset.html\#env-key)

Environment variable(s) to remove e.g.: NODE\_ENV

## Flags [​](https://mise.jdx.dev/cli/unset.html\#flags)

### `-f --file <FILE>` [​](https://mise.jdx.dev/cli/unset.html\#f-file-file)

Specify a file to use instead of `mise.toml`

### `-g --global` [​](https://mise.jdx.dev/cli/unset.html\#g-global)

Use the global config file

Examples:

```
# Remove NODE_ENV from the current directory's config
$ mise unset NODE_ENV

# Remove NODE_ENV from the global config
$ mise unset NODE_ENV -g
```

<|firecrawl-page-95-lllmstxt|>
## Remove Installed Tools
[Skip to content](https://mise.jdx.dev/cli/unuse.html#VPContent)

Return to top

# `mise unuse` [​](https://mise.jdx.dev/cli/unuse.html\#mise-unuse)

- **Usage**: `mise unuse [FLAGS] <INSTALLED_TOOL@VERSION>…`
- **Aliases**: `rm`, `remove`
- **Source code**: [`src/cli/unuse.rs`](https://github.com/jdx/mise/blob/main/src/cli/unuse.rs)

Removes installed tool versions from mise.toml

By default, this will use the `mise.toml` file that has the tool defined.

In the following order:

- If `--global` is set, it will use the global config file.
- If `--path` is set, it will use the config file at the given path.
- If `--env` is set, it will use `mise.<env>.toml`.
- If `MISE_DEFAULT_CONFIG_FILENAME` is set, it will use that instead.
- If `MISE_OVERRIDE_CONFIG_FILENAMES` is set, it will the first from that list.
- Otherwise just "mise.toml" or global config if cwd is home directory.

Will also prune the installed version if no other configurations are using it.

## Arguments [​](https://mise.jdx.dev/cli/unuse.html\#arguments)

### `<INSTALLED_TOOL@VERSION>…` [​](https://mise.jdx.dev/cli/unuse.html\#installed-tool-version)

Tool(s) to remove

## Flags [​](https://mise.jdx.dev/cli/unuse.html\#flags)

### `-g --global` [​](https://mise.jdx.dev/cli/unuse.html\#g-global)

Use the global config file ( `~/.config/mise/config.toml`) instead of the local one

### `-e --env <ENV>` [​](https://mise.jdx.dev/cli/unuse.html\#e-env-env)

Create/modify an environment-specific config file like .mise.<env>.toml

### `-p --path <PATH>` [​](https://mise.jdx.dev/cli/unuse.html\#p-path-path)

Specify a path to a config file or directory

If a directory is specified, it will look for a config file in that directory following the rules above.

### `--no-prune` [​](https://mise.jdx.dev/cli/unuse.html\#no-prune)

Do not also prune the installed version

Examples:

```
# will uninstall specific version
$ mise unuse node@18.0.0

# will uninstall specific version from global config
$ mise unuse -g node@18.0.0

# will uninstall specific version from .mise.local.toml
$ mise unuse --env local node@20

# will uninstall specific version from .mise.staging.toml
$ mise unuse --env staging node@20
```

<|firecrawl-page-96-lllmstxt|>
## Upgrade Tools Command
[Skip to content](https://mise.jdx.dev/cli/upgrade.html#VPContent)

Return to top

# `mise upgrade` [​](https://mise.jdx.dev/cli/upgrade.html\#mise-upgrade)

- **Usage**: `mise upgrade [FLAGS] [TOOL@VERSION]…`
- **Aliases**: `up`
- **Source code**: [`src/cli/upgrade.rs`](https://github.com/jdx/mise/blob/main/src/cli/upgrade.rs)

Upgrades outdated tools

By default, this keeps the range specified in mise.toml. So if you have node@20 set, it will upgrade to the latest 20.x.x version available. See the `--bump` flag to use the latest version and bump the version in mise.toml.

This will update mise.lock if it is enabled, see [https://mise.jdx.dev/configuration/settings.html#lockfile](https://mise.jdx.dev/configuration/settings.html#lockfile)

## Arguments [​](https://mise.jdx.dev/cli/upgrade.html\#arguments)

### `[TOOL@VERSION]…` [​](https://mise.jdx.dev/cli/upgrade.html\#tool-version)

Tool(s) to upgrade e.g.: node@20 python@3.10 If not specified, all current tools will be upgraded

## Flags [​](https://mise.jdx.dev/cli/upgrade.html\#flags)

### `-n --dry-run` [​](https://mise.jdx.dev/cli/upgrade.html\#n-dry-run)

Just print what would be done, don't actually do it

### `-i --interactive` [​](https://mise.jdx.dev/cli/upgrade.html\#i-interactive)

Display multiselect menu to choose which tools to upgrade

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/upgrade.html\#j-jobs-jobs)

Number of jobs to run in parallel \[default: 4\]

### `-l --bump` [​](https://mise.jdx.dev/cli/upgrade.html\#l-bump)

Upgrades to the latest version available, bumping the version in mise.toml

For example, if you have `node = "20.0.0"` in your mise.toml but 22.1.0 is the latest available, this will install 22.1.0 and set `node = "22.1.0"` in your config.

It keeps the same precision as what was there before, so if you instead had `node = "20"`, it would change your config to `node = "22"`.

### `--raw` [​](https://mise.jdx.dev/cli/upgrade.html\#raw)

Directly pipe stdin/stdout/stderr from plugin to user Sets --jobs=1

Examples:

```
# Upgrades node to the latest version matching the range in mise.toml
$ mise upgrade node

# Upgrades node to the latest version and bumps the version in mise.toml
$ mise upgrade node --bump

# Upgrades all tools to the latest versions
$ mise upgrade

# Upgrades all tools to the latest versions and bumps the version in mise.toml
$ mise upgrade --bump

# Just print what would be done, don't actually do it
$ mise upgrade --dry-run

# Upgrades node and python to the latest versions
$ mise upgrade node python

# Show a multiselect menu to choose which tools to upgrade
$ mise upgrade --interactive
```

<|firecrawl-page-97-lllmstxt|>
## Mise Tool Installation
[Skip to content](https://mise.jdx.dev/cli/use.html#VPContent)

Return to top

# `mise use` [​](https://mise.jdx.dev/cli/use.html\#mise-use)

- **Usage**: `mise use [FLAGS] [TOOL@VERSION]…`
- **Aliases**: `u`
- **Source code**: [`src/cli/use.rs`](https://github.com/jdx/mise/blob/main/src/cli/use.rs)

Installs a tool and adds the version to mise.toml.

This will install the tool version if it is not already installed. By default, this will use a `mise.toml` file in the current directory.

In the following order:

- If `--global` is set, it will use the global config file.
- If `--path` is set, it will use the config file at the given path.
- If `--env` is set, it will use `mise.<env>.toml`.
- If `MISE_DEFAULT_CONFIG_FILENAME` is set, it will use that instead.
- If `MISE_OVERRIDE_CONFIG_FILENAMES` is set, it will the first from that list.
- Otherwise just "mise.toml" or global config if cwd is home directory.

Use the `--global` flag to use the global config file instead.

## Arguments [​](https://mise.jdx.dev/cli/use.html\#arguments)

### `[TOOL@VERSION]…` [​](https://mise.jdx.dev/cli/use.html\#tool-version)

Tool(s) to add to config file

e.g.: node@20, cargo:ripgrep@latest npm:prettier@3 If no version is specified, it will default to @latest

Tool options can be set with this syntax:

```
mise use ubi:BurntSushi/ripgrep[exe=rg]
```

## Flags [​](https://mise.jdx.dev/cli/use.html\#flags)

### `-f --force` [​](https://mise.jdx.dev/cli/use.html\#f-force)

Force reinstall even if already installed

### `--fuzzy` [​](https://mise.jdx.dev/cli/use.html\#fuzzy)

Save fuzzy version to config file

e.g.: `mise use --fuzzy node@20` will save 20 as the version this is the default behavior unless `MISE_PIN=1`

### `-g --global` [​](https://mise.jdx.dev/cli/use.html\#g-global)

Use the global config file ( `~/.config/mise/config.toml`) instead of the local one

### `-e --env <ENV>` [​](https://mise.jdx.dev/cli/use.html\#e-env-env)

Create/modify an environment-specific config file like .mise.<env>.toml

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/use.html\#j-jobs-jobs)

Number of jobs to run in parallel \[default: 4\]

### `--raw` [​](https://mise.jdx.dev/cli/use.html\#raw)

Directly pipe stdin/stdout/stderr from plugin to user Sets `--jobs=1`

### `--remove… <PLUGIN>` [​](https://mise.jdx.dev/cli/use.html\#remove-plugin)

Remove the plugin(s) from config file

### `-p --path <PATH>` [​](https://mise.jdx.dev/cli/use.html\#p-path-path)

Specify a path to a config file or directory

If a directory is specified, it will look for a config file in that directory following the rules above.

### `--pin` [​](https://mise.jdx.dev/cli/use.html\#pin)

Save exact version to config file e.g.: `mise use --pin node@20` will save 20.0.0 as the version Set `MISE_PIN=1` to make this the default behavior

Consider using mise.lock as a better alternative to pinning in mise.toml: [https://mise.jdx.dev/configuration/settings.html#lockfile](https://mise.jdx.dev/configuration/settings.html#lockfile)

Examples:

```

# run with no arguments to use the interactive selector
$ mise use

# set the current version of node to 20.x in mise.toml of current directory
# will write the fuzzy version (e.g.: 20)
$ mise use node@20

# set the current version of node to 20.x in ~/.config/mise/config.toml
# will write the precise version (e.g.: 20.0.0)
$ mise use -g --pin node@20

# sets .mise.local.toml (which is intended not to be committed to a project)
$ mise use --env local node@20

# sets .mise.staging.toml (which is used if MISE_ENV=staging)
$ mise use --env staging node@20
```

<|firecrawl-page-98-lllmstxt|>
## Mise Version Command
[Skip to content](https://mise.jdx.dev/cli/version.html#VPContent)

Return to top

# `mise version` [​](https://mise.jdx.dev/cli/version.html\#mise-version)

- **Usage**: `mise version [-J --json]`
- **Aliases**: `v`
- **Source code**: [`src/cli/version.rs`](https://github.com/jdx/mise/blob/main/src/cli/version.rs)

Display the version of mise

Displays the version, os, architecture, and the date of the build.

If the version is out of date, it will display a warning.

## Flags [​](https://mise.jdx.dev/cli/version.html\#flags)

### `-J --json` [​](https://mise.jdx.dev/cli/version.html\#j-json)

Print the version information in JSON format

Examples:

```
mise version
mise --version
mise -v
mise -V
```

<|firecrawl-page-99-lllmstxt|>
## Mise Watch Command
[Skip to content](https://mise.jdx.dev/cli/watch.html#VPContent)

Return to top

# `mise watch` [​](https://mise.jdx.dev/cli/watch.html\#mise-watch)

- **Usage**: `mise watch [FLAGS] [TASK] [ARGS]…`
- **Aliases**: `w`
- **Source code**: [`src/cli/watch.rs`](https://github.com/jdx/mise/blob/main/src/cli/watch.rs)

Run task(s) and watch for changes to rerun it

This command uses the `watchexec` tool to watch for changes to files and rerun the specified task(s). It must be installed for this command to work, but you can install it with `mise use -g watchexec@latest`.

## Arguments [​](https://mise.jdx.dev/cli/watch.html\#arguments)

### `[TASK]` [​](https://mise.jdx.dev/cli/watch.html\#task)

Tasks to run Can specify multiple tasks by separating with `:::` e.g.: `mise run task1 arg1 arg2 ::: task2 arg1 arg2`

### `[ARGS]…` [​](https://mise.jdx.dev/cli/watch.html\#args)

Task and arguments to run

## Flags [​](https://mise.jdx.dev/cli/watch.html\#flags)

### `-w --watch… <PATH>` [​](https://mise.jdx.dev/cli/watch.html\#w-watch-path)

Watch a specific file or directory

By default, Watchexec watches the current directory.

When watching a single file, it's often better to watch the containing directory instead, and filter on the filename. Some editors may replace the file with a new one when saving, and some platforms may not detect that or further changes.

Upon starting, Watchexec resolves a "project origin" from the watched paths. See the help for '--project-origin' for more information.

This option can be specified multiple times to watch multiple files or directories.

The special value '/dev/null', provided as the only path watched, will cause Watchexec to not watch any paths. Other event sources (like signals or key events) may still be used.

### `-W --watch-non-recursive… <PATH>` [​](https://mise.jdx.dev/cli/watch.html\#w-watch-non-recursive-path)

Watch a specific directory, non-recursively

Unlike '-w', folders watched with this option are not recursed into.

This option can be specified multiple times to watch multiple directories non-recursively.

### `-F --watch-file <PATH>` [​](https://mise.jdx.dev/cli/watch.html\#f-watch-file-path)

Watch files and directories from a file

Each line in the file will be interpreted as if given to '-w'.

For more complex uses (like watching non-recursively), use the argfile capability: build a file containing command-line options and pass it to watchexec with `@path/to/argfile`.

The special value '-' will read from STDIN; this in incompatible with '--stdin-quit'.

### `-c --clear <MODE>` [​](https://mise.jdx.dev/cli/watch.html\#c-clear-mode)

Clear screen before running command

If this doesn't completely clear the screen, try '--clear=reset'.

**Choices:**

- `clear`
- `reset`

### `-o --on-busy-update <MODE>` [​](https://mise.jdx.dev/cli/watch.html\#o-on-busy-update-mode)

What to do when receiving events while the command is running

Default is to 'do-nothing', which ignores events while the command is running, so that changes that occur due to the command are ignored, like compilation outputs. You can also use 'queue' which will run the command once again when the current run has finished if any events occur while it's running, or 'restart', which terminates the running command and starts a new one. Finally, there's 'signal', which only sends a signal; this can be useful with programs that can reload their configuration without a full restart.

The signal can be specified with the '--signal' option.

**Choices:**

- `queue`
- `do-nothing`
- `restart`
- `signal`

### `-r --restart` [​](https://mise.jdx.dev/cli/watch.html\#r-restart)

Restart the process if it's still running

This is a shorthand for '--on-busy-update=restart'.

### `-s --signal <SIGNAL>` [​](https://mise.jdx.dev/cli/watch.html\#s-signal-signal)

Send a signal to the process when it's still running

Specify a signal to send to the process when it's still running. This implies '--on-busy-update=signal'; otherwise the signal used when that mode is 'restart' is controlled by '--stop-signal'.

See the long documentation for '--stop-signal' for syntax.

Signals are not supported on Windows at the moment, and will always be overridden to 'kill'. See '--stop-signal' for more on Windows "signals".

### `--stop-signal <SIGNAL>` [​](https://mise.jdx.dev/cli/watch.html\#stop-signal-signal)

Signal to send to stop the command

This is used by 'restart' and 'signal' modes of '--on-busy-update' (unless '--signal' is provided). The restart behaviour is to send the signal, wait for the command to exit, and if it hasn't exited after some time (see '--timeout-stop'), forcefully terminate it.

The default on unix is "SIGTERM".

Input is parsed as a full signal name (like "SIGTERM"), a short signal name (like "TERM"), or a signal number (like "15"). All input is case-insensitive.

On Windows this option is technically supported but only supports the "KILL" event, as Watchexec cannot yet deliver other events. Windows doesn't have signals as such; instead it has termination (here called "KILL" or "STOP") and "CTRL+C", "CTRL+BREAK", and "CTRL+CLOSE" events. For portability the unix signals "SIGKILL", "SIGINT", "SIGTERM", and "SIGHUP" are respectively mapped to these.

### `--stop-timeout <TIMEOUT>` [​](https://mise.jdx.dev/cli/watch.html\#stop-timeout-timeout)

Time to wait for the command to exit gracefully

This is used by the 'restart' mode of '--on-busy-update'. After the graceful stop signal is sent, Watchexec will wait for the command to exit. If it hasn't exited after this time, it is forcefully terminated.

Takes a unit-less value in seconds, or a time span value such as "5min 20s". Providing a unit-less value is deprecated and will warn; it will be an error in the future.

The default is 10 seconds. Set to 0 to immediately force-kill the command.

This has no practical effect on Windows as the command is always forcefully terminated; see '--stop-signal' for why.

### `--map-signal… <SIGNAL:SIGNAL>` [​](https://mise.jdx.dev/cli/watch.html\#map-signal-signal-signal)

Translate signals from the OS to signals to send to the command

Takes a pair of signal names, separated by a colon, such as "TERM:INT" to map SIGTERM to SIGINT. The first signal is the one received by watchexec, and the second is the one sent to the command. The second can be omitted to discard the first signal, such as "TERM:" to not do anything on SIGTERM.

If SIGINT or SIGTERM are mapped, then they no longer quit Watchexec. Besides making it hard to quit Watchexec itself, this is useful to send pass a Ctrl-C to the command without also terminating Watchexec and the underlying program with it, e.g. with "INT:INT".

This option can be specified multiple times to map multiple signals.

Signal syntax is case-insensitive for short names (like "TERM", "USR2") and long names (like "SIGKILL", "SIGHUP"). Signal numbers are also supported (like "15", "31"). On Windows, the forms "STOP", "CTRL+C", and "CTRL+BREAK" are also supported to receive, but Watchexec cannot yet deliver other "signals" than a STOP.

### `-d --debounce <TIMEOUT>` [​](https://mise.jdx.dev/cli/watch.html\#d-debounce-timeout)

Time to wait for new events before taking action

When an event is received, Watchexec will wait for up to this amount of time before handling it (such as running the command). This is essential as what you might perceive as a single change may actually emit many events, and without this behaviour, Watchexec would run much too often. Additionally, it's not infrequent that file writes are not atomic, and each write may emit an event, so this is a good way to avoid running a command while a file is partially written.

An alternative use is to set a high value (like "30min" or longer), to save power or bandwidth on intensive tasks, like an ad-hoc backup script. In those use cases, note that every accumulated event will build up in memory.

Takes a unit-less value in milliseconds, or a time span value such as "5sec 20ms". Providing a unit-less value is deprecated and will warn; it will be an error in the future.

The default is 50 milliseconds. Setting to 0 is highly discouraged.

### `--stdin-quit` [​](https://mise.jdx.dev/cli/watch.html\#stdin-quit)

Exit when stdin closes

This watches the stdin file descriptor for EOF, and exits Watchexec gracefully when it is closed. This is used by some process managers to avoid leaving zombie processes around.

### `--no-vcs-ignore` [​](https://mise.jdx.dev/cli/watch.html\#no-vcs-ignore)

Don't load gitignores

Among other VCS exclude files, like for Mercurial, Subversion, Bazaar, DARCS, Fossil. Note that Watchexec will detect which of these is in use, if any, and only load the relevant files. Both global (like '~/.gitignore') and local (like '.gitignore') files are considered.

This option is useful if you want to watch files that are ignored by Git.

### `--no-project-ignore` [​](https://mise.jdx.dev/cli/watch.html\#no-project-ignore)

Don't load project-local ignores

This disables loading of project-local ignore files, like '.gitignore' or '.ignore' in the watched project. This is contrasted with '--no-vcs-ignore', which disables loading of Git and other VCS ignore files, and with '--no-global-ignore', which disables loading of global or user ignore files, like '~/.gitignore' or '~/.config/watchexec/ignore'.

Supported project ignore files:

- Git: .gitignore at project root and child directories, .git/info/exclude, and the file pointed to by `core.excludesFile` in .git/config.
- Mercurial: .hgignore at project root and child directories.
- Bazaar: .bzrignore at project root.
- Darcs: \_darcs/prefs/boring
- Fossil: .fossil-settings/ignore-glob
- Ripgrep/Watchexec/generic: .ignore at project root and child directories.

VCS ignore files (Git, Mercurial, Bazaar, Darcs, Fossil) are only used if the corresponding VCS is discovered to be in use for the project/origin. For example, a .bzrignore in a Git repository will be discarded.

### `--no-global-ignore` [​](https://mise.jdx.dev/cli/watch.html\#no-global-ignore)

Don't load global ignores

This disables loading of global or user ignore files, like '~/.gitignore', '~/.config/watchexec/ignore', or '%APPDATA%\\Bazzar\\2.0\\ignore'. Contrast with '--no-vcs-ignore' and '--no-project-ignore'.

Supported global ignore files

- Git (if core.excludesFile is set): the file at that path
- Git (otherwise): the first found of $XDG\_CONFIG\_HOME/git/ignore, %APPDATA%/.gitignore, %USERPROFILE%/.gitignore, $HOME/.config/git/ignore, $HOME/.gitignore.
- Bazaar: the first found of %APPDATA%/Bazzar/2.0/ignore, $HOME/.bazaar/ignore.
- Watchexec: the first found of $XDG\_CONFIG\_HOME/watchexec/ignore, %APPDATA%/watchexec/ignore, %USERPROFILE%/.watchexec/ignore, $HOME/.watchexec/ignore.

Like for project files, Git and Bazaar global files will only be used for the corresponding VCS as used in the project.

### `--no-default-ignore` [​](https://mise.jdx.dev/cli/watch.html\#no-default-ignore)

Don't use internal default ignores

Watchexec has a set of default ignore patterns, such as editor swap files, `*.pyc`, `*.pyo`, `.DS_Store`, `.bzr`, `_darcs`, `.fossil-settings`, `.git`, `.hg`, `.pijul`, `.svn`, and Watchexec log files.

### `--no-discover-ignore` [​](https://mise.jdx.dev/cli/watch.html\#no-discover-ignore)

Don't discover ignore files at all

This is a shorthand for '--no-global-ignore', '--no-vcs-ignore', '--no-project-ignore', but even more efficient as it will skip all the ignore discovery mechanisms from the get go.

Note that default ignores are still loaded, see '--no-default-ignore'.

### `--ignore-nothing` [​](https://mise.jdx.dev/cli/watch.html\#ignore-nothing)

Don't ignore anything at all

This is a shorthand for '--no-discover-ignore', '--no-default-ignore'.

Note that ignores explicitly loaded via other command line options, such as '--ignore' or '--ignore-file', will still be used.

### `-p --postpone` [​](https://mise.jdx.dev/cli/watch.html\#p-postpone)

Wait until first change before running command

By default, Watchexec will run the command once immediately. With this option, it will instead wait until an event is detected before running the command as normal.

### `--delay-run <DURATION>` [​](https://mise.jdx.dev/cli/watch.html\#delay-run-duration)

Sleep before running the command

This option will cause Watchexec to sleep for the specified amount of time before running the command, after an event is detected. This is like using "sleep 5 && command" in a shell, but portable and slightly more efficient.

Takes a unit-less value in seconds, or a time span value such as "2min 5s". Providing a unit-less value is deprecated and will warn; it will be an error in the future.

### `--poll <INTERVAL>` [​](https://mise.jdx.dev/cli/watch.html\#poll-interval)

Poll for filesystem changes

By default, and where available, Watchexec uses the operating system's native file system watching capabilities. This option disables that and instead uses a polling mechanism, which is less efficient but can work around issues with some file systems (like network shares) or edge cases.

Optionally takes a unit-less value in milliseconds, or a time span value such as "2s 500ms", to use as the polling interval. If not specified, the default is 30 seconds. Providing a unit-less value is deprecated and will warn; it will be an error in the future.

Aliased as '--force-poll'.

### `--shell <SHELL>` [​](https://mise.jdx.dev/cli/watch.html\#shell-shell)

Use a different shell

By default, Watchexec will use '$SHELL' if it's defined or a default of 'sh' on Unix-likes, and either 'pwsh', 'powershell', or 'cmd' (CMD.EXE) on Windows, depending on what Watchexec detects is the running shell.

With this option, you can override that and use a different shell, for example one with more features or one which has your custom aliases and functions.

If the value has spaces, it is parsed as a command line, and the first word used as the shell program, with the rest as arguments to the shell.

The command is run with the '-c' flag (except for 'cmd' on Windows, where it's '/C').

The special value 'none' can be used to disable shell use entirely. In that case, the command provided to Watchexec will be parsed, with the first word being the executable and the rest being the arguments, and executed directly. Note that this parsing is rudimentary, and may not work as expected in all cases.

Using 'none' is a little more efficient and can enable a stricter interpretation of the input, but it also means that you can't use shell features like globbing, redirection, control flow, logic, or pipes.

Examples:

Use without shell:

$ watchexec -n -- zsh -x -o shwordsplit scr

Use with powershell core:

$ watchexec --shell=pwsh -- Test-Connection localhost

Use with CMD.exe:

$ watchexec --shell=cmd -- dir

Use with a different unix shell:

$ watchexec --shell=bash -- 'echo $BASH\_VERSION'

Use with a unix shell and options:

$ watchexec --shell='zsh -x -o shwordsplit' -- scr

### `-n` [​](https://mise.jdx.dev/cli/watch.html\#n)

Shorthand for '--shell=none'

### `--emit-events-to <MODE>` [​](https://mise.jdx.dev/cli/watch.html\#emit-events-to-mode)

Configure event emission

Watchexec can emit event information when running a command, which can be used by the child process to target specific changed files.

One thing to take care with is assuming inherent behaviour where there is only chance. Notably, it could appear as if the `RENAMED` variable contains both the original and the new path being renamed. In previous versions, it would even appear on some platforms as if the original always came before the new. However, none of this was true. It's impossible to reliably and portably know which changed path is the old or new, "half" renames may appear (only the original, only the new), "unknown" renames may appear (change was a rename, but whether it was the old or new isn't known), rename events might split across two debouncing boundaries, and so on.

This option controls where that information is emitted. It defaults to 'none', which doesn't emit event information at all. The other options are 'environment' (deprecated), 'stdio', 'file', 'json-stdio', and 'json-file'.

The 'stdio' and 'file' modes are text-based: 'stdio' writes absolute paths to the stdin of the command, one per line, each prefixed with `create:`, `remove:`, `rename:`, `modify:`, or `other:`, then closes the handle; 'file' writes the same thing to a temporary file, and its path is given with the $WATCHEXEC\_EVENTS\_FILE environment variable.

There are also two JSON modes, which are based on JSON objects and can represent the full set of events Watchexec handles. Here's an example of a folder being created on Linux:

json

```
  {
```

"tags": \[ { "kind": "path", "absolute": "/home/user/your/new-folder", "filetype": "dir" }, { "kind": "fs", "simple": "create", "full": "Create(Folder)" }, { "kind": "source", "source": "filesystem", } \], "metadata": { "notify-backend": "inotify" }

```
  }
```

The fields are as follows:

- `tags`, structured event data.
- `tags[].kind`, which can be:

```
* 'path', along with:
  + `absolute`, an absolute path.
  + `filetype`, a file type if known ('dir', 'file', 'symlink', 'other').
* 'fs':
  + `simple`, the "simple" event type ('access', 'create', 'modify', 'remove', or 'other').
  + `full`, the "full" event type, which is too complex to fully describe here, but looks like 'General(Precise(Specific))'.
* 'source', along with:
  + `source`, the source of the event ('filesystem', 'keyboard', 'mouse', 'os', 'time', 'internal').
* 'keyboard', along with:
  + `keycode`. Currently only the value 'eof' is supported.
* 'process', for events caused by processes:
  + `pid`, the process ID.
* 'signal', for signals sent to Watchexec:
  + `signal`, the normalised signal name ('hangup', 'interrupt', 'quit', 'terminate', 'user1', 'user2').
* 'completion', for when a command ends:
  + `disposition`, the exit disposition ('success', 'error', 'signal', 'stop', 'exception', 'continued').
  + `code`, the exit, signal, stop, or exception code.
```

- `metadata`, additional information about the event.

The 'json-stdio' mode will emit JSON events to the standard input of the command, one per line, then close stdin. The 'json-file' mode will create a temporary file, write the events to it, and provide the path to the file with the $WATCHEXEC\_EVENTS\_FILE environment variable.

Finally, the 'environment' mode was the default until 2.0. It sets environment variables with the paths of the affected files, for filesystem events:

$WATCHEXEC\_COMMON\_PATH is set to the longest common path of all of the below variables, and so should be prepended to each path to obtain the full/real path. Then:

- $WATCHEXEC\_CREATED\_PATH is set when files/folders were created
- $WATCHEXEC\_REMOVED\_PATH is set when files/folders were removed
- $WATCHEXEC\_RENAMED\_PATH is set when files/folders were renamed
- $WATCHEXEC\_WRITTEN\_PATH is set when files/folders were modified
- $WATCHEXEC\_META\_CHANGED\_PATH is set when files/folders' metadata were modified
- $WATCHEXEC\_OTHERWISE\_CHANGED\_PATH is set for every other kind of pathed event

Multiple paths are separated by the system path separator, ';' on Windows and ':' on unix. Within each variable, paths are deduplicated and sorted in binary order (i.e. neither Unicode nor locale aware).

This is the legacy mode, is deprecated, and will be removed in the future. The environment is a very restricted space, while also limited in what it can usefully represent. Large numbers of files will either cause the environment to be truncated, or may error or crash the process entirely. The $WATCHEXEC\_COMMON\_PATH is also unintuitive, as demonstrated by the multiple confused queries that have landed in my inbox over the years.

**Choices:**

- `environment`
- `stdio`
- `file`
- `json-stdio`
- `json-file`
- `none`

### `--only-emit-events` [​](https://mise.jdx.dev/cli/watch.html\#only-emit-events)

Only emit events to stdout, run no commands.

This is a convenience option for using Watchexec as a file watcher, without running any commands. It is almost equivalent to using `cat` as the command, except that it will not spawn a new process for each event.

This option requires `--emit-events-to` to be set, and restricts the available modes to `stdio` and `json-stdio`, modifying their behaviour to write to stdout instead of the stdin of the command.

### `-E --env… <KEY=VALUE>` [​](https://mise.jdx.dev/cli/watch.html\#e-env-key-value)

Add env vars to the command

This is a convenience option for setting environment variables for the command, without setting them for the Watchexec process itself.

Use key=value syntax. Multiple variables can be set by repeating the option.

### `--wrap-process <MODE>` [​](https://mise.jdx.dev/cli/watch.html\#wrap-process-mode)

Configure how the process is wrapped

By default, Watchexec will run the command in a process group in Unix, and in a Job Object in Windows.

Some Unix programs prefer running in a session, while others do not work in a process group.

Use 'group' to use a process group, 'session' to use a process session, and 'none' to run the command directly. On Windows, either of 'group' or 'session' will use a Job Object.

**Choices:**

- `group`
- `session`
- `none`

### `-N --notify` [​](https://mise.jdx.dev/cli/watch.html\#n-notify)

Alert when commands start and end

With this, Watchexec will emit a desktop notification when a command starts and ends, on supported platforms. On unsupported platforms, it may silently do nothing, or log a warning.

### `--color <MODE>` [​](https://mise.jdx.dev/cli/watch.html\#color-mode)

When to use terminal colours

Setting the environment variable `NO_COLOR` to any value is equivalent to `--color=never`.

**Choices:**

- `auto`
- `always`
- `never`

### `--timings` [​](https://mise.jdx.dev/cli/watch.html\#timings)

Print how long the command took to run

This may not be exactly accurate, as it includes some overhead from Watchexec itself. Use the `time` utility, high-precision timers, or benchmarking tools for more accurate results.

### `-q --quiet` [​](https://mise.jdx.dev/cli/watch.html\#q-quiet)

Don't print starting and stopping messages

By default Watchexec will print a message when the command starts and stops. This option disables this behaviour, so only the command's output, warnings, and errors will be printed.

### `--bell` [​](https://mise.jdx.dev/cli/watch.html\#bell)

Ring the terminal bell on command completion

### `--project-origin <DIRECTORY>` [​](https://mise.jdx.dev/cli/watch.html\#project-origin-directory)

Set the project origin

Watchexec will attempt to discover the project's "origin" (or "root") by searching for a variety of markers, like files or directory patterns. It does its best but sometimes gets it it wrong, and you can override that with this option.

The project origin is used to determine the path of certain ignore files, which VCS is being used, the meaning of a leading '/' in filtering patterns, and maybe more in the future.

When set, Watchexec will also not bother searching, which can be significantly faster.

### `--workdir <DIRECTORY>` [​](https://mise.jdx.dev/cli/watch.html\#workdir-directory)

Set the working directory

By default, the working directory of the command is the working directory of Watchexec. You can change that with this option. Note that paths may be less intuitive to use with this.

### `-e --exts… <EXTENSIONS>` [​](https://mise.jdx.dev/cli/watch.html\#e-exts-extensions)

Filename extensions to filter to

This is a quick filter to only emit events for files with the given extensions. Extensions can be given with or without the leading dot (e.g. 'js' or '.js'). Multiple extensions can be given by repeating the option or by separating them with commas.

### `-f --filter… <PATTERN>` [​](https://mise.jdx.dev/cli/watch.html\#f-filter-pattern)

Filename patterns to filter to

Provide a glob-like filter pattern, and only events for files matching the pattern will be emitted. Multiple patterns can be given by repeating the option. Events that are not from files (e.g. signals, keyboard events) will pass through untouched.

### `--filter-file… <PATH>` [​](https://mise.jdx.dev/cli/watch.html\#filter-file-path)

Files to load filters from

Provide a path to a file containing filters, one per line. Empty lines and lines starting with '#' are ignored. Uses the same pattern format as the '--filter' option.

This can also be used via the $WATCHEXEC\_FILTER\_FILES environment variable.

### `-J --filter-prog… <EXPRESSION>` [​](https://mise.jdx.dev/cli/watch.html\#j-filter-prog-expression)

\[experimental\] Filter programs.

/!\ This option is EXPERIMENTAL and may change and/or vanish without notice.

Provide your own custom filter programs in jaq (similar to jq) syntax. Programs are given an event in the same format as described in '--emit-events-to' and must return a boolean. Invalid programs will make watchexec fail to start; use '-v' to see program runtime errors.

In addition to the jaq stdlib, watchexec adds some custom filter definitions:

- 'path \| file\_meta' returns file metadata or null if the file does not exist.

- 'path \| file\_size' returns the size of the file at path, or null if it does not exist.

- 'path \| file\_read(bytes)' returns a string with the first n bytes of the file at path. If the file is smaller than n bytes, the whole file is returned. There is no filter to read the whole file at once to encourage limiting the amount of data read and processed.

- 'string \| hash', and 'path \| file\_hash' return the hash of the string or file at path. No guarantee is made about the algorithm used: treat it as an opaque value.

- 'any \| kv\_store(key)', 'kv\_fetch(key)', and 'kv\_clear' provide a simple key-value store. Data is kept in memory only, there is no persistence. Consistency is not guaranteed.

- 'any \| printout', 'any \| printerr', and 'any \| log(level)' will print or log any given value to stdout, stderr, or the log (levels = error, warn, info, debug, trace), and pass the value through (so '\[1\] \| log("debug") \| .\[\]' will produce a '1' and log '\[1\]').


All filtering done with such programs, and especially those using kv or filesystem access, is much slower than the other filtering methods. If filtering is too slow, events will back up and stall watchexec. Take care when designing your filters.

If the argument to this option starts with an '@', the rest of the argument is taken to be the path to a file containing a jaq program.

Jaq programs are run in order, after all other filters, and short-circuit: if a filter (jaq or not) rejects an event, execution stops there, and no other filters are run. Additionally, they stop after outputting the first value, so you'll want to use 'any' or 'all' when iterating, otherwise only the first item will be processed, which can be quite confusing!

Find user-contributed programs or submit your own useful ones at < [https://github.com/watchexec/watchexec/discussions/592](https://github.com/watchexec/watchexec/discussions/592) >.

## Examples: [​](https://mise.jdx.dev/cli/watch.html\#examples)

Regexp ignore filter on paths:

'all(.tags\[\] \| select(.kind == "path"); .absolute \| test("\[.\]test\[.\]js$")) \| not'

Pass any event that creates a file:

'any(.tags\[\] \| select(.kind == "fs"); .simple == "create")'

Pass events that touch executable files:

'any(.tags\[\] \| select(.kind == "path" && .filetype == "file"); .absolute \| metadata \| .executable)'

Ignore files that start with shebangs:

'any(.tags\[\] \| select(.kind == "path" && .filetype == "file"); .absolute \| read(2) == "#!") \| not'

### `-i --ignore… <PATTERN>` [​](https://mise.jdx.dev/cli/watch.html\#i-ignore-pattern)

Filename patterns to filter out

Provide a glob-like filter pattern, and events for files matching the pattern will be excluded. Multiple patterns can be given by repeating the option. Events that are not from files (e.g. signals, keyboard events) will pass through untouched.

### `--ignore-file… <PATH>` [​](https://mise.jdx.dev/cli/watch.html\#ignore-file-path)

Files to load ignores from

Provide a path to a file containing ignores, one per line. Empty lines and lines starting with '#' are ignored. Uses the same pattern format as the '--ignore' option.

This can also be used via the $WATCHEXEC\_IGNORE\_FILES environment variable.

### `--fs-events… <EVENTS>` [​](https://mise.jdx.dev/cli/watch.html\#fs-events-events)

Filesystem events to filter to

This is a quick filter to only emit events for the given types of filesystem changes. Choose from 'access', 'create', 'remove', 'rename', 'modify', 'metadata'. Multiple types can be given by repeating the option or by separating them with commas. By default, this is all types except for 'access'.

This may apply filtering at the kernel level when possible, which can be more efficient, but may be more confusing when reading the logs.

**Choices:**

- `access`
- `create`
- `remove`
- `rename`
- `modify`
- `metadata`

### `--no-meta` [​](https://mise.jdx.dev/cli/watch.html\#no-meta)

Don't emit fs events for metadata changes

This is a shorthand for '--fs-events create,remove,rename,modify'. Using it alongside the '--fs-events' option is non-sensical and not allowed.

### `--print-events` [​](https://mise.jdx.dev/cli/watch.html\#print-events)

Print events that trigger actions

This prints the events that triggered the action when handling it (after debouncing), in a human readable form. This is useful for debugging filters.

Use '-vvv' instead when you need more diagnostic information.

### `--manual` [​](https://mise.jdx.dev/cli/watch.html\#manual)

Show the manual page

This shows the manual page for Watchexec, if the output is a terminal and the 'man' program is available. If not, the manual page is printed to stdout in ROFF format (suitable for writing to a watchexec.1 file).

Examples:

```
$ mise watch build
Runs the "build" tasks. Will re-run the tasks when any of its sources change.
Uses "sources" from the tasks definition to determine which files to watch.

$ mise watch build --glob src/**/*.rs
Runs the "build" tasks but specify the files to watch with a glob pattern.
This overrides the "sources" from the tasks definition.

$ mise watch build --clear
Extra arguments are passed to watchexec. See `watchexec --help` for details.

$ mise watch serve --watch src --exts rs --restart
Starts an api server, watching for changes to "*.rs" files in "./src" and kills/restarts the server when they change.
```

<|firecrawl-page-100-lllmstxt|>
## Tool Installation Path
[Skip to content](https://mise.jdx.dev/cli/where.html#VPContent)

Return to top

# `mise where` [​](https://mise.jdx.dev/cli/where.html\#mise-where)

- **Usage**: `mise where <TOOL@VERSION>`
- **Source code**: [`src/cli/where.rs`](https://github.com/jdx/mise/blob/main/src/cli/where.rs)

Display the installation path for a tool

The tool must be installed for this to work.

## Arguments [​](https://mise.jdx.dev/cli/where.html\#arguments)

### `<TOOL@VERSION>` [​](https://mise.jdx.dev/cli/where.html\#tool-version)

Tool(s) to look up e.g.: ruby@3 if "@<PREFIX>" is specified, it will show the latest installed version that matches the prefix otherwise, it will show the current, active installed version

Examples:

```
# Show the latest installed version of node
# If it is is not installed, errors
$ mise where node@20
/home/jdx/.local/share/mise/installs/node/20.0.0

# Show the current, active install directory of node
# Errors if node is not referenced in any .tool-version file
$ mise where node
/home/jdx/.local/share/mise/installs/node/20.0.0
```

<|firecrawl-page-101-lllmstxt|>
## Mise Which Command
[Skip to content](https://mise.jdx.dev/cli/which.html#VPContent)

Return to top

# `mise which` [​](https://mise.jdx.dev/cli/which.html\#mise-which)

- **Usage**: `mise which [FLAGS] [BIN_NAME]`
- **Source code**: [`src/cli/which.rs`](https://github.com/jdx/mise/blob/main/src/cli/which.rs)

Shows the path that a tool's bin points to.

Use this to figure out what version of a tool is currently active.

## Arguments [​](https://mise.jdx.dev/cli/which.html\#arguments)

### `[BIN_NAME]` [​](https://mise.jdx.dev/cli/which.html\#bin-name)

The bin to look up

## Flags [​](https://mise.jdx.dev/cli/which.html\#flags)

### `--plugin` [​](https://mise.jdx.dev/cli/which.html\#plugin)

Show the plugin name instead of the path

### `--version` [​](https://mise.jdx.dev/cli/which.html\#version)

Show the version instead of the path

### `-t --tool <TOOL@VERSION>` [​](https://mise.jdx.dev/cli/which.html\#t-tool-tool-version)

Use a specific tool@version e.g.: `mise which npm --tool=node@20`

Examples:

```
$ mise which node
/home/username/.local/share/mise/installs/node/20.0.0/bin/node

$ mise which node --plugin
node

$ mise which node --version
20.0.0
```

<|firecrawl-page-102-lllmstxt|>
## Configuration Environments Overview
[Skip to content](https://mise.jdx.dev/configuration/environments.html#VPContent)

Return to top

# Config Environments [​](https://mise.jdx.dev/configuration/environments.html\#config-environments)

It's possible to have separate `mise.toml` files in the same directory for different environments like `development` and `production`. To enable, either set the `-E,--env` option or `MISE_ENV` environment variable to an environment like `development` or `production`. mise will then look for a `mise.{MISE_ENV}.toml` file in the current directory, parent directories and the `MISE_CONFIG_DIR` directory.

mise will also look for "local" files like `mise.local.toml` and `mise.{MISE_ENV}.local.toml` in the current directory and parent directories. These are intended to not be committed to version control. (Add `mise.local.toml` and `mise.*.local.toml` to your `.gitignore` file.)

The priority of these files goes in this order (top overrides bottom):

- `mise.{MISE_ENV}.local.toml`
- `mise.local.toml`
- `mise.{MISE_ENV}.toml`
- `mise.toml`

If `MISE_OVERRIDE_CONFIG_FILENAMES` is set, that will be used instead of all of this.

You can also use paths like `mise/config.{MISE_ENV}.toml` or `.config/mise.{MISE_ENV}.toml` Those rules follow the order in [Configuration](https://mise.jdx.dev/configuration.html).

Use `mise config` to see which files are being used.

The rules around which file is written are different because we ultimately need to choose one. See the docs for [`mise use`](https://mise.jdx.dev/cli/use.html) for more information.

Multiple environments can be specified, e.g. `MISE_ENV=ci,test` with the last one taking precedence.

<|firecrawl-page-103-lllmstxt|>
## Mise Configuration Settings
[Skip to content](https://mise.jdx.dev/configuration/settings.html#VPContent)

Return to top

# Settings [​](https://mise.jdx.dev/configuration/settings.html\#settings)

The following is a list of all of mise's settings. These can be set via `mise settings key=value`, 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.

## `activate_aggressive`

- Type: `Bool`
- Env: `MISE_ACTIVATE_AGGRESSIVE`
- 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`:

```toml
[tools]
node = '20'
python = '3.12'

```

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

```sh
eval "$(mise activate zsh)"
PATH="/some/other/python:$PATH"

```

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.

## `all_compile`

- Type: `Bool`
- Env: `MISE_ALL_COMPILE`
- Default: `false`

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.

## `always_keep_download`

- Type: `Bool`
- Env: `MISE_ALWAYS_KEEP_DOWNLOAD`
- Default: `false`

should mise keep downloaded files after installation

## `always_keep_install`

- Type: `Bool`
- Env: `MISE_ALWAYS_KEEP_INSTALL`
- Default: `false`

should mise keep install files after installation even if the installation fails

## `arch`

- Type: `string`
- Env: `MISE_ARCH`
- Default: `"x86_64" | "aarch64" | "arm" | "loongarch64" | "riscv64"`

Architecture to use for precompiled binaries. This is used to determine which precompiled binaries
to download. If unset, mise will use the system's architecture.

## `auto_install`

- Type: `Bool`
- Env: `MISE_AUTO_INSTALL`
- Default: `true`

Automatically install missing tools when running `mise x`, `mise run`, or as part of the 'not found' handler.

## `auto_install_disable_tools`

- Type: `string[]`(optional)
- Env: `MISE_AUTO_INSTALL_DISABLE_TOOLS`(comma separated)
- Default: `None`

List of tools to skip automatically installing when running `mise x`, `mise run`, or as part of the 'not found' handler.

## `cache_prune_age`

- Type: `Duration`
- Env: `MISE_CACHE_PRUNE_AGE`
- Default: `30d`

The age of the cache before it is considered stale. mise will occasionally delete cache files which
have not been accessed in this amount of time.

Set to `0s` to keep cache files indefinitely.

## `color`

- Type: `Bool`
- Env: `MISE_COLOR`
- Default: `true`

Use color in mise terminal output

## `default_config_filename`

- Type: `string`
- Env: `MISE_DEFAULT_CONFIG_FILENAME`
- Default: `mise.toml`

The default config filename read. `mise use` and other commands that create new config files will use this value. This must be an env var.

## `default_tool_versions_filename`

- Type: `string`
- Env: `MISE_DEFAULT_TOOL_VERSIONS_FILENAME`
- Default: `.tool-versions`

The default .tool-versions filename read. This will not ignore .tool-versions—use override\_tool\_versions\_filename for that. This must be an env var.

## `disable_backends`

- Type: `string[]`
- Env: `MISE_DISABLE_BACKENDS`(comma separated)
- Default: `[]`

Backends to disable such as `asdf` or `pipx`

## `disable_default_registry`

- Type: `Bool`
- Env: `MISE_DISABLE_DEFAULT_REGISTRY`
- Default: `false`

Disable the default mapping of short tool names like `go` -\> `vfox:version-fox/vfox-golang`. This parameter disables only for the backends `vfox` and `asdf`.

## `disable_hints`

- Type: `SetString`
- Env: `MISE_DISABLE_HINTS`
- Default: `[]`

Turns off helpful hints when using different mise features

## `disable_tools`

- Type: `SetString`
- Env: `MISE_DISABLE_TOOLS`
- Default: `[]`

Tools defined in mise.toml that should be ignored

## `enable_tools`

- Type: `SetString`
- Env: `MISE_ENABLE_TOOLS`
- Default: `[]`

Tools defined in mise.toml that should be used - all other tools are ignored

## `env`

- Type: `string[]`
- Env: `MISE_ENV`(comma separated)
- Default: `[]`

Enables profile-specific config files such as `.mise.development.toml`.
Use this for different env vars or different tool versions in
development/staging/production environments. See
[Configuration Environments](https://mise.jdx.dev/configuration/environments.html) for more on how
to use this feature.

Multiple envs can be set by separating them with a comma, e.g. `MISE_ENV=ci,test`.
They will be read in order, with the last one taking precedence.

## `env_file`

- Type: `Path`(optional)
- Env: `MISE_ENV_FILE`
- Default: `None`

Path to a file containing environment variables to automatically load.

## `exec_auto_install`

- Type: `Bool`
- Env: `MISE_EXEC_AUTO_INSTALL`
- Default: `true`

Automatically install missing tools when running `mise x`.

## `experimental`

- Type: `Bool`
- Env: `MISE_EXPERIMENTAL`
- Default: `false`

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.

## `fetch_remote_versions_cache`

- Type: `Duration`
- Env: `MISE_FETCH_REMOTE_VERSIONS_CACHE`
- Default: `1h`

duration that remote version cache is kept for
"fast" commands (represented by PREFER\_STALE), these are always
cached. For "slow" commands like `mise ls-remote` or `mise install`:

- if MISE\_FETCH\_REMOTE\_VERSIONS\_CACHE is set, use that
- if MISE\_FETCH\_REMOTE\_VERSIONS\_CACHE is not set, use HOURLY

## `fetch_remote_versions_timeout`

- Type: `Duration`
- Env: `MISE_FETCH_REMOTE_VERSIONS_TIMEOUT`
- Default: `5s`

Timeout in seconds for HTTP requests to fetch new tool versions in mise.

## `global_config_file`

- Type: `Path`(optional)
- Env: `MISE_GLOBAL_CONFIG_FILE`
- Default: `None`

Path to the global mise config file. Default is `~/.config/mise/config.toml`. This must be an env var.

## `global_config_root`

- Type: `Path`(optional)
- Env: `MISE_GLOBAL_CONFIG_ROOT`
- Default: `None`

Path which is used as `{{config_root}}` for the global config file. Default is `$HOME`. This must be an env var.

## `go_default_packages_file`

- Type: `Path`
- Env: `MISE_GO_DEFAULT_PACKAGES_FILE`
- Default: `~/.default-go-packages`

Path to a file containing default go packages to install when installing go

## `go_download_mirror`

- Type: `string`
- Env: `MISE_GO_DOWNLOAD_MIRROR`
- Default: `https://dl.google.com/go`

Mirror to download go sdk tarballs from.

## `go_repo`

- Type: `Url`
- Env: `MISE_GO_REPO`
- Default: `https://github.com/golang/go`

URL to fetch go from.

## `go_set_gobin`

- Type: `Bool`(optional)
- Env: `MISE_GO_SET_GOBIN`
- Default: `None`

Defaults to `~/.local/share/mise/installs/go/.../bin`.
Set to `true` to override GOBIN if previously set.
Set to `false` to not set GOBIN (default is `${GOPATH:-$HOME/go}/bin`).

## `go_set_gopath` deprecated

- Type: `Bool`
- Env: `MISE_GO_SET_GOPATH`
- Default: `false`
- Deprecated: Use env.\_go.set\_goroot instead.

\[deprecated\] Set to true to set GOPATH=~/.local/share/mise/installs/go/.../packages.

## `go_set_goroot`

- Type: `Bool`
- Env: `MISE_GO_SET_GOROOT`
- Default: `true`

Sets GOROOT=~/.local/share/mise/installs/go/.../.

## `go_skip_checksum`

- Type: `Bool`
- Env: `MISE_GO_SKIP_CHECKSUM`
- Default: `false`

Set to true to skip checksum verification when downloading go sdk tarballs.

## `gpg_verify`

- Type: `Bool`(optional)
- Env: `MISE_GPG_VERIFY`
- Default: `None`

Use gpg to verify all tool signatures.

## `http_timeout`

- Type: `Duration`
- Env: `MISE_HTTP_TIMEOUT`
- Default: `30s`

Timeout in seconds for all HTTP requests in mise.

## `idiomatic_version_file` deprecated

- Type: `Bool`
- Env: `MISE_IDIOMATIC_VERSION_FILE`
- Default: `true`
- Deprecated: This has been replaced with the idiomatic\_version\_file\_enable\_tools setting.

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 [idiomatic version files](https://mise.jdx.dev/configuration.html#idiomatic-version-files)
for more
information.

Set to "false" to disable idiomatic version file parsing.

## `idiomatic_version_file_disable_tools` deprecated

- Type: `SetString`
- Env: `MISE_IDIOMATIC_VERSION_FILE_DISABLE_TOOLS`
- Default: `[]`
- Deprecated: This has been replaced with the idiomatic\_version\_file\_enable\_tools setting.

Specific tools to disable idiomatic version files for.

## `idiomatic_version_file_enable_tools`

- Type: `SetString`
- Env: `MISE_IDIOMATIC_VERSION_FILE_ENABLE_TOOLS`
- Default: ``

Specific tools to enable idiomatic version files for like .node-version, .ruby-version, etc.

## `ignored_config_paths`

- Type: `string[]`
- Env: `MISE_IGNORED_CONFIG_PATHS`(colon separated)
- Default: `[]`

This is a list of config paths that mise will ignore.

## `jobs`

- Type: `integer`
- Env: `MISE_JOBS`
- Default: `8`

How many jobs to run concurrently such as tool installs.

## `lockfile`

- Type: `Bool`
- Env: `MISE_LOCKFILE`
- Default: `true`

> \[!NOTE\]
> This feature is [experimental](https://mise.jdx.dev/configuration/settings.html#experimental) and may change in the future.

Read/update lockfiles for tool versions. This is useful when you'd like to have loose versions in mise.toml like this:

```toml
[tools]
node = "22"
gh = "latest"

```

But you'd like the versions installed to be consistent within a project. When this is enabled, mise will update mise.lock
files next to mise.toml files containing pinned versions. When installing tools, mise will reference this lockfile if it exists and this setting is enabled to resolve versions.

The lockfiles are not created automatically. To generate them, run the following (assuming the config file is `mise.toml`):

```sh
touch mise.lock && mise install

```

The lockfile is named the same as the config file but with `.lock` instead of `.toml` as the extension, e.g.:

- `mise.toml` -\> `mise.lock`
- `mise.local.toml` -\> `mise.local.lock`
- `.config/mise.toml` -\> `.config/mise.lock`

## `not_found_auto_install`

- Type: `Bool`
- Env: `MISE_NOT_FOUND_AUTO_INSTALL`
- Default: `true`

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.

**Important limitation**: This handler only installs missing versions of tools that already have
at least one version installed. mise cannot determine which tool provides a binary without having
the tool installed first, so it cannot auto-install completely new tools.

This also runs in shims if the terminal is interactive.

## `os`

- Type: `string`
- Env: `MISE_OS`
- Default: `"linux" | "macos" | "windows"`

OS to use for precompiled binaries.

## `override_config_filenames`

- Type: `string[]`
- Env: `MISE_OVERRIDE_CONFIG_FILENAMES`(colon separated)
- Default: `[]`

If set, mise will ignore default config files like `mise.toml` and use these filenames instead. This must be an env var.

## `override_tool_versions_filenames`

- Type: `string[]`
- Env: `MISE_OVERRIDE_TOOL_VERSIONS_FILENAMES`(colon separated)
- Default: `[]`

If set, mise will ignore .tool-versions files and use these filenames instead. Can be set to `none` to disable .tool-versions. This must be an env var.

## `paranoid`

- Type: `Bool`
- Env: `MISE_PARANOID`
- Default: `false`

Enables extra-secure behavior. See [Paranoid](https://mise.jdx.dev/paranoid.html).

## `pin`

- Type: `Bool`
- Env: `MISE_PIN`
- Default: `false`

This sets `--pin` by default when running `mise use` in mise.toml files. This can be overridden by
passing `--fuzzy` on the command line.

## `plugin_autoupdate_last_check_duration`

- Type: `string`
- Env: `MISE_PLUGIN_AUTOUPDATE_LAST_CHECK_DURATION`
- Default: `7d`

How long to wait before updating plugins automatically (note this isn't currently implemented).

## `quiet`

- Type: `Bool`
- Env: `MISE_QUIET`
- Default: `false`

Suppress all output except errors.

## `raw`

- Type: `Bool`
- Env: `MISE_RAW`
- Default: `false`

Connect stdin/stdout/stderr to child processes.

## `shorthands_file`

- Type: `Path`(optional)
- Env: `MISE_SHORTHANDS_FILE`
- Default: `None`

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](https://github.com/asdf-vm/asdf-elixir) plugin. By
default, it uses the shorthands in
[`registry.toml`](https://github.com/jdx/mise/blob/main/registry.toml).

The file should be in this toml format:

```toml
elixir = "https://github.com/my-org/mise-elixir.git"
node = "https://github.com/my-org/mise-node.git"

```

## `silent`

- Type: `Bool`
- Env: `MISE_SILENT`
- Default: `false`

Suppress all `mise run|watch` output except errors—including what tasks output.

## `system_config_file`

- Type: `Path`(optional)
- Env: `MISE_SYSTEM_CONFIG_FILE`
- Default: `None`

Path to the system mise config file. Default is `/etc/mise/config.toml`. This must be an env var.

## `task_disable_paths`

- Type: `string[]`
- Env: `MISE_TASK_DISABLE_PATHS`(colon separated)
- Default: `[]`

Paths that mise will not look for tasks in.

## `task_output`

- Type: `string`(optional)
- Env: `MISE_TASK_OUTPUT`
- Default: `None`
- Choices:
  - `prefix` – (default if jobs > 1) print by line with the prefix of the task name
  - `interleave` – (default if jobs == 1 or all tasks run sequentially) print output as it comes in
  - `keep-order` – print output from tasks in the order they are defined
  - `replacing` – replace stdout each time a line is printed-this uses similar logic as \`mise install\`
  - `timed` – only show stdout lines that take longer than 1s to complete
  - `quiet` – print only stdout/stderr from tasks and nothing from mise
  - `silent` – print nothing from tasks or mise

Change output style when executing tasks. This controls the output of `mise run`.

## `task_remote_no_cache`

- Type: `Bool`(optional)
- Env: `MISE_TASK_REMOTE_NO_CACHE`
- Default: `None`

Mise will always fetch the latest tasks from the remote, by default the cache is used.

## `task_run_auto_install`

- Type: `Bool`
- Env: `MISE_TASK_RUN_AUTO_INSTALL`
- Default: `true`

Automatically install missing tools when executing tasks.

## `task_skip`

- Type: `SetString`
- Env: `MISE_TASK_SKIP`
- Default: `[]`

Tasks to skip when running `mise run`.

## `task_timings`

- Type: `Bool`(optional)
- Env: `MISE_TASK_TIMINGS`
- Default: `None`

Show completion message with elapsed time for each task on `mise run`. Default shows when output type is `prefix`.

## `trusted_config_paths`

- Type: `string[]`
- Env: `MISE_TRUSTED_CONFIG_PATHS`(colon separated)
- Default: `[]`

This is a list of config paths that mise will automatically mark as trusted.

## `unix_default_file_shell_args`

- Type: `string`
- Env: `MISE_UNIX_DEFAULT_FILE_SHELL_ARGS`
- Default: `sh`

List of default shell arguments for unix to be used with `file`. For example `sh`.

## `unix_default_inline_shell_args`

- Type: `string`
- Env: `MISE_UNIX_DEFAULT_INLINE_SHELL_ARGS`
- Default: `sh -c -o errexit`

List of default shell arguments for unix to be used with inline commands. For example, `sh`, `-c` for sh.

## `use_file_shell_for_executable_tasks`

- Type: `Bool`
- Env: `MISE_USE_FILE_SHELL_FOR_EXECUTABLE_TASKS`
- Default: `false`

Determines whether to use a specified shell for executing tasks in the tasks directory. When set to true, the shell defined in the file will be used, or the default shell specified by `windows_default_file_shell_args` or `unix_default_file_shell_args` will be applied. If set to false, tasks will be executed directly as programs.

## `use_versions_host`

- Type: `Bool`
- Env: `MISE_USE_VERSIONS_HOST`
- Default: `true`

Set to "false" to disable using [mise-versions](https://mise-versions.jdx.dev/) 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.

mise-versions itself also struggles with rate limits but you can help it to fetch more frequently by authenticating
with its [GitHub app](https://github.com/apps/mise-versions). It does not require any permissions since it simply
fetches public repository information.

See [Troubleshooting](https://mise.jdx.dev/troubleshooting.html#new-version-of-a-tool-is-not-available) for more information.

## `verbose`

- Type: `Bool`
- Env: `MISE_VERBOSE`
- Default: `false`

Shows more verbose output such as installation logs when installing tools.

## `windows_default_file_shell_args`

- Type: `string[]`
- Env: `MISE_WINDOWS_DEFAULT_FILE_SHELL_ARGS`
- Default: `cmd /c`

List of default shell arguments for Windows to be used for file commands. For example, `cmd`, `/c` for cmd.exe.

## `windows_default_inline_shell_args`

- Type: `string`
- Env: `MISE_WINDOWS_DEFAULT_INLINE_SHELL_ARGS`
- Default: `cmd /c`

List of default shell arguments for Windows to be used for inline commands. For example, `cmd`, `/c` for cmd.exe.

## `windows_executable_extensions`

- Type: `string[]`
- Env: `MISE_WINDOWS_EXECUTABLE_EXTENSIONS`(comma separated)
- Default: `[\
    "exe",\
    "bat",\
    "cmd",\
    "com",\
    "ps1",\
    "vbs"\
]`

List of executable extensions for Windows. For example, `exe` for .exe files, `bat` for .bat files, and so on.

## `windows_shim_mode`

- Type: `string`
- Env: `MISE_WINDOWS_SHIM_MODE`
- Default: `file`

- values:
  - `file`: Creates a file with the content `mise exec`.
  - `hardlink`: Uses Windows NTFS Hardlink, required on same filesystems. Need run `mise reshim --force` after upgrade mise.
  - `symlink`: Uses Windows NTFS SymbolicLink. Requires Windows Vista or later with admin privileges or enabling "Developer Mode" in Windows 10/11.

## `yes`

- Type: `Bool`
- Env: `MISE_YES`
- Default: `false`

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

## `aqua`

### `aqua.baked_registry`

- Type: `Bool`
- Env: `MISE_AQUA_BAKED_REGISTRY`
- Default: `true`

Use baked-in aqua registry (if compiled in).

### `aqua.cosign`

- Type: `Bool`
- Env: `MISE_AQUA_COSIGN`
- Default: `true`

Use cosign to verify aqua tool signatures.

### `aqua.cosign_extra_args`

- Type: `string[]`(optional)
- Env: `MISE_AQUA_COSIGN_EXTRA_ARGS`
- Default: `None`

Extra arguments to pass to cosign when verifying aqua tool signatures.

### `aqua.minisign`

- Type: `Bool`
- Env: `MISE_AQUA_MINISIGN`
- Default: `true`

Use minisign to verify aqua tool signatures.

### `aqua.registry_url`

- Type: `Url`(optional)
- Env: `MISE_AQUA_REGISTRY_URL`
- Default: `None`

URL to fetch aqua registry from. This is used to install tools from the aqua registry.

By default, the official aqua registry is used: https://github.com/aquaproj/aqua-registry

However when this is not specified, instead of cloning the entire registry each individual tool's metadata is fetched
via HTTP individually.

### `aqua.slsa`

- Type: `Bool`
- Env: `MISE_AQUA_SLSA`
- Default: `true`

Use SLSA to verify aqua tool signatures.

## `cargo`

### `cargo.binstall`

- Type: `Bool`
- Env: `MISE_CARGO_BINSTALL`
- Default: `true`

If true, mise will use `cargo binstall` instead of `cargo install` if
[`cargo-binstall`](https://crates.io/crates/cargo-binstall) is installed and on PATH.
This makes installing CLIs with cargo _much_ faster by downloading precompiled binaries.

You can install it with mise:

```sh
mise use -g cargo-binstall

```

### `cargo.registry_name`

- Type: `string`(optional)
- Env: `MISE_CARGO_REGISTRY_NAME`
- Default: `None`

Packages are installed from the official cargo registry.

You can set this to a different registry name if you have a custom feed or want to use a different source.

Please follow the [cargo alternative registries documentation](https://doc.rust-lang.org/cargo/reference/registries.html#using-an-alternate-registry) to configure your registry.

## `dotnet`

### `dotnet.package_flags`

- Type: `string[]`
- Env: `MISE_DOTNET_PACKAGE_FLAGS`(comma separated)
- Default: `[]`

This is a list of flags to extend the search and install abilities of dotnet tools.

Here are the available flags:

- 'prerelease' : include prerelease versions in search and install

### `dotnet.registry_url`

- Type: `Url`
- Env: `MISE_DOTNET_REGISTRY_URL`
- Default: `https://api.nuget.org/v3/index.json`

URL to fetch dotnet tools from. This is used when installing dotnet tools.

By default, mise will use the [nuget](https://api.nuget.org/v3/index.json) API to fetch.

However, you can set this to a different URL if you have a custom feed or want to use a different source.

## `erlang`

### `erlang.compile`

- Type: `Bool`(optional)
- Env: `MISE_ERLANG_COMPILE`
- Default: `None`

If true, compile erlang from source. If false, use precompiled binaries. If not set, use precompiled binaries if available.

## `node`

### `node.compile`

- Type: `Bool`(optional)
- Env: `MISE_NODE_COMPILE`
- Default: `None`

Compile node from source.

### `node.flavor`

- Type: `string`(optional)
- Env: `MISE_NODE_FLAVOR`
- Default: `None`

Install a specific node flavor like glibc-217 or musl. Use with unofficial node build repo.

### `node.gpg_verify`

- Type: `Bool`(optional)
- Env: `MISE_NODE_GPG_VERIFY`
- Default: `None`

Use gpg to verify node tool signatures.

### `node.mirror_url`

- Type: `Url`(optional)
- Env: `MISE_NODE_MIRROR_URL`
- Default: `None`

Mirror to download node tarballs from.

## `npm`

### `npm.bun`

- Type: `Bool`
- Env: `MISE_NPM_BUN`
- Default: `false`

If true, mise will use `bun` instead of `npm` if
[`bun`](https://bun.sh/) is installed and on PATH.
This makes installing CLIs faster by using `bun` as the package manager.

You can install it with mise:

```sh
mise use -g bun

```

## `pipx`

### `pipx.registry_url`

- Type: `string`
- Env: `MISE_PIPX_REGISTRY_URL`
- Default: `https://pypi.org/pypi/{}/json`

URL to use for pipx registry.

This is used to fetch the latest version of a package from the pypi registry.

The default is `https://pypi.org/pypi/{}/json` which is the JSON endpoint for the pypi
registry.

You can also use the HTML endpoint by setting this to `https://pypi.org/simple/{}/`.

### `pipx.uvx`

- Type: `Bool`
- Env: `MISE_PIPX_UVX`
- Default: `true`

If true, mise will use `uvx` instead of `pipx` if
[`uv`](https://docs.astral.sh/uv/) is installed and on PATH.
This makes installing CLIs _much_ faster by using `uv` as the package manager.

You can install it with mise:

```sh
mise use -g uv

```

## `python`

### `python.compile`

- Type: `Bool`(optional)
- Env: `MISE_PYTHON_COMPILE`
- Default: `None`

- Values:
  - `true` \- always compile with python-build instead of downloading [precompiled binaries](https://mise.jdx.dev/lang/python.html#precompiled-python-binaries).
  - `false` \- always download precompiled binaries.
  - \[undefined\] - use precompiled binary if one is available for the current platform, compile otherwise.

### `python.default_packages_file`

- Type: `Path`(optional)
- Env: `MISE_PYTHON_DEFAULT_PACKAGES_FILE`
- Default: `None`

Path to a file containing default python packages to install when installing a python version.

### `python.patch_url`

- Type: `Url`(optional)
- Env: `MISE_PYTHON_PATCH_URL`
- Default: `None`

URL to fetch python patches from to pass to python-build.

### `python.patches_directory`

- Type: `Path`(optional)
- Env: `MISE_PYTHON_PATCHES_DIRECTORY`
- Default: `None`

Directory to fetch python patches from.

### `python.precompiled_arch`

- Type: `string`
- Env: `MISE_PYTHON_PRECOMPILED_ARCH`
- Default: `"apple-darwin" | "unknown-linux-gnu" | "unknown-linux-musl"`

Specify the architecture to use for precompiled binaries.

### `python.precompiled_flavor`

- Type: `string`
- Env: `MISE_PYTHON_PRECOMPILED_FLAVOR`
- Default: `install_only_stripped`

Specify the flavor to use for precompiled binaries.

Options are available here: [https://gregoryszorc.com/docs/python-build-standalone/main/running.html](https://gregoryszorc.com/docs/python-build-standalone/main/running.html)

### `python.precompiled_os`

- Type: `string`
- Env: `MISE_PYTHON_PRECOMPILED_OS`
- Default: `"x86_64_v3" | "aarch64"`

Specify the architecture to use for precompiled binaries. If on an old CPU, you may want to set this to "x86\_64" for the most compatible binaries. See https://gregoryszorc.com/docs/python-build-standalone/main/running.html for more information.

### `python.pyenv_repo`

- Type: `string`
- Env: `MISE_PYENV_REPO`
- Default: `https://github.com/pyenv/pyenv.git`

URL to fetch pyenv from for compiling python with python-build.

### `python.uv_venv_auto`

- Type: `Bool`
- Env: `MISE_PYTHON_UV_VENV_AUTO`
- Default: `false`

Integrate with uv to automatically create/source venvs if uv.lock is present.

### `python.uv_venv_create_args`

- Type: `string[]`(optional)
- Env: `MISE_PYTHON_UV_VENV_CREATE_ARGS`(colon separated)
- Default: `None`

Arguments to pass to uv when creating a venv.

### `python.venv_auto_create` deprecated

- Type: `Bool`
- Env: `MISE_PYTHON_VENV_AUTO_CREATE`
- Default: `false`
- Deprecated: Use env.\_python.venv instead.

Automatically create virtualenvs for python tools.

### `python.venv_create_args`

- Type: `string[]`(optional)
- Env: `MISE_PYTHON_VENV_CREATE_ARGS`(colon separated)
- Default: `None`

Arguments to pass to python when creating a venv. (not used for uv venv creation)

### `python.venv_stdlib`

- Type: `Bool`
- Env: `MISE_VENV_STDLIB`
- Default: `false`

Prefer to use venv from Python's standard library.

## `ruby`

### `ruby.apply_patches`

- Type: `string`(optional)
- Env: `MISE_RUBY_APPLY_PATCHES`
- Default: `None`

A list of patch files or URLs to apply to ruby source.

### `ruby.default_packages_file`

- Type: `string`
- Env: `MISE_RUBY_DEFAULT_PACKAGES_FILE`
- Default: `~/.default-gems`

Path to a file containing default ruby gems to install when installing ruby.

### `ruby.ruby_build_opts`

- Type: `string`(optional)
- Env: `MISE_RUBY_BUILD_OPTS`
- Default: `None`

Options to pass to ruby-build.

### `ruby.ruby_build_repo`

- Type: `string`
- Env: `MISE_RUBY_BUILD_REPO`
- Default: `https://github.com/rbenv/ruby-build.git`

URL to fetch ruby-build from.

### `ruby.ruby_install`

- Type: `Bool`
- Env: `MISE_RUBY_INSTALL`
- Default: `false`

Use ruby-install instead of ruby-build.

### `ruby.ruby_install_opts`

- Type: `string`(optional)
- Env: `MISE_RUBY_INSTALL_OPTS`
- Default: `None`

Options to pass to ruby-install.

### `ruby.ruby_install_repo`

- Type: `string`
- Env: `MISE_RUBY_INSTALL_REPO`
- Default: `https://github.com/postmodern/ruby-install.git`

URL to fetch ruby-install from.

### `ruby.verbose_install`

- Type: `Bool`(optional)
- Env: `MISE_RUBY_VERBOSE_INSTALL`
- Default: `None`

Set to true to enable verbose output during ruby installation.

## `rust`

### `rust.cargo_home`

- Type: `Path`(optional)
- Env: `MISE_CARGO_HOME`
- Default: `None`

Path to the cargo home directory. Defaults to `~/.cargo` or `%USERPROFILE%\.cargo`

### `rust.rustup_home`

- Type: `Path`(optional)
- Env: `MISE_RUSTUP_HOME`
- Default: `None`

Path to the rustup home directory. Defaults to `~/.rustup` or `%USERPROFILE%\.rustup`

## `sops`

### `sops.age_key`

- Type: `string`(optional)
- Env: `MISE_SOPS_AGE_KEY`
- Default: `None`

The age private key to use for sops secret decryption.

### `sops.age_key_file`

- Type: `Path`
- Env: `MISE_SOPS_AGE_KEY_FILE`
- Default: `~/.config/mise/age.txt`

Path to the age private key file to use for sops secret decryption.

### `sops.age_recipients`

- Type: `string`(optional)
- Env: `MISE_SOPS_AGE_RECIPIENTS`
- Default: `None`

The age public keys to use for sops secret encryption.

### `sops.rops`

- Type: `Bool`
- Env: `MISE_SOPS_ROPS`
- Default: `true`

Use rops to decrypt sops files. Disable to shell out to `sops` which will slow down mise but sops may offer features not available in rops.

### `sops.strict`

- Type: `Bool`
- Env: `MISE_SOPS_STRICT`
- Default: `true`

If true, fail when sops decryption fails (including when sops is not available, the key is missing, or the key is invalid). If false, skip decryption and continue in these cases.

## `status`

### `status.missing_tools`

- Type: `string`
- Env: `MISE_STATUS_MESSAGE_MISSING_TOOLS`
- Default: `if_other_versions_installed`

| Choice | Description |
| --- | --- |
| `if_other_versions_installed` \[default\] | Show the warning only when the tool has at least 1 other version installed |
| `always` | Always show the warning |
| `never` | Never 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`](https://mise.jdx.dev/configuration/settings.html#disable_tools).

### `status.show_env`

- Type: `Bool`
- Env: `MISE_STATUS_MESSAGE_SHOW_ENV`
- Default: `false`

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

### `status.show_tools`

- Type: `Bool`
- Env: `MISE_STATUS_MESSAGE_SHOW_TOOLS`
- Default: `false`

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

### `status.truncate`

- Type: `Bool`
- Env: `MISE_STATUS_MESSAGE_TRUNCATE`
- Default: `true`

Truncate status messages.

## `swift`

### `swift.gpg_verify`

- Type: `Bool`(optional)
- Env: `MISE_SWIFT_GPG_VERIFY`
- Default: `None`

Use gpg to verify swift tool signatures.

### `swift.platform`

- Type: `string`
- Env: `MISE_SWIFT_PLATFORM`
- Default: `"osx" | "windows10" | "ubuntu20.04" | "ubuntu22.04" | "ubuntu24.04" | "amazonlinux2" | "ubi9" | "fedora39"`

Override the platform to use for precompiled binaries.

<|firecrawl-page-104-lllmstxt|>
## Contact Jeff Dickey
[Skip to content](https://mise.jdx.dev/contact.html#VPContent)

Return to top

# Contact [​](https://mise.jdx.dev/contact.html\#contact)

`mise` is mostly built and maintained by me, [Jeff Dickey](https://jdx.dev/). The goal is to make local development of software easy and consistent across languages. I have spent many years building dev tools and thinking about the problems that `mise` addresses.

I try to use the first-person in these docs since the reality is it's generally me writing them and I think it makes it more interesting having a bit of my personality in the text.

This project is simply a labor of love. I am making it because I want to make your life as a developer easier. I hope you find it useful. Feedback is a massive driver for me. If you have anything positive or negative to say-even if it's just to say hi-please reach out to me either on [Twitter](https://twitter.com/jdxcode), [Mastodon](https://fosstodon.org/@jdx), [Discord](https://discord.gg/UBa7pJUN7Z), or `jdx at this domain`.

<|firecrawl-page-105-lllmstxt|>
## Continuous Integration with Mise
[Skip to content](https://mise.jdx.dev/continuous-integration.html#VPContent)

Return to top

# Continuous integration [​](https://mise.jdx.dev/continuous-integration.html\#continuous-integration)

You can use Mise in continuous integration environments to provision the environment with the tools the project needs. We recommend that your project pins the tools to a specific version to ensure the environment is reproducible.

## Any CI provider [​](https://mise.jdx.dev/continuous-integration.html\#any-ci-provider)

Continuous integration pipelines allow running arbitrary commands. You can use this to install Mise and run `mise install` to install the tools:

yaml

```
script: |
  curl https://mise.run | sh
  mise install
```

To ensure you run the version of the tools installed by Mise, make sure you run them through the `mise x` command:

yaml

```
script: |
  mise x -- npm test
```

Alternatively, you can add the [shims](https://mise.jdx.dev/dev-tools/shims.html) directory to your `PATH`, if the CI provider allows it.

### Bootstrapping [​](https://mise.jdx.dev/continuous-integration.html\#bootstrapping)

An alternative to calling `curl https://mise.run | sh` is to use [`mise generate bootstrap`](https://mise.jdx.dev/cli/generate/bootstrap.html) to generate a script that runs and install `mise`.

shell

```
mise generate bootstrap -l -w
```

Add the `.mise/` to your `.gitignore` and commit the generated `./bin/mise` file. You can now use `./bin/mise` to install and run `mise` directly in CI.

yaml

```
script: |
  ./bin/mise install
  ./bin/mise x -- npm test
```

## GitHub Actions [​](https://mise.jdx.dev/continuous-integration.html\#github-actions)

If you use GitHub Actions, we provide a [mise-action](https://github.com/jdx/mise-action) that wraps the installation of Mise and the tools. All you need to do is to add the action to your workflow:

yaml

```
name: test
on:
  pull_request:
    branches:
      - main
  push:
    branches:
      - main
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4
      - uses: jdx/mise-action@v2
        with:
          version: 2024.12.14 # [default: latest] mise version to install
          install: true # [default: true] run `mise install`
          cache: true # [default: true] cache mise using GitHub's cache
          experimental: true # [default: false] enable experimental features
          # automatically write this mise.toml file
          mise_toml: |
            [tools]
            shellcheck = "0.9.0"
          # or, if you prefer .tool-versions:
          tool_versions: |
            shellcheck 0.9.0
      - run: shellcheck scripts/*.sh
```

## GitLab CI [​](https://mise.jdx.dev/continuous-integration.html\#gitlab-ci)

You can use any docker image with `mise` installed to run your CI jobs. Here's an example using `debian-slim` as base image:

Example Dockerfile

dockerfile

```
FROM debian:12-slim

RUN apt-get update  \
    && apt-get -y --no-install-recommends install  \
      # install any tools you need
      sudo curl git ca-certificates build-essential \
    && rm -rf /var/lib/apt/lists/*

RUN curl https://mise.run | MISE_VERSION=v... MISE_INSTALL_PATH=/usr/local/bin/mise sh
```

When configuring your job, you can cache some of the [Mise directories](https://mise.jdx.dev/directories.html).

yaml

```
build-job:
  stage: build
  image: mise-debian-slim # Use the image you created
  variables:
    MISE_DATA_DIR: $CI_PROJECT_DIR/.mise/mise-data
  cache:
    - key:
        prefix: mise-
        files: ["mise.toml", "mise.lock"] # mise.lock is optional, only if using `lockfile = true`
      paths:
        - $MISE_DATA_DIR
  script:
    - mise install
    - mise exec --command 'npm build'
```

### Example with the bootstrap script [​](https://mise.jdx.dev/continuous-integration.html\#example-with-the-bootstrap-script)

An alternative is to use [`mise generate bootstrap`](https://mise.jdx.dev/cli/generate/bootstrap.html) to easily [bootstrap](https://mise.jdx.dev/continuous-integration.html#bootstrapping) `mise` on GitLab CI.

```
mise generate bootstrap -l -w
```

You can now use a generic docker image such as this one to run and install `mise` in CI.

Example Dockerfile

dockerfile

```
FROM debian:12-slim

RUN apt-get update  \
    && apt-get -y --no-install-recommends install sudo curl git ca-certificates build-essential \
    && rm -rf /var/lib/apt/lists/*
```

Here's an example of a `.gitlab-ci.yml` file:

yaml

```
.mise-cache: &mise-cache
  key:
    prefix: mise-
    files: ["mise.toml", "./bin/mise"]
  paths:
    - .mise/installs
    - .mise/mise-2025.1.3

build-job:
  stage: build
  image: my-debian-slim-image # Use the image you created
  cache:
    - <<: *mise-cache
      policy: pull-push
  script:
    - ./bin/mise install
    - ./bin/mise exec --command 'npm build'
```

## Xcode Cloud [​](https://mise.jdx.dev/continuous-integration.html\#xcode-cloud)

If you are using Xcode Cloud, you can use custom `ci_post_clone.sh` [build script](https://developer.apple.com/documentation/xcode/writing-custom-build-scripts) to install Mise. Here's an example:

bash

```
#!/bin/sh
curl https://mise.run | sh
export PATH="$HOME/.local/bin:$PATH"

mise install # Installs the tools in mise.toml
eval "$(mise activate bash --shims)" # Adds the activated tools to $PATH

swiftlint {args}
```

<|firecrawl-page-106-lllmstxt|>
## Contributing Guidelines
[Skip to content](https://mise.jdx.dev/contributing.html#VPContent)

Return to top

# Contributing [​](https://mise.jdx.dev/contributing.html\#contributing)

Before submitting a PR, unless it's something obvious, consider filing an issue or simply mention what you plan to do in the [Discord](https://discord.gg/UBa7pJUN7Z). PRs are often either rejected or need to change significantly after submission so make sure before you start working on something it won't be a wasted effort.

Issues ideal for contributors can be found with the ["help wanted"](https://github.com/jdx/mise/issues?q=is%3Aissue+is%3Aopen+label%3A%22help+wanted%22) and ["good first issue"](https://github.com/jdx/mise/issues?q=is%3Aissue%20state%3Aopen%20label%3A%22good%20first%20issue%22) labels. These are issues that I feel are self-contained therefore don't require super in-depth understanding of the codebase or that require knowledge about something I don't understand very well myself.

## Contributing Guidelines [​](https://mise.jdx.dev/contributing.html\#contributing-guidelines)

1. **Before starting**: File an issue or discuss in Discord for non-obvious changes
2. **Look for issues**: Check "help wanted" and "good first issue" labels
3. **Test thoroughly**: Ensure both unit and E2E tests pass
4. **Follow conventions**: Use existing code style and patterns
5. **Update documentation**: Add/update docs for new features

### Pull Request Workflow [​](https://mise.jdx.dev/contributing.html\#pull-request-workflow)

1. **PR titles**: Must follow conventional commit format (validated automatically)
   - For new tools in registry: Use `registry: add tool-name`
2. **Auto-formatting**: Code will be automatically formatted by autofix.ci
3. **CI checks**: All tests must pass across Linux, macOS, and Windows
4. **Coverage**: New code should maintain or improve test coverage
5. **Dependencies**: New dependencies are validated with cargo-deny

### Development Tips [​](https://mise.jdx.dev/contributing.html\#development-tips)

1. **Disable mise during development**: If you use mise in your shell, disable it when running tests to avoid conflicts
2. **Use dev container**: Docker setup available (currently needs fixing)
3. **Test specific features**: Use `cargo test test_name` for targeted testing
4. **Update snapshots**: Use `mise run snapshots` when changing test outputs
5. **Rate limiting**: Set `MISE_GITHUB_TOKEN` to avoid GitHub API rate limits during development

## Testing [​](https://mise.jdx.dev/contributing.html\#testing)

mise has a comprehensive test suite with multiple types of tests to ensure reliability and functionality across different platforms and scenarios.

### Unit Tests [​](https://mise.jdx.dev/contributing.html\#unit-tests)

Unit tests are fast, focused tests for individual components and functions:

bash

```
# Run all unit tests
cargo test --all-features

# Run specific unit tests
cargo test <test_name>
```

**Unit test structure:**

- Located in `src/` directory alongside source code
- Use Rust's built-in test framework
- Test individual functions and modules
- Fast execution (used for quick feedback during development)

### E2E Tests [​](https://mise.jdx.dev/contributing.html\#e2e-tests)

End-to-end tests validate the complete functionality of mise in realistic scenarios:

bash

```
# Run all E2E tests
mise run test:e2e

# Run specific E2E test
./e2e/run_test test_name

# Run E2E tests matching pattern
./e2e/run_test task  # runs tests matching *task*

# Run all tests including slow ones
TEST_ALL=1 mise run test:e2e
```

**E2E test structure:**

- Located in `e2e/` directory
- Organized by functionality:
  - `e2e/cli/` \- Command-line interface tests
  - `e2e/core/` \- Core functionality tests
  - `e2e/env/` \- Environment variable tests
  - `e2e/tasks/` \- Task runner tests
  - `e2e/config/` \- Configuration tests
  - `e2e/tools/` \- Tool management tests
  - `e2e/shell/` \- Shell integration tests
  - `e2e/backend/` \- Backend tests
  - `e2e/plugins/` \- Plugin tests

**E2E test categories:**

- **Fast tests** ( `test_*`): Run in normal test suites
- **Slow tests** ( `test_*_slow`): Only run when `TEST_ALL=1` is set
- **Isolated environment**: Each test runs in a clean, isolated environment

### Coverage Tests [​](https://mise.jdx.dev/contributing.html\#coverage-tests)

Coverage tests measure how much of the codebase is covered by tests:

bash

```
# Run coverage tests
mise run test:coverage

# Coverage tests run in parallel tranches for CI
TEST_TRANCHE=0 TEST_TRANCHE_COUNT=8 mise run test:coverage
```

### Windows E2E Tests [​](https://mise.jdx.dev/contributing.html\#windows-e2e-tests)

Windows has its own test suite written in PowerShell:

powershell

```
# Run all Windows E2E tests
pwsh e2e-win\run.ps1

# Run specific Windows tests
pwsh e2e-win\run.ps1 task  # run tests matching *task*
```

### Plugin Tests [​](https://mise.jdx.dev/contributing.html\#plugin-tests)

Test plugin functionality across different backends:

bash

```
# Test specific plugin
mise test-tool ripgrep

# Test all plugins in registry
mise test-tool --all

# Test all plugins in config files
mise test-tool --all-config

# Test with parallel jobs
mise test-tool --all --jobs 4
```

### Test Environment Setup [​](https://mise.jdx.dev/contributing.html\#test-environment-setup)

Tests run in isolated environments to avoid conflicts:

bash

```
# Disable mise during development testing
export MISE_DISABLE_TOOLS=1

# Run tests with specific environment
MISE_TRUSTED_CONFIG_PATHS=$PWD cargo test
```

### Test Assertions [​](https://mise.jdx.dev/contributing.html\#test-assertions)

The E2E tests use a custom assertion framework ( `e2e/assert.sh`):

bash

```
# Basic assertions
assert "command" "expected_output"
assert_contains "command" "substring"
assert_fail "command" "expected_error"

# JSON assertions
assert_json "command" '{"key": "value"}'
assert_json_partial_array "command" "fields" '[{...}]'

# File/directory assertions
assert_directory_exists "/path/to/dir"
assert_directory_not_exists "/path/to/dir"
assert_empty "command"
```

### Running Specific Test Categories [​](https://mise.jdx.dev/contributing.html\#running-specific-test-categories)

bash

```
# Run all tests (unit + e2e)
mise run test

# Run only unit tests
mise run test:unit

# Run only e2e tests
mise run test:e2e

# Run tests with shuffle (for detecting order dependencies)
mise run test:shuffle

# Run nightly tests (with bleeding edge Rust)
rustup default nightly && mise run test
```

### Running Individual Tests [​](https://mise.jdx.dev/contributing.html\#running-individual-tests)

#### Running Single Unit Tests [​](https://mise.jdx.dev/contributing.html\#running-single-unit-tests)

bash

```
# Run a specific unit test by name
cargo test test_name

# Run tests matching a pattern
cargo test pattern

# Run tests in a specific module
cargo test module_name

# Run a single test with output
cargo test test_name -- --nocapture
```

#### Running Single E2E Tests [​](https://mise.jdx.dev/contributing.html\#running-single-e2e-tests)

bash

```
# Run a specific E2E test by name
./e2e/run_test test_name

# Run E2E tests matching a pattern
mise run test:e2e pattern

# Examples:
./e2e/run_test test_use                    # Run specific test
./e2e/run_test test_config_set            # Run config-related test
mise run test:e2e task                     # Run all tests matching "task"
```

#### Testing Individual Plugins [​](https://mise.jdx.dev/contributing.html\#testing-individual-plugins)

bash

```
# Test a specific plugin
mise test-tool ripgrep

# Test a plugin with verbose output
mise test-tool ripgrep --raw

# Test multiple plugins
mise test-tool ripgrep jq terraform
```

### Performance Testing [​](https://mise.jdx.dev/contributing.html\#performance-testing)

bash

```
# Run performance benchmarks
mise run test:perf

# Build performance test workspace
mise run test:build-perf-workspace
```

### Snapshot Testing [​](https://mise.jdx.dev/contributing.html\#snapshot-testing)

Used for testing output consistency:

bash

```
# Update test snapshots when output changes
mise run snapshots

# Use cargo-insta for snapshot testing
cargo insta test --accept --unreferenced delete
```

## Development Setup [​](https://mise.jdx.dev/contributing.html\#development-setup)

### Prerequisites [​](https://mise.jdx.dev/contributing.html\#prerequisites)

- [Rust](https://www.rust-lang.org/) (latest stable, we don't use mise to manage rust)
- mise

### Getting Started [​](https://mise.jdx.dev/contributing.html\#getting-started)

bash

```
# Clone the repository
git clone https://github.com/jdx/mise.git
cd mise

# Install dependencies
mise install

# Build the project
mise run build
```

### Development Shim [​](https://mise.jdx.dev/contributing.html\#development-shim)

Create a development shim to easily run mise during development:

bash

```
# Create ~/.local/bin/@mise
#!/bin/sh
exec cargo run -q --all-features --manifest-path ~/src/mise/Cargo.toml -- "$@"
```

Then use `@mise` to run the development version:

bash

```
@mise --help
eval "$(@mise activate zsh)"
```

## Project Structure [​](https://mise.jdx.dev/contributing.html\#project-structure)

text

```
mise/
├── src/           # Main Rust source code
├── e2e/           # End-to-end tests
├── docs/          # Documentation
├── tasks.toml     # Development tasks
├── mise.toml      # Project configuration
├── Cargo.toml     # Rust project configuration
└── xtasks/        # Additional build scripts
```

## Available Development Tasks [​](https://mise.jdx.dev/contributing.html\#available-development-tasks)

Use `mise tasks` to see all available development tasks:

### Common Tasks [​](https://mise.jdx.dev/contributing.html\#common-tasks)

- `mise run build` \- Build the project
- `mise run test` \- Run all tests (unit + E2E)
- `mise run test:unit` \- Run unit tests only
- `mise run test:e2e` \- Run E2E tests only
- `mise run lint` \- Run linting
- `mise run lint:fix` \- Run linting with fixes
- `mise run format` \- Format code
- `mise run clean` \- Clean build artifacts
- `mise run snapshots` \- Update test snapshots
- `mise run render` \- Generate documentation and completions

### Documentation Tasks [​](https://mise.jdx.dev/contributing.html\#documentation-tasks)

- `mise run docs` \- Start documentation development server
- `mise run docs:build` \- Build documentation
- `mise run render:help` \- Generate help documentation
- `mise run render:completions` \- Generate shell completions

### Release Tasks [​](https://mise.jdx.dev/contributing.html\#release-tasks)

- `mise run release` \- Create a release
- `mise run ci` \- Run CI tasks (format, build, test)

## Setup [​](https://mise.jdx.dev/contributing.html\#setup)

Shouldn't require anything special I'm aware of, but `mise run build` is a good sanity check to run and make sure it's all working.

## Dev Container [​](https://mise.jdx.dev/contributing.html\#dev-container)

DANGER

The docker setup quit working and since I don't use it I haven't bothered to fix it. For now you'll need to run outside of docker or you can try to fix the docker setup.

There is a docker setup that makes development with mise easier. It is especially helpful for running the E2E tests. Here's some example ways to use it:

sh

```
mise run docker:cargo build
mise run docker:cargo test
mise run docker:mise --help # run `mise --help` in the dev container
# run the e2e tests inside of the docker container
mise run docker:mise run test:e2e
# shortcut for `mise run docker:mise run test:e2e`
mise run docker:e2e
```

## Pre-commit Hooks & Code Quality [​](https://mise.jdx.dev/contributing.html\#pre-commit-hooks-code-quality)

mise uses [hk](https://hk.jdx.dev/) as its git hook manager for linting and code quality checks. hk is a modern alternative to lefthook written by the same author as mise.

### hk Configuration [​](https://mise.jdx.dev/contributing.html\#hk-configuration)

The project uses `hk.pkl` (written in the Pkl configuration language) to define linting rules:

bash

```
# Run all linting checks
hk check --all

# Run linting with fixes
hk fix --all

# Run specific linter
hk check --linter shellcheck
```

### Available Linters in hk [​](https://mise.jdx.dev/contributing.html\#available-linters-in-hk)

- **prettier**: Code formatting for multiple languages
- **clippy**: Rust linting with `cargo clippy`
- **shellcheck**: Shell script linting
- **shfmt**: Shell script formatting
- **pkl**: Pkl configuration file validation

### Using hk in Development [​](https://mise.jdx.dev/contributing.html\#using-hk-in-development)

bash

```
# Run linting (used in CI and pre-commit)
mise run lint  # This runs hk check --all

# Run linting with fixes
hk fix --all

# Check specific file types
hk check --linter prettier
hk check --linter shellcheck
```

### Pre-commit Task Configuration [​](https://mise.jdx.dev/contributing.html\#pre-commit-task-configuration)

mise defines a `pre-commit` task that runs the main linting checks:

toml

```
[pre-commit]
env = { PRE_COMMIT = 1 }
run = ["mise run lint"]
```

This task:

1. Sets `PRE_COMMIT=1` environment variable
2. Runs `mise run lint`, which executes `hk check --all`

### Setting Up Pre-commit Hooks [​](https://mise.jdx.dev/contributing.html\#setting-up-pre-commit-hooks)

bash

```
# Set up git hook to run mise's pre-commit task
mise generate git-pre-commit --write --task=pre-commit
```

### Running Pre-commit Checks Manually [​](https://mise.jdx.dev/contributing.html\#running-pre-commit-checks-manually)

bash

```
# Run all pre-commit checks
mise run pre-commit

# Run specific linting checks
mise run lint

# Run linting with fixes
hk fix --all

# Run checks on specific files
hk check --files="src/**/*.rs"
```

## Running the CLI [​](https://mise.jdx.dev/contributing.html\#running-the-cli)

Even if using the devcontainer, it's a good idea to create a shim to make it easy to launch mise. I use the following shim in `~/.local/bin/@mise`:

sh

```
#!/bin/sh
exec cargo run -q --all-features --manifest-path ~/src/mise/Cargo.toml -- "$@"
```

INFO

Don't forget to change the manifest path to the correct path for your setup.

Then if that is in PATH just use `@mise` to run mise by compiling it on the fly.

sh

```
@mise --help
@mise run docker:e2e
eval "$(@mise activate zsh)"
@mise activate fish | source
```

## Releasing [​](https://mise.jdx.dev/contributing.html\#releasing)

Run `mise run release -x [minor|patch]`. (minor if it is the first release in a month)

## Linting [​](https://mise.jdx.dev/contributing.html\#linting)

- Lint codebase: `mise run lint`
- Lint and fix codebase: `mise run lint:fix`

## Generating readme and shell completion files [​](https://mise.jdx.dev/contributing.html\#generating-readme-and-shell-completion-files)

sh

```
mise run render
```

## Dependency Management [​](https://mise.jdx.dev/contributing.html\#dependency-management)

mise uses several tools to validate dependencies and code quality:

- **cargo-deny**: Validates licenses, security advisories, and dependency duplicates
- **cargo-msrv**: Verifies minimum supported Rust version compatibility
- **cargo-machete**: Detects unused dependencies in Cargo.toml

These checks run automatically in CI and can be run locally:

bash

```
# Run checks (tools are automatically available via mise.toml)
cargo deny check
cargo msrv verify
cargo machete --with-metadata
```

## Conventional Commits [​](https://mise.jdx.dev/contributing.html\#conventional-commits)

mise uses [Conventional Commits](https://www.conventionalcommits.org/) for consistent commit messages and automated changelog generation. All commits should follow this format:

text

```
<type>[optional scope]: <description>

[optional body]

[optional footer(s)]
```

### Commit Types [​](https://mise.jdx.dev/contributing.html\#commit-types)

- **feat**: New features (🚀 Features)
- **fix**: Bug fixes (🐛 Bug Fixes)
- **refactor**: Code refactoring (🚜 Refactor)
- **docs**: Documentation changes (📚 Documentation)
- **style**: Code style changes (🎨 Styling)
- **perf**: Performance improvements (⚡ Performance)
- **test**: Testing changes (🧪 Testing)
- **chore**: Maintenance tasks, dependency updates
- **revert**: Reverting previous changes (◀️ Revert)

### Examples [​](https://mise.jdx.dev/contributing.html\#examples)

bash

```
feat(cli): add new command for listing plugins
fix(parser): handle edge case in version parsing
refactor(config): simplify configuration loading logic
docs(readme): update installation instructions
test(e2e): add tests for new plugin functionality
chore(deps): update dependencies to latest versions
```

### Scopes [​](https://mise.jdx.dev/contributing.html\#scopes)

Common scopes used in mise:

- `cli` \- Command line interface changes
- `config` \- Configuration system changes
- `parser` \- Parsing logic changes
- `deps` \- Dependency updates
- `security` \- Security-related changes

### Breaking Changes [​](https://mise.jdx.dev/contributing.html\#breaking-changes)

#### Breaking Change Policy [​](https://mise.jdx.dev/contributing.html\#breaking-change-policy)

Breaking changes are rarely accepted into mise and are only performed in exceptional situations where there is no better alternative. When a breaking change is necessary, the process includes:

1. **CLI warnings**: Users receive deprecation warnings in the CLI
2. **Migration period**: Several months are provided for users to migrate
3. **Documentation**: Clear migration guides are provided
4. **Community notice**: Announcements in Discord and GitHub discussions

For breaking changes, add `!` after the type or include `BREAKING CHANGE:` in the footer:

bash

```
feat(api)!: remove deprecated configuration options
# OR
feat(api): remove deprecated configuration options

BREAKING CHANGE: The old configuration format is no longer supported
```

## CI/CD & Pull Request Automation [​](https://mise.jdx.dev/contributing.html\#ci-cd-pull-request-automation)

mise uses several automated workflows to maintain code quality and streamline development:

### Automated Code Formatting [​](https://mise.jdx.dev/contributing.html\#automated-code-formatting)

- **autofix.ci**: Automatically formats code and fixes linting issues in PRs
- Runs `mise run render` and `mise run lint-fix` automatically
- Commits fixes directly to the PR branch

### PR Title Validation [​](https://mise.jdx.dev/contributing.html\#pr-title-validation)

- **semantic-pr-lint**: Validates PR titles follow conventional commit format
- PR titles must match: `<type>[optional scope]: <description>`
- Example: `feat(cli): add new command for listing plugins`

### Continuous Integration [​](https://mise.jdx.dev/contributing.html\#continuous-integration)

- **Cross-platform testing**: Ubuntu, macOS, and Windows
- **Unit tests**: Fast component-level tests
- **E2E tests**: Full integration testing with multiple test tranches
- **Dependency validation**: `cargo deny`, `cargo msrv`, `cargo machete`

### Release Automation [​](https://mise.jdx.dev/contributing.html\#release-automation)

- **release-plz**: Automated release management based on conventional commits
- Automatically creates release PRs and publishes releases
- Runs daily via scheduled workflow
- Handles version bumping and changelog generation

## Adding a new setting [​](https://mise.jdx.dev/contributing.html\#adding-a-new-setting)

To add a new setting, add it to [`settings.toml`](https://github.com/jdx/mise/blob/main/settings.toml) in the root of the project and run `mise run render` to update the codebase.

## Adding Tools [​](https://mise.jdx.dev/contributing.html\#adding-tools)

Adding tools to mise involves adding entries to the [registry.toml](https://github.com/jdx/mise/blob/main/registry.toml) file. This allows users to install tools using short names like `mise use ripgrep` instead of the full backend specification.

### Quick Start [​](https://mise.jdx.dev/contributing.html\#quick-start)

1. **Choose the right backend** for your tool:

   - **[aqua](https://mise.jdx.dev/dev-tools/backends/aqua.html)** \- Preferred for GitHub releases with security features
   - **[ubi](https://mise.jdx.dev/dev-tools/backends/ubi.html)** \- Simple GitHub/GitLab releases following standard conventions
   - **Language package managers** \- `npm`, `pipx`, `cargo`, `gem`, etc. for ecosystem-specific tools
   - **[Core tools](https://mise.jdx.dev/core-tools.html)** \- Built-in support for major languages (not user-contributed)
2. **Add to registry.toml**:

toml

```
your-tool.description = "Brief description of the tool"
your-tool.backends = ["aqua:owner/repo", "ubi:owner/repo"]
your-tool.test = ["your-tool --version", "{{version}}"]
```

3. **Test the tool** works properly with `mise test-tool your-tool`


### Guidelines and Requirements [​](https://mise.jdx.dev/contributing.html\#guidelines-and-requirements)

When adding a new tool, the following requirements apply (automatically enforced by [GitHub Actions workflow](https://github.com/jdx/mise/blob/main/.github/workflows/registry_comment.yml)):

- **New asdf plugins are not accepted** \- Use aqua/ubi instead
- **Tools may be rejected if they are not notable** \- The tool should be reasonably popular and well-maintained
- **A test is required in `registry.toml`** \- Must include a `test` field to verify installation

### Registry Format [​](https://mise.jdx.dev/contributing.html\#registry-format)

The `registry.toml` file uses this format:

toml

```
# Tool name (becomes the short name for `mise use`)
your-tool.description = "Tool description"
your-tool.backends = [\
    "aqua:owner/repo",           # Preferred backend first\
    "ubi:owner/repo",            # Fallback backends\
    "npm:package-name"           # Multiple backends supported\
]
your-tool.test = [\
    "your-tool --version",       # Command to run\
    "{{version}}"                # Expected output pattern\
]
your-tool.aliases = ["alt-name"] # Optional alternative names
your-tool.os = ["linux", "macos"] # Optional OS restrictions
```

### Backend Priority [​](https://mise.jdx.dev/contributing.html\#backend-priority)

List backends in order of preference. Users will get the first available backend, but can override with explicit syntax like `mise use aqua:owner/repo`.

### Tool Testing [​](https://mise.jdx.dev/contributing.html\#tool-testing)

All tools must include a test to verify proper installation:

toml

```
your-tool.test = [\
    "command-to-run",\
    "expected-output-pattern"\
]
```

The test command should be reliable and the output pattern should use `` to match any version number.

### Registry Examples [​](https://mise.jdx.dev/contributing.html\#registry-examples)

Recent tool additions:

- **DuckDB**: Simple ubi backend ( [#4248](https://github.com/jdx/mise/pull/4248))

toml

```
duckdb.backends = ["ubi:duckdb/duckdb"]
duckdb.test = ["duckdb --version", "{{version}}"]
```

- **Biome**: Multiple backends ( [#4283](https://github.com/jdx/mise/pull/4283))

toml

```
biome.backends = ["aqua:biomejs/biome", "ubi:biomejs/biome"]
biome.test = ["biome --version", "Version: {{version}}"]
```


## Adding Backends [​](https://mise.jdx.dev/contributing.html\#adding-backends)

Backend vs Tool Confusion

**Most contributors want to add tools, not backends.** Before reading this section, make sure you actually need a new backend. Tools are individual software packages (like `node` or `ripgrep`), while backends are installation mechanisms (like `aqua` or `ubi`). If you want to add a specific tool to mise, see [Adding Tools](https://mise.jdx.dev/contributing.html#adding-tools) instead.

Core Backend Acceptance Policy

**New backends are unlikely to be accepted into mise core.** They require a lot of maintenance so it's generally better to use the [backend plugin system](https://mise.jdx.dev/backend-plugin-development.html) to add backends without core changes. A new backend would only be accepted for a major package manager or tool that would greatly enhance mise's capabilities.

If you need a custom backend:

1. **Discuss with jdx first** in [Discord](https://discord.gg/UBa7pJUN7Z) or by creating a [discussion](https://github.com/jdx/mise/discussions)
2. **Consider if existing backends** (ubi, aqua, npm, pipx, etc.) can meet your needs
3. **Create a plugin** \- use the [plugin system](https://mise.jdx.dev/tool-plugin-development.html) to create plugins for private/custom tools without core changes

Most tool installation needs can be met by existing backends, especially [ubi](https://mise.jdx.dev/dev-tools/backends/ubi.html) for GitHub releases and [aqua](https://mise.jdx.dev/dev-tools/backends/aqua.html) for comprehensive package management.

Backends are mise's abstraction for different tool installation methods. Each backend implements the `Backend` trait to provide consistent functionality across different installation systems.

### Backend Types [​](https://mise.jdx.dev/contributing.html\#backend-types)

- **Core Backends** ( `src/backend/core/`) \- Built-in language runtimes like Node.js, Python, Ruby
- **Package Manager Backends** ( `src/backend/`) \- npm, pipx, cargo, gem, go modules
- **Universal Installers** ( `src/backend/`) \- ubi, aqua for GitHub releases and package management
- **Plugin Backends** ( `src/backend/`) \- plugins can provide custom backends or individual tools

### Implementation Steps [​](https://mise.jdx.dev/contributing.html\#implementation-steps)

1. **Create the backend module** in `src/backend/` (e.g., `my_backend.rs`)

2. **Implement the Backend trait**:

rust

```
use crate::backend::{Backend, BackendType};
use crate::install_context::InstallContext;

#[derive(Debug)]
pub struct MyBackend {
       // backend-specific fields
}

impl Backend for MyBackend {
       fn get_type(&self) -> BackendType { BackendType::MyBackend }

       async fn list_remote_versions(&self) -> Result<Vec<String>> {
           // Implementation for listing available versions
       }

       async fn install_version(&self, ctx: &InstallContext,
                                 tv: &ToolVersion) -> Result<()> {
           // Implementation for installing a specific version
       }

       async fn uninstall_version(&self, tv: &ToolVersion) -> Result<()> {
           // Implementation for uninstalling a version
       }

       // ... other required methods
}
```

3. **Register the backend** in `src/backend/mod.rs`:

   - Add your backend to the imports
   - Add it to the backend registry/factory function
   - Add the `BackendType` enum variant
4. **Add CLI argument parsing** in `src/cli/args/backend_arg.rs` if needed

5. **Update the registry** in `registry.toml` if it should be available as a shorthand


### Testing Requirements [​](https://mise.jdx.dev/contributing.html\#testing-requirements)

- **Integration tests** in `e2e/backend/test_my_backend`
- **Test both installation and usage** of tools from your backend
- **Windows testing** if the backend supports Windows

### Documentation [​](https://mise.jdx.dev/contributing.html\#documentation)

- **Update backend documentation** in `docs/dev-tools/backends/`
- **Add usage examples** showing how to install tools with your backend
- **Update the registry documentation** if adding new shorthand tools

### Implementation Examples [​](https://mise.jdx.dev/contributing.html\#implementation-examples)

Look at existing backends for patterns:

- `src/backend/ubi.rs` \- Simple GitHub release installer
- `src/backend/npm.rs` \- Package manager integration
- `src/backend/core/node.rs` \- Full language runtime implementation

For detailed architecture information, see [Backend Architecture](https://mise.jdx.dev/dev-tools/backend_architecture.html).

## Testing packaging [​](https://mise.jdx.dev/contributing.html\#testing-packaging)

This is only necessary to test if actually changing the packaging setup.

### Ubuntu (apt) [​](https://mise.jdx.dev/contributing.html\#ubuntu-apt)

This is for arm64, but you can change the arch to amd64 if you want.

sh

```
docker run -ti --rm ubuntu
apt update -y
apt install -y gpg sudo wget curl
sudo install -dm 755 /etc/apt/keyrings
wget -qO - https://mise.jdx.dev/gpg-key.pub | gpg --dearmor | \
  sudo tee /etc/apt/keyrings/mise-archive-keyring.gpg 1> /dev/null
echo "deb [signed-by=/etc/apt/keyrings/mise-archive-keyring.gpg arch=arm64] \
https://mise.jdx.dev/deb stable main" | sudo tee /etc/apt/sources.list.d/mise.list
apt update
apt install -y mise
mise -V
```

### Fedora (dnf) [​](https://mise.jdx.dev/contributing.html\#fedora-dnf)

sh

```
docker run -ti --rm fedora
dnf copr enable -y jdxcode/mise && dnf install -y mise && mise -v
```

### RHEL (dnf) [​](https://mise.jdx.dev/contributing.html\#rhel-dnf)

sh

```
docker run -ti --rm registry.access.redhat.com/ubi9/ubi:latest
dnf copr enable -y jdxcode/mise && dnf install -y mise && mise -v
```

<|firecrawl-page-107-lllmstxt|>
## Core Tools Overview
[Skip to content](https://mise.jdx.dev/core-tools.html#VPContent)

Return to top

# Core Tools [​](https://mise.jdx.dev/core-tools.html\#core-tools)

`mise` comes with some plugins built into the CLI written in Rust. These are new and will improve over time.

They can be easily overridden by installing an asdf/vfox plugin with the same name, e.g.: `mise plugin install python https://github.com/asdf-community/asdf-python`.

You can see the core plugins with `mise registry -b core`.

- [Bun](https://mise.jdx.dev/lang/bun.html)
- [Deno](https://mise.jdx.dev/lang/deno.html)
- [Elixir](https://mise.jdx.dev/lang/elixir.html) experimental
- [Erlang](https://mise.jdx.dev/lang/erlang.html)
- [Go](https://mise.jdx.dev/lang/go.html)
- [Java](https://mise.jdx.dev/lang/java.html)
- [NodeJS](https://mise.jdx.dev/lang/node.html)
- [Python](https://mise.jdx.dev/lang/python.html)
- [Ruby](https://mise.jdx.dev/lang/ruby.html)
- [Rust](https://mise.jdx.dev/lang/rust.html) experimental
- [Swift](https://mise.jdx.dev/lang/swift.html) experimental
- [Zig](https://mise.jdx.dev/lang/zig.html)

<|firecrawl-page-108-lllmstxt|>
## Mise Tool Version Management
[Skip to content](https://mise.jdx.dev/demo.html#VPContent)

Return to top

# Demo [​](https://mise.jdx.dev/demo.html\#demo)

The following demo shows:

- how to use `mise exec` to run a command with a specific version of a tool
- how you can use `mise` to install and many other tools such as `jq`, `terraform`, or `go`.
- how to use `mise` to manage multiple versions of `node` on the same system.

## Transcript [​](https://mise.jdx.dev/demo.html\#transcript)

`mise exec <tool> -- <command>` allows you to run any tools with mise

shell

```
mise exec node@22 -- node -v
# mise node@22.14.0 ✓ installed
# v22.14.0
```

node is only available in the mise environment, not globally

shell

```
node -v
# bash: node: command not found
```

* * *

Here is another example where we run terraform with `mise exec`

shell

```
mise exec terraform -- terraform -v
# mise terraform@1.11.3 ✓ installed
# Terraform v1.11.3
```

* * *

`mise exec` is great for running one-off commands, however it can be convenient to activate mise. When activated, mise will automatically update your `PATH` to include the tools you have installed, making them available directly.

We will start by installing node@lts and make it the global default

shell

```
mise use --global node@lts
# v22.14.0
```

shell

```
node -v
# v22.14.0
```

shell

```
which node
# /root/.local/share/mise/installs/node/22.14.0/bin/node
```

Note that we get back the path to the real node here, not a shim.

* * *

We can also install other tools with mise. For example, we will install terraform, jq, and go

shell

```
mise use -g terraform jq go
# mise jq@1.7.1 ✓ installed
# mise terraform@1.11.3 ✓ installed
# mise go@1.24.1 ✓ installed
# mise ~/.config/mise/config.toml tools: go@1.24.1, jq@1.7.1, terraform@1.11.3
```

shell

```
terraform -v
# Terraform v1.11.3
```

shell

```
jq --version
# jq-1.7
```

shell

```
go version
# go version go1.24.1 linux/amd64
```

shell

```
mise ls
# Tool       Version  Source                      Requested
# go         1.24.1   ~/.config/mise/config.toml  latest
# jq         1.7.1    ~/.config/mise/config.toml  latest
# node       22.14.0  ~/.config/mise/config.toml  lts
# terraform  1.11.3   ~/.config/mise/config.toml  latest
```

* * *

Let's enter a project directory where we will set up node@23

shell

```
cd myproj
mise use node@23 pnpm@10
# mise node@23.10.0 ✓ installed
# mise pnpm@10.7.0 ✓ installed
```

shell

```
node -v
# v23.10.0
pnpm -v
# 10.7.0
```

As expected, `node -v` is now v23.x

shell

```
cat mise.toml
# [tools]
# node = "23"
# pnpm = "10"
```

We will leave this directory. The node version will revert to the global LTS version

shell

```
cd ..
node -v
# v22.14.0
```

<|firecrawl-page-109-lllmstxt|>
## Mise Aliases Guide
[Skip to content](https://mise.jdx.dev/dev-tools/aliases.html#VPContent)

Return to top

# Aliases [​](https://mise.jdx.dev/dev-tools/aliases.html\#aliases)

## Aliased Backends [​](https://mise.jdx.dev/dev-tools/aliases.html\#aliased-backends)

Tools can be aliased so that something like `node` which normally maps to `core:node` can be changed to something like `asdf:company/our-custom-node` instead.

~/.config/mise/config.toml

toml

```
[alias]
node = 'asdf:company/our-custom-node' # shorthand for https://github.com/company/our-custom-node
erlang = 'asdf:https://github.com/company/our-custom-erlang'
```

## Aliased Versions [​](https://mise.jdx.dev/dev-tools/aliases.html\#aliased-versions)

mise supports aliasing the versions of runtimes. One use-case for this is to define aliases for LTS versions of runtimes. For example, you may want to specify `lts-hydrogen` as the version for [node@20.x](mailto:node@20.x) so you can use set it with `node lts-hydrogen` in `mise.toml`/ `.tool-versions`.

User aliases can be created by adding an `alias.<PLUGIN>` section to `~/.config/mise/config.toml`:

toml

```
[alias.node.versions]
my_custom_20 = '20'
```

Plugins can also provide aliases via a `bin/list-aliases` script. Here is an example showing node.js versions:

bash

```
#!/usr/bin/env bash

echo "lts-hydrogen 18"
echo "lts-gallium 16"
echo "lts-fermium 14"
```

INFO

Because this is mise-specific functionality not currently used by asdf it isn't likely to be in any plugin currently, but plugin authors can add this script without impacting asdf users.

## Templates [​](https://mise.jdx.dev/dev-tools/aliases.html\#templates)

Alias values can be templates, see [Templates](https://mise.jdx.dev/templates.html) for details.

toml

```
[alias.node.versions]
current = "{{exec(command='node --version')}}"
```

<|firecrawl-page-110-lllmstxt|>
## Understanding Backend Architecture
[Skip to content](https://mise.jdx.dev/dev-tools/backend_architecture.html#VPContent)

Return to top

# Backend Architecture [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#backend-architecture)

Understanding how mise's backend system works can help you choose the right backend for your tools and troubleshoot issues when they arise. Most users don't need to explicitly choose backends since the [mise registry](https://mise.jdx.dev/registry.html) defines smart defaults, but understanding the system helps when you need specific tools or want to optimize performance.

## What are Backends? [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#what-are-backends)

Backends are mise's way of supporting different tool installation methods. Each backend knows how to:

- List available versions of tools
- Download and install specific versions
- Set up the environment for installed tools
- Manage tool lifecycles (updates, uninstalls)

Think of backends as "adapters" that let mise work with different package managers and installation systems.

## The Backend Trait System [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#the-backend-trait-system)

All backends implement a common interface (called a "trait" in Rust), which means they all provide the same basic functionality:

rust

```
pub trait Backend {
    async fn list_remote_versions(&self) -> Result<Vec<String>>;
    async fn install_version(&self, ctx: &InstallContext, tv: &ToolVersion) -> Result<()>;
    async fn uninstall_version(&self, tv: &ToolVersion) -> Result<()>;
    // ... other methods
}
```

This design allows mise to treat all backends uniformly while each backend handles the specifics of its installation method.

## Backend Types [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#backend-types)

### Core Tools [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#core-tools)

Built directly into mise, written in Rust for performance and reliability:

- **Node.js, Python, Ruby, Go, Java, etc.** \- Native implementations
- **Benefits**: Fastest performance, no external dependencies, best integration
- **Drawbacks**: Require much more maintenance; new core tool contributions are likely to be rejected unless they're for very popular tools like Node.js, Python, or Go

**Note**: Core tools like Node.js and Java are implemented as backends even though they represent single tools. This consistent backend architecture allows mise to handle all tools uniformly, whether they're complex ecosystems or individual tools.

### Language Package Managers [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#language-package-managers)

Leverage existing language ecosystems:

- **npm** \- Node.js packages ( `npm:prettier`, `npm:typescript`)
- **pipx** \- Python packages ( `pipx:black`, `pipx:poetry`)
- **cargo** \- Rust packages ( `cargo:ripgrep`, `cargo:fd-find`)
- **gem** \- Ruby packages ( `gem:bundler`, `gem:rails`)
- **go** \- Go packages ( `go:github.com/golangci/golangci-lint/cmd/golangci-lint`)

### Universal Installers [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#universal-installers)

#### ubi - Universal Binary Installer [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#ubi-universal-binary-installer)

Zero-configuration installer that works with any GitHub/GitLab repository following standard conventions:

- **Usage**: `ubi:BurntSushi/ripgrep`
- **Requirements**: Repository must follow standard release tarball conventions
- **Sources**: Primarily GitHub releases, with GitLab support (rarely used in mise)
- **Configuration**: None required - automatically detects and downloads appropriate binaries

#### aqua - Comprehensive Package Manager [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#aqua-comprehensive-package-manager)

Registry-based package manager with strong security features:

- **Usage**: `aqua:golangci/golangci-lint`
- **Requirements**: Tools must be available in the [aqua registry](https://github.com/aquaproj/aqua-registry)
- **Sources**: Primarily GitHub but supports other sources through registry configuration
- **Security**: Comprehensive checksums, signatures, and verification

### Plugin Systems [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#plugin-systems)

Support for external plugin ecosystems:

- **Tool Plugins** \- Hook-based plugins for single tools ( `my-tool`) \- a superset of vfox plugins functionality
- **asdf Plugins** \- Legacy plugin ecosystem ( `asdf:postgres`, `asdf:redis`) \- generally Linux/macOS only
- **Backend Plugins** \- Enhanced plugins using the `plugin:tool` format ( `my-plugin:some-tool`) \- enables private/custom tools with backend methods

## How Backend Selection Works [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#how-backend-selection-works)

When you specify a tool, mise determines the backend using this priority:

1. **Explicit backend**: `mise use aqua:golangci/golangci-lint`
2. **Registry lookup**: `mise use golangci-lint` → checks registry for default backend
3. **Core tools**: `mise use node` → uses built-in core backend
4. **Fallback**: If not found, suggests available backends

The [mise registry](https://mise.jdx.dev/registry.html) defines a priority order for which backend to use for each tool, so typically end-users don't need to know which backend to choose unless they want tools not available in the registry or want to override the default selection.

### Registry System [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#registry-system)

The [registry](https://mise.jdx.dev/registry.html) ( `mise registry`) maps short names to full backend specifications with a preferred priority order:

toml

```
# ~/.config/mise/config.toml
[aliases]
go = "core:go"                    # Use core backend
terraform = "aqua:hashicorp/terraform"  # Use aqua backend
```

## Backend Capabilities Comparison [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#backend-capabilities-comparison)

| Feature | Core | npm/pipx/cargo | ubi | aqua | Backend Plugins | Tool Plugins (vfox) | asdf Plugins (legacy) |
| --- | --- | --- | --- | --- | --- | --- | --- |
| **Speed** | ✅ | ✅ | ✅ | ✅ | ⚠️ | ⚠️ | ⚠️ |
| **Security** | ✅ | ⚠️ | ⚠️ | ✅ | ⚠️ | ⚠️ | ⚠️ |
| **Windows Support** | ✅ | ✅ | ✅ | ✅ | ✅ | ✅ | ❌ |
| **Env Var Support** | ✅ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |
| **Custom Scripts** | ✅ | ❌ | ❌ | ❌ | ✅ | ✅ | ✅ |

## When to Use Each Backend [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#when-to-use-each-backend)

### Use **Core Tools** when [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#use-core-tools-when)

- Available for your tool (check the [registry](https://mise.jdx.dev/registry.html))
- You want the fastest performance
- You're using major programming languages

**Note**: Core tools should generally always be used when available, as they provide the best performance and integration with mise.

### Use **Language Package Managers** when [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#use-language-package-managers-when)

- Installing tools specific to that language ecosystem
- The tool is primarily distributed through that package manager
- You want automatic dependency management

### Use **ubi** when [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#use-ubi-when)

- Installing pre-compiled binaries from GitHub/GitLab releases
- The repository follows standard conventions for release tarballs
- You want zero configuration - no registry setup required
- You need simple, fast binary installation
- The tool doesn't require complex build processes or environment setup

### Use **aqua** when [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#use-aqua-when)

- Installing pre-compiled binaries or static packages (no compilation needed)
- You want comprehensive security features (checksums, signatures)
- You need Windows support
- The tool is already available in the [aqua registry](https://github.com/aquaproj/aqua-registry)
- You're willing to contribute tools to the aqua registry for tools not yet available

### Use **Backend Plugins** when [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#use-backend-plugins-when)

- You need to manage multiple tools with one plugin
- Want enhanced backend methods for better performance
- Need the `plugin:tool` format for flexibility
- Working with custom or private tools
- Want modern plugin architecture with backend methods

### Use **Tool Plugins** when [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#use-tool-plugins-when)

- Creating traditional single-tool plugins
- Need fine-grained control over installation hooks
- Want to use the vfox hook system
- Tool requires complex installation logic or build processes
- Tool requires environment variable setup (like `JAVA_HOME`, `GOROOT`, etc.)
- You need cross-platform support including Windows

### Use **asdf Plugins** when [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#use-asdf-plugins-when)

- Tool requires compilation from source
- Need complex installation logic or build processes
- Tool requires environment variable setup (like `JAVA_HOME`, `GOROOT`, etc.)
- No other backend supports the tool
- Migrating from existing asdf setup
- Working on Linux/macOS (no Windows support)

## Backend Dependencies [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#backend-dependencies)

Some backends have dependencies on others:

mise automatically handles these dependencies, installing Node.js before npm tools, Python before pipx tools, etc.

## Configuration and Overrides [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#configuration-and-overrides)

### Disable Backends [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#disable-backends)

toml

```
# ~/.config/mise/config.toml
[settings]
disable_backends = ["asdf", "vfox"]  # Don't use these backends
```

### Force Backend for Tool [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#force-backend-for-tool)

toml

```
# mise.toml
[tools]
node = "core:node@20"     # Explicitly use core backend
prettier = "npm:prettier" # Use npm backend instead of default
```

### Backend-Specific Settings [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#backend-specific-settings)

Some backends support additional configuration:

toml

```
# mise.toml
[tools]
python = { version = "3.12", virtualenv = ".venv" }  # Core backend options
black = { version = "latest", python = "3.12" }      # pipx backend options
```

## Troubleshooting Backend Issues [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#troubleshooting-backend-issues)

### Debug Backend Selection [​](https://mise.jdx.dev/dev-tools/backend_architecture.html\#debug-backend-selection)

bash

```
mise doctor                   # Check backend configuration
mise tool python              # See which backend is used for a tool
mise config get tools         # Verify tool configurations
```

<|firecrawl-page-111-lllmstxt|>
## Aqua Backend Overview
[Skip to content](https://mise.jdx.dev/dev-tools/backends/aqua.html#VPContent)

Return to top

# Aqua Backend [​](https://mise.jdx.dev/dev-tools/backends/aqua.html\#aqua-backend)

[Aqua](https://aquaproj.github.io/) tools may be used natively in mise. aqua is the ideal backend to use for new tools since they don't require plugins, they work on windows, they offer security features like cosign/slsa verification in addition to checksums. aqua installs also show more progress bars, which is nice.

You do not need to separately install aqua. The aqua CLI is not used in mise at all. What is used is the [aqua registry](https://github.com/aquaproj/aqua-registry) which is a bunch of yaml files that get compiled into the mise binary on release. Here's an example of one of these files: [`aqua:hashicorp/terraform`](https://github.com/aquaproj/aqua-registry/blob/main/pkgs/hashicorp/terraform/registry.yaml). mise has a reimplementation of aqua that knows how to work with these files to install tools.

As of this writing, aqua is relatively new to mise and because a lot of tools are being converted from asdf to aqua, there may be some configuration in aqua tools that need to be tightened up. I put some common issues below and would strongly recommend contributing changes back to the aqua registry if you notice problems. The maintainer is super responsive and great to work with.

If all else fails, you can disable aqua entirely with [`MISE_DISABLE_BACKENDS=aqua`](https://mise.jdx.dev/configuration/settings.html#disable_backends).

Currently aqua tools don't support setting environment variables or doing more than simply downloading binaries though (and I'm not sure this functionality would ever get added), so some tools will likely always require plugins like asdf/vfox.

The code for this is inside the mise repository at [`./src/backend/aqua.rs`](https://github.com/jdx/mise/blob/main/src/backend/aqua.rs).

## Usage [​](https://mise.jdx.dev/dev-tools/backends/aqua.html\#usage)

The following installs the latest version of ripgrep and sets it as the active version on PATH:

sh

```
$ mise use -g aqua:BurntSushi/ripgrep
$ rg --version
ripgrep 14.1.1
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"aqua:BurntSushi/ripgrep" = "latest"
```

Some tools will default to use aqua if they're specified in [registry.toml](https://github.com/jdx/mise/blob/main/registry.toml) to use the aqua backend. To see these tools, run `mise registry | grep aqua:`.

## Settings [​](https://mise.jdx.dev/dev-tools/backends/aqua.html\#settings)

### `aqua.baked_registry`

- Type: `Bool`
- Env: `MISE_AQUA_BAKED_REGISTRY`
- Default: `true`

Use baked-in aqua registry (if compiled in).

### `aqua.cosign`

- Type: `Bool`
- Env: `MISE_AQUA_COSIGN`
- Default: `true`

Use cosign to verify aqua tool signatures.

### `aqua.cosign_extra_args`

- Type: `string[]`(optional)
- Env: `MISE_AQUA_COSIGN_EXTRA_ARGS`
- Default: `None`

Extra arguments to pass to cosign when verifying aqua tool signatures.

### `aqua.minisign`

- Type: `Bool`
- Env: `MISE_AQUA_MINISIGN`
- Default: `true`

Use minisign to verify aqua tool signatures.

### `aqua.registry_url`

- Type: `Url`(optional)
- Env: `MISE_AQUA_REGISTRY_URL`
- Default: `None`

URL to fetch aqua registry from. This is used to install tools from the aqua registry.

By default, the official aqua registry is used: https://github.com/aquaproj/aqua-registry

However when this is not specified, instead of cloning the entire registry each individual tool's metadata is fetched
via HTTP individually.

### `aqua.slsa`

- Type: `Bool`
- Env: `MISE_AQUA_SLSA`
- Default: `true`

Use SLSA to verify aqua tool signatures.

## Common aqua issues [​](https://mise.jdx.dev/dev-tools/backends/aqua.html\#common-aqua-issues)

Here's some common issues I've seen when working with aqua tools.

### Supported env missing [​](https://mise.jdx.dev/dev-tools/backends/aqua.html\#supported-env-missing)

The aqua registry defines supported envs for each tool of the os/arch. I've noticed some of these are simply missing os/arch combos that are in fact supported—possibly because it was added after the registry was created for that tool.

The fix is simple, just edit the `supported_envs` section of `registry.yaml` for the tool in question.

### Using `version_filter` instead of `version_prefix` [​](https://mise.jdx.dev/dev-tools/backends/aqua.html\#using-version-filter-instead-of-version-prefix)

This is a weird one that causes weird issues in mise. In general in mise we like versions like `1.2.3` with no decoration like `v1.2.3` or `cli-v1.2.3`. This consistency not only makes `mise.toml` cleaner but, it also helps make things like `mise up` function right because it's able to parse it as semver without dealing with a bunch of edge-cases.

Really if you notice aqua tools are giving you versions that aren't simple triplets, it's worth fixing.

One common thing I've seen is registries using a `version_filter` expression like `Version startsWith "Version startsWith "atlascli/""`.

This ultimately causes the version to be `atlascli/1.2.3` which is not what we want. The fix is to use `version_prefix` instead of `version_filter` and just put the prefix in the `version_prefix` field. In this example, it would be `atlascli/`. mise will automatically strip this out and add it back in, which it can't do with `version_filter`.

<|firecrawl-page-112-lllmstxt|>
## asdf Backend Overview
[Skip to content](https://mise.jdx.dev/dev-tools/backends/asdf.html#VPContent)

Return to top

# asdf Backend [​](https://mise.jdx.dev/dev-tools/backends/asdf.html\#asdf-backend)

`asdf` is the original backend for mise.

It relies on asdf plugins for each tool. asdf plugins are more risky to use because they're typically written by a single developer unrelated to the tool vendor. They also generally do not function on Windows because they're written in bash which is often not available on Windows and the scripts generally are not written to be cross-platform.

asdf plugins are not used for tools inside the [registry](https://github.com/jdx/mise/blob/main/registry.toml) whenever possible. Sometimes it is not possible to use more secure backends like aqua/ubi because tools have complex install setups or need to export env vars.

All of these are hosted in the mise-plugins org to secure the supply chain so you do not need to rely on plugins maintained by anyone except me.

Because of the extra complexity of asdf tools and security concerns we are actively moving tools in the registry away from asdf where possible to backends like aqua and ubi which don't require plugins. That said, not all tools can function with ubi/aqua if they have a unique installation process or need to set env vars other than `PATH`.

## Writing asdf (legacy) plugins for mise [​](https://mise.jdx.dev/dev-tools/backends/asdf.html\#writing-asdf-legacy-plugins-for-mise)

See the asdf documentation for more information on [writing plugins](https://asdf-vm.com/plugins/create.html).

<|firecrawl-page-113-lllmstxt|>
## Cargo Backend Installation Guide
[Skip to content](https://mise.jdx.dev/dev-tools/backends/cargo.html#VPContent)

Return to top

# Cargo Backend [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#cargo-backend)

You may install packages directly from [Cargo Crates](https://crates.io/) even if there isn't an asdf plugin for it.

The code for this is inside the mise repository at [`./src/backend/cargo.rs`](https://github.com/jdx/mise/blob/main/src/backend/cargo.rs).

## Dependencies [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#dependencies)

This relies on having `cargo` installed. You can either install it on your system via [rustup](https://rustup.rs/):

sh

```
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

Or you can install it via mise:

sh

```
mise use -g rust
```

## Usage [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#usage)

The following installs the latest version of [eza](https://crates.io/crates/eza) and sets it as the active version on PATH:

sh

```
$ mise use -g cargo:eza
$ eza --version
eza - A modern, maintained replacement for ls
v0.17.1 [+git]
https://github.com/eza-community/eza
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"cargo:eza" = "latest"
```

### Using Git [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#using-git)

You can install any package from a Git repository using the `mise` command. This allows you to install a particular tag, branch, or commit revision:

sh

```
# Install a specific tag
mise use cargo:https://github.com/username/demo@tag:<release_tag>

# Install the latest from a branch
mise use cargo:https://github.com/username/demo@branch:<branch_name>

# Install a specific commit revision
mise use cargo:https://github.com/username/demo@rev:<commit_hash>
```

This will execute a `cargo install` command with the corresponding Git options.

## Settings [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#settings)

Set these with `mise settings set [VARIABLE] [VALUE]` or by setting the environment variable listed.

### `cargo.binstall`

- Type: `Bool`
- Env: `MISE_CARGO_BINSTALL`
- Default: `true`

If true, mise will use `cargo binstall` instead of `cargo install` if
[`cargo-binstall`](https://crates.io/crates/cargo-binstall) is installed and on PATH.
This makes installing CLIs with cargo _much_ faster by downloading precompiled binaries.

You can install it with mise:

```sh
mise use -g cargo-binstall

```

### `cargo.registry_name`

- Type: `string`(optional)
- Env: `MISE_CARGO_REGISTRY_NAME`
- Default: `None`

Packages are installed from the official cargo registry.

You can set this to a different registry name if you have a custom feed or want to use a different source.

Please follow the [cargo alternative registries documentation](https://doc.rust-lang.org/cargo/reference/registries.html#using-an-alternate-registry) to configure your registry.

## Tool Options [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `cargo` backend—these go in `[tools]` in `mise.toml`.

### `features` [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#features)

Install additional components (passed as `cargo install --features`):

toml

```
[tools]
"cargo:cargo-edit" = { version = "latest", features = "add" }
```

### `default-features` [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#default-features)

Disable default features (passed as `cargo install --no-default-features`):

toml

```
[tools]
"cargo:cargo-edit" = { version = "latest", default-features = false }
```

### `bin` [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#bin)

Select the CLI bin name to install when multiple are available (passed as `cargo install --bin`):

toml

```
[tools]
"cargo:https://github.com/username/demo" = { version = "tag:v1.0.0", bin = "demo" }
```

### `crate` [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#crate)

Select the crate name to install when multiple are available (passed as `cargo install --git=<repo> <crate>`):

toml

```
[tools]
"cargo:https://github.com/username/demo" = { version = "tag:v1.0.0", crate = "demo" }
```

### `locked` [​](https://mise.jdx.dev/dev-tools/backends/cargo.html\#locked)

Use Cargo.lock (passes `cargo install --locked`) when building CLI. This is the default behavior, pass `false` to disable:

toml

```
[tools]
"cargo:https://github.com/username/demo" = { version = "latest", locked = false }
```

<|firecrawl-page-114-lllmstxt|>
## Dotnet Backend Tools
[Skip to content](https://mise.jdx.dev/dev-tools/backends/dotnet.html#VPContent)

Return to top

# Dotnet backend [​](https://mise.jdx.dev/dev-tools/backends/dotnet.html\#dotnet-backend)

The code for this is inside the mise repository at [`./src/backend/dotnet.rs`](https://github.com/jdx/mise/blob/main/src/backend/dotnet.rs).

Important

The dotnet backend requires having the .NET runtime installed. You can install it using mise:

sh

```
# Install the latest version
mise use dotnet

# Or install a specific version (8, 9, etc.)
mise use dotnet@8
mise use dotnet@9
```

This will install the .NET runtime, which is required for dotnet tools to work properly.

## Usage [​](https://mise.jdx.dev/dev-tools/backends/dotnet.html\#usage)

The following installs the latest version of [GitVersion.Tool](https://gitversion.net/) and sets it as the active version on PATH:

sh

```
$ mise use dotnet:GitVersion.Tool@5.12.0
$ dotnet-gitversion /version
5.12.0+Branch.support-5.x.Sha.3f75764963eb3d7956dcd5a40488c074dd9faf9e
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"dotnet:GitVersion.Tool" = "5.12.0"
```

sh

```
$ mise use dotnet:GitVersion.Tool
$ dotnet-gitversion /version
6.1.0+Branch.main.Sha.8856e3041dbb768118a55a31ad4e465ae70c6767
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"dotnet:GitVersion.Tool" = "latest"
```

### Supported Dotnet Syntax [​](https://mise.jdx.dev/dev-tools/backends/dotnet.html\#supported-dotnet-syntax)

| Description | Usage |
| --- | --- |
| Dotnet shorthand latest version | `dotnet:GitVersion.Tool` |
| Dotnet shorthand for specific version | `dotnet:GitVersion.Tool@5.12.0` |

## Settings [​](https://mise.jdx.dev/dev-tools/backends/dotnet.html\#settings)

Set these with `mise settings set [VARIABLE] [VALUE]` or by setting the environment variable listed.

### `dotnet.package_flags`

- Type: `string[]`
- Env: `MISE_DOTNET_PACKAGE_FLAGS`(comma separated)
- Default: `[]`

This is a list of flags to extend the search and install abilities of dotnet tools.

Here are the available flags:

- 'prerelease' : include prerelease versions in search and install

### `dotnet.registry_url`

- Type: `Url`
- Env: `MISE_DOTNET_REGISTRY_URL`
- Default: `https://api.nuget.org/v3/index.json`

URL to fetch dotnet tools from. This is used when installing dotnet tools.

By default, mise will use the [nuget](https://api.nuget.org/v3/index.json) API to fetch.

However, you can set this to a different URL if you have a custom feed or want to use a different source.

## Tool Options [​](https://mise.jdx.dev/dev-tools/backends/dotnet.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `dotnet` backend—these go in `[tools]` in `mise.toml`.

<|firecrawl-page-115-lllmstxt|>
## Gem Backend Guide
[Skip to content](https://mise.jdx.dev/dev-tools/backends/gem.html#VPContent)

Return to top

# gem Backend [​](https://mise.jdx.dev/dev-tools/backends/gem.html\#gem-backend)

mise can be used to install CLIs from RubyGems. The code for this is inside of the mise repository at [`./src/backend/gem.rs`](https://github.com/jdx/mise/blob/main/src/backend/gem.rs).

## Dependencies [​](https://mise.jdx.dev/dev-tools/backends/gem.html\#dependencies)

This relies on having `gem` (provided with ruby) installed. You can install it with or without mise. Here is how to install `ruby` with mise:

sh

```
mise use -g ruby
```

## Usage [​](https://mise.jdx.dev/dev-tools/backends/gem.html\#usage)

The following installs the latest version of [rubocop](https://rubygems.org/gems/rubocop) and sets it as the active version on PATH:

sh

```
mise use -g gem:rubocop
rubocop --version
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"gem:rubocop" = "latest"
```

## Ruby upgrades [​](https://mise.jdx.dev/dev-tools/backends/gem.html\#ruby-upgrades)

If the ruby version used by a gem package changes, (by mise or system ruby), you may need to reinstall the gem. This can be done with:

sh

```
mise install -f gem:rubocop
```

Or you can reinstall all gems with:

sh

```
mise install -f "gem:*"
```

## Settings [​](https://mise.jdx.dev/dev-tools/backends/gem.html\#settings)

Set these with `mise settings set [VARIABLE] [VALUE]` or by setting the environment variable listed.

No settings available.

<|firecrawl-page-116-lllmstxt|>
## GitHub Backend Installation
[Skip to content](https://mise.jdx.dev/dev-tools/backends/github.html#VPContent)

Return to top

# GitHub Backend [​](https://mise.jdx.dev/dev-tools/backends/github.html\#github-backend)

You may install GitHub release assets directly using the `github` backend. This backend downloads release assets from GitHub repositories and is ideal for tools that distribute pre-built binaries through GitHub releases.

The code for this is inside of the mise repository at [`./src/backend/github.rs`](https://github.com/jdx/mise/blob/main/src/backend/github.rs).

## Usage [​](https://mise.jdx.dev/dev-tools/backends/github.html\#usage)

The following installs the latest version of ripgrep from GitHub releases and sets it as the active version on PATH:

sh

```
$ mise use -g github:BurntSushi/ripgrep
$ rg --version
ripgrep 14.1.1
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"github:BurntSushi/ripgrep" = "latest"
```

## Tool Options [​](https://mise.jdx.dev/dev-tools/backends/github.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `github` backend—these go in `[tools]` in `mise.toml`.

### Asset Autodetection [​](https://mise.jdx.dev/dev-tools/backends/github.html\#asset-autodetection)

When no `asset_pattern` is specified, mise automatically selects the best asset for your platform. The system scores assets based on:

- **OS compatibility** (linux, macos, windows)
- **Architecture compatibility** (x64, arm64, x86, arm)
- **Libc variant** (gnu or musl, for Linux)
- **Archive format preference** (tar.gz, zip, etc.)
- **Build type** (avoids debug/test builds)

For most tools, you can simply install without specifying patterns:

sh

```
mise install github:user/repo
```

TIP

The autodetection logic is implemented in [`src/backend/asset_detector.rs`](https://github.com/jdx/mise/blob/main/src/backend/asset_detector.rs), which is shared by both the GitHub and GitLab backends.

### `asset_pattern` [​](https://mise.jdx.dev/dev-tools/backends/github.html\#asset-pattern)

Specifies the pattern to match against release asset names. This is useful when there are multiple assets for your OS/arch combination or when you need to override autodetection.

toml

```
[tools]
"github:cli/cli" = { version = "latest", asset_pattern = "gh_*_linux_x64.tar.gz" }
```

### `version_prefix` [​](https://mise.jdx.dev/dev-tools/backends/github.html\#version-prefix)

Specifies a custom version prefix for release tags. By default, mise handles the common `v` prefix (e.g., `v1.0.0`), but some repositories use different prefixes like `release-`, `version-`, or no prefix at all.

When `version_prefix` is configured, mise will:

- Strip the prefix when listing available versions
- Add the prefix when searching for releases
- Try both prefixed and non-prefixed versions during installation

toml

```
[tools]
"github:user/repo" = { version = "latest", version_prefix = "release-" }
```

**Examples:**

- With `version_prefix = "release-"`:
  - User specifies `1.0.0` → mise searches for `release-1.0.0` tag
  - Available versions show as `1.0.0` (prefix stripped)
- With `version_prefix = ""` (empty string):
  - User specifies `1.0.0` → mise searches for `1.0.0` tag (no prefix)
  - Useful for repositories that don't use any prefix

### Platform-specific Asset Patterns [​](https://mise.jdx.dev/dev-tools/backends/github.html\#platform-specific-asset-patterns)

For different asset patterns per platform:

toml

```
[tools."github:cli/cli"]
version = "latest"

[tools."github:cli/cli".platforms]
linux-x64 = { asset_pattern = "gh_*_linux_x64.tar.gz" }
macos-arm64 = { asset_pattern = "gh_*_macOS_arm64.tar.gz" }
```

### `checksum` [​](https://mise.jdx.dev/dev-tools/backends/github.html\#checksum)

Verify the downloaded file with a checksum:

toml

```
[tools."github:owner/repo"]
version = "1.0.0"
asset_pattern = "tool-1.0.0-x64.tar.gz"
checksum = "sha256:a1b2c3d4e5f6789..."
```

_Instead of specifying the checksum here, you can use [mise.lock](https://mise.jdx.dev/dev-tools/mise-lock.html) to manage checksums._

### Platform-specific Checksums [​](https://mise.jdx.dev/dev-tools/backends/github.html\#platform-specific-checksums)

toml

```
[tools."github:cli/cli"]
version = "latest"

[tools."github:cli/cli".platforms]
linux-x64 = { asset_pattern = "gh_*_linux_x64.tar.gz", checksum = "sha256:a1b2c3d4e5f6789..." }
macos-arm64 = { asset_pattern = "gh_*_macOS_arm64.tar.gz", checksum = "sha256:b2c3d4e5f6789..." }
```

### `size` [​](https://mise.jdx.dev/dev-tools/backends/github.html\#size)

Verify the downloaded asset size:

toml

```
[tools]
"github:cli/cli" = { version = "latest", size = "12345678" }
```

### `strip_components` [​](https://mise.jdx.dev/dev-tools/backends/github.html\#strip-components)

Number of directory components to strip when extracting archives:

toml

```
[tools]
"github:cli/cli" = { version = "latest", strip_components = 1 }
```

INFO

If `strip_components` is not explicitly set, mise will automatically detect when to apply `strip_components = 1`. This happens when the extracted archive contains exactly one directory at the root level and no files. This is common with tools like ripgrep that package their binaries in a versioned directory (e.g., `ripgrep-14.1.0-x86_64-unknown-linux-musl/rg`). The auto-detection ensures the binary is placed directly in the install path where mise expects it.

### `bin_path` [​](https://mise.jdx.dev/dev-tools/backends/github.html\#bin-path)

Specify the directory containing binaries within the extracted archive, or where to place the downloaded file. This supports templating with `{name}`, `{version}`, `{os}`, `{arch}`, and `{ext}`:

toml

```
[tools."github:cli/cli"]
version = "latest"
bin_path = "{name}-{version}/bin" # expands to cli-1.0.0/bin
```

**Binary path lookup order:**

1. If `bin_path` is specified, use that directory
2. If `bin_path` is not set, look for a `bin/` directory in the install path
3. If no `bin/` directory exists, search subdirectories for `bin/` directories
4. If no `bin/` directories are found, use the root of the extracted directory

### `api_url` [​](https://mise.jdx.dev/dev-tools/backends/github.html\#api-url)

For GitHub Enterprise or self-hosted GitHub instances, specify the API URL:

toml

```
[tools]
"github:myorg/mytool" = { version = "latest", api_url = "https://github.mycompany.com/api/v3" }
```

## Self-hosted GitHub [​](https://mise.jdx.dev/dev-tools/backends/github.html\#self-hosted-github)

If you are using a self-hosted GitHub instance, set the `api_url` tool option and optionally the `MISE_GITHUB_ENTERPRISE_TOKEN` environment variable for authentication:

sh

```
export MISE_GITHUB_ENTERPRISE_TOKEN="your-token"
```

## Supported GitHub Syntax [​](https://mise.jdx.dev/dev-tools/backends/github.html\#supported-github-syntax)

- **GitHub shorthand for latest release version:** `github:cli/cli`
- **GitHub shorthand for specific release version:** `github:cli/cli@2.40.1`

## Settings [​](https://mise.jdx.dev/dev-tools/backends/github.html\#settings)

No settings available.

<|firecrawl-page-117-lllmstxt|>
## GitLab Backend Installation Guide
[Skip to content](https://mise.jdx.dev/dev-tools/backends/gitlab.html#VPContent)

Return to top

# GitLab Backend [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#gitlab-backend)

You may install GitLab release assets directly using the `gitlab` backend. This backend downloads release assets from GitLab repositories and is ideal for tools that distribute pre-built binaries through GitLab releases.

The code for this is inside of the mise repository at [`./src/backend/gitlab.rs`](https://github.com/jdx/mise/blob/main/src/backend/gitlab.rs).

## Usage [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#usage)

The following installs the latest version of gitlab-runner from GitLab releases and sets it as the active version on PATH:

sh

```
$ mise use -g gitlab:gitlab-org/gitlab-runner
$ gitlab-runner --version
gitlab-runner 16.8.0
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"gitlab:gitlab-org/gitlab-runner" = { version = "latest", asset_pattern = "gitlab-runner-linux-x64" }
```

## Tool Options [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `gitlab` backend—these go in `[tools]` in `mise.toml`.

### Asset Autodetection [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#asset-autodetection)

When no `asset_pattern` is specified, mise automatically selects the best asset for your platform. The system scores assets based on:

- **OS compatibility** (linux, macos, windows)
- **Architecture compatibility** (x64, arm64, x86, arm)
- **Libc variant** (gnu or musl, for Linux)
- **Archive format preference** (tar.gz, zip, etc.)
- **Build type** (avoids debug/test builds)

For most tools, you can simply install without specifying patterns:

sh

```
mise install gitlab:user/repo
```

TIP

The autodetection logic is implemented in [`src/backend/asset_detector.rs`](https://github.com/jdx/mise/blob/main/src/backend/asset_detector.rs), which is shared by both the GitHub and GitLab backends.

### `asset_pattern` [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#asset-pattern)

Specifies the pattern to match against release asset names. This is useful when there are multiple assets for your OS/arch combination or when you need to override autodetection.

toml

```
[tools."gitlab:gitlab-org/gitlab-runner"]
version = "latest"
asset_pattern = "gitlab-runner-linux-x64"
```

### `version_prefix` [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#version-prefix)

Specifies a custom version prefix for release tags. By default, mise handles the common `v` prefix (e.g., `v1.0.0`), but some repositories use different prefixes like `release-`, `version-`, or no prefix at all.

When `version_prefix` is configured, mise will:

- Strip the prefix when listing available versions
- Add the prefix when searching for releases
- Try both prefixed and non-prefixed versions during installation

toml

```
[tools]
"gitlab:user/repo" = { version = "latest", version_prefix = "release-" }
```

**Examples:**

- With `version_prefix = "release-"`:
  - User specifies `1.0.0` → mise searches for `release-1.0.0` tag
  - Available versions show as `1.0.0` (prefix stripped)
- With `version_prefix = ""` (empty string):
  - User specifies `1.0.0` → mise searches for `1.0.0` tag (no prefix)
  - Useful for repositories that don't use any prefix

### Platform-specific Asset Patterns [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#platform-specific-asset-patterns)

For different asset patterns per platform:

toml

```
[tools."gitlab:gitlab-org/gitlab-runner"]
version = "latest"

[tools."gitlab:gitlab-org/gitlab-runner".platforms]
linux-x64 = { asset_pattern = "gitlab-runner-linux-x64" }
macos-arm64 = { asset_pattern = "gitlab-runner-macos-arm64" }
```

### `checksum` [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#checksum)

Verify the downloaded file with a checksum:

toml

```
[tools."gitlab:owner/repo"]
version = "1.0.0"
asset_pattern = "tool-1.0.0-x64.tar.gz"
checksum = "sha256:a1b2c3d4e5f6789..."
```

_Instead of specifying the checksum here, you can use [mise.lock](https://mise.jdx.dev/dev-tools/mise-lock.html) to manage checksums._

### Platform-specific Checksums [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#platform-specific-checksums)

toml

```
[tools."gitlab:gitlab-org/gitlab-runner"]
version = "latest"

[tools."gitlab:gitlab-org/gitlab-runner".platforms]
linux-x64 = { asset_pattern = "gitlab-runner-linux-x64", checksum = "sha256:a1b2c3d4e5f6789..." }
macos-arm64 = { asset_pattern = "gitlab-runner-macos-arm64", checksum = "sha256:b2c3d4e5f6789..." }
```

### `size` [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#size)

Verify the downloaded asset size:

toml

```
[tools]
"gitlab:gitlab-org/gitlab-runner" = { version = "latest", size = "12345678" }
```

### Platform-specific Size [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#platform-specific-size)

You can specify different sizes for different platforms:

toml

```
[tools."gitlab:gitlab-org/gitlab-runner"]
version = "latest"

[tools."gitlab:gitlab-org/gitlab-runner".platforms]
linux-x64 = { size = "12345678" }
macos-arm64 = { size = "9876543" }
```

### `strip_components` [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#strip-components)

Number of directory components to strip when extracting archives:

toml

```
[tools]
"gitlab:gitlab-org/gitlab-runner" = { version = "latest", strip_components = 1 }
```

INFO

If `strip_components` is not explicitly set, mise will automatically detect when to apply `strip_components = 1`. This happens when the extracted archive contains exactly one directory at the root level and no files. This is common with tools like ripgrep that package their binaries in a versioned directory (e.g., `ripgrep-14.1.0-x86_64-unknown-linux-musl/rg`). The auto-detection ensures the binary is placed directly in the install path where mise expects it.

### `bin_path` [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#bin-path)

Specify the directory containing binaries within the extracted archive, or where to place the downloaded file. This supports templating with `{name}`, `{version}`, `{os}`, `{arch}`, and `{ext}`:

toml

```
[tools."gitlab:gitlab-org/gitlab-runner"]
version = "latest"
bin_path = "{name}-{version}/bin" # expands to gitlab-runner-1.0.0/bin
```

**Binary path lookup order:**

1. If `bin_path` is specified, use that directory
2. If `bin_path` is not set, look for a `bin/` directory in the install path
3. If no `bin/` directory exists, search subdirectories for `bin/` directories
4. If no `bin/` directories are found, use the root of the extracted directory

### `api_url` [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#api-url)

For self-hosted GitLab instances, specify the API URL:

toml

```
[tools]
"gitlab:myorg/mytool" = { version = "latest", api_url = "https://gitlab.mycompany.com/api/v4" }
```

## Self-hosted GitLab [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#self-hosted-gitlab)

If you are using a self-hosted GitLab instance, set the `api_url` tool option and optionally the `MISE_GITLAB_ENTERPRISE_TOKEN` environment variable for authentication:

sh

```
export MISE_GITLAB_ENTERPRISE_TOKEN="your-token"
```

## Supported GitLab Syntax [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#supported-gitlab-syntax)

- **GitLab shorthand for latest release version:** `gitlab:gitlab-org/gitlab-runner`
- **GitLab shorthand for specific release version:** `gitlab:gitlab-org/gitlab-runner@16.8.0`

## Settings [​](https://mise.jdx.dev/dev-tools/backends/gitlab.html\#settings)

No settings available.

<|firecrawl-page-118-lllmstxt|>
## Go Backend Installation Guide
[Skip to content](https://mise.jdx.dev/dev-tools/backends/go.html#VPContent)

Return to top

# Go Backend experimental [​](https://mise.jdx.dev/dev-tools/backends/go.html\#go-backend)

You may install packages directly via [go install](https://go.dev/doc/install) even if there isn't an asdf plugin for it.

The code for this is inside of the mise repository at [`./src/backend/go.rs`](https://github.com/jdx/mise/blob/main/src/backend/go.rs).

## Dependencies [​](https://mise.jdx.dev/dev-tools/backends/go.html\#dependencies)

This relies on having `go` installed. Which you can install via mise:

sh

```
mise use -g go
```

TIP

Any method of installing `go` is fine if you want to install go some other way. mise will use whatever `go` is on PATH.

## Usage [​](https://mise.jdx.dev/dev-tools/backends/go.html\#usage)

The following installs the latest version of [hivemind](https://github.com/DarthSim/hivemind) and sets it as the active version on PATH:

sh

```
$ mise use -g go:github.com/DarthSim/hivemind
$ hivemind --help
Hivemind version 1.1.0
```

## Tool Options [​](https://mise.jdx.dev/dev-tools/backends/go.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `go` backend—these go in `[tools]` in `mise.toml`.

### `tags` [​](https://mise.jdx.dev/dev-tools/backends/go.html\#tags)

Specify go build tags (passed as `go install --tags`):

toml

```
[tools]
"go:github.com/golang-migrate/migrate/v4/cmd/migrate" = { version = "latest", tags = "postgres" }
```

<|firecrawl-page-119-lllmstxt|>
## HTTP Backend Installation Guide
[Skip to content](https://mise.jdx.dev/dev-tools/backends/http.html#VPContent)

Return to top

# HTTP Backend experimental [​](https://mise.jdx.dev/dev-tools/backends/http.html\#http-backend)

You may install tools directly from HTTP URLs using the `http` backend. This backend downloads files from any HTTP/HTTPS URL and is ideal for tools that distribute pre-built binaries or archives through direct download links.

The code for this is inside of the mise repository at [`./src/backend/http.rs`](https://github.com/jdx/mise/blob/main/src/backend/http.rs).

## Usage [​](https://mise.jdx.dev/dev-tools/backends/http.html\#usage)

The following installs a tool from a direct HTTP URL:

sh

```
mise use -g http:my-tool[url=https://example.com/releases/my-tool-v1.0.0.tar.gz]@1.0.0
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"http:my-tool" = { version = "1.0.0", url = "https://example.com/releases/my-tool-v1.0.0.tar.gz" }
```

## Supported HTTP Syntax [​](https://mise.jdx.dev/dev-tools/backends/http.html\#supported-http-syntax)

- **HTTP with URL parameter:** `http:my-tool[url=https://example.com/releases/my-tool-v1.0.0.tar.gz]@1.0.0`

## Tool Options [​](https://mise.jdx.dev/dev-tools/backends/http.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `http` backend—these go in `[tools]` in `mise.toml`.

### `url` (Required) [​](https://mise.jdx.dev/dev-tools/backends/http.html\#url-required)

Specifies the HTTP URL to download the tool from. The URL supports templating with ``:

toml

```
[tools]
"http:my-tool" = { version = "1.0.0", url = "https://example.com/releases/my-tool-v{{version}}.tar.gz" }
```

You can also use static URLs without templating:

toml

```
[tools]
"http:my-tool" = { version = "1.0.0", url = "https://example.com/releases/my-tool-v1.0.0.tar.gz" }
```

### Platform-specific URLs [​](https://mise.jdx.dev/dev-tools/backends/http.html\#platform-specific-urls)

For tools that need different downloads per platform, use the table format:

toml

```
[tools."http:my-tool"]
version = "1.0.0"

[tools."http:my-tool".platforms]
macos-x64 = { url = "https://example.com/releases/my-tool-v1.0.0-macos-x64.tar.gz" }
macos-arm64 = { url = "https://example.com/releases/my-tool-v1.0.0-macos-arm64.tar.gz" }
linux-x64 = { url = "https://example.com/releases/my-tool-v1.0.0-linux-x64.tar.gz" }
```

TIP

You can use either `macos` or `darwin`, and `x64` or `amd64` for platform keys. `macos` and `x64` are preferred in documentation and examples, but all variants are accepted.

OS/architecture values use mise's conventions: `linux`, `macos`, `windows` for operating systems and `x64`, `arm64` for architectures. For platform-specific URLs, use the appropriate platform key (e.g., `macos-x64`, `linux-arm64`) and specify the full URL for each platform.

If you mess up and use something like `darwin-aarch64` mise will try to figure out what you meant and do the right thing anyhow.

### `checksum` [​](https://mise.jdx.dev/dev-tools/backends/http.html\#checksum)

Verify the downloaded file with a checksum:

toml

```
[tools."http:my-tool"]
version = "1.0.0"
url = "https://example.com/releases/my-tool-v1.0.0.tar.gz"
checksum = "sha256:a1b2c3d4e5f6789..."
```

_Instead of specifying the checksum here, you can use [mise.lock](https://mise.jdx.dev/dev-tools/mise-lock.html) to manage checksums._

### Platform-specific Checksums [​](https://mise.jdx.dev/dev-tools/backends/http.html\#platform-specific-checksums)

toml

```
[tools."http:my-tool"]
version = "1.0.0"

[tools."http:my-tool".platforms]
macos-x64 = { url = "https://example.com/releases/my-tool-v1.0.0-macos-x64.tar.gz", checksum = "sha256:a1b2c3d4e5f6789..." }
macos-arm64 = { url = "https://example.com/releases/my-tool-v1.0.0-macos-arm64.tar.gz", checksum = "sha256:b2c3d4e5f6789..." }
linux-x64 = { url = "https://example.com/releases/my-tool-v1.0.0-linux-x64.tar.gz", checksum = "sha256:c3d4e5f6789..." }
```

### `size` [​](https://mise.jdx.dev/dev-tools/backends/http.html\#size)

Verify the downloaded file size:

toml

```
[tools."http:my-tool"]
version = "1.0.0"
url = "https://example.com/releases/my-tool-v1.0.0.tar.gz"
size = "12345678"
```

### Platform-specific Size [​](https://mise.jdx.dev/dev-tools/backends/http.html\#platform-specific-size)

You can specify different sizes for different platforms:

toml

```
[tools."http:my-tool"]
version = "1.0.0"

[tools."http:my-tool".platforms]
macos-x64 = { url = "https://example.com/releases/my-tool-v1.0.0-macos-x64.tar.gz", size = "12345678" }
macos-arm64 = { url = "https://example.com/releases/my-tool-v1.0.0-macos-arm64.tar.gz", size = "9876543" }
linux-x64 = { url = "https://example.com/releases/my-tool-v1.0.0-linux-x64.tar.gz", size = "11111111" }
```

### `strip_components` [​](https://mise.jdx.dev/dev-tools/backends/http.html\#strip-components)

Number of directory components to strip when extracting archives:

toml

```
[tools."http:my-tool"]
version = "1.0.0"
url = "https://example.com/releases/my-tool-v1.0.0.tar.gz"
strip_components = 1
```

INFO

If `strip_components` is not explicitly set, mise will automatically detect when to apply `strip_components = 1`. This happens when the extracted archive contains exactly one directory at the root level and no files. This is common with tools like ripgrep that package their binaries in a versioned directory (e.g., `ripgrep-14.1.0-x86_64-unknown-linux-musl/rg`). The auto-detection ensures the binary is placed directly in the install path where mise expects it.

### `bin_path` [​](https://mise.jdx.dev/dev-tools/backends/http.html\#bin-path)

Specify the directory containing binaries within the extracted archive, or where to place the downloaded file. This supports templating with ``:

toml

```
[tools."http:my-tool"]
version = "1.0.0"
url = "https://example.com/releases/my-tool-v1.0.0.tar.gz"
bin_path = "my-tool-{{version}}/bin" # expands to my-tool-1.0.0/bin
```

**Binary path lookup order:**

1. If `bin_path` is specified, use that directory
2. If `bin_path` is not set, look for a `bin/` directory in the install path
3. If no `bin/` directory exists, search subdirectories for `bin/` directories
4. If no `bin/` directories are found, use the root of the extracted directory

## Caching Behavior [​](https://mise.jdx.dev/dev-tools/backends/http.html\#caching-behavior)

The HTTP backend implements an intelligent caching system to optimize disk usage and installation speed:

### Cache Location [​](https://mise.jdx.dev/dev-tools/backends/http.html\#cache-location)

Downloaded and extracted files are cached in `$MISE_CACHE_DIR/http-tarballs/` instead of being stored separately for each tool installation. By default:

- **Linux**: `~/.cache/mise/http-tarballs/`
- **macOS**: `~/Library/Caches/mise/http-tarballs/`

### Cache Key Generation [​](https://mise.jdx.dev/dev-tools/backends/http.html\#cache-key-generation)

Cache keys are generated based on the file content to ensure identical downloads are shared across tools:

1. **Blake3 hash of file content**: When no checksum is provided, mise calculates a Blake3 hash of the downloaded file
2. **Extraction options**: `strip_components` is included in the cache key since it affects the extracted structure

Example cache directory structure:

```
~/.cache/mise/http-tarballs/
├── 71f774faa03daf1a58cc3339f8c73e6557348c8e0a2f3fb8148cc26e26bad83f/
│   ├── extracted/
│   │   └── bin/my-tool
│   └── metadata.json
└── 1c2af379bdf1fed266bc44b49271e2df5b0dafae09f1cc744b3505ec50c84719_strip_1/
    ├── extracted/
    │   └── my-tool
    └── metadata.json
```

### Symlinked Installations [​](https://mise.jdx.dev/dev-tools/backends/http.html\#symlinked-installations)

Tool installations are symlinks to the cached extracted content:

bash

```
~/.local/share/mise/installs/http-my-tool/1.0.0 → ~/.cache/mise/http-tarballs/71f774.../extracted
```

This approach provides several benefits:

- **Space efficiency**: Multiple tools using the same tarball share a single cached copy
- **Faster installations**: Cache hits avoid re-downloading and re-extracting files
- **Consistency**: Identical file content always uses the same cache entry

### Cache Metadata [​](https://mise.jdx.dev/dev-tools/backends/http.html\#cache-metadata)

Each cache entry includes a `metadata.json` file with information about the cached content:

json

```
{
  "url": "https://example.com/releases/my-tool-v1.0.0.tar.gz",
  "checksum": "sha256:a1b2c3d4e5f6789...",
  "size": 1024000,
  "extracted_at": 1703001234,
  "platform": "macos-arm64"
}
```

### Cache Management [​](https://mise.jdx.dev/dev-tools/backends/http.html\#cache-management)

The HTTP backend cache follows mise's standard cache management:

- Cache entries can be cleared with `mise cache clear`
- The cache directory respects the `MISE_CACHE_DIR` environment variable
- **Autopruner**: mise automatically cleans up unused cache entries after 30 days of inactivity
- Manual cleanup is available with `mise cache clear` if needed

<|firecrawl-page-120-lllmstxt|>
## Object Not Found
# Error 404

### Object not found

This object does not exist or is not publicly accessible at this
URL. Check the URL of the object that you're looking for or contact
the owner to enable Public access.


Is this your bucket?

Learn how to enable
[Public Access](https://developers.cloudflare.com/r2/data-access/public-buckets/)

<|firecrawl-page-121-lllmstxt|>
## npm Backend Installation Guide
[Skip to content](https://mise.jdx.dev/dev-tools/backends/npm.html#VPContent)

Return to top

# npm Backend [​](https://mise.jdx.dev/dev-tools/backends/npm.html\#npm-backend)

You may install packages directly from [npmjs.org](https://npmjs.org/) even if there isn't an asdf plugin for it.

The code for this is inside of the mise repository at [`./src/backend/npm.rs`](https://github.com/jdx/mise/blob/main/src/backend/npm.rs).

## Dependencies [​](https://mise.jdx.dev/dev-tools/backends/npm.html\#dependencies)

This relies on having `npm` installed. You can install it with or without mise. Here is how to install `npm` with mise:

sh

```
mise use -g node
```

## Usage [​](https://mise.jdx.dev/dev-tools/backends/npm.html\#usage)

The following installs the latest version of [prettier](https://www.npmjs.com/package/prettier) and sets it as the active version on PATH:

sh

```
$ mise use -g npm:prettier
$ prettier --version
3.1.0
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"npm:prettier" = "latest"
```

## Settings [​](https://mise.jdx.dev/dev-tools/backends/npm.html\#settings)

Set these with `mise settings set [VARIABLE] [VALUE]` or by setting the environment variable listed.

### `npm.bun`

- Type: `Bool`
- Env: `MISE_NPM_BUN`
- Default: `false`

If true, mise will use `bun` instead of `npm` if
[`bun`](https://bun.sh/) is installed and on PATH.
This makes installing CLIs faster by using `bun` as the package manager.

You can install it with mise:

```sh
mise use -g bun

```

<|firecrawl-page-122-lllmstxt|>
## SPM Backend Installation Guide
[Skip to content](https://mise.jdx.dev/dev-tools/backends/spm.html#VPContent)

Return to top

# SPM Backend experimental [​](https://mise.jdx.dev/dev-tools/backends/spm.html\#spm-backend)

You may install executables managed by [Swift Package Manager](https://www.swift.org/documentation/package-manager) directly from GitHub releases.

The code for this is inside of the mise repository at [`./src/backend/spm.rs`](https://github.com/jdx/mise/blob/main/src/backend/spm.rs).

## Dependencies [​](https://mise.jdx.dev/dev-tools/backends/spm.html\#dependencies)

This relies on having `swift` installed. You can either install it [manually](https://www.swift.org/install) or [with mise](https://mise.jdx.dev/lang/swift.html).

NOTE

If you have Xcode installed and selected in your system via `xcode-select`, Swift is already available through the toolchain embedded in the Xcode installation.

## Usage [​](https://mise.jdx.dev/dev-tools/backends/spm.html\#usage)

The following installs the latest version of `tuist` and sets it as the active version on PATH:

sh

```
$ mise use -g spm:tuist/tuist
$ tuist --help
OVERVIEW: Generate, build and test your Xcode projects.

USAGE: tuist <subcommand>
...
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"spm:tuist/tuist" = "latest"
```

### Supported Syntax [​](https://mise.jdx.dev/dev-tools/backends/spm.html\#supported-syntax)

| Description | Usage |
| --- | --- |
| GitHub shorthand for latest release version | `spm:tuist/tuist` |
| GitHub shorthand for specific release version | `spm:tuist/tuist@4.15.0` |
| GitHub url for latest release version | `spm:https://github.com/tuist/tuist.git` |
| GitHub url for specific release version | `spm:https://github.com/tuist/tuist.git@4.15.0` |

Other syntax may work but is unsupported and untested.

<|firecrawl-page-123-lllmstxt|>
## Ubi Backend Installation Guide
[Skip to content](https://mise.jdx.dev/dev-tools/backends/ubi.html#VPContent)

Return to top

# Ubi Backend [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#ubi-backend)

You may install GitHub Releases and URL packages directly using [ubi](https://github.com/houseabsolute/ubi) backend. ubi is directly compiled into the mise codebase so it does not need to be installed separately to be used. ubi is preferred over plugins for new tools since it doesn't require a plugin, supports Windows, and is really easy to use.

ubi doesn't require plugins or even any configuration for each tool. What it does is try to deduce what the proper binary/tarball is from GitHub releases and downloads the right one. As long as the vendor uses a somewhat standard labeling scheme for their releases, ubi should be able to figure it out.

The code for this is inside of the mise repository at [`./src/backend/ubi.rs`](https://github.com/jdx/mise/blob/main/src/backend/ubi.rs).

## Usage [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#usage)

The following installs the latest version of goreleaser and sets it as the active version on PATH:

sh

```
$ mise use -g ubi:goreleaser/goreleaser
$ goreleaser --version
1.25.1
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"ubi:goreleaser/goreleaser" = "latest"
```

## Tool Options [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `ubi` backend—these go in `[tools]` in `mise.toml`.

### `exe` [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#exe)

The `exe` option allows you to specify the executable name in the archive. This is useful when the archive contains multiple executables.

If you get an error like `could not find any files named cli in the downloaded zip file`, you can use the `exe` option to specify the executable name:

toml

```
[tools]
"ubi:cli/cli" = { version = "latest", exe = "gh" } # github's cli
```

### `rename_exe` [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#rename-exe)

The `rename_exe` option allows you to specify the name of the executable once it has been extracted.

use the `rename_exe` option to specify the target executable name:

toml

```
[tools]
"ubi:cli/cli" = { version = "latest", exe = "gh", rename_exe = "github" } # github's cli
```

### `matching` [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#matching)

Set a string to match against the release filename when there are multiple files for your OS/arch, i.e. "gnu" or "musl". Note that this is only used when there is more than one matching release filename for your OS/arch. If only one release asset matches your OS/arch, then this will be ignored.

toml

```
[tools]
"ubi:BurntSushi/ripgrep" = { version = "latest", matching = "musl" }
```

### `matching_regex` [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#matching-regex)

Set a regular expression string that will be matched against release filenames before matching against OS/arch. If the pattern yields a single match, that release will be selected. If no matches are found, this will result in an error.

toml

```
[tools]
"ubi:shader-slang/slang" = { version = "latest", matching_regex = "\\d+\\.tar" }
```

### `provider` [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#provider)

Set the provider type to use for fetching assets and release information. Either `github` or `gitlab` (default is `github`). Ensure the `provider` is set to the correct type if you use `api_url` as the type probably cannot be derived correctly from the URL.

toml

```
[tools]
"ubi:gitlab-org/cli" = { version = "latest", exe = "glab", provider = "gitlab" }
```

### `api_url` [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#api-url)

Set the URL for the provider's API. This is useful when using a self-hosted instance.

toml

```
[tools]
"ubi:acme/my-tool" = { version = "latest", provider= "gitlab", api_url = "https://gitlab.acme.com/api/v4" }
```

### `extract_all` [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#extract-all)

Set to `true` to extract all files in the tarball instead of just the "bin". Not compatible with `exe` nor `rename_exe`.

toml

```
[tools]
"ubi:helix-editor/helix" = { version = "latest", extract_all = "true" }
```

### `bin_path` [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#bin-path)

The directory in the tarball where the binary(s) are located. This is useful when the binary is not in the root of the tarball. This only makes sense when `extract_all` is set to `true`.

toml

```
[tools]
"ubi:BurntSushi/ripgrep" = { version = "latest", extract_all = "true", bin_path = "target/release" }
```

**Binary path lookup order:**

1. If `bin_path` is specified, use that directory
2. If `extract_all` is set to `true`, use the install path root
3. If `bin_path` is not set, look for a `bin/` directory in the install path
4. If no `bin/` directory exists, use the root of the extracted directory

### `tag_regex` [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#tag-regex)

Set a regex to filter out tags that don't match the regex. This is useful when a vendor has a bunch of releases for unrelated CLIs in the same repo. For example, `cargo-bins/cargo-binstall` has a bunch of releases for unrelated CLIs that are not `cargo-binstall`. This option can be used to filter out those releases.

toml

```
[tools]
"ubi:cargo-bins/cargo-binstall" = { version = "latest", tag_regex = '^\d+\.' }
```

## Self-hosted GitHub/GitLab [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#self-hosted-github-gitlab)

If you are using a self-hosted GitHub/GitLab instance, you can set the `provider` and `api_url` tool options. Additionally, you can set the `MISE_GITHUB_ENTERPRISE_TOKEN` or `MISE_GITLAB_ENTERPRISE_TOKEN` environment variable to authenticate with the API.

## Supported Ubi Syntax [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#supported-ubi-syntax)

- **GitHub shorthand for latest release version:** `ubi:goreleaser/goreleaser`
- **GitHub shorthand for specific release version:** `ubi:goreleaser/goreleaser@1.25.1`
- **URL syntax:** `ubi:https://github.com/goreleaser/goreleaser/releases/download/v1.16.2/goreleaser_Darwin_arm64.tar.gz`

## Troubleshooting ubi [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#troubleshooting-ubi)

### `ubi` resolver can't find os/arch [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#ubi-resolver-can-t-find-os-arch)

Sometimes vendors use strange formats for their releases that ubi can't figure out, possibly for a specific os/arch combination. For example this recently happend in [this ticket](https://github.com/houseabsolute/ubi/issues/79) because a vendor used "mac" instead of the more common "macos" or "darwin" tags.

Try using ubi by itself to see if the issue is related to mise or ubi:

sh

```
ubi -p jdx/mise
./bin/mise -v # yes this technically means you could do `mise use ubi:jdx/mise` though I don't know why you would
```

### `ubi` picks the wrong tarball [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#ubi-picks-the-wrong-tarball)

Another issue is that a GitHub release may have a bunch of tarballs, some that don't contain the CLI you want, you can use the `matching` field in order to specify a string to match against the release.

sh

```
mise use ubi:tamasfe/taplo[matching=full]
# or with ubi directly
ubi -p tamasfe/taplo -m full
```

### `ubi` can't find the binary in the tarball [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#ubi-can-t-find-the-binary-in-the-tarball)

ubi assumes that the repo name is the same as the binary name, however that is often not the case. For example, BurntSushi/ripgrep gives us a binary named `rg` not `ripgrep`. In this case, you can specify the binary name with the `exe` field:

sh

```
mise use ubi:BurntSushi/ripgrep[exe=rg]
# or with ubi directly
ubi -p BurntSushi/ripgrep -e rg
```

### `ubi` uses weird versions [​](https://mise.jdx.dev/dev-tools/backends/ubi.html\#ubi-uses-weird-versions)

This issue is actually with mise and not with ubi. mise needs to be able to list the available versions of the tools so that "latest" points to whatever is the actual latest release of the CLI. What sometimes happens is vendors will have GitHub releases for unrelated things. For example, `cargo-bins/cargo-binstall` is the repo for cargo-binstall, however it has a bunch of releases for unrelated CLIs that are not cargo-binstall. We need to filter these out and that can be specified with the `tag_regex` tool option:

sh

```
mise use 'ubi:cargo-bins/cargo-binstall[tag_regex=^\d+\.]'
```

Now when running `mise ls-remote ubi:cargo-bins/cargo-binstall[tag_regex=^\d+\.]` you should only see versions starting with a number. Note that this command is cached so you likely will need to run `mise cache clear` first.

<|firecrawl-page-124-lllmstxt|>
## Vfox Backend Tools
[Skip to content](https://mise.jdx.dev/dev-tools/backends/vfox.html#VPContent)

Return to top

# Vfox Backend experimental [​](https://mise.jdx.dev/dev-tools/backends/vfox.html\#vfox-backend)

[Vfox](https://github.com/version-fox/vfox) plugins may be used in mise to install tools.

The code for this is inside the mise repository at [`./src/backend/vfox.rs`](https://github.com/jdx/mise/blob/main/src/backend/vfox.rs).

## Dependencies [​](https://mise.jdx.dev/dev-tools/backends/vfox.html\#dependencies)

No dependencies are required for vfox. Vfox lua code is read via a lua interpreter built into mise.

## Usage [​](https://mise.jdx.dev/dev-tools/backends/vfox.html\#usage)

The following installs the latest version of cmake and sets it as the active version on PATH:

sh

```
$ mise use -g vfox:version-fox/vfox-cmake
$ cmake --version
cmake version 3.21.3
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"vfox:version-fox/vfox-cmake" = "latest"
```

## Default plugin backend [​](https://mise.jdx.dev/dev-tools/backends/vfox.html\#default-plugin-backend)

On Windows, mise uses vfox plugins by default. If you'd like to use plugins by default even on Linux/macOS, set the following settings:

sh

```
mise settings add disable_backends asdf
```

Now you can list available plugins with `mise registry`:

sh

```
$ mise registry | grep vfox:
clang                         vfox:mise-plugins/vfox-clang
cmake                         vfox:mise-plugins/vfox-cmake
crystal                       vfox:mise-plugins/vfox-crystal
dart                          vfox:mise-plugins/vfox-dart
dotnet                        vfox:mise-plugins/vfox-dotnet
etcd                          aqua:etcd-io/etcd vfox:mise-plugins/vfox-etcd
flutter                       vfox:mise-plugins/vfox-flutter
gradle                        aqua:gradle/gradle vfox:mise-plugins/vfox-gradle
groovy                        vfox:mise-plugins/vfox-groovy
kotlin                        vfox:mise-plugins/vfox-kotlin
maven                         aqua:apache/maven vfox:mise-plugins/vfox-maven
php                           vfox:mise-plugins/vfox-php
scala                         vfox:mise-plugins/vfox-scala
terraform                     aqua:hashicorp/terraform vfox:mise-plugins/vfox-terraform
vlang                         vfox:mise-plugins/vfox-vlang
```

And they will be installed when running commands such as `mise use -g cmake` without needing to specify `vfox:cmake`.

## Plugins [​](https://mise.jdx.dev/dev-tools/backends/vfox.html\#plugins)

In addition to the standard vfox plugins, mise supports modern plugins that can manage multiple tools using the `plugin:tool` format. These plugins are perfect for:

- Installing tools from private repositories
- Package managers (npm, pip, etc.)
- Custom tool families

### Example: Plugin Usage [​](https://mise.jdx.dev/dev-tools/backends/vfox.html\#example-plugin-usage)

bash

```
# Install a plugin
mise plugin install my-plugin https://github.com/username/my-plugin

# Use the plugin:tool format
mise install my-plugin:some-tool@1.0.0
mise use my-plugin:some-tool@latest
```

For more information, see:

- [Using Plugins](https://mise.jdx.dev/plugin-usage.html) \- End-user guide
- [Plugin Development](https://mise.jdx.dev/tool-plugin-development.html) \- Developer guide

<|firecrawl-page-125-lllmstxt|>
## Mise vs Asdf Comparison
[Skip to content](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html#VPContent)

Return to top

# Comparison to asdf [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#comparison-to-asdf)

mise can be used as a drop-in replacement for asdf. It supports the same `.tool-versions` files that you may have used with asdf and can use asdf plugins through the [asdf backend](https://mise.jdx.dev/dev-tools/backends/asdf.html).

It will not, however, reuse existing asdf directories (so you'll need to either reinstall them or move them), and 100% compatibility is not a design goal. That said, if you're coming from asdf-bash (0.15 and below), mise actually has [fewer breaking changes than asdf-go (0.16 and above)](https://asdf-vm.com/guide/upgrading-to-v0-16.html) despite 100% compatibility not being a design goal of mise.

Casual users coming from asdf have generally found mise to just be a faster, easier to use asdf.

TIP

Make sure you have a look at [environments](https://mise.jdx.dev/environments/) and [tasks](https://mise.jdx.dev/tasks/) which are major portions of mise that have no asdf equivalent.

## Migrate from asdf to mise [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#migrate-from-asdf-to-mise)

If you're moving from asdf to mise, please review [#how-do-i-migrate-from-asdf](https://mise.jdx.dev/faq.html#how-do-i-migrate-from-asdf) for guidance.

## asdf in go (0.16+) [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#asdf-in-go-0-16)

asdf has gone through a rewrite in go. Because this is quite new as of this writing (2025-01-01), I'm going to keep information about 0.16+ asdf versions (which I call "asdf-go" vs "asdf-bash") in this section and the rest of this doc will apply to asdf-bash (0.15 and below).

In terms of performance, mise is still faster than the go asdf, however the difference is much closer. asdf is likely fast enough that the difference in overhead between asdf-go and mise may not even be enough to notice for you—after all there are plenty of people still using asdf-bash that claim they don't even notice how slow it is (don't ask me how):

![GgAQJJmWIAAUlec](https://github.com/user-attachments/assets/05689925-396d-41f3-bcd1-7b3b1bf6c2fa)

I don't think performance is a good enough reason to switch though now that asdf-go is a thing. It's a reason, but it's a minor one. The improved security in mise, better DX, and lack of reliance on shims are all more important than performance.

Given they went through the trouble of rewriting asdf—that's also an indication they want to keep working on it (which is awesome that they're doing that btw). This does mean that some of what's written here may go out of date if they address some of the problems with asdf.

## Supply chain security [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#supply-chain-security)

asdf plugins are not secure. This is explained in [SECURITY.md](https://github.com/jdx/mise/blob/main/SECURITY.md), but the quick explanation is that asdf plugins involve shell code which can essentially do anything on your machine. It's dangerous code. What's worse is asdf plugins are rarely written by the tool vendor (who you need to trust anyway to use the tool), which means for every asdf plugin you use you'll be trusting a random developer to not go rogue and to not get hacked themselves and publish changes to a plugin with an exploit.

mise still uses asdf plugins for some tools, but we're actively reducing that count as well as moving things into the [mise-plugins org](https://github.com/mise-plugins). It looks like asdf has a similar model with their asdf-community org, but it isn't. asdf gives plugin authors commit access to their plugin in [asdf-community](https://github.com/asdf-community) when they move it in, which I feel like defeats the purpose of having a dedicated org in the first place. By the end of 2025 I would like for there to no longer be any asdf plugins in the registry that aren't owned by me.

I've also been adopting extra security verification steps when vendors offer that ability such as gpg verification on node installs, or slsa-verify/cosign checks on some aqua tools.

## UX [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#ux)

![CleanShot 2024-01-28 at 12 36 20@2x](https://github.com/jdx/mise-docs/assets/216188/47f381d7-1566-4b78-9260-3b85a21dd6ec)

Some commands are the same in asdf but others have been changed. Everything that's possible in asdf should be possible in mise but may use slightly different syntax. mise has more forgiving commands, such as using fuzzy-matching, e.g.: `mise install node@20`. While in asdf you _can_ run `asdf install node latest:20`, you can't use `latest:20` in a `.tool-versions` file or many other places. In `mise` you can use fuzzy-matching everywhere.

asdf requires several steps to install a new runtime if the plugin isn't installed, e.g.:

sh

```
asdf plugin add node
asdf install node latest:20
asdf local node latest:20
```

In `mise` this can all be done in a single step which installs the plugin, installs the runtime, and sets the version:

sh

```
mise use node@20
```

If you have an existing `.tool-versions` file, or `.mise-toml`, you can install all plugins and runtimes with a single command:

sh

```
mise install
```

I've found asdf to be particularly rigid and difficult to learn. It also made strange decisions like having `asdf list all` but `asdf latest --all` (why is one a flag and one a positional argument?). `mise` makes heavy use of aliases so you don't need to remember if it's `mise plugin add node` or `mise plugin install node`. If I can guess what you meant, then I'll try to get mise to respond in the right way.

That said, there are a lot of great things about asdf. It's the best multi-runtime manager out there and I've really been impressed with the plugin system. Most of the design decisions the authors made were very good. I really just have 2 complaints: the shims and the fact it's written in Bash.

## Performance [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#performance)

asdf made (what I consider) a poor design decision to use shims that go between a call to a runtime and the runtime itself. e.g.: when you call `node` it will call an asdf shim file `~/.asdf/shims/node`, which then calls `asdf exec`, which then calls the correct version of node.

These shims have terrible performance, adding ~120ms to every runtime call. `mise activate` does not use shims and instead updates `PATH` so that it doesn't have any overhead when simply calling binaries. These shims are the main reason that I wrote this. Note that in the demo GIF at the top of this README that `mise` isn't actually used when calling `node -v` for this reason. The performance is identical to running node without using mise.

I don't think it's possible for asdf to fix these issues. The author of asdf did a great writeup of [performance problems](https://stratus3d.com/blog/2022/08/11/asdf-performance/). asdf is written in bash which certainly makes it challenging to be performant, however I think the real problem is the shim design. I don't think it's possible to fix that without a complete rewrite.

mise does call an internal command `mise hook-env` every time the directory has changed, but because it's written in Rust, this is very quick—taking ~10ms on my machine. 4ms if there are no changes, 14ms if it's a full reload.

tl;dr: asdf adds overhead (~120ms) when calling a runtime, mise adds a small amount of overhead (~ 5ms) when the prompt loads.

## Windows support [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#windows-support)

asdf does not run on Windows at all. With mise, tools using non-asdf backends can support Windows. Of course, this means the tool vendor must provide Windows binaries but if they do, and the backend isn't asdf, the tool should work on Windows.

## Security [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#security)

asdf plugins are insecure. They typically are written by individuals with no ties to the vendors that provide the underlying tool. Where possible, mise does not use asdf plugins and instead uses backends like aqua and ubi which do not require separate plugins.

Aqua tools can be configured with cosign/slsa verification as well. See [SECURITY](https://github.com/jdx/mise/blob/main/SECURITY.md) for more information.

## Command Compatibility [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#command-compatibility)

In nearly all places you can use the exact syntax that works in asdf, however this likely won't show up in the help or CLI reference. If you're coming from asdf and comfortable with that way of working you can almost always use the same syntax with mise, e.g.:

sh

```
mise install node 20.0.0
mise local node 20.0.0
```

UPDATE (2025-01-01): asdf-go (0.16+) actually got rid of `asdf global|local` entirely in favor of `asdf set` which we can't support since we already have a command named `mise set`. mise command compatibility will likely not be as good with asdf-go 0.16+.

It's not recommended though. You almost always want to modify config files and install things so `mise use node@20` saves an extra command. Also, the "@" in the command is preferred since it allows you to install multiple tools at once: `mise use|install node@20 node@18`. Also, there are edge cases where it's not possible—or at least very challenging—for us to definitively know which syntax is being used and so we default to mise-style. While there aren't many of these, asdf-compatibility is done as a "best-effort" in order to make transitioning from asdf feel familiar for those users who can rely on their muscle memory. Ensuring asdf-syntax works with everything is not a design goal.

## Extra backends [​](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html\#extra-backends)

mise has support for backends other than asdf plugins. For example you can install CLIs directly from cargo and npm:

sh

```
mise use -g cargo:ripgrep@14
mise use -g npm:prettier@3
```

<|firecrawl-page-126-lllmstxt|>
## Error 404 Page
# Error 404

### Object not found

This object does not exist or is not publicly accessible at this
URL. Check the URL of the object that you're looking for or contact
the owner to enable Public access.


Is this your bucket?

Learn how to enable
[Public Access](https://developers.cloudflare.com/r2/data-access/public-buckets/)

<|firecrawl-page-127-lllmstxt|>
## Mise Lockfile Overview
[Skip to content](https://mise.jdx.dev/dev-tools/mise-lock.html#VPContent)

Return to top

# mise.lock Lockfile experimental [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#mise-lock-lockfile)

`mise.lock` is a lockfile that pins exact versions and checksums of tools for reproducible environments. When enabled, mise will automatically maintain this file to ensure consistent tool versions across different machines and deployments.

## Overview [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#overview)

The lockfile serves similar purposes to `package-lock.json` in npm or `Cargo.lock` in Rust:

- **Reproducible builds**: Ensures everyone on your team uses exactly the same tool versions
- **Security**: Verifies tool integrity with checksums when supported by the backend
- **Version pinning**: Locks tools to specific versions while allowing flexibility in `mise.toml`
- **Avoids API rate limits**: By storing download URLs, future installs use the lockfile and do not need to call GitHub (or other providers), avoiding rate limits and the need for `GITHUB_TOKEN` in most cases

## Enabling Lockfiles [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#enabling-lockfiles)

Lockfiles are controlled by the `lockfile` setting:

sh

```
# Enable lockfiles globally
mise settings lockfile=true

# Or set in mise.toml
[settings]
lockfile = true
```

## How It Works [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#how-it-works)

1. **Automatic Creation**: When you run `mise install` or `mise use`, mise updates `mise.lock` with the exact versions installed
2. **Version Resolution**: If a `mise.lock` exists, mise will prefer locked versions over version ranges in `mise.toml`
3. **Checksum Verification**: For supported backends, mise stores and verifies checksums of downloaded tools

## File Format [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#file-format)

`mise.lock` is a TOML file with a platform-based format that organizes asset information by platform:

toml

```
# Example mise.lock
[tools.node]
version = "20.11.0"
backend = "core:node"

[tools.node.platforms.linux-x64]
checksum = "sha256:a6c213b7a2c3b8b9c0aaf8d7f5b3a5c8d4e2f4a5b6c7d8e9f0a1b2c3d4e5f6a7"
size = 23456789
url = "https://nodejs.org/dist/v20.11.0/node-v20.11.0-linux-x64.tar.xz"

[tools.python]
version = "3.11.7"
backend = "core:python"

[tools.python.platforms.linux-x64]
checksum = "sha256:def456..."
size = 12345678

[tools.ripgrep]
version = "14.1.1"
backend = "aqua:BurntSushi/ripgrep"

[tools.ripgrep.platforms.linux-x64]
checksum = "sha256:4cf9f2741e6c465ffdb7c26f38056a59e2a2544b51f7cc128ef28337eeae4d8e"
size = 1234567
```

### Platform Information [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#platform-information)

Each platform in a tool's `[tools.name.platforms]` section uses a key format like `"os-arch"` (e.g., `"linux-x64"`, `"macos-arm64"`) and can contain:

- **`checksum`** (optional): SHA256 or Blake3 hash for integrity verification
- **`size`** (optional): File size in bytes for download validation
- **`url`** (optional): Original download URL for reference or re-downloading

### Platform Keys [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#platform-keys)

The platform key format is generally `os-arch` but can be customized by backends:

- **Standard format**: `linux-x64`, `macos-arm64`, `windows-x64`
- **Backend-specific**: Some backends like Java may use more specific platform identifiers
- **Tool-specific**: Backends like `ubi` may include additional tool-specific information in the platform key

### Legacy Format Migration [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#legacy-format-migration)

Older lockfiles with separate `[tools.name.assets]` and `[tools.name.checksums]` sections are automatically migrated to the new platform-based `[tools.name.platforms]` format when read. The migration is seamless and maintains all existing functionality.

## Workflow [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#workflow)

### Initial Setup [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#initial-setup)

sh

```
# Create the lockfile
touch mise.lock

# Install tools (this will populate the lockfile)
mise install
```

### Daily Usage [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#daily-usage)

sh

```
# Install exact versions from lockfile
mise install

# Update tools and lockfile
mise upgrade
```

### Updating Versions [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#updating-versions)

When you want to update tool versions:

sh

```
# Update tool version in mise.toml
mise use node@22

# This will update both the installation and mise.lock
```

## Backend Support [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#backend-support)

Backend support for lockfile features varies:

- ✅ **Full support** (version + checksum + size + URL): `aqua`, `http`, `github`, `gitlab`
- ⚠️ **Partial support** (version + checksum + size): `ubi`
- 📝 **Basic support** (version + checksum): `core` (some tools)
- 📝 **Version only**: `asdf`, `npm`, `cargo`, `pipx`
- 📝 **Planned**: More backends will add full asset tracking support over time

## Best Practices [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#best-practices)

### Version Control [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#version-control)

sh

```
# Always commit the lockfile
git add mise.lock
git commit -m "Update tool versions"
```

### Team Workflow [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#team-workflow)

1. **Team Lead**: Updates `mise.toml` with new version ranges
2. **Team Lead**: Runs `mise install` to update `mise.lock`
3. **Team Lead**: Commits both files
4. **Team Members**: Pull changes and run `mise install` to get exact versions

### CI/CD [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#ci-cd)

yaml

```
# Example GitHub Actions
- name: Install tools
  run: |
    mise install  # Uses exact versions from mise.lock

- name: Cache lockfile
  uses: actions/cache@v3
  with:
    key: mise-lock-${{ hashFiles('mise.lock') }}
```

## Troubleshooting [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#troubleshooting)

### Regenerating Checksums [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#regenerating-checksums)

If checksums become invalid or you need to regenerate them:

sh

```
# Remove all tools and reinstall
mise uninstall --all
mise install
```

### Lockfile Conflicts [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#lockfile-conflicts)

When merging branches with different lockfiles:

1. Resolve conflicts in `mise.lock`
2. Run `mise install` to verify everything works
3. Commit the resolved lockfile

### Disabling for Specific Projects [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#disabling-for-specific-projects)

toml

```
# In project's mise.toml
[settings]
lockfile = false
```

## Migration from Other Tools [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#migration-from-other-tools)

### From asdf [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#from-asdf)

sh

```
# Convert .tool-versions to mise.toml
mise config generate

# Enable lockfiles and populate
mise settings lockfile=true
mise install
```

### From package.json engines [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#from-package-json-engines)

sh

```
# Set versions based on package.json
mise use node@$(jq -r '.engines.node' package.json)
```

## Experimental Features [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#experimental-features)

Since lockfiles are still experimental, enable them with:

sh

```
mise settings experimental=true
mise settings lockfile=true
```

## Benefits of the New Format [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#benefits-of-the-new-format)

The platform-based format provides several advantages:

01. **Organized Structure**: Platform information is logically grouped by operating system and architecture
02. **Cross-platform Support**: Each tool can have different assets for different platforms in the same lockfile
03. **Reduced Duplication**: Platform-specific checksums and sizes are consolidated per platform
04. **Extended Metadata**: Support for file sizes and download URLs per platform
05. **Better Maintainability**: Clear separation of tool versions and their platform-specific assets
06. **Easier Navigation**: Platform-specific assets are easier to locate and manage by os-arch keys
07. **Full Traceability**: URLs provide complete audit trail of asset sources per platform
08. **Enhanced Security**: Better compliance and security auditing capabilities across platforms
09. **Avoids Rate Limits**: By storing URLs, future installs do not need to make API calls to GitHub or other providers, reducing the risk of hitting rate limits and removing the need for `GITHUB_TOKEN` in simple workflows
10. **Backend Flexibility**: Backends can customize platform keys for tool-specific requirements (e.g., Java's detailed platform specifications)

## See Also [​](https://mise.jdx.dev/dev-tools/mise-lock.html\#see-also)

- [Configuration Settings](https://mise.jdx.dev/configuration/settings.html) \- All available settings
- [Tool Version Management](https://mise.jdx.dev/dev-tools/) \- How tool versions work
- [Backends](https://mise.jdx.dev/dev-tools/backends/) \- Backend-specific checksum support

<|firecrawl-page-128-lllmstxt|>
## Mise Shims Overview
[Skip to content](https://mise.jdx.dev/dev-tools/shims.html#VPContent)

Return to top

# Shims [​](https://mise.jdx.dev/dev-tools/shims.html\#shims)

There are several ways for the `mise` context (dev tools, environment variables) to be loaded into your shell:

- `mise activate` (also called ["mise PATH activation"](https://mise.jdx.dev/dev-tools/shims.html#path-activation)) where `mise` updates your `PATH` and other environment variables every time your prompt is displayed.
- [`mise activate --shims`](https://mise.jdx.dev/dev-tools/shims.html#mise-activate-shims) which uses shims to load dev tools.
- Using [`mise x|exec`](https://mise.jdx.dev/cli/exec.html) or [`mise r|run`](https://mise.jdx.dev/cli/run.html) for ad-hoc commands or tasks (see ["neither shims nor PATH"](https://mise.jdx.dev/dev-tools/shims.html#neither-shims-nor-path)).

This page will help you understand the differences between these methods and how to use them. In particular, it will help you decide if you should use shims or `mise activate` in your shell.

## Overview of the `mise` activation methods [​](https://mise.jdx.dev/dev-tools/shims.html\#overview)

### PATH activation [​](https://mise.jdx.dev/dev-tools/shims.html\#path-activation)

Mise's "PATH" activation method updates environment variables every time the prompt is displayed. In particular, it updates the `PATH` environment variable, which is used by your shell to search for the programs it can run.

INFO

This is the method used when you add the `echo 'eval "$(mise activate bash)"' >> ~/.bashrc` line to your shell rc file (in this case, for bash).

For example, by default, your `PATH` variable might look like this:

sh

```
echo $PATH
/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin
```

If using [`mise activate`](https://mise.jdx.dev/cli/activate.html), `mise` will automatically add the required tools to `PATH`.

sh

```
PATH="$HOME/.local/share/mise/installs/python/3.13.0/bin:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
```

In this example, the python `bin` directory was added at the beginning of the `PATH`, making it available in the current shell session.

While the `PATH` design of `mise` works great in most cases, there are some situations where `shims` are preferable. This is the case when you are not using an interactive shell (for example, when using `mise` in an IDE or a script).

### Shims [​](https://mise.jdx.dev/dev-tools/shims.html\#mise-activate-shims)

WARNING

`mise activate --shims` does not support all the features of `mise activate`.

See [shims vs path](https://mise.jdx.dev/dev-tools/shims.html#shims-vs-path) for more information.

When using shims, `mise` places small executables ( `shims`) in a directory that is included in your `PATH`. You can think of `shims` as symlinks to the mise binary that intercept commands and load the appropriate context.

sh

```
ls -l ~/.local/share/mise/shims/node
# [...] ~/.local/share/mise/shims/node -> ~/.local/bin/mise
```

By default, the shim directory is located at `~/.local/share/mise/shims`. When installing a tool (for example, `node`), `mise` will add some entries for every binary provided by this tool in the `shims` directory (for example, `~/.local/share/mise/shims/node`).

sh

```
mise use -g node@20
npm install -g prettier@3.1.0

~/.local/share/mise/shims/node -v
# v20.0.0
~/.local/share/mise/shims/prettier -v
# 3.1.0
```

To avoid calling `~/.local/share/mise/shims/node`, you can add the `shims` directory to your `PATH`.

sh

```
export PATH="$HOME/.local/share/mise/shims:/usr/local/bin:/usr/bin:/bin:/usr/sbin:/sbin"
```

This will effectively make all dev tools available in your current shell session as well as non-interactive environments.

TIP

[`mise activate --shims`](https://mise.jdx.dev/cli/activate.html#shims) is a shorthand for adding the shims directory to PATH.

## How to add mise shims to PATH [​](https://mise.jdx.dev/dev-tools/shims.html\#how-to-add-mise-shims-to-path)

The recommended way to add `shims` to `PATH` is to call [`mise activate --shims`](https://mise.jdx.dev/cli/activate.html#shims) in one of your shell initialization file. For example, you can do the following:

bashzshfish

sh

```
# note that bash will read from ~/.profile or ~/.bash_profile if the latter exists
# ergo, you may want to check to see which is defined on your system and only append to the existing file
echo 'eval "$(mise activate bash --shims)"' >> ~/.bash_profile # this sets up non-interactive sessions
echo 'eval "$(mise activate bash)"' >> ~/.bashrc       # this sets up interactive sessions
```

sh

```
echo 'eval "$(mise activate zsh --shims)"' >> ~/.zprofile # this sets up non-interactive sessions
echo 'eval "$(mise activate zsh)"' >> ~/.zshrc    # this sets up interactive sessions
```

sh

```
echo 'mise activate fish --shims | source' >> ~/.config/fish/config.fish
echo 'mise activate fish | source' >> ~/.config/fish/fish.config
```

In this example, we use [`mise activate --shims`](https://mise.jdx.dev/cli/activate.html#shims) in the non-interactive shell configuration file (like `.bash_profile` or `.zprofile`) and `mise activate` in the interactive shell configuration file (like `.bashrc` or `.zshrc`)

INFO

[`mise activate`](https://mise.jdx.dev/cli/activate.html) will remove the shims directory from the `PATH` so it's fine to call [`mise activate --shims`](https://mise.jdx.dev/cli/activate.html#shims) in your shell profile file then later call `mise activate` in an interactive session.

- You can also decide to use only `shims` if you prefer, though this comes with some [limitations](https://mise.jdx.dev/dev-tools/shims.html#shims-vs-path).
- An alternative to [`mise activate --shims`](https://mise.jdx.dev/cli/activate.html#shims) is to use `export PATH="$HOME/.local/share/mise/shims:$PATH"`. This can be helpful if `mise` is not yet available at that point in time.

### mise reshim [​](https://mise.jdx.dev/dev-tools/shims.html\#mise-reshim)

To force `mise` to update the content of the `shims` directory, you can manually call `mise reshim`.

Note that `mise` already runs a reshim anytime a tool is installed/updated/removed, so you don't need to use it for those scenarios. It is also done by default when using most tools such as `npm`.

`mise reshim` only creates/removes the shims. Some users sometimes use it as a "fix it" button, but it is only necessary if `~/.local/share/mise/shims` doesn't contain something it should.

Do not add additional executable in the `mise` directory, `mise` will delete them with the next reshim.

## Shims vs PATH [​](https://mise.jdx.dev/dev-tools/shims.html\#shims-vs-path)

The following features are affected when shims are used **instead** of [PATH activation](https://mise.jdx.dev/dev-tools/shims.html#path-activation):

- [Env vars](https://mise.jdx.dev/environments/) defined in mise are only available to mise tools
- Most [hooks](https://mise.jdx.dev/hooks.html) won't trigger
- The unix `which` command points to the shim, obscuring the real executable

In general, using PATH ( `mise activate`) instead of shims for _interactive_ situations is recommended.

The way `activate` works is every time the prompt is displayed, mise-en-place will determine what PATH and other env vars should be and export them. This is why it doesn't work well for non-interactive situations like scripts. The prompt never gets displayed so you have to manually call `mise hook-env` to get mise to update the env vars. (though there are exceptions, see [hook on `cd`](https://mise.jdx.dev/dev-tools/shims.html#hook-on-cd))

### Env vars and shims [​](https://mise.jdx.dev/dev-tools/shims.html\#env-vars-and-shims)

A downside of shims is that the environment variables are only loaded when a shim is called. This means if you set an [environment variable](https://mise.jdx.dev/environments/) in `mise.toml`, it will only be used when a shim is called.

The following example only works under `mise activate`:

sh

```
$ mise set NODE_ENV=production
$ echo $NODE_ENV
production
```

But this will work in either:

sh

```
$ mise set NODE_ENV=production
$ node -p process.env.NODE_ENV
production
```

Also, [`mise x|exec`](https://mise.jdx.dev/cli/exec.html) and [`mise r|run`](https://mise.jdx.dev/cli/run.html) can be used to get the environment even if you don't need any mise tools:

sh

```
$ mise set NODE_ENV=production
$ mise x -- bash -c "echo \$NODE_ENV"
production
$ mise r some_task_that_uses_NODE_ENV
production
```

TIP

In general, [tasks](https://mise.jdx.dev/tasks/) are a good way to ensure that the mise environment is always loaded.

### Hooks and shims [​](https://mise.jdx.dev/dev-tools/shims.html\#hooks-and-shims)

The [hooks](https://mise.jdx.dev/hooks.html) `cd`, `enter`, `exit`, and `watch_files` only trigger with `mise activate`. However `preinstall` and `postinstall` still work with shims because they don't require shell integration.

### `which` [​](https://mise.jdx.dev/dev-tools/shims.html\#which)

`which` is a command that a lot of users find great value in. Using shims effectively "break" `which` and cause it to show the location of the shim. A workaround is to use `mise which` will show the actual location. Some users prefer the "cleanliness" of running `which node` and getting back a real path with a version number inside of it. e.g:

sh

```
$ which node
~/.mise/installs/node/20/bin/node
```

### Performance [​](https://mise.jdx.dev/dev-tools/shims.html\#performance)

Truthfully, you're probably not going to notice a difference in performance when using shims vs. using `mise activate`.

- Since mise runs every time the prompt is displayed with `mise activate`, you'll pay a few ms cost every time the prompt is displayed. Regardless of whether you're actively using a mise tool, you'll pay that penalty every time you run any command. It does have some short-circuiting logic to make it faster if there are no changes, but it doesn't help much unless you have a very complex setup.
- shims have basically the same performance profile but run when the shim is called. This makes some situations better, and some worse.

If you are calling a shim from within a bash script like this:

sh

```
for i in {1..500}; do
    node script.js
done
```

You'll pay the mise penalty every time you call it within the loop. However, if you did the same thing but call a subprocess from within a shim (say, node creating a node subprocess), you will _not_ pay a new penalty. This is because when a shim is called, mise sets up the environment with PATH for all tools and those PATH entries will be before the shim directory.

In other words, which is better in terms of performance just depends on how you're calling mise. Really though most users will not notice a few ms lag on their terminal caused by `mise activate`.

The only difference between these would be that using `hook-env` you will need to call it again if you change directories but with shims that won't be necessary. The shims directory will be removed by `mise activate` automatically so you won't need to worry about dealing with shims in your PATH.

## Neither shims nor PATH [​](https://mise.jdx.dev/dev-tools/shims.html\#neither-shims-nor-path)

There are many ways to load the mise environment that don't require either, chiefly: [`mise x|exec`](https://mise.jdx.dev/cli/exec.html), [`mise r|run`](https://mise.jdx.dev/cli/run.html) or [`mise en`](https://mise.jdx.dev/cli/en.html).

These will both load all the tools and env vars before executing something. This might be ideal because you don't need to modify your shell rc file at all and the environment is always loaded explicitly. Some might find this is a "clean" way of working.

The obvious downside is that anytime one wants to use `mise` they need to prefix it with `mise exec|run`. Though, you can easily alias them to `mx|mr`.

- This is what one prefers if they like things to be precise over "easy".
- Or perhaps if you're just wanting to use mise on a single project because that's what your team uses and prefer not to use it to manage anything else on your system. Using a shell extension for that use-case would be overkill.

This is the method Jeff uses

> Part of the reason for this is I often need to make sure I'm on my development version of mise. If you work on mise yourself I would recommend working in a similar way and disabling `mise activate` or shims while you are working on it.
>
> See [How I use mise](https://mise.jdx.dev/how-i-use-mise.html) for more information.

## Hook on `cd` [​](https://mise.jdx.dev/dev-tools/shims.html\#hook-on-cd)

For some shells ( `bash`, `zsh`, `fish`, `xonsh`), `mise` hooks into the `cd` command, while in others, it only runs when the prompt is displayed. This relies on `chpwd` in `zsh`, `PROMPT_COMMAND` in `bash`, `fish_prompt` in `fish`, and `on_chdir` in `xonsh`.

The upside is that it doesn't run as frequently but since mise is written in Rust the cost for executing mise is negligible (a few ms).

Running several commands in a single line

If you run a set of commands in a single line like the following:

sh

```
cd ~
cd ~/src/proj1 && node -v && cd ~/src/proj2 && node -v
```

If using `mise activate`, in shell without hook on cd, this will use the tools from `~`, not from `~/src/proj1` or `~/src/proj2` even after the directory changed.

This is because, in these shells `mise` runs just before your prompt gets displayed whereas in others, it hooks on `cd`. Note that shims _will_ always work with the inline example above.

## Using mise in rc files [​](https://mise.jdx.dev/dev-tools/shims.html\#using-mise-in-rc-files)

rc files like `.zshrc` are unusual. It's a script but also runs only for interactive sessions. If you need to access tools provided by mise inside of an rc file you have 2 options:

hook-envshims

sh

```
eval "$(mise activate zsh)"
eval "$(mise hook-env -s zsh)"
node some_script.js
```

sh

```
eval "$(mise activate zsh --shims)" # should be first
eval "$(mise activate zsh)"
node some_script.js
```

<|firecrawl-page-129-lllmstxt|>
## Tool Stubs Overview
[Skip to content](https://mise.jdx.dev/dev-tools/tool-stubs.html#VPContent)

Return to top

# Tool Stubs [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#tool-stubs)

Tool stubs allow you to create executable files with embedded TOML configuration for tool execution. They provide a convenient way to define tool versions, backends, and execution parameters directly within executable scripts. They are also a good way to have some tools in mise lazy-load since the tools are only fetched when called and not when calling something like `mise install`.

This feature is inspired by [dotslash](https://github.com/facebook/dotslash), which pioneered the concept of executable files with embedded configuration for portable tool execution.

## Overview [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#overview)

A tool stub is an executable file that begins with a shebang line pointing to `mise tool-stub` and contains TOML configuration specifying which tool to execute and how to execute it. When the stub is run, mise automatically installs the specified tool version (if needed) and executes it with the provided arguments.

Tool stubs can use any mise backend but because they default to http—and http backend tools have things like urls and don't require a version—the http stubs look a bit different than non-http stubs.

TIP

Tool stubs are particularly useful for adding less-commonly used tools to your mise setup. Since tools are only installed when their stub is first executed, you can define many tools without the overhead of installing them all upfront. This is perfect for specialized tools, testing utilities, or project-specific binaries that you might not use every day.

## Tool (non-http) Stubs [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#tool-non-http-stubs)

bash

```
#!/usr/bin/env -S mise tool-stub
# Optional comment describing the tool

version = "1.0.0"
tool = "python"
bin = "python"
```

Why use `env -S`?

The `-S` flag tells `env` to split the command line on spaces, allowing multiple arguments to be passed to the interpreter. This is necessary because shebangs on Unix systems traditionally only support a single argument after the interpreter path. Using `env -S mise tool-stub` allows the shebang to work correctly by splitting it into `env` → `mise` → `tool-stub`.

## Configuration Fields [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#configuration-fields)

Tool stub configuration is essentially a subset of what can be done in `mise.toml` \[tools\] sections, with the addition of a `tool` field to specify which tool to use. All the same options available for tool configuration in `mise.toml` are supported in tool stubs.

### Optional Fields [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#optional-fields)

- `tool` \- Explicit tool name or backend specification (e.g., "python", "github:cli/cli"). This is the only field unique to tool stubs - it specifies which tool entry from the configuration to use. If omitted and a `url` field is present, defaults to the HTTP backend.
- `version` \- The version of the tool to use
- `bin` \- The binary name to execute within the tool (defaults to the stub filename)

## HTTP Stubs [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#http-stubs)

For multi-platform tarballs:

toml

```
#!/usr/bin/env -S mise tool-stub
url = "https://example.com/releases/1.0.0/tool-linux-x64.tar.gz"
```

For platform-specific tarballs:

toml

```
#!/usr/bin/env -S mise tool-stub
[platforms.linux-x64]
url = "https://example.com/releases/1.0.0/tool-linux-x64.tar.gz"

[platforms.darwin-arm64]
url = "https://example.com/releases/1.0.0/tool-macos-arm64.tar.gz"
```

### Platform-Specific Binary Paths [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#platform-specific-binary-paths)

Different platforms may have different binary structures or names. You can specify platform-specific `bin` fields when the binary path differs between platforms:

toml

```
#!/usr/bin/env -S mise tool-stub
# Global bin field used when platforms have the same structure
bin = "bin/tool"

[platforms.linux-x64]
url = "https://example.com/tool-linux.tar.gz"
# Uses global bin field: "bin/tool"

[platforms.windows-x64]
url = "https://example.com/tool-windows.zip"
bin = "tool.exe"  # Platform-specific binary for Windows
```

The tool stub generator automatically detects when platforms have different binary paths and will generate platform-specific `bin` fields when needed, or use a global `bin` field when all platforms have the same binary structure.

TIP

tool stubs default to the HTTP backend if no `tool` field is specified and a `url` field is present. See the [HTTP backend documentation](https://mise.jdx.dev/dev-tools/backends/http.html) for full details on configuring HTTP-based tools.

## Generating Tool Stubs (http) [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#generating-tool-stubs-http)

While you can manually create tool stubs with TOML configuration, mise provides a [`mise generate tool-stub`](https://mise.jdx.dev/cli/generate/tool-stub.html) command to automatically create stubs for HTTP-based tools.

Incremental Building

When using platform-specific URLs, the tool stub generator will append new platforms to existing stub files rather than overwriting them. This allows you to incrementally build cross-platform tool stubs by running the command multiple times with different platforms.

### Basic Generation [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#basic-generation)

Generate a tool stub for a tool distributed via HTTP:

bash

```
mise generate tool-stub ./bin/gh --url "https://github.com/cli/cli/releases/download/v2.336.0/gh_2.336.0_linux_amd64.tar.gz"
```

This will:

- Download the archive to detect checksums (for security)
- Extract it to auto-detect the binary path
- Generate an executable stub with complete TOML configuration

### Platform-Specific Generation [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#platform-specific-generation)

For tools with different URLs per platform, you can generate all platforms at once:

bash

```
mise generate tool-stub ./bin/rg \
  --platform-url linux-x64:https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-x86_64-unknown-linux-musl.tar.gz \
  --platform-url darwin-arm64:https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-aarch64-apple-darwin.tar.gz
```

**Auto-Platform Detection**: If the URL contains platform information, you can omit the platform prefix and let mise auto-detect it:

bash

```
# Auto-detect platform from URL (detects as 'macos-arm64')
mise generate tool-stub ./bin/node \
  --platform-url https://nodejs.org/dist/v22.17.1/node-v22.17.1-darwin-arm64.tar.gz

# Auto-detect platform from URL (detects as 'linux-x64')
mise generate tool-stub ./bin/node \
  --platform-url https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-x86_64-unknown-linux-musl.tar.gz
```

Or build them incrementally by adding platforms one at a time:

bash

```
# Start with Linux support (explicit platform)
mise generate tool-stub ./bin/rg \
  --platform-url linux-x64:https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-x86_64-unknown-linux-musl.tar.gz

# Later, add macOS support using auto-detection (appends to existing file)
mise generate tool-stub ./bin/rg \
  --platform-url https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-aarch64-apple-darwin.tar.gz

# Add Windows support using auto-detection (appends to existing file)
mise generate tool-stub ./bin/rg \
  --platform-url https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-x86_64-pc-windows-msvc.zip
```

The generator will preserve existing configuration and merge new platforms into the `[platforms]` table. If you specify a platform that already exists, its URL will be updated.

### Generation Options [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#generation-options)

- `--version VERSION` \- Specify tool version (defaults to "latest").
- `--bin PATH` \- Override auto-detected binary path
- `--platform-url PLATFORM:URL` \- Add platform-specific URL (can be used multiple times)
- `--platform-url URL` \- Add platform-specific URL with auto-detected platform from URL filename
- `--platform-bin PLATFORM:PATH` \- Set platform-specific binary path
- `--skip-download` \- Skip downloading for faster generation (no checksums or binary detection)

### Supported Archive Formats [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#supported-archive-formats)

The generator automatically detects and extracts various archive formats:

- `.tar.gz` / `.tgz` (gzip compressed tarballs)
- `.tar.xz` / `.txz` (xz compressed tarballs)
- `.tar.bz2` / `.tbz2` (bzip2 compressed tarballs)
- `.tar.zst` / `.tzst` (zstd compressed tarballs)
- `.zip` (zip archives)
- `.7z` (7-zip archives, Windows only)

### Generated Stub Example [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#generated-stub-example)

Running the generation command produces an executable stub like:

bash

```
#!/usr/bin/env -S mise tool-stub

version = "latest"
bin = "bin/gh"
url = "https://github.com/cli/cli/releases/download/v2.336.0/gh_2.336.0_linux_amd64.tar.gz"
checksum = "blake3:a1b2c3d4e5f6..."
size = 12345678
```

The generator automatically:

- Calculates BLAKE3 checksums for integrity verification
- Detects file sizes
- Identifies the correct binary path within archives
- Uses the output filename as the tool name

## Examples [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#examples)

### Basic Node.js Stub [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#basic-node-js-stub)

bash

```
#!/usr/bin/env -S mise tool-stub
# Node.js v20 tool stub

tool = "node"
version = "20.0.0"
bin = "node"
```

### Python with Custom Binary Name [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#python-with-custom-binary-name)

bash

```
#!/usr/bin/env -S mise tool-stub
# Python tool accessible as 'py'

tool = "python"
version = "3.11"
bin = "python"
```

### GitHub Release Backend [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#github-release-backend)

bash

```
#!/usr/bin/env -S mise tool-stub
# GitHub CLI tool

tool = "github:cli/cli"
version = "latest"
```

### HTTP Backend with Platform Support [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#http-backend-with-platform-support)

bash

```
#!/usr/bin/env -S mise tool-stub
# Custom HTTP tool with platform-specific downloads

version = "1.0.0"

[platforms.linux-x64]
url = "https://releases.example.com/v{{version}}/tool-linux-x64.tar.gz"

[platforms.darwin-arm64]
url = "https://releases.example.com/v{{version}}/tool-macos-arm64.tar.gz"
```

## Usage [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#usage)

### Direct Execution [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#direct-execution)

Make the stub executable and run it directly:

bash

```
chmod +x ./bin/my-tool
./bin/my-tool --version
```

### Via mise Command [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#via-mise-command)

Execute using the [`mise tool-stub`](https://mise.jdx.dev/cli/tool-stub.html) command—useful for testing if something isn't working right:

bash

```
mise tool-stub ./bin/my-tool --version
```

## Caching [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#caching)

Tool stubs implement intelligent caching which reduces the overhead mise has when running stubs:

- Binary paths are cached based on stub file path and modification time
- Cache is automatically invalidated when the stub file changes
- Missing binaries trigger cache cleanup automatically

Cached stubs have ~4ms of overhead.

## Alternative: Creating Simple Stubs with `mise x` [​](https://mise.jdx.dev/dev-tools/tool-stubs.html\#alternative-creating-simple-stubs-with-mise-x)

For basic use cases, you can quickly create simple tool stubs using the [`mise x`](https://mise.jdx.dev/cli/exec.html) command as an alternative to writing TOML configuration manually:

bash

```
# Create bin directory
mkdir -p ./bin

# Create a simple Node.js stub
cat > ./bin/node << 'EOF'
#!/usr/bin/env bash
exec mise x node@20 -- "$@"
EOF
chmod +x ./bin/node

# Create a Python stub with specific version
cat > ./bin/python << 'EOF'
#!/usr/bin/env bash
exec mise x python@3.11 -- "$@"
EOF
chmod +x ./bin/python
```

This approach is ideal for simple tool execution without the need for custom options, environment variables, or platform-specific settings. For more complex configurations, use the full TOML configuration format described above.

<|firecrawl-page-130-lllmstxt|>
## Mise Directory Structure
[Skip to content](https://mise.jdx.dev/directories.html#VPContent)

Return to top

# Directory Structure [​](https://mise.jdx.dev/directories.html\#directory-structure)

The following are the directories that mise uses.

TIP

If you often find yourself using these directories (as I do), I suggest setting all of them to `~/.mise` for easy access.

## `~/.config/mise` [​](https://mise.jdx.dev/directories.html\#config-mise)

- Override: `$MISE_CONFIG_DIR`
- Default: `${XDG_CONFIG_HOME:-$HOME/.config}/mise`

This directory stores the global configuration file `~/.config/mise/config.toml`. This is intended to go into your dotfiles repo to share across machines.

## `~/.cache/mise` [​](https://mise.jdx.dev/directories.html\#cache-mise)

- Override: `$MISE_CACHE_DIR`
- Default: `${XDG_CACHE_HOME:-$HOME/.cache}/mise`, _macOS: `~/Library/Caches/mise`._

Stores internal cache that mise uses for things like the list of all available versions of a plugin. Do not share this across machines. You may delete this directory any time mise isn't actively installing something. Do this with `mise cache clear`. See [Cache Behavior](https://mise.jdx.dev/cache-behavior.html) for more information.

## `~/.local/state/mise` [​](https://mise.jdx.dev/directories.html\#local-state-mise)

- Override: `$MISE_STATE_DIR`
- Default: `${XDG_STATE_HOME:-$HOME/.local/state}/mise`

Used for storing state local to the machine such as which config files are trusted. These should not be shared across machines.

## `~/.local/share/mise` [​](https://mise.jdx.dev/directories.html\#local-share-mise)

- Override: `$MISE_DATA_DIR`
- Default: `${XDG_DATA_HOME:-$HOME/.local/share}/mise`

This is the main directory that mise uses and is where plugins and tools are installed into. It is nearly identical to `~/.asdf` in asdf, so much so that you may be able to get by symlinking these together and using asdf and mise simultaneously. (Supporting this isn't a project goal, however).

This directory _could_ be shared across machines but only if they run the same OS/arch. In general I wouldn't advise doing so.

### `~/.local/share/mise/downloads` [​](https://mise.jdx.dev/directories.html\#local-share-mise-downloads)

This is where plugins may optionally cache downloaded assets such as tarballs. Use the `always_keep_downloads` setting to prevent mise from removing files from here.

### `~/.local/share/mise/plugins` [​](https://mise.jdx.dev/directories.html\#local-share-mise-plugins)

mise installs plugins to this directory when running `mise plugins install`. If you are working on a plugin, I suggest symlinking it manually by running:

sh

```
ln -s ~/src/mise-my-tool ~/.local/share/mise/plugins/my-tool
```

### `~/.local/share/mise/installs` [​](https://mise.jdx.dev/directories.html\#local-share-mise-installs)

This is where tools are installed to when running `mise install`. For example, `mise install node@20.0.0` will install to `~/.local/share/mise/installs/node/20.0.0`

This will also create other symlinks to this directory for version prefixes ("20" and "20.15") and matching aliases ("lts", "latest"). For example:

sh

```
$ tree ~/.local/share/mise/installs/node
20 -> ./20.15.0
20.15 -> ./20.15.0
lts -> ./20.15.0
latest -> ./20.15.0
```

You can set the `MISE_INSTALLS_DIR` environment variable to override this location.

### `~/.local/share/mise/shims` [​](https://mise.jdx.dev/directories.html\#local-share-mise-shims)

This is where mise places shims. Generally these are used for IDE integration or if `mise activate` does not work for some reason.

<|firecrawl-page-131-lllmstxt|>
## Direnv Compatibility with Mise
[Skip to content](https://mise.jdx.dev/direnv.html#VPContent)

Return to top

# direnv deprecated [​](https://mise.jdx.dev/direnv.html\#direnv)

[direnv](https://direnv.net/) and mise both manage environment variables based on directory. Because they both analyze the current environment variables before and after their respective "hook" commands are run, they can sometimes conflict with each other.

WARNING

The official stance is you should not use direnv with mise. Issues arising from incompatibilities are not considered bugs. If mise has feature gaps that direnv resolves, please open an issue so we can close those gaps. While that's the official stance, the reality is mise and direnv usually will work together just fine despite this. It's only more advanced use-cases where problems arise.

If you have an issue, it's likely to do with the ordering of PATH. This means it would really only be a problem if you were trying to manage the same tool with direnv and mise. For example, you may use `layout python` in an `.envrc` but also be maintaining a `.tool-versions` file with python in it as well.

A more typical usage of direnv would be to set some arbitrary environment variables, or add unrelated binaries to PATH. In these cases, mise will not interfere with direnv.

## mise inside of direnv ( `use mise` in `.envrc`) [​](https://mise.jdx.dev/direnv.html\#mise-inside-of-direnv-use-mise-in-envrc)

WARNING

`use mise` is deprecated and no longer supported. If `mise activate` does not fit your use-case please post an issue.

If you do encounter issues with `mise activate`, or just want to use direnv in an alternate way, this is a simpler setup that's less likely to cause issues—at the cost of functionality.

This may be required if you want to use direnv's `layout python` with mise. Otherwise there are situations where mise will override direnv's PATH. `use mise` ensures that direnv always has control.

To do this, first use `mise` to build a `use_mise` function that you can use in `.envrc` files:

sh

```
mise direnv activate > ~/.config/direnv/lib/use_mise.sh
```

Now in your `.envrc` file add the following:

sh

```
use mise
```

direnv will now call mise to export its environment variables. You'll need to make sure to add `use_mise` to all projects that use mise (or use direnv's `source_up` to load it from a subdirectory). You can also add `use mise` to `~/.config/direnv/direnvrc`.

Note that in this method direnv typically won't know to refresh `.tool-versions` files unless they're at the same level as a `.envrc` file. You'll likely always want to have a `.envrc` file next to your `.tool-versions` for this reason. To make this a little easier to manage, I encourage _not_ actually using `.tool-versions` at all, and instead setting environment variables entirely in `.envrc`:

sh

```
export MISE_NODE_VERSION=20.0.0
export MISE_PYTHON_VERSION=3.11
```

Of course if you use `mise activate`, then these steps won't have been necessary and you can use mise as if direnv was not used.

If you continue to struggle, you can also try using the [shims method](https://mise.jdx.dev/dev-tools/shims.html).

### Do you need direnv? [​](https://mise.jdx.dev/direnv.html\#do-you-need-direnv)

While making mise compatible with direnv is, and will always be a major goal of this project, I also want mise to be capable of replacing direnv if needed. This is why mise includes support for managing env vars and [virtualenv](https://mise.jdx.dev/lang/python.html#automatic-virtualenv-activation) for python using `mise.toml`.

<|firecrawl-page-132-lllmstxt|>
## Page Not Found
# Error 404

### Object not found

This object does not exist or is not publicly accessible at this
URL. Check the URL of the object that you're looking for or contact
the owner to enable Public access.


Is this your bucket?

Learn how to enable
[Public Access](https://developers.cloudflare.com/r2/data-access/public-buckets/)

<|firecrawl-page-133-lllmstxt|>
## Secrets Management in Mise
[Skip to content](https://mise.jdx.dev/environments/secrets.html#VPContent)

Return to top

# Secrets experimental [​](https://mise.jdx.dev/environments/secrets.html\#secrets)

Because env vars in mise.toml can store sensitive information, mise has built-in support for reading encrypted secrets from files. Currently, this is done with a [sops](https://getsops.io/) implementation however other secret backends could be added in the future.

Secrets are `.env.(json|yaml|toml)` files with a simple structure, for example:

json

```
{
  "AWS_ACCESS_KEY_ID": "AKIAIOSFODNN7EXAMPLE",
  "AWS_SECRET_ACCESS_KEY": "wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY"
}
```

Env vars from this can be imported into a mise config with the following:

toml

```
[env]
_.file = ".env.json"
```

mise will automatically use a secret backend like sops if the file is encrypted.

## sops [​](https://mise.jdx.dev/environments/secrets.html\#sops)

mise uses the rust [rops](https://github.com/gibbz00/rops) library to interact with [sops](https://getsops.io/) files. If you encrypt a sops file, mise will automatically decrypt it when reading the file. sops files can be in json, yaml, or toml format—however if you want to use toml you'll need to use the rops cli instead of sops. Otherwise, either sops or rops will work fine.

INFO

Currently age is the only sops encryption method supported.

In order to encrypt a file with sops, you'll first need to install it ( `mise use -g sops`). You'll also need to install [age](https://github.com/FiloSottile/age) ( `mise use -g age`) to generate a keypair for sops to use if you have not already done so.

To generate a keypair with age run the following and note the public key that is output to use in the next command to `sops`:

sh

```
$ age-keygen -o ~/.config/mise/age.txt
Public key: <public key>
```

Assuming we have a `.env.json` file like at the top of this doc, we can now encrypt it with sops:

sh

```
sops encrypt -i --age "<public key>" .env.json
```

TIP

The `-i` here overwrites the file with an encrypted version. This encrypted version is safe to commit into your repo as without the private key ( `~/.config/mise/age.txt` in this case) the file is useless.

You can later decrypt the file with `sops decrypt -i .env.json` or edit it in EDITOR with `sops edit .env.json`. However, you'll first need to set SOPS\_AGE\_KEY\_FILE to `~/.config/mise/age.txt` to decrypt the file.

Lastly, we need to add the file to our mise config which can be done with `mise set _.file=.env.json`.

Now when you run `mise env` you should see the env vars from the file:

sh

```
$ mise env
export AWS_ACCESS_KEY_ID=AKIAIOSFODNN7EXAMPLE
export AWS_SECRET_ACCESS_KEY=wJalrXUtnFEMI/K7MDENG/bPxRfiCYEXAMPLEKEY
```

### `sops` Settings [​](https://mise.jdx.dev/environments/secrets.html\#sops-settings)

#### `sops.age_key`

- Type: `string`(optional)
- Env: `MISE_SOPS_AGE_KEY`
- Default: `None`

The age private key to use for sops secret decryption.

#### `sops.age_key_file`

- Type: `Path`
- Env: `MISE_SOPS_AGE_KEY_FILE`
- Default: `~/.config/mise/age.txt`

Path to the age private key file to use for sops secret decryption.

#### `sops.age_recipients`

- Type: `string`(optional)
- Env: `MISE_SOPS_AGE_RECIPIENTS`
- Default: `None`

The age public keys to use for sops secret encryption.

#### `sops.rops`

- Type: `Bool`
- Env: `MISE_SOPS_ROPS`
- Default: `true`

Use rops to decrypt sops files. Disable to shell out to `sops` which will slow down mise but sops may offer features not available in rops.

#### `sops.strict`

- Type: `Bool`
- Env: `MISE_SOPS_STRICT`
- Default: `true`

If true, fail when sops decryption fails (including when sops is not available, the key is missing, or the key is invalid). If false, skip decryption and continue in these cases.

<|firecrawl-page-134-lllmstxt|>
## Error Handling Guide
[Skip to content](https://mise.jdx.dev/errors.html#VPContent)

Return to top

# Errors [​](https://mise.jdx.dev/errors.html\#errors)

TODO

<|firecrawl-page-135-lllmstxt|>
## Mise External Resources
[Skip to content](https://mise.jdx.dev/external-resources.html#VPContent)

Return to top

# External Resources [​](https://mise.jdx.dev/external-resources.html\#external-resources)

Links to articles, videos, and other resources that are relevant to mise.

- 2025-04-09 - Keeping your Swift apps' sensitive data secret - [https://tuist.dev/blog/2025/04/09/secrets](https://tuist.dev/blog/2025/04/09/secrets)
- 2025-02-17 - hk: git hook manager that pairs well with mise - [https://hk.jdx.dev](https://hk.jdx.dev/)
- 2025-02-04 - A Mise guide for Swift developers - [https://tuist.dev/blog/2025/02/04/mise](https://tuist.dev/blog/2025/02/04/mise)
- 2025-01-26 - devtools.fm: Jeff Dickey - Mise, Usage, and Pitchfork and the Future of Polyglot Tools - [https://www.devtools.fm/episode/129](https://www.devtools.fm/episode/129)
- 2025-01-12 - \[fr\] Mise-En-Place: Simplifiez la Gestion de vos Environnements et Tâches – [https://blog.stephane-robert.info/docs/developper/autres-outils/mise-en-place/](https://blog.stephane-robert.info/docs/developper/autres-outils/mise-en-place/)
- 2024-11-20 - Migrating from nvm to mise - [https://dev.to/hverlin/migrating-from-nvm-to-mise-4mfp](https://dev.to/hverlin/migrating-from-nvm-to-mise-4mfp)
- 2024-06-27 - Managing Development Tool Versions with mise - [https://haril.dev/en/blog/2024/06/27/Easy-devtools-version-management-mise](https://haril.dev/en/blog/2024/06/27/Easy-devtools-version-management-mise)
- 2024-06-09 - Replacing pyenv, nvm, direnv with Mise - [https://arunmozhi.in/2024/09/06/replacing-pyenv-nvm-direnv-with-mise](https://arunmozhi.in/2024/09/06/replacing-pyenv-nvm-direnv-with-mise)
- 2024-04-14 - Shims: How they work in mise-en-place: [https://jdx.dev/posts/2024-04-13-shims-how-they-work-in-mise-en-place/](https://jdx.dev/posts/2024-04-13-shims-how-they-work-in-mise-en-place/)
- 2024-04-07 - Lalaluka stream: Grroxy, Cook, and jdx/mise - [https://www.youtube.com/watch?v=zA1hjrLQiPw](https://www.youtube.com/watch?v=zA1hjrLQiPw)
- 2024-20-02 - Can Mise replace Volta? - [https://ricostacruz.com/posts/mise-vs-volta](https://ricostacruz.com/posts/mise-vs-volta)
- 2024-01-14 - Manage all your runtime versions with one tool (asdf, mise) - [https://blog.andreyfadeev.com/p/manage-all-your-runtime-versions](https://blog.andreyfadeev.com/p/manage-all-your-runtime-versions)
- 2023-12-30 - You should be using mise - [https://andrei-calazans.com/posts/you-should-be-using-rtx/](https://andrei-calazans.com/posts/you-should-be-using-rtx/)
- 2023-03-04 - Beginner's Guide to rtx (mise) - [https://dev.to/jdxcode/beginners-guide-to-rtx-ac4](https://dev.to/jdxcode/beginners-guide-to-rtx-ac4)

<|firecrawl-page-136-lllmstxt|>
## Mise FAQ Guide
[Skip to content](https://mise.jdx.dev/faq.html#VPContent)

Return to top

# FAQs [​](https://mise.jdx.dev/faq.html\#faqs)

## I don't want to put a `mise.toml`/ `.tool-versions` file into my project since git shows it as an untracked file [​](https://mise.jdx.dev/faq.html\#i-don-t-want-to-put-a-mise-toml-tool-versions-file-into-my-project-since-git-shows-it-as-an-untracked-file)

Use [`mise.local.toml`](https://mise.jdx.dev/configuration.html#mise-toml) and put that into your global gitignore file. This file should never be committed.

If you really want to use a `mise.toml` or `.tool-versions`, here are 3 ways to make git ignore these files:

- Adding `mise.toml` to project's `.git/info/exclude`. This file is local to your project so there is no need to commit it.
- Adding `mise.toml` to project's `.gitignore` file. This has the downside that you need to commit the change to the ignore file.
- Adding `mise.toml` to global gitignore ( `core.excludesFile`). This will cause git to ignore `mise.toml` files in all projects. You can explicitly add one to a project if needed with `git add --force mise.toml`.

## What is the difference between "nodejs" and "node" (or "golang" and "go")? [​](https://mise.jdx.dev/faq.html\#what-is-the-difference-between-nodejs-and-node-or-golang-and-go)

These are aliased. For example, `mise use nodejs@14.0` is the same as `mise install node@14.0`. This means it is not possible to have these be different plugins.

This is for convenience so you don't need to remember which one is the "official" name. However if something with the aliasing is acting up, submit a ticket or just stick to using "node" and "go". Under the hood, when mise reads a config file or takes CLI input it will swap out "nodejs" and "golang".

While this change is rolling out, there is some migration code that will move installs/plugins from the "nodejs" and "golang" directories to the new names. If this runs for you you'll see a message but it should not run again unless there is some kind of problem. In this case, it's probably easiest to just run `rm -rf ~/.local/share/mise/installs/{golang,nodejs} ~/.local/share/mise/plugins/{golang,nodejs}`.

Once most users have migrated over this migration code will be removed.

## What does `mise activate` do? [​](https://mise.jdx.dev/faq.html\#what-does-mise-activate-do)

It registers a shell hook to run `mise hook-env` every time the shell prompt is displayed. `mise hook-env` checks the current env vars (most importantly `PATH` but there are others like `GOROOT` or `JAVA_HOME` for some tools) and adds/removes/updates the ones that have changed.

For example, if you `cd` into a different directory that has `java 18` instead of `java 17` specified, just before the next prompt is displayed the shell runs: `eval "$(mise hook-env)"` which will execute something like this in the current shell session:

sh

```
export JAVA_HOME=$HOME/.local/share/installs/java/18
export PATH=$HOME/.local/share/installs/java/18/bin:$PATH
```

In reality updating `PATH` is a bit more complex than that because it also needs to remove java-17, but you get the idea.

You may think that is excessive to run `mise hook-env` every time the prompt is displayed and it should only run on `cd`, however there are plenty of situations where it needs to run without the directory changing, for example if `.tool-versions` or `mise.toml` was just edited in the current shell.

Because it runs on prompt display, if you attempt to use `mise activate` in a non-interactive session (like a bash script), it will never call `mise hook-env` and in effect will never modify PATH because it never displays a prompt. For this type of setup, you can either call `mise hook-env` manually every time you wish to update PATH, or use [shims](https://mise.jdx.dev/dev-tools/shims.html) instead (preferred). Or if you only need to use mise for certain commands, just prefix the commands with [`mise x --`](https://mise.jdx.dev/cli/exec.html). For example, `mise x -- npm test` or `mise x -- ./my_script.sh`.

`mise hook-env` will exit early in different situations if no changes have been made. This prevents adding latency to your shell prompt every time you run a command. You can run `mise hook-env` yourself to see what it outputs, however it is likely nothing if you're in a shell that has already been activated.

`mise activate` also creates a shell function (in most shells) called `mise`. This is a trick that makes it possible for `mise shell` and `mise deactivate` to work without wrapping them in `eval "$(mise shell)"`.

## Windows support? [​](https://mise.jdx.dev/faq.html\#windows-support)

WARNING

While mise runs great in WSL, native Windows is also supported, though via the use of shims until someone adds [powershell](https://github.com/jdx/mise/issues/3451) support.

As you'll need to use shims, this means you won't have environment variables from mise.toml unless you run mise via [`mise x`](https://mise.jdx.dev/cli/exec.html) or [`mise run`](https://mise.jdx.dev/cli/run.html)—though that's actually how I use mise on my mac so for me that's my preferred workflow anyway.

## How do I use mise with http proxies? [​](https://mise.jdx.dev/faq.html\#how-do-i-use-mise-with-http-proxies)

Short answer: just set `http_proxy` and `https_proxy` environment variables. These should be lowercase.

This may not work with all plugins if they are not configured to use these env vars. If you're having a proxy-related issue installing something specific you should post an issue on the plugin's repository.

## How do the shorthand plugin names map to repositories? [​](https://mise.jdx.dev/faq.html\#how-do-the-shorthand-plugin-names-map-to-repositories)

e.g.: how does `mise plugin install elixir` know to fetch [https://github.com/asdf-vm/asdf-elixir](https://github.com/asdf-vm/asdf-elixir)?

We maintain [an index](https://github.com/mise-plugins/registry) of shorthands that mise uses as a base. This is regularly updated every time that mise has a release. This repository is stored directly into the codebase in [registry.toml](https://github.com/jdx/mise/blob/main/registry.toml).

## Does "node@20" mean the newest available version of node? [​](https://mise.jdx.dev/faq.html\#does-node-20-mean-the-newest-available-version-of-node)

It depends on the command. Normally, for most commands and inside of config files, "node@20" will point to the latest _installed_ version of node-20.x. You can find this version by running `mise latest --installed node@20` or by seeing what the `~/.local/share/mise/installs/node/20` symlink points to:

sh

```
$ ls -l ~/.local/share/mise/installs/node/20
[...] /home/jdx/.local/share/mise/installs/node/20 -> node-v20.0.0-linux-x64
```

There are some exceptions to this, such as the following:

- `mise install node@20`
- `mise latest node@20`
- `mise upgrade node@20`

These will use the latest _available_ version of node-20.x. This generally makes sense because you wouldn't want to install a version that is already installed.

## How do I migrate from asdf? [​](https://mise.jdx.dev/faq.html\#how-do-i-migrate-from-asdf)

- Install mise and set up `mise activate` as described in the [getting started guide](https://mise.jdx.dev/getting-started.html)
- remove asdf from your shell rc file
- Run `mise install` in a directory with an asdf `.tool-versions` file and mise will install the tools

INFO

Note that `mise` does not consider `~/.tool-versions` files to be a global config file like `asdf` does. `mise` uses a `~/.config/mise/config.toml` file for global configuration.

Here is an example script you can use to migrate your global `.tool-versions` file to mise:

shell

```
mv ~/.tool-versions ~/.tool-versions.bak
cat ~/.tool-versions.bak | tr -s ' ' | tr ' ' '@' | xargs -n2 mise use -g
```

Once you are comfortable with mise, you can remove the `.tool-versions.bak` file and [uninstall `asdf`](https://asdf-vm.com/manage/core.html#uninstall)

## How compatible is mise with asdf? [​](https://mise.jdx.dev/faq.html\#how-compatible-is-mise-with-asdf)

mise should be able to read/install any `.tool-versions` file used by asdf. Any asdf plugin should be usable in mise. The commands in mise are slightly different, such as `mise install node@20.0.0` vs `asdf install node 20.0.0`—this is done so multiple tools can be specified at once. However, asdf-style syntax is still supported: ( `mise install node 20.0.0`). This is the case for most commands, though the help for the command may say that asdf-style syntax is supported. When in doubt, just try asdf syntax and see if it works—it probably does.

INFO

UPDATE (2025-01-01): mise was designed to be compatible with the asdf written in bash (<=0.15). The new asdf written in go (>=0.16) has commands mise does not support like `asdf set`. `mise set` is an existing command that is completely different than `asdf set`—in mise that sets env vars.

This isn't important for usability reasons so much as making it so plugins continue to work that call asdf commands inside of the plugin code.

Using commands like `mise use` may output `.tool-versions` files that are not compatible with asdf, such as using fuzzy versions. You can set `--pin` or `MISE_PIN=1` to make `mise use` output asdf-compatible versions in `.tool-versions`. Alternatively, you can have `mise.toml` and `.tool-versions` sitting side-by-side. `mise.toml` tools will override tools defined in a `.tool-versions` in the same directory.

That said, in general compatibility with asdf is no longer a design goal. It's long been the case that there is no reason to prefer asdf to mise so users should migrate. While plenty of users have teams which use both in tandem, issues with such a setup are unlikely to be prioritized.

## How do I disable/force CLI color output? [​](https://mise.jdx.dev/faq.html\#how-do-i-disable-force-cli-color-output)

mise uses [console.rs](https://docs.rs/console/latest/console/fn.colors_enabled.html) which honors the [clicolors spec](https://bixense.com/clicolors/):

- `CLICOLOR != 0`: ANSI colors are supported and should be used when the program isn't piped.
- `CLICOLOR == 0`: Don't output ANSI color escape codes.
- `CLICOLOR_FORCE != 0`: ANSI colors should be enabled no matter what.

## Is mise secure? [​](https://mise.jdx.dev/faq.html\#is-mise-secure)

Providing a secure supply chain is incredibly important. mise already provides a more secure experience when compared to asdf. Security-oriented evaluations and contributions are welcome. We also urge users to look after the plugins they use, and urge plugin authors to look after the users they serve.

For more details see [SECURITY.md](https://github.com/jdx/mise/blob/main/SECURITY.md).

## What is usage? [​](https://mise.jdx.dev/faq.html\#what-is-usage)

usage ( [https://usage.jdx.dev/](https://usage.jdx.dev/)) is a spec and CLI for defining CLI tools.

Arguments, flags, environment variables, and config files can all be defined in a Usage spec. It can be thought of like OpenAPI (swagger) for CLIs.

`usage` can be installed with `mise` using `mise use -g usage` and is required to get the autocompletion working. See [autocompletion](https://mise.jdx.dev/installing-mise.html#autocompletion).

You can leverage usage in file tasks to get auto-completion working, see [file tasks arguments](https://mise.jdx.dev/tasks/file-tasks.html#arguments).

## VSCode for windows extension with error `spawn EINVAL` [​](https://mise.jdx.dev/faq.html\#vscode-for-windows-extension-with-error-spawn-einval)

In VSCode, many extensions will throw an "error spawn EINVAL" due to a [Node.js security fix](https://nodejs.org/en/blog/vulnerability/april-2024-security-releases-2#command-injection-via-args-parameter-of-child_processspawn-without-shell-option-enabled-on-windows-cve-2024-27980---high).

You can change [windows\_shim\_mode](https://mise.jdx.dev/configuration/settings.html#windows_shim_mode) to `hardlink` or `symlink`

<|firecrawl-page-137-lllmstxt|>
## Mise Hooks Overview
[Skip to content](https://mise.jdx.dev/hooks.html#VPContent)

Return to top

# Hooks experimental [​](https://mise.jdx.dev/hooks.html\#hooks)

You can have mise automatically execute scripts during a `mise activate` session. You cannot use these without the `mise activate` shell hook installed in your shell—except the `preinstall` and `postinstall` hooks. The configuration goes into `mise.toml`.

## CD hook [​](https://mise.jdx.dev/hooks.html\#cd-hook)

This hook is run anytimes the directory is changed.

toml

```
[hooks]
cd = "echo 'I changed directories'"
```

## Enter hook [​](https://mise.jdx.dev/hooks.html\#enter-hook)

This hook is run when the project is entered. Changing directories while in the project will not trigger this hook again.

toml

```
[hooks]
enter = "echo 'I entered the project'"
```

## Leave hook [​](https://mise.jdx.dev/hooks.html\#leave-hook)

This hook is run when the project is left. Changing directories while in the project will not trigger this hook.

toml

```
[hooks]
leave = "echo 'I left the project'"
```

## Preinstall/postinstall hook [​](https://mise.jdx.dev/hooks.html\#preinstall-postinstall-hook)

These hooks are run before tools are installed. Unlike other hooks, these hooks do not require `mise activate`.

toml

```
[hooks]
preinstall = "echo 'I am about to install tools'"
postinstall = "echo 'I just installed tools'"
```

## Watch files hook [​](https://mise.jdx.dev/hooks.html\#watch-files-hook)

While using `mise activate` you can have mise watch files for changes and execute a script when a file changes.

bash

```
[[watch_files]]
patterns = ["src/**/*.rs"]
run = "cargo fmt"
```

This hook will have the following environment variables set:

- `MISE_WATCH_FILES_MODIFIED`: A colon-separated list of the files that have been modified. Colons are escaped with a backslash.

## Hook execution [​](https://mise.jdx.dev/hooks.html\#hook-execution)

Hooks are executed with the following environment variables set:

- `MISE_ORIGINAL_CWD`: The directory that the user is in.
- `MISE_PROJECT_ROOT`: The root directory of the project.
- `MISE_PREVIOUS_DIR`: The directory that the user was in before the directory change (only if a directory change occurred).

## Shell hooks [​](https://mise.jdx.dev/hooks.html\#shell-hooks)

Hooks can be executed in the current shell, for example if you'd like to add bash completions when entering a directory:

toml

```
[hooks.enter]
shell = "bash"
script = "source completions.sh"
```

WARNING

I feel this should be obvious but in case it's not, this isn't going to do any sort of cleanup when you _leave_ the directory like using `[env]` does in `mise.toml`. You're literally just executing shell code when you enter the directory which mise has no way to track at all. I don't think there is a solution to this problem and it's likely the reason direnv has never implemented something similar.

I think in most situations this is probably fine, though worth keeping in mind.

## Multiple hooks syntax [​](https://mise.jdx.dev/hooks.html\#multiple-hooks-syntax)

You can use arrays to define multiple hooks in the same file:

toml

```
[hooks]
enter = [\
  "echo 'I entered the project'",\
  "echo 'I am in the project'"\
]

[[hooks.cd]]
script = "echo 'I changed directories'"
[[hooks.cd]]
script = "echo 'I also directories'"
```

<|firecrawl-page-138-lllmstxt|>
## IDE Integration Guide
[Skip to content](https://mise.jdx.dev/ide-integration.html#VPContent)

Return to top

# IDE Integration [​](https://mise.jdx.dev/ide-integration.html\#ide-integration)

Code editors and IDEs work differently than interactive shells.

Usually, they will either inherit the environment from your current shell (this is the case if you start it from a terminal like `nvim .` or `code .`) or will have [their own way](https://github.com/microsoft/vscode-docs/blob/906acccd6180d8425577f8297ed29e221ad3daca/docs/supporting/faq.md?plain=1#L238) to set up the environment.

Once you have launched the IDE, it won't reload the environment variables or the `PATH` provided by `mise` if you update your mise configuration files. Therefore, we cannot rely on the default `mise activate` method to automatically set up the editor.

There are a few ways to make `mise` work with your editor:

- Some editors or IDE plugins have direct support for `mise` and can let you select the tools/sdk path from the IDE settings. This will let you access to the tool binaries but won't load the environment variables.
- Most editors (and language plugins) will look for tools on the `PATH` and run them in the context of your project. Therefore, adding the `mise` shims to the `PATH` might be enough (see [below](https://mise.jdx.dev/ide-integration.html#adding-shims-to-path-default-shell)). This will run the tool provided by mise and load the environment variables.
- In other cases, you may need to manually indicate the path to the tools provided by `mise` in the IDE settings. This can be done by using [`mise which <tool>`](https://mise.jdx.dev/cli/which.html) or [`mise where`](https://mise.jdx.dev/cli/where.html). You can also provide the path to the tool shim (e.g. `~/.local/share/mise/shims/node`) if the plugin supports it as this will also load the environment variables when the tool is run.
- Finally, some custom plugins have been developed to work with `mise`. You can find them in the [IDE Plugins](https://mise.jdx.dev/ide-integration.html#ide-plugins) section.

## Adding shims to PATH in your default shell profile [​](https://mise.jdx.dev/ide-integration.html\#adding-shims-to-path-default-shell)

IDEs work better with [shims](https://mise.jdx.dev/dev-tools/shims.html) than they do environment variable modifications. The simplest way is to add the mise shim directory to `PATH`.

For IntelliJ and VSCode—and likely others, you can modify your default shell's profile script. Your default shell can be found with:

macoslinux

shell

```
dscl . -read /Users/$USER UserShell
```

shell

```
getent passwd $USER | cut -d: -f7
```

You can change your default shell with `chsh -s /path/to/shell` but you may need to first add it to `/etc/shells`. Once you know the right one, modify the appropriate file:

zshbashfish

zsh

```
# ~/.zprofile
eval "$(mise activate zsh --shims)"
```

bash

```
# ~/.bash_profile or ~/.bash_login or ~/.profile
eval "$(mise activate bash --shims)"
```

fish

```
# ~/.config/fish/config.fish
if status is-interactive
  mise activate fish | source
else
  mise activate fish --shims | source
end
```

This assumes that `mise` is on `PATH`. If it is not, you'll need to use the absolute path ( e.g.: `eval "$($HOME/.local/bin/mise activate zsh --shims)"`).

Here is an example showing that VSCode will use `node` provided by `mise`:

VSCodeIntelliJ

![vscode using shims](https://mise.jdx.dev/assets/shims-vscode.DZbNqNJ7.png)

As mentioned above, using `shims` doesn't work with all mise features. For example, arbitrary [env vars](https://mise.jdx.dev/environments/) in `[env]` will only be set if a shim is executed. For this we need tighter integration with the IDE and/or a custom plugin.

## IDE Plugins [​](https://mise.jdx.dev/ide-integration.html\#ide-plugins)

Here are some community plugins that have been developed to work with `mise`:

- Emacs: [mise.el](https://github.com/liuyinz/mise.el)
- IntelliJ: [intellij-mise](https://github.com/134130/intellij-mise)
- VSCode: [mise-vscode](https://github.com/hverlin/mise-vscode)

If you want to build a custom plugin for your editor, have a look at the existing plugins or take a look at existing direnv extensions and see if you can modify it to work for `mise`. `direnv` and `mise` work similarly and there should be a direnv extension that can be used as a starting point.

## Vim [​](https://mise.jdx.dev/ide-integration.html\#vim)

vim

```
" Prepend mise shims to PATH
let $PATH = $HOME . '/.local/share/mise/shims:' . $PATH
```

## Neovim [​](https://mise.jdx.dev/ide-integration.html\#neovim)

lua

```
-- Prepend mise shims to PATH
vim.env.PATH = vim.env.HOME .. "/.local/share/mise/shims:" .. vim.env.PATH
```

For a better Treesitter and LSP integration, check out the [neovim cookbook](https://mise.jdx.dev/mise-cookbook/neovim.html).

## emacs [​](https://mise.jdx.dev/ide-integration.html\#emacs)

### Traditional shims way [​](https://mise.jdx.dev/ide-integration.html\#traditional-shims-way)

lisp

```
;; CLI tools installed by Mise
;; See: https://www.emacswiki.org/emacs/ExecPath
(setenv "PATH" (concat (getenv "PATH") ":/home/user/.local/share/mise/shims"))
(setq exec-path (append exec-path '("/home/user/.local/share/mise/shims")))
```

### Use with package [mise.el](https://github.com/eki3z/mise.el) [​](https://mise.jdx.dev/ide-integration.html\#use-with-package-mise-el)

[https://github.com/eki3z/mise.el](https://github.com/eki3z/mise.el)

> A GNU Emacs library which uses the mise tool to determine per-directory/project environment variables and then set those environment variables on a per-buffer basis.

lisp

```
(require 'mise)
(add-hook 'after-init-hook #'global-mise-mode)
```

## JetBrains Editors (IntelliJ, RustRover, PyCharm, WebStorm, RubyMine, GoLand, etc) [​](https://mise.jdx.dev/ide-integration.html\#jetbrains-editors-intellij-rustrover-pycharm-webstorm-rubymine-goland-etc)

### IntelliJ Plugin [​](https://mise.jdx.dev/ide-integration.html\#intellij-plugin)

[https://github.com/134130/intellij-mise](https://github.com/134130/intellij-mise)

This plugin can automatically configure the IDE to use the tools provided by mise. It has also some support for running mise tasks and loading environment variables in the run configurations.

### Direct SDK selection [​](https://mise.jdx.dev/ide-integration.html\#direct-sdk-selection)

Some JetBrains IDEs (or language plugins) have direct support for `mise`. This allows you to select the SDK version from the IDE settings. Example for Java:

![SDK settings](https://mise.jdx.dev/assets/intellij-sdk-selection.DUhGxVAN.png)

### SDK selection using asdf layout [​](https://mise.jdx.dev/ide-integration.html\#sdk-selection-using-asdf-layout)

Some plugins cannot find SDK installed by `mise` yet but might have support for asdf. In that case, a workaround is to symlink the mise tool directory which has same layout as asdf:

sh

```
ln -s ~/.local/share/mise ~/.asdf
```

Then they should show up on in Project Settings:

![project settings](https://github.com/jdx/mise-docs/assets/216188/b34a0e3f-7af8-45c9-85b8-2c72bd1dc226)

Or in the case of node (possibly other languages), it's under "Languages & Frameworks":

![languages & frameworks](https://github.com/jdx/mise-docs/assets/216188/9926be1c-ab88-451a-8ace-edf2dac564b5)

## VSCode [​](https://mise.jdx.dev/ide-integration.html\#vscode)

### VSCode Plugin [​](https://mise.jdx.dev/ide-integration.html\#vscode-plugin)

There is a [VSCode plugin](https://marketplace.visualstudio.com/items?itemName=hverlin.mise-vscode) which can configure other extensions for you, without having to modify your shell profile to add the shims to `PATH`.

In addition, it provides additional features such as:

- Automatic configuration of other extensions to use tools provided by `mise`
- Manage `mise` tasks, tools, and environment variables directly from VSCode
- Load environment variables from `mise.toml` files in VSCode
- Support for autocompletion and snippets for `mise.toml` file
- Integration with VSCode tasks

[https://github.com/hverlin/mise-vscode/](https://github.com/hverlin/mise-vscode/) ( [Documentation](https://hverlin.github.io/mise-vscode/))

### Use [`mise exec`](https://mise.jdx.dev/cli/exec.html) in launch Configuration [​](https://mise.jdx.dev/ide-integration.html\#use-mise-exec-in-launch-configuration)

While modifying your default shell profile is likely the easiest solution, you can also set the tools in `launch.json`:

mise exec launch.json example

json

```
{
  "configurations": [\
    {\
      "type": "node",\
      "request": "launch",\
      "name": "Launch Program",\
      "program": "${file}",\
      "args": [],\
      "osx": {\
        "runtimeExecutable": "mise"\
      },\
      "linux": {\
        "runtimeExecutable": "mise"\
      },\
      "runtimeArgs": ["exec", "--", "node"]\
    }\
  ]
}
```

## Xcode [​](https://mise.jdx.dev/ide-integration.html\#xcode)

Xcode projects can run system commands from script build phases and schemes. Since Xcode sandboxes the execution of the script using the tool `/usr/bin/sandbox-exec`, don't expect Mise and the automatically-activated tools to work out of the box. First, you'll need to add `$(SRCROOT)/mise.toml` to the list of **Input files**. This is necessary for Xcode to allow reads to that file. Then, you can use `mise activate` to activate the tools you need:

bash

```
# -C ensures that Mise loads the configuration from the Mise configuration
# file in the project's root directory.
eval "$($HOME/.local/bin/mise activate -C $SRCROOT bash --shims)"

swiftlint
```

## \[YOUR IDE HERE\] [​](https://mise.jdx.dev/ide-integration.html\#your-ide-here)

I am not a heavy IDE user. I use JetBrains products but I don't actually like to execute code directly inside of them often so I don't have much personal advice to offer for IDEs generally. That said, people often ask about how to get their IDE to work with mise so if you've done this for your IDE, please consider sending a PR to this page with some instructions (however rough they are, starting somewhere is better than nothing).

Also if you've found a setup that you prefer to what is listed here consider adding it as a suggestion.

<|firecrawl-page-139-lllmstxt|>
## Mise Installation Guide
[Skip to content](https://mise.jdx.dev/installing-mise.html#VPContent)

Return to top

# Installing Mise [​](https://mise.jdx.dev/installing-mise.html\#installing-mise)

If you are new to `mise`, follow the [Getting Started](https://mise.jdx.dev/getting-started.html) guide first.

## Installation Methods [​](https://mise.jdx.dev/installing-mise.html\#installation-methods)

This page lists various ways to install `mise` on your system.

### [https://mise.run](https://mise.run/) [​](https://mise.jdx.dev/installing-mise.html\#https-mise-run)

Note that it isn't necessary for `mise` to be on `PATH`. If you run the activate script in your shell's rc file, mise will automatically add itself to `PATH`.

sh

```
curl https://mise.run | sh

# or with options
curl https://mise.run | MISE_INSTALL_PATH=/usr/local/bin/mise sh
```

#### Shell-specific installation + activation [​](https://mise.jdx.dev/installing-mise.html\#shell-specific-installation-activation)

For a more streamlined setup, you can use shell-specific endpoints that will install mise and automatically configure activation in your shell's configuration file:

zshbashfish

sh

```
curl https://mise.run/zsh | sh
# Installs mise and adds activation to ~/.zshrc
```

sh

```
curl https://mise.run/bash | sh
# Installs mise and adds activation to ~/.bashrc
```

sh

```
curl https://mise.run/fish | sh
# Installs mise and adds activation to ~/.config/fish/config.fish
```

These shell-specific installers will:

- Install mise using the same logic as the main installer
- Automatically detect your shell's configuration file
- Add the activation line if it's not already present
- Skip adding activation if it's already configured (safe to run multiple times)

Options:

- `MISE_DEBUG=1` – enable debug logging
- `MISE_QUIET=1` – disable non-error output
- `MISE_INSTALL_PATH=/some/path` – change the binary path (default: `~/.local/bin/mise`)
- `MISE_VERSION=v2024.5.17` – install a specific version

If you want to verify the install script hasn't been tampered with:

sh

```
gpg --keyserver hkps://keyserver.ubuntu.com --recv-keys 0x7413A06D
curl https://mise.jdx.dev/install.sh.sig | gpg --decrypt > install.sh
# ensure the above is signed with the mise release key
sh ./install.sh
```

TIP

As long as you don't change the version with `MISE_VERSION`, the install script will be pinned to whatever the latest version was when it was downloaded with checksums inside the file. This makes downloading the file and putting it into a project a great way to ensure that anyone installing with that script fetches the exact same mise bin.

Supported os/arch:

- `macos-x64`
- `macos-arm64`
- `linux-x64`
- `linux-x64-musl`
- `linux-arm64`
- `linux-arm64-musl`
- `linux-armv6`
- `linux-armv6-musl`
- `linux-armv7`
- `linux-armv7-musl`

If you need something else, compile it with `cargo install mise` (see below).

### apk [​](https://mise.jdx.dev/installing-mise.html\#apk)

For Alpine Linux:

sh

```
apk add mise
```

_mise lives in the [community repository](https://gitlab.alpinelinux.org/alpine/aports/-/blob/master/community/mise/APKBUILD)._

### apt [​](https://mise.jdx.dev/installing-mise.html\#apt)

For installation on Ubuntu/Debian:

amd64arm64

sh

```
sudo apt update -y && sudo apt install -y gpg sudo wget curl
sudo install -dm 755 /etc/apt/keyrings
wget -qO - https://mise.jdx.dev/gpg-key.pub | gpg --dearmor | sudo tee /etc/apt/keyrings/mise-archive-keyring.gpg 1> /dev/null
echo "deb [signed-by=/etc/apt/keyrings/mise-archive-keyring.gpg arch=amd64] https://mise.jdx.dev/deb stable main" | sudo tee /etc/apt/sources.list.d/mise.list
sudo apt update
sudo apt install -y mise
```

sh

```
sudo apt update -y && apt install -y gpg sudo wget curl
sudo install -dm 755 /etc/apt/keyrings
wget -qO - https://mise.jdx.dev/gpg-key.pub | gpg --dearmor | sudo tee /etc/apt/keyrings/mise-archive-keyring.gpg 1> /dev/null
echo "deb [signed-by=/etc/apt/keyrings/mise-archive-keyring.gpg arch=arm64] https://mise.jdx.dev/deb stable main" | sudo tee /etc/apt/sources.list.d/mise.list
sudo apt update
sudo apt install -y mise
```

### pacman [​](https://mise.jdx.dev/installing-mise.html\#pacman)

For Arch Linux:

sh

```
sudo pacman -S mise
```

### Cargo [​](https://mise.jdx.dev/installing-mise.html\#cargo)

Build from source with Cargo:

sh

```
cargo install mise
```

Do it faster with [cargo-binstall](https://github.com/cargo-bins/cargo-binstall):

sh

```
cargo install cargo-binstall
cargo binstall mise
```

Build from the latest commit in main:

sh

```
cargo install mise --git https://github.com/jdx/mise --branch main
```

### dnf [​](https://mise.jdx.dev/installing-mise.html\#dnf)

#### Fedora 41+, RHEL 9+, CentOS Stream 9+ [​](https://mise.jdx.dev/installing-mise.html\#fedora-41-rhel-9-centos-stream-9)

sh

```
dnf copr enable jdxcode/mise
dnf install mise
```

### Docker [​](https://mise.jdx.dev/installing-mise.html\#docker)

sh

```
docker run jdxcode/mise x node@20 -- node -v
```

### Homebrew [​](https://mise.jdx.dev/installing-mise.html\#homebrew)

sh

```
brew install mise
```

### npm [​](https://mise.jdx.dev/installing-mise.html\#npm)

mise is available on npm as a precompiled binary. This isn't a Node.js package—just distributed via npm. This is useful for JS projects that want to setup mise via `package.json` or `npx`.

sh

```
npm install -g @jdxcode/mise
```

Use npx if you just want to test it out for a single command without fully installing:

sh

```
npx @jdxcode/mise exec python@3.11 -- python some_script.py
```

### GitHub Releases [​](https://mise.jdx.dev/installing-mise.html\#github-releases)

Download the latest release from [GitHub](https://github.com/jdx/mise/releases).

sh

```
curl -L https://github.com/jdx/mise/releases/download/v2024.1.0/mise-v2024.1.0-linux-x64 > /usr/local/bin/mise
chmod +x /usr/local/bin/mise
```

### MacPorts [​](https://mise.jdx.dev/installing-mise.html\#macports)

sh

```
sudo port install mise
```

### nix [​](https://mise.jdx.dev/installing-mise.html\#nix)

For the Nix package manager, at release 23.05 or later:

sh

```
nix-env -iA mise
```

You can also import the package directly using `mise-flake.packages.${system}.mise`. It supports all default Nix systems.

### yum (RHEL 8, CentOS Stream 8, Amazon Linux 2) [​](https://mise.jdx.dev/installing-mise.html\#yum-rhel-8-centos-stream-8-amazon-linux-2)

sh

```
yum install -y yum-utils
yum-config-manager --add-repo https://mise.jdx.dev/rpm/mise.repo
yum install -y mise
```

### Windows - Scoop [​](https://mise.jdx.dev/installing-mise.html\#windows-scoop)

This is the recommended way to install mise on Windows. It will automatically add your shims to PATH.

sh

```
scoop install mise
```

### Windows - winget [​](https://mise.jdx.dev/installing-mise.html\#windows-winget)

sh

```
winget install jdx.mise
```

### Windows - Chocolatey [​](https://mise.jdx.dev/installing-mise.html\#windows-chocolatey)

INFO

chocolatey version is currently outdated.

sh

```
choco install mise
```

### Windows - manual [​](https://mise.jdx.dev/installing-mise.html\#windows-manual)

Download the latest release from [GitHub](https://github.com/jdx/mise/releases) and add the binary to your PATH.

If your shell does not support `mise activate`, you would want to edit PATH to include the shims directory (by default: `%LOCALAPPDATA%\mise\shims`).

## Shells [​](https://mise.jdx.dev/installing-mise.html\#shells)

### Bash [​](https://mise.jdx.dev/installing-mise.html\#bash)

sh

```
echo 'eval "$(mise activate bash)"' >> ~/.bashrc
```

### Zsh [​](https://mise.jdx.dev/installing-mise.html\#zsh)

sh

```
echo 'eval "$(mise activate zsh)"' >> "${ZDOTDIR-$HOME}/.zshrc"
```

### Fish [​](https://mise.jdx.dev/installing-mise.html\#fish)

sh

```
echo 'mise activate fish | source' >> ~/.config/fish/config.fish
```

TIP

For homebrew and possibly other installs mise is automatically activated so this is not necessary.

See [`MISE_FISH_AUTO_ACTIVATE=1`](https://mise.jdx.dev/configuration.html#mise_fish_auto_activate1) for more information.

### Powershell [​](https://mise.jdx.dev/installing-mise.html\#powershell)

WARNING

See [about\_Profiles](https://learn.microsoft.com/en-us/powershell/module/microsoft.powershell.core/about/about_profiles) docs to find your actual profile location. You will need to first create the parent directory if it does not exist.

powershell

```
echo 'mise activate pwsh | Out-String | Invoke-Expression' >> $HOME\Documents\PowerShell\Microsoft.PowerShell_profile.ps1
```

### Nushell [​](https://mise.jdx.dev/installing-mise.html\#nushell)

Nu does [not support `eval`](https://www.nushell.sh/book/how_nushell_code_gets_run.html#eval-function) Install Mise by appending `env.nu` and `config.nu`:

nushell

```
'
let mise_path = $nu.default-config-dir | path join mise.nu
^mise activate nu | save $mise_path --force
' | save $nu.env-path --append
"\nuse ($nu.default-config-dir | path join mise.nu)" | save $nu.config-path --append
```

If you prefer to keep your dotfiles clean you can save it to a different directory then update `$env.NU_LIB_DIRS`:

nushell

```
"\n$env.NU_LIB_DIRS ++= ($mise_path | path dirname | to nuon)" | save $nu.env-path --append
```

### Xonsh [​](https://mise.jdx.dev/installing-mise.html\#xonsh)

Since `.xsh` files are [not compiled](https://github.com/xonsh/xonsh/issues/3953) you may shave a bit off startup time by using a pure Python import: add the code below to, for example, `~/.config/xonsh/mise.py` config file and `import mise` it in `~/.config/xonsh/rc.xsh`:

python

```
from pathlib         import Path
from xonsh.built_ins import XSH

ctx = XSH.ctx
mise_init = subprocess.run([Path('~/bin/mise').expanduser(),'activate','xonsh'],capture_output=True,encoding="UTF-8").stdout
XSH.builtins.execx(mise_init,'exec',ctx,filename='mise')
```

Or continue to use `rc.xsh`/ `.xonshrc`:

sh

```
echo 'execx($(~/bin/mise activate xonsh))' >> ~/.config/xonsh/rc.xsh # or ~/.xonshrc
```

Given that `mise` replaces both shell env `$PATH` and OS environ `PATH`, watch out that your configs don't have these two set differently (might throw `os.environ['PATH'] = xonsh.built_ins.XSH.env.get_detyped('PATH')` at the end of a config to make sure they match)

### Elvish [​](https://mise.jdx.dev/installing-mise.html\#elvish)

Add following to your `rc.elv`:

shell

```
var mise: = (ns [&])
eval (mise activate elvish | slurp) &ns=$mise: &on-end={|ns| set mise: = $ns }
mise:activate
```

Optionally alias `mise` to `mise:mise` for seamless integration of `mise {activate,deactivate,shell}`:

shell

```
edit:add-var mise~ {|@args| mise:mise $@args }
```

### Something else? [​](https://mise.jdx.dev/installing-mise.html\#something-else)

Adding a new shell is not hard at all since very little shell code is in this project. [See here](https://github.com/jdx/mise/tree/main/src/shell) for how the others are implemented. If your shell isn't currently supported I'd be happy to help you get yours integrated.

## Autocompletion [​](https://mise.jdx.dev/installing-mise.html\#autocompletion)

TIP

Some installation methods automatically install autocompletion scripts.

The [`mise completion`](https://mise.jdx.dev/cli/completion.html) command can generate autocompletion scripts for your shell. This requires `usage` to be installed. If you don't have it, install it with:

shell

```
mise use -g usage
```

Then, run the following commands to install the completion script for your shell:

bashzshfish

sh

```
# This requires bash-completion to be installed
mkdir -p ~/.local/share/bash-completion/
mise completion bash --include-bash-completion-lib > ~/.local/share/bash-completion/completions/mise
```

sh

```
# If you use oh-my-zsh, there is a `mise` plugin. Update your .zshrc file with:
# plugins=(... mise)
# This must be after `source $ZSH/oh-my-zsh.sh` line in your .zshrc file.

# Otherwise, look where zsh search for completions with
echo $fpath | tr ' ' '\n'

# if you installed zsh with `apt-get` for example, this will work:
mkdir -p /usr/local/share/zsh/site-functions
mise completion zsh  > /usr/local/share/zsh/site-functions/_mise
```

sh

```
mise completion fish > ~/.config/fish/completions/mise.fish
```

Then source your shell's rc file or restart your shell.

## Uninstalling [​](https://mise.jdx.dev/installing-mise.html\#uninstalling)

Use `mise implode` to uninstall mise. This will remove the mise binary and all of its data. Use `mise implode --help` for more information.

Alternatively, manually remove the following directories to fully clean up:

- `~/.local/share/mise` (can also be `MISE_DATA_DIR` or `XDG_DATA_HOME/mise`)
- `~/.local/state/mise` (can also be `MISE_STATE_DIR` or `XDG_STATE_HOME/mise`)
- `~/.config/mise` (can also be `MISE_CONFIG_DIR` or `XDG_CONFIG_HOME/mise`)
- on Linux: `~/.cache/mise` (can also be `MISE_CACHE_DIR` or `XDG_CACHE_HOME/mise`)
- on macOS: `~/Library/Caches/mise` (can also be `MISE_CACHE_DIR`)

<|firecrawl-page-140-lllmstxt|>
## Bun Version Management
[Skip to content](https://mise.jdx.dev/lang/bun.html#VPContent)

Return to top

# Bun [​](https://mise.jdx.dev/lang/bun.html\#bun)

`mise` can be used to install and manage multiple versions of [bun](https://bun.sh/) on the same system.

> The following are instructions for using the bun mise core plugin. This is used when there isn't a git plugin installed named "bun".

The code for this is inside the mise repository at [`./src/plugins/core/bun.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/bun.rs).

## Usage [​](https://mise.jdx.dev/lang/bun.html\#usage)

The following installs bun and makes it the global default:

sh

```
mise use -g bun@0.7     # install bun 0.7.x
mise use -g bun@latest  # install latest bun
```

See available versions with `mise ls-remote bun`.

NOTE

Avoid using `bun upgrade` to upgrade bun as `mise` will not be aware of the change.

<|firecrawl-page-141-lllmstxt|>
## Manage Deno Versions
[Skip to content](https://mise.jdx.dev/lang/deno.html#VPContent)

Return to top

# Deno [​](https://mise.jdx.dev/lang/deno.html\#deno)

`mise` can be used to install and manage multiple versions of [deno](https://deno.land/) on the same system.

> The following are instructions for using the deno mise core plugin. This is used when there isn't a git plugin installed named "deno". If you want to use [asdf-deno](https://github.com/asdf-community/asdf-deno) then run `mise plugins install deno https://github.com/asdf-community/asdf-deno`.

The code for this is inside the mise repository at [`./src/plugins/core/deno.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/deno.rs).

## Usage [​](https://mise.jdx.dev/lang/deno.html\#usage)

The following installs deno and makes it the global default:

sh

```
mise use -g deno@1       # install deno 1.x
mise use -g deno@latest  # install latest deno
```

See available versions with `mise ls-remote deno`.

NOTE

Avoid using `deno upgrade` to upgrade `deno` as `mise` will not be aware of the change.

<|firecrawl-page-142-lllmstxt|>
## Elixir Version Management
[Skip to content](https://mise.jdx.dev/lang/elixir.html#VPContent)

Return to top

# Elixir experimental [​](https://mise.jdx.dev/lang/elixir.html\#elixir)

`mise` can be used to manage multiple [`elixir`](https://elixir-lang.org/) versions on the same system.

> The following are instructions for using the elixir core plugin. This is used when there isn't a git plugin installed named "elixir".

The code for this is inside the mise repository at [`./src/plugins/core/elixir.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/elixir.rs).

## Usage [​](https://mise.jdx.dev/lang/elixir.html\#usage)

Use the latest stable version of elixir:

sh

```
mise use -g erlang elixir
```

Note that [`erlang`](https://mise.jdx.dev/lang/erlang.html) is required to install `elixir`.

<|firecrawl-page-143-lllmstxt|>
## Erlang Version Management
[Skip to content](https://mise.jdx.dev/lang/erlang.html#VPContent)

Return to top

# Erlang [​](https://mise.jdx.dev/lang/erlang.html\#erlang)

`mise` can be used to install and manage multiple versions of [erlang](https://www.erlang.org/) on the same system.

> The following are instructions for using the erlang core plugin. This is used when there isn't a git plugin installed named "erlang".

The code for this is inside the mise repository at [`./src/plugins/core/erlang.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/erlang.rs).

## Usage [​](https://mise.jdx.dev/lang/erlang.html\#usage)

The following installs erlang and makes it the global default:

sh

```
mise use -g erlang@26
```

See available versions with `mise ls-remote erlang`.

## kerl [​](https://mise.jdx.dev/lang/erlang.html\#kerl)

The plugin uses [kerl](https://github.com/kerl/kerl) under the hood to build erlang. See kerl's docs for information on configuring kerl.

## Settings [​](https://mise.jdx.dev/lang/erlang.html\#settings)

### `erlang.compile`

- Type: `Bool`(optional)
- Env: `MISE_ERLANG_COMPILE`
- Default: `None`

If true, compile erlang from source. If false, use precompiled binaries. If not set, use precompiled binaries if available.

<|firecrawl-page-144-lllmstxt|>
## Manage Go Versions
[Skip to content](https://mise.jdx.dev/lang/go.html#VPContent)

Return to top

# Go [​](https://mise.jdx.dev/lang/go.html\#go)

`mise` can be used to install and manage multiple versions of [go](https://golang.org/) on the same system.

> The following are instructions for using the go mise core plugin. This is used when there isn't a git plugin installed named "go". If you want to use [asdf-golang](https://github.com/kennyp/asdf-golang) then use `mise plugins install go GIT_URL`.

The code for this is inside the mise repository at [`./src/plugins/core/go.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/go.rs).

## Usage [​](https://mise.jdx.dev/lang/go.html\#usage)

The following installs the latest version of go-1.21.x (if some version of 1.21.x is not already installed) and makes it the global default:

sh

```
mise use -g go@1.21
```

Minor go versions 1.20 and below require specifying `prefix` before the version number because the first version of each series was released without a `.0` suffix, making 1.20 an exact version match:

sh

```
mise use -g go@prefix:1.20
```

## `.go-version` file support [​](https://mise.jdx.dev/lang/go.html\#go-version-file-support)

mise uses a `mise.toml` or `.tool-versions` file for auto-switching between software versions. However, it can also read go-specific version files named `.go-version`.

See [idiomatic version files](https://mise.jdx.dev/configuration.html#idiomatic-version-files)

## Default packages [​](https://mise.jdx.dev/lang/go.html\#default-packages)

mise can automatically install a default set of packages right after installing a new go version. To enable this feature, provide a `$HOME/.default-go-packages` file that lists one packages per line, for example:

text

```
github.com/Dreamacro/clash # allows comments
github.com/jesseduffield/lazygit
```

## Settings [​](https://mise.jdx.dev/lang/go.html\#settings)

No settings available.

<|firecrawl-page-145-lllmstxt|>
## Java Version Management
[Skip to content](https://mise.jdx.dev/lang/java.html#VPContent)

Return to top

# Java [​](https://mise.jdx.dev/lang/java.html\#java)

Like `sdkman`, `mise` can manage multiple versions of Java on the same system.

> The following are instructions for using the java mise core plugin. This is used when there isn't a git plugin installed named "java". If you want to use [asdf-java](https://github.com/halcyon/asdf-java) then use `mise plugins install java GIT_URL`.

The code for this is inside the mise repository at [`./src/plugins/core/java.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/java.rs).

## Usage [​](https://mise.jdx.dev/lang/java.html\#usage)

The following installs the latest version of openjdk-21.x (if some version of openjdk-21.x is not already installed) and makes it the global default:

sh

```
mise use -g java@openjdk-21
mise use -g java@21         # alternate shorthands for openjdk-only
```

You can also install a jdk from a different vendor:

sh

```
mise use -g java@temurin-21
mise use -g java@zulu-21
mise use -g java@corretto-21
```

See available versions with `mise ls-remote java`.

WARNING

Note that shorthand versions (like `21` in the example) use [`OpenJDK`](https://openjdk.org/) as the vendor. The OpenJDK versions will only be updated for a 6-month period. Updates and security patches will not be available after this short period. This also applies for LTS versions.

For more information on which JDK to choose, see [https://whichjdk.com](https://whichjdk.com/).

## macOS JAVA\_HOME Integration [​](https://mise.jdx.dev/lang/java.html\#macos-java-home-integration)

Some applications in macOS rely on `/usr/libexec/java_home` to find installed Java runtimes.

To integrate an installed Java runtime with macOS run the following commands for the proper version (e.g. openjdk-21).

sh

```
sudo mkdir /Library/Java/JavaVirtualMachines/openjdk-21.jdk
sudo ln -s ~/.local/share/mise/installs/java/openjdk-21/Contents /Library/Java/JavaVirtualMachines/openjdk-21.jdk/Contents
```

> Note: Not all distributions of the Java SDK support this integration (e.g liberica).

## `.java-version` and `.sdkmanrc` files support [​](https://mise.jdx.dev/lang/java.html\#java-version-and-sdkmanrc-files-support)

The Java core plugin supports the idiomatic version files `.java-version` and `.sdkmanrc`. See [idiomatic version files](https://mise.jdx.dev/configuration.html#idiomatic-version-files).

For `.sdkmanrc` files, mise will try to map the vendor and version to the appropriate version string. For example, the version `20.0.2-tem` will be mapped to `temurin-20.0.2`. Due to Azul's Zulu versioning, the version `11.0.12-zulu` will be mapped to the major version `zulu-11`.

Not all vendors available in [sdkman](https://sdkman.io/jdks) are supported by mise. The following vendors are NOT supported: `bsg` (Bisheng), `graal` (GraalVM), `nik` (Liberica NIK).

### Using unsupported versions [​](https://mise.jdx.dev/lang/java.html\#using-unsupported-versions)

In case an unsupported version of java is needed, some manual work is required:

1. Download the unsupported version to a directory (e.g `~/.sdkman/candidates/java/21.0.1-open`)
2. symlink the new version:

sh

```
ln -s ~/.sdkman/candidates/java/21.0.1-open ~/.local/share/mise/installs/java/21.0.1-open
```

3. If on Mac:

sh

```
mkdir ~/.local/share/mise/installs/java/21.0.1-open/Contents
mkdir ~/.local/share/mise/installs/java/21.0.1-open/Contents/MacOS

ln -s ~/.sdkman/candidates/java/21.0.1-open ~/.local/share/mise/installs/java/21.0.1-open/Contents/Home
cp ~/.local/share/mise/installs/java/21.0.1-open/lib/libjli.dylib ~/.local/share/mise/installs/java/21.0.1-open/Contents/MacOS/libjli.dylib
```

4. Don't forget to make sure the cache is blocked and valid, by making sure an **empty** directory **exists** for your version in the [mise cache](https://mise.jdx.dev/directories.html#cache-mise): e.g.

sh

```
$ ls -R $MISE_CACHE_DIR/java
21.0.1-open

mise/java/21.0.1-open:
```

## Tool Options [​](https://mise.jdx.dev/lang/java.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `java` backend. These options go in the `[tools]` section in `mise.toml`.

### `release_type` [​](https://mise.jdx.dev/lang/java.html\#release-type)

The `release_type` option allows you to specify the type of release to install. The following values are supported:

- `ga` (default): General Availability release
- `ea`: Early Access release

toml

```
[tools]
"java" = { version = "openjdk-21", release_type = "ea" }
```

## Gradle toolchains detection [​](https://mise.jdx.dev/lang/java.html\#gradle-toolchains-detection)

Gradle can automatically detect toolchains installed by some tools (see [toolchain \| auto-detection](https://docs.gradle.org/current/userguide/toolchains.html#sec:auto_detection)).

At the moment, `Gradle` does not support auto-detecting Java installations by `mise` (see [gradle/issues/29508](https://github.com/gradle/gradle/issues/29508) and [gradle/issues/29355](https://github.com/gradle/gradle/issues/29355)). A workaround is to leverage the fact that `mise` install layout is [similar to the one used by `asdf`](https://mise.jdx.dev/ide-integration.html#sdk-selection-using-asdf-layout).

shell

```
mkdir -p ~/.asdf/installs/ && ln -s ~/.local/share/mise/installs/java ~/.asdf/installs/
```

Otherwise, you can always use the [foojay-resolver-convention](https://plugins.gradle.org/plugin/org.gradle.toolchains.foojay-resolver-convention) plugin to let Gradle automatically install JDKs required by your project.

<|firecrawl-page-146-lllmstxt|>
## Node.js Version Management
[Skip to content](https://mise.jdx.dev/lang/node.html#VPContent)

Return to top

# Node [​](https://mise.jdx.dev/lang/node.html\#node)

Like `nvm`, (or `volta`, `fnm` or `asdf`...), `mise` can manage multiple versions of Node.js on the same system.

> The following are instructions for using the node mise core plugin. This is used when there isn't a git plugin installed named "node". If you want to use [asdf-nodejs](https://github.com/asdf-vm/asdf-nodejs) then run `mise plugins install node https://github.com/asdf-vm/asdf-nodejs`

The code for this is inside the mise repository at [`./src/plugins/core/node.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/node.rs).

## Usage [​](https://mise.jdx.dev/lang/node.html\#usage)

The following installs the latest version of node-20.x and makes it the global default:

sh

```
mise use -g node@20
```

See the [Node.JS Cookbook](https://mise.jdx.dev/mise-cookbook/nodejs.html) for common tasks and examples.

## `.nvmrc` and `.node-version` support [​](https://mise.jdx.dev/lang/node.html\#nvmrc-and-node-version-support)

By default, mise uses a `mise.toml` file for auto-switching between software versions.

It also supports `.tool-versions`, `.nvmrc` or `.node-version` file to find out what version of Node.js should be used. This will be used if `node` isn't defined in `mise.toml`.

This makes it a drop-in replacement for `nvm`. See [idiomatic version files](https://mise.jdx.dev/configuration.html#idiomatic-version-files) for more information.

## Default node packages [​](https://mise.jdx.dev/lang/node.html\#default-node-packages)

mise-node can automatically install a default set of npm packages right after installing a node version. To enable this feature, provide a `$HOME/.default-npm-packages` file that lists one package per line, for example:

text

```
lodash
request
express
```

You can specify a non-default location of this file by setting a `MISE_NODE_DEFAULT_PACKAGES_FILE` variable.

## "nodejs" -> "node" Alias [​](https://mise.jdx.dev/lang/node.html\#nodejs-node-alias)

You cannot install/use a plugin named "nodejs". If you attempt this, mise will just rename it to "node". See the [FAQ](https://mise.jdx.dev/faq.html#what-is-the-difference-between-nodejs-and-node-or-golang-and-go) for an explanation.

## Building from source [​](https://mise.jdx.dev/lang/node.html\#building-from-source)

If compiling from source, see [BUILDING.md](https://github.com/nodejs/node/blob/main/BUILDING.md#building-nodejs-on-supported-platforms) in node's documentation for required system dependencies.

shell

```
mise settings node.compile=1
mise use node@latest
```

## Unofficial Builds [​](https://mise.jdx.dev/lang/node.html\#unofficial-builds)

Nodejs.org offers a set of [unofficial builds](https://unofficial-builds.nodejs.org/) which are compatible with some platforms that are not supported by the official binaries. These are a nice alternative to compiling from source for these platforms.

To use, first set the mirror url to point to the unofficial builds:

sh

```
mise settings node.mirror_url=https://unofficial-builds.nodejs.org/download/release/
```

If your goal is to simply support an alternative arch/os like linux-loong64 or linux-armv6l, this is all that is required. Node also provides flavors such as musl or glibc-217 (an older glibc version than what the official binaries are built with).

To use these, set `node.flavor`:

sh

```
mise settings node.flavor=musl
mise settings node.flavor=glibc-217
```

## Settings [​](https://mise.jdx.dev/lang/node.html\#settings)

### `node.compile`

- Type: `Bool`(optional)
- Env: `MISE_NODE_COMPILE`
- Default: `None`

Compile node from source.

### `node.flavor`

- Type: `string`(optional)
- Env: `MISE_NODE_FLAVOR`
- Default: `None`

Install a specific node flavor like glibc-217 or musl. Use with unofficial node build repo.

### `node.gpg_verify`

- Type: `Bool`(optional)
- Env: `MISE_NODE_GPG_VERIFY`
- Default: `None`

Use gpg to verify node tool signatures.

### `node.mirror_url`

- Type: `Url`(optional)
- Env: `MISE_NODE_MIRROR_URL`
- Default: `None`

Mirror to download node tarballs from.

## Environment Variables [​](https://mise.jdx.dev/lang/node.html\#environment-variables)

- `MISE_NODE_VERIFY` \[bool\]: Verify the downloaded assets using GPG. Defaults to `true`.
- `MISE_NODE_NINJA` \[bool\]: Use ninja instead of make to compile node. Defaults to `true` if installed.
- `MISE_NODE_CONCURRENCY` \[uint\]: How many jobs should be used in compilation. Defaults to half the computer cores
- `MISE_NODE_DEFAULT_PACKAGES_FILE` \[string\]: location of default packages file, defaults to `$HOME/.default-npm-packages`
- `MISE_NODE_CFLAGS` \[string\]: Additional CFLAGS options (e.g., to override -O3).
- `MISE_NODE_CONFIGURE_OPTS` \[string\]: Additional `./configure` options.
- `MISE_NODE_MAKE_OPTS` \[string\]: Additional `make` options.
- `MISE_NODE_MAKE_INSTALL_OPTS` \[string\]: Additional `make install` options.
- `MISE_NODE_COREPACK` \[bool\]: Installs the default corepack shims after installing any node version that ships with [corepack](https://github.com/nodejs/corepack).

INFO

These environment variables will be migrated to compatible settings in the future.

<|firecrawl-page-147-lllmstxt|>
## Manage Python Versions Easily
[Skip to content](https://mise.jdx.dev/lang/python.html#VPContent)

Return to top

# Python [​](https://mise.jdx.dev/lang/python.html\#python)

Like `pyenv`, `mise` can manage multiple versions of Python on the same system. Mise can also automatically create virtual environments for your projects and integrates with `uv`.

> The following are instructions for using the python mise core plugin. The core plugin will be used so long as no plugin is manually installed named "python" using `mise plugins install python [GIT_URL]`.

The code for this is inside of the mise repository at [`./src/plugins/core/python.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/python.rs).

## Usage [​](https://mise.jdx.dev/lang/python.html\#usage)

The following installs the latest version of python-3.11.x and makes it the global default:

sh

```
mise use -g python@3.11
```

You can also use multiple versions of python at the same time:

sh

```
$ mise use -g python@3.10 python@3.11
$ python -V
3.10.0
$ python3.11 -V
3.11.0
```

See the [Python Cookbook](https://mise.jdx.dev/mise-cookbook/python.html) for common tasks and examples.

## `.python-version` support [​](https://mise.jdx.dev/lang/python.html\#python-version-support)

`.python-version`/ `.python-versions` files are supported by mise. See [idiomatic version files](https://mise.jdx.dev/configuration.html#idiomatic-version-files).

## Automatic virtualenv activation [​](https://mise.jdx.dev/lang/python.html\#automatic-virtualenv-activation)

Python comes with virtualenv support built in, use it with `mise.toml` configuration like one of the following:

toml

```
[tools]
python = "3.11" # [optional] will be used for the venv

[env]
_.python.venv = ".venv" # relative to this file's directory
_.python.venv = "/root/.venv" # can be absolute
_.python.venv = "{{env.HOME}}/.cache/venv/myproj" # can use templates
_.python.venv = { path = ".venv", create = true } # create the venv if it doesn't exist
_.python.venv = { path = ".venv", create = true, python = "3.10" } # use a specific python version
_.python.venv = { path = ".venv", create = true, python_create_args = ["--without-pip"] } # pass args to python -m venv
_.python.venv = { path = ".venv", create = true, uv_create_args = ["--system-site-packages"] } # pass args to uv venv
# Install seed packages (pip, setuptools, and wheel) into the virtual environment.
_.python.venv = { path = ".venv", create = true, uv_create_args = ['--seed'] }
```

The venv will need to be created manually with `python -m venv /path/to/venv` unless `create=true`.

## mise & uv [​](https://mise.jdx.dev/lang/python.html\#mise-uv)

If you have installed `uv` (for example, with `mise use -g uv@latest`), `mise` will use it to create virtual environments. Otherwise, it will use the built-in `python -m venv` command.

Note that `uv` does not include `pip` by default (as `uv` provides `uv pip` instead). If you need the `pip` package, add the `uv_create_args = ['--seed']` option.

See the [mise + uv Cookbook](https://mise.jdx.dev/mise-cookbook/python.html#mise-uv) for more examples.

## Default Python packages [​](https://mise.jdx.dev/lang/python.html\#default-python-packages)

mise can automatically install a default set of Python packages with pip right after installing a Python version. To enable this feature, provide a `$HOME/.default-python-packages` file that lists one package per line, for example:

text

```
ansible
pipenv
```

You can specify a non-default location of this file by setting a `MISE_PYTHON_DEFAULT_PACKAGES_FILE` variable.

## Precompiled python binaries [​](https://mise.jdx.dev/lang/python.html\#precompiled-python-binaries)

By default, mise will download [precompiled binaries](https://github.com/astral-sh/python-build-standalone) for python instead of compiling them with python-build. This makes installing python much faster.

In addition to being faster, it also means you don't have to install all of the system dependencies either.

That said, there are some [quirks](https://github.com/astral-sh/python-build-standalone/blob/main/docs/quirks.rst) with the precompiled binaries to be aware of.

If you'd like to disable these binaries, set `mise settings python.compile=1`.

These binaries may not work on older CPUs however you may opt into binaries which are more compatible with older CPUs by setting `MISE_PYTHON_PRECOMPILED_ARCH` with a different version. See [https://gregoryszorc.com/docs/python-build-standalone/main/running.html](https://gregoryszorc.com/docs/python-build-standalone/main/running.html) for more information on this option. Set it to "x86\_64" for the most compatible binaries.

## python-build [​](https://mise.jdx.dev/lang/python.html\#python-build)

Optionally, mise uses [python-build](https://github.com/pyenv/pyenv/tree/master/plugins/python-build) (part of pyenv) to compile python runtimes, you need to ensure its [dependencies](https://github.com/pyenv/pyenv/wiki#suggested-build-environment) are installed before installing python with python-build.

## Installing free-threaded python [​](https://mise.jdx.dev/lang/python.html\#installing-free-threaded-python)

Free-threaded python can be installed via python-build by running the following:

bash

```
MISE_PYTHON_COMPILE=0 MISE_PYTHON_PRECOMPILED_FLAVOR=freethreaded+pgo-full mise install python
```

Or to compile with python-build:

bash

```
MISE_PYTHON_COMPILE=1 PYTHON_BUILD_FREE_THREADING=1 mise install python
```

## Troubleshooting errors with Homebrew [​](https://mise.jdx.dev/lang/python.html\#troubleshooting-errors-with-homebrew)

If you normally use Homebrew and you see errors regarding OpenSSL, your best bet might be using the following command to install Python:

sh

```
CFLAGS="-I$(brew --prefix openssl)/include" \
LDFLAGS="-L$(brew --prefix openssl)/lib" \
mise install python@latest;
```

Homebrew installs its own OpenSSL version, which may collide with system-expected ones. You could even add that to your `.profile`, `.bashrc`, `.zshrc`... to avoid setting them every time

Additionally, if you encounter issues with python-build, you may benefit from unlinking pkg-config prior to install ( [reason](https://github.com/pyenv/pyenv/issues/2823#issuecomment-1769081965)).

sh

```
brew unlink pkg-config
mise install python@latest
brew link pkg-config
```

Thus the entire script would look like:

sh

```
brew unlink pkg-config
CFLAGS="-I$(brew --prefix openssl)/include" \
  LDFLAGS="-L$(brew --prefix openssl)/lib" \
  mise install python@latest
brew link pkg-config
```

## Settings [​](https://mise.jdx.dev/lang/python.html\#settings)

`python-build` already has a [handful of settings](https://github.com/pyenv/pyenv/tree/master/plugins/python-build), in additional to that python in mise has a few extra configuration variables.

Set these with `mise settings set [VARIABLE] [VALUE]` or by setting the environment variable.

### `python.compile`

- Type: `Bool`(optional)
- Env: `MISE_PYTHON_COMPILE`
- Default: `None`

- Values:
  - `true` \- always compile with python-build instead of downloading [precompiled binaries](https://mise.jdx.dev/lang/python.html#precompiled-python-binaries).
  - `false` \- always download precompiled binaries.
  - \[undefined\] - use precompiled binary if one is available for the current platform, compile otherwise.

### `python.default_packages_file`

- Type: `Path`(optional)
- Env: `MISE_PYTHON_DEFAULT_PACKAGES_FILE`
- Default: `None`

Path to a file containing default python packages to install when installing a python version.

### `python.patch_url`

- Type: `Url`(optional)
- Env: `MISE_PYTHON_PATCH_URL`
- Default: `None`

URL to fetch python patches from to pass to python-build.

### `python.patches_directory`

- Type: `Path`(optional)
- Env: `MISE_PYTHON_PATCHES_DIRECTORY`
- Default: `None`

Directory to fetch python patches from.

### `python.precompiled_arch`

- Type: `string`
- Env: `MISE_PYTHON_PRECOMPILED_ARCH`
- Default: `"apple-darwin" | "unknown-linux-gnu" | "unknown-linux-musl"`

Specify the architecture to use for precompiled binaries.

### `python.precompiled_flavor`

- Type: `string`
- Env: `MISE_PYTHON_PRECOMPILED_FLAVOR`
- Default: `install_only_stripped`

Specify the flavor to use for precompiled binaries.

Options are available here: [https://gregoryszorc.com/docs/python-build-standalone/main/running.html](https://gregoryszorc.com/docs/python-build-standalone/main/running.html)

### `python.precompiled_os`

- Type: `string`
- Env: `MISE_PYTHON_PRECOMPILED_OS`
- Default: `"x86_64_v3" | "aarch64"`

Specify the architecture to use for precompiled binaries. If on an old CPU, you may want to set this to "x86\_64" for the most compatible binaries. See https://gregoryszorc.com/docs/python-build-standalone/main/running.html for more information.

### `python.pyenv_repo`

- Type: `string`
- Env: `MISE_PYENV_REPO`
- Default: `https://github.com/pyenv/pyenv.git`

URL to fetch pyenv from for compiling python with python-build.

### `python.uv_venv_auto`

- Type: `Bool`
- Env: `MISE_PYTHON_UV_VENV_AUTO`
- Default: `false`

Integrate with uv to automatically create/source venvs if uv.lock is present.

### `python.uv_venv_create_args`

- Type: `string[]`(optional)
- Env: `MISE_PYTHON_UV_VENV_CREATE_ARGS`(colon separated)
- Default: `None`

Arguments to pass to uv when creating a venv.

### `python.venv_auto_create` deprecated

- Type: `Bool`
- Env: `MISE_PYTHON_VENV_AUTO_CREATE`
- Default: `false`
- Deprecated: Use env.\_python.venv instead.

Automatically create virtualenvs for python tools.

### `python.venv_create_args`

- Type: `string[]`(optional)
- Env: `MISE_PYTHON_VENV_CREATE_ARGS`(colon separated)
- Default: `None`

Arguments to pass to python when creating a venv. (not used for uv venv creation)

### `python.venv_stdlib`

- Type: `Bool`
- Env: `MISE_VENV_STDLIB`
- Default: `false`

Prefer to use venv from Python's standard library.

<|firecrawl-page-148-lllmstxt|>
## Ruby Version Management
[Skip to content](https://mise.jdx.dev/lang/ruby.html#VPContent)

Return to top

# Ruby [​](https://mise.jdx.dev/lang/ruby.html\#ruby)

Like `rvm`, `rbenv`, or `asdf`, `mise` can manage multiple versions of [Ruby](https://www.ruby-lang.org/) on the same system.

> The following are instructions for using the ruby mise core plugin. This is used when there isn't a git plugin installed named "ruby". If you want to use [asdf-ruby](https://github.com/asdf-vm/asdf-ruby) then use `mise plugins install ruby GIT_URL`.

The code for this is inside the mise repository at [`./src/plugins/core/ruby.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/ruby.rs).

## Usage [​](https://mise.jdx.dev/lang/ruby.html\#usage)

The following installs the latest version of ruby-3.2.x (if some version of 3.2.x is not already installed) and makes it the global default:

sh

```
mise use -g ruby@3.2
```

Behind the scenes, mise uses [`ruby-build`](https://github.com/rbenv/ruby-build) to compile ruby from source. Ensure that you have the necessary [dependencies](https://github.com/rbenv/ruby-build/wiki#suggested-build-environment) installed. You can check its [README](https://github.com/rbenv/ruby-build/blob/master/README.md) for additional settings and some troubleshooting.

## Default gems [​](https://mise.jdx.dev/lang/ruby.html\#default-gems)

mise can automatically install a default set of gems right after installing a new ruby version. To enable this feature, provide a `$HOME/.default-gems` file that lists one gem per line, for example:

text

```
# supports comments
pry
bcat ~> 0.6.0 # supports version constraints
rubocop --pre # install prerelease version
```

## `.ruby-version` and `Gemfile` support [​](https://mise.jdx.dev/lang/ruby.html\#ruby-version-and-gemfile-support)

mise uses a `mise.toml` or `.tool-versions` file for auto-switching between software versions. However, it can also read ruby-specific version files `.ruby-version` or `Gemfile` (if it specifies a ruby version).

Create a `.ruby-version` file for the current version of ruby:

sh

```
ruby -v > .ruby-version
```

Enable idiomatic version file reading for ruby:

sh

```
mise settings add idiomatic_version_file_enable_tools ruby
```

See [idiomatic version files](https://mise.jdx.dev/configuration.html#idiomatic-version-files) for more information.

## Manually updating ruby-build [​](https://mise.jdx.dev/lang/ruby.html\#manually-updating-ruby-build)

ruby-build should update daily, however if you find versions do not yet exist you can force an update:

bash

```
mise cache clean
mise ls-remote ruby
```

## Settings [​](https://mise.jdx.dev/lang/ruby.html\#settings)

`ruby-build` already has a [handful of settings](https://github.com/rbenv/ruby-build?tab=readme-ov-file#custom-build-configuration), in additional to that mise has a few extra settings:

### `ruby.apply_patches`

- Type: `string`(optional)
- Env: `MISE_RUBY_APPLY_PATCHES`
- Default: `None`

A list of patch files or URLs to apply to ruby source.

### `ruby.default_packages_file`

- Type: `string`
- Env: `MISE_RUBY_DEFAULT_PACKAGES_FILE`
- Default: `~/.default-gems`

Path to a file containing default ruby gems to install when installing ruby.

### `ruby.ruby_build_opts`

- Type: `string`(optional)
- Env: `MISE_RUBY_BUILD_OPTS`
- Default: `None`

Options to pass to ruby-build.

### `ruby.ruby_build_repo`

- Type: `string`
- Env: `MISE_RUBY_BUILD_REPO`
- Default: `https://github.com/rbenv/ruby-build.git`

URL to fetch ruby-build from.

### `ruby.ruby_install`

- Type: `Bool`
- Env: `MISE_RUBY_INSTALL`
- Default: `false`

Use ruby-install instead of ruby-build.

### `ruby.ruby_install_opts`

- Type: `string`(optional)
- Env: `MISE_RUBY_INSTALL_OPTS`
- Default: `None`

Options to pass to ruby-install.

### `ruby.ruby_install_repo`

- Type: `string`
- Env: `MISE_RUBY_INSTALL_REPO`
- Default: `https://github.com/postmodern/ruby-install.git`

URL to fetch ruby-install from.

### `ruby.verbose_install`

- Type: `Bool`(optional)
- Env: `MISE_RUBY_VERBOSE_INSTALL`
- Default: `None`

Set to true to enable verbose output during ruby installation.

<|firecrawl-page-149-lllmstxt|>
## Rust Installation Guide
[Skip to content](https://mise.jdx.dev/lang/rust.html#VPContent)

Return to top

# Rust experimental [​](https://mise.jdx.dev/lang/rust.html\#rust)

Rust/cargo can be installed which uses rustup under the hood. mise will install rustup if it is not already installed and add the requested targets. By default, mise respects the `RUSTUP_HOME` and `CARGO_HOME` environment variables for the home directories and falls back to their standard location ( `~/.rustup` and `~/.cargo`) if they are not set. You can change this by setting the `MISE_RUSTUP_HOME` and `MISE_CARGO_HOME` environment variables if you'd like to isolate mise's rustup/cargo from your other rustup/cargo installations.

Unlike most tools, these won't exist inside of `~/.local/share/mise/installs` because they are managed by rustup. All mise does is set the `RUSTUP_TOOLCHAIN` environment variable to the requested version and rustup will automatically install it if it doesn't exist.

## Usage [​](https://mise.jdx.dev/lang/rust.html\#usage)

Use the latest stable version of rust:

sh

```
mise use -g rust
cargo build
```

Use the latest beta version of rust:

sh

```
mise use -g rust@beta
cargo build
```

Use a specific version of rust:

sh

```
mise use -g rust@1.82
cargo build
```

## Tool Options [​](https://mise.jdx.dev/lang/rust.html\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `rust` backend—these go in `[tools]` in `mise.toml`.

### `components` [​](https://mise.jdx.dev/lang/rust.html\#components)

The `components` option allows you to specify which components to install. Multiple components can be specified by separating them with a comma. The set of available components may vary with different releases and toolchains. Please consult the Rust documentation for the most up-to-date list of components.

toml

```
[tools]
"rust" = { version = "1.83.0", components = "rust-src,llvm-tools" }
```

### `profile` [​](https://mise.jdx.dev/lang/rust.html\#profile)

The `profile` option allows you to specify the type of release to install. The following values are supported:

- `minimal`: Includes as few components as possible to get a working compiler (rustc, rust-std, and cargo)
- `default` (default): Includes all of components in the minimal profile, and adds rust-docs, rustfmt, and clippy
- `complete`: Includes all the components available through rustup. This should never be used, as it includes every component ever included in the metadata and thus will almost always fail.

toml

```
[tools]
"rust" = { version = "1.83.0", profile = "minimal" }
```

### `targets` [​](https://mise.jdx.dev/lang/rust.html\#targets)

The `targets` option allows you to specify a list of platforms to install for cross-compilation. Multiple targets can be specified by separating them with a comma.

toml

```
[tools]
"rust" = { version = "1.83.0", targets = "wasm32-unknown-unknown,thumbv2-none-eabi" }
```

## Settings [​](https://mise.jdx.dev/lang/rust.html\#settings)

### `rust.cargo_home`

- Type: `Path`(optional)
- Env: `MISE_CARGO_HOME`
- Default: `None`

Path to the cargo home directory. Defaults to `~/.cargo` or `%USERPROFILE%\.cargo`

### `rust.rustup_home`

- Type: `Path`(optional)
- Env: `MISE_RUSTUP_HOME`
- Default: `None`

Path to the rustup home directory. Defaults to `~/.rustup` or `%USERPROFILE%\.rustup`

<|firecrawl-page-150-lllmstxt|>
## Manage Swift Versions
[Skip to content](https://mise.jdx.dev/lang/swift.html#VPContent)

Return to top

# Swift experimental [​](https://mise.jdx.dev/lang/swift.html\#swift)

`mise` can be used to manage multiple versions of [`swift`](https://swift.org/) on the same system. Swift is supported for macos and linux.

## Usage [​](https://mise.jdx.dev/lang/swift.html\#usage)

Use the latest stable version of swift:

sh

```
mise use -g swift
swift --version
```

See [a mise guide for Swift developers](https://tuist.dev/blog/2025/02/04/mise) on how to use `mise` with `swift`.

## Settings [​](https://mise.jdx.dev/lang/swift.html\#settings)

### `swift.gpg_verify`

- Type: `Bool`(optional)
- Env: `MISE_SWIFT_GPG_VERIFY`
- Default: `None`

Use gpg to verify swift tool signatures.

### `swift.platform`

- Type: `string`
- Env: `MISE_SWIFT_PLATFORM`
- Default: `"osx" | "windows10" | "ubuntu20.04" | "ubuntu22.04" | "ubuntu24.04" | "amazonlinux2" | "ubi9" | "fedora39"`

Override the platform to use for precompiled binaries.

<|firecrawl-page-151-lllmstxt|>
## Zig Version Management
[Skip to content](https://mise.jdx.dev/lang/zig.html#VPContent)

Return to top

# Zig [​](https://mise.jdx.dev/lang/zig.html\#zig)

`mise` can be used to install and manage multiple versions of [zig](https://ziglang.org/) on the same system.

> The following are instructions for using the zig mise core plugin.

The code for this is inside the mise repository at [`./src/plugins/core/zig.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/zig.rs).

## Usage [​](https://mise.jdx.dev/lang/zig.html\#usage)

The following installs zig and makes it the global default:

sh

```
mise use -g zig@0.14           # install zig 0.14.x
mise use -g zig@latest         # install latest zig release
mise use -g zig@master         # install latest nightly from master
mise use -g zig@2024.11.0-mach # install Mach nominated zig
mise use -g zig@mach-latest    # install latest Mach nominated zig
```

See available stable versions with `mise ls-remote zig`.

Note that [Mach](https://machengine.org/) versions won't show in `mise ls-remote zig` due to workaround for [version ordering bug](https://github.com/jdx/mise/discussions/5232). Despite of that, you still can install Mach versions listed in [Mach version index](https://machengine.org/zig/index.json). The following command will list available Mach versions:

sh

```
curl https://machengine.org/zig/index.json | yq 'keys'
```

## zig Language Server [​](https://mise.jdx.dev/lang/zig.html\#zig-language-server)

The `zig` language server ( [zls](https://github.com/zigtools/zls)) needs to be installed separately. You can install it with `mise`:

sh

```
mise use -g zls@0.14   # install zls 0.14.x
mise use -g zls@latest # install latest zls release
```

Note that a tagged release of `zig` should be used with the same tagged release of `zls`. Currently there is no Mach version of `zls`.

<|firecrawl-page-152-lllmstxt|>
## Model Context Protocol Overview
[Skip to content](https://mise.jdx.dev/mcp.html#VPContent)

Return to top

# Model Context Protocol (MCP) [​](https://mise.jdx.dev/mcp.html\#model-context-protocol-mcp)

The Model Context Protocol (MCP) is a standard protocol that enables AI assistants to interact with development tools and access project context. Mise provides an MCP server that allows AI assistants to query information about your development environment.

## Overview [​](https://mise.jdx.dev/mcp.html\#overview)

When you run `mise mcp`, it starts a server that AI assistants can connect to and query information about your mise-managed development environment. The server communicates over stdin/stdout using JSON-RPC protocol.

WARNING

The MCP feature is experimental and requires enabling experimental features with `MISE_EXPERIMENTAL=1`.

## Usage [​](https://mise.jdx.dev/mcp.html\#usage)

The MCP server is typically launched by AI assistants automatically, but you can also run it manually for testing:

bash

```
# Enable experimental features
export MISE_EXPERIMENTAL=1

# Start the MCP server (it will wait for JSON-RPC input on stdin)
mise mcp
```

## Available Resources [​](https://mise.jdx.dev/mcp.html\#available-resources)

The MCP server exposes the following read-only resources that AI assistants can query:

### `mise://tools` [​](https://mise.jdx.dev/mcp.html\#mise-tools)

Lists all tools managed by mise in your project, including:

- Tool names and versions
- Installation status
- Configuration source

### `mise://tasks` [​](https://mise.jdx.dev/mcp.html\#mise-tasks)

Shows all available mise tasks with:

- Task names and descriptions
- Task dependencies
- Command definitions

### `mise://env` [​](https://mise.jdx.dev/mcp.html\#mise-env)

Displays environment variables defined in your mise configuration:

- Variable names and values
- Environment-specific overrides

### `mise://config` [​](https://mise.jdx.dev/mcp.html\#mise-config)

Provides information about mise configuration:

- Active configuration files
- Project root directory
- Settings and preferences

## Available Tools [​](https://mise.jdx.dev/mcp.html\#available-tools)

The following tools are available for AI assistants to call (currently stubbed for future implementation):

### `install_tool` [​](https://mise.jdx.dev/mcp.html\#install-tool)

Install a specific tool version (not yet implemented)

### `run_task` [​](https://mise.jdx.dev/mcp.html\#run-task)

Execute a mise task (not yet implemented)

## Integration with AI Assistants [​](https://mise.jdx.dev/mcp.html\#integration-with-ai-assistants)

### Claude Desktop [​](https://mise.jdx.dev/mcp.html\#claude-desktop)

To use mise with Claude Desktop, add the following to your Claude configuration file:

**macOS**: `~/Library/Application Support/Claude/claude_desktop_config.json`

**Windows**: `%APPDATA%\Claude\claude_desktop_config.json`

**Linux**: `~/.config/claude/claude_desktop_config.json`

json

```
{
  "mcpServers": {
    "mise": {
      "command": "mise",
      "args": ["mcp"],
      "env": {
        "MISE_EXPERIMENTAL": "1"
      }
    }
  }
}
```

After adding this configuration and restarting Claude Desktop, the assistant will be able to:

- Query your installed tools and versions
- List available tasks in your project
- Access environment variables from your mise configuration
- View your mise configuration structure

### Other AI Assistants [​](https://mise.jdx.dev/mcp.html\#other-ai-assistants)

The MCP server uses standard JSON-RPC 2.0 over stdio, making it compatible with any AI assistant that supports the Model Context Protocol. Consult your AI assistant's documentation for specific integration instructions.

## Examples [​](https://mise.jdx.dev/mcp.html\#examples)

When integrated with an AI assistant, you can ask questions like:

- "What version of Node.js is this project using?"
- "List all the tasks available in this project"
- "What environment variables are set by mise?"
- "Show me the mise configuration for this project"

The AI assistant will query the MCP server to provide accurate, up-to-date information about your development environment.

## Technical Details [​](https://mise.jdx.dev/mcp.html\#technical-details)

The MCP server implementation can be found in [`src/cli/mcp.rs`](https://github.com/jdx/mise/blob/main/src/cli/mcp.rs). It implements the ServerHandler trait from the rmcp crate to handle:

- Resource listing and reading
- Tool invocation (planned)
- JSON-RPC communication over stdio

For more information about the Model Context Protocol, visit the [official MCP documentation](https://modelcontextprotocol.io/).

<|firecrawl-page-153-lllmstxt|>
## Mise C++ Project Management
[Skip to content](https://mise.jdx.dev/mise-cookbook/cpp.html#VPContent)

Return to top

# Mise + C++ Cookbook [​](https://mise.jdx.dev/mise-cookbook/cpp.html\#mise-c-cookbook)

Here are some tips on managing C++ projects with mise.

## A C++ Project with CMake [​](https://mise.jdx.dev/mise-cookbook/cpp.html\#a-c-project-with-cmake)

mise.toml

toml

```
min_version = "2024.9.5"

[env]
# Project information
PROJECT_NAME = "{{ config_root | basename }}"

# Build directory
BUILD_DIR = "{{ config_root }}/build"

[tools]
# Install CMake and make
cmake = "latest"
make = "latest"

[tasks.configure]
description = "Configure the project"
run = "mkdir -p $BUILD_DIR && cd $BUILD_DIR && cmake .."

[tasks.build]
description = "Build the project"
alias = "b"
run = "cd $BUILD_DIR && make"

[tasks.clean]
description = "Clean the build directory"
alias = "c"
run = "rm -rf $BUILD_DIR"

[tasks.run]
alias = "r"
description = "Run the application"
run = "$BUILD_DIR/bin/$PROJECT_NAME"

[tasks.info]
description = "Print project information"
run = '''
echo "Project: $PROJECT_NAME"
echo "Build Directory: $BUILD_DIR"
'''
```

<|firecrawl-page-154-lllmstxt|>
## Mise Docker Cookbook
[Skip to content](https://mise.jdx.dev/mise-cookbook/docker.html#VPContent)

Return to top

# Mise + Docker Cookbook [​](https://mise.jdx.dev/mise-cookbook/docker.html\#mise-docker-cookbook)

Here are some tips on using Docker with mise.

## Docker image with mise [​](https://mise.jdx.dev/mise-cookbook/docker.html\#docker-image-with-mise)

Here is an example Dockerfile showing how to install mise in a Docker image.

Dockerfile

Dockerfile

```
FROM debian:12-slim

RUN apt-get update  \
    && apt-get -y --no-install-recommends install  \
        # install any other dependencies you might need
        sudo curl git ca-certificates build-essential \
    && rm -rf /var/lib/apt/lists/*

SHELL ["/bin/bash", "-o", "pipefail", "-c"]
ENV MISE_DATA_DIR="/mise"
ENV MISE_CONFIG_DIR="/mise"
ENV MISE_CACHE_DIR="/mise/cache"
ENV MISE_INSTALL_PATH="/usr/local/bin/mise"
ENV PATH="/mise/shims:$PATH"
# ENV MISE_VERSION="..."

RUN curl https://mise.run | sh
```

Build and run the Docker image:

shell

```
docker build -t debian-mise .
docker run -it --rm debian-mise
```

## Task to run mise in a Docker container [​](https://mise.jdx.dev/mise-cookbook/docker.html\#task-to-run-mise-in-a-docker-container)

This can be useful use if you need to reproduce an issue you're having with mise in a clean environment.

mise.toml

toml

```
[tasks.docker]
run = "docker run --pull=always -it --rm --entrypoint bash jdxcode/mise:latest"
```

Example usage:

shell

```
❯ mise docker
[docker] $ docker run --pull=always -it --rm --entrypoint bash jdxcode/mise:latest
# latest: Pulling from jdxcode/mise
# Digest: sha256:eecc479b6259479ffca5a4f9c68dbfe8631ca62dc59aa60c9ab5e4f6e9982701
# Status: Image is up to date for jdxcode/mise:latest
root@75f179a190a1:/mise# eval "$(mise activate bash)"
# overwrite configuration and prune to give us a clean state
root@75f179a190a1:/mise# echo "" >/mise/config.toml
root@75f179a190a1:/mise# mise prune --yes
# mise pruned configuration links
# mise python@3.13.1 ✓ remove /mise/cache/python/3.13.1
# ...
```

<|firecrawl-page-155-lllmstxt|>
## Page Not Found
# Error 404

### Object not found

This object does not exist or is not publicly accessible at this
URL. Check the URL of the object that you're looking for or contact
the owner to enable Public access.


Is this your bucket?

Learn how to enable
[Public Access](https://developers.cloudflare.com/r2/data-access/public-buckets/)

<|firecrawl-page-156-lllmstxt|>
## Mise Neovim Cookbook
[Skip to content](https://mise.jdx.dev/mise-cookbook/neovim.html#VPContent)

Return to top

# Mise + Neovim Cookbook [​](https://mise.jdx.dev/mise-cookbook/neovim.html\#mise-neovim-cookbook)

Here are some tips for an improved mise workflow with [Neovim](https://github.com/neovim/neovim).

## Code highlight for run commands [​](https://mise.jdx.dev/mise-cookbook/neovim.html\#code-highlight-for-run-commands)

Use [Treesitter](https://github.com/nvim-treesitter/nvim-treesitter) to highlight code in the run commands of your mise files as shown on the left side of the image:

![image](https://github.com/user-attachments/assets/2961163b-1e6b-4ff6-b2e6-29eb53afc7e5)

In your neovim config, create a `after/queries/toml/injections.scm` file with these queries:

scm

```
; extends

(pair
  (bare_key) @key (#eq? @key "run")
  (string) @injection.content @injection.language

  (#is-mise?)
  (#match? @injection.language "^['\"]{3}\n*#!(/\\w+)+/env\\s+\\w+") ; multiline shebang using env
  (#gsub! @injection.language "^.*#!/.*/env%s+([^%s]+).*" "%1") ; extract lang
  (#offset! @injection.content 0 3 0 -3) ; rm quotes
)

(pair
  (bare_key) @key (#eq? @key "run")
  (string) @injection.content @injection.language

  (#is-mise?)
  (#match? @injection.language "^['\"]{3}\n*#!(/\\w+)+\s*\n") ; multiline shebang
  (#gsub! @injection.language "^.*#!/.*/([^/%s]+).*" "%1") ; extract lang
  (#offset! @injection.content 0 3 0 -3) ; rm quotes
)

(pair
  (bare_key) @key (#eq? @key "run")
  (string) @injection.content

  (#is-mise?)
  (#match? @injection.content "^['\"]{3}\n*.*") ; multiline
  (#not-match? @injection.content "^['\"]{3}\n*#!") ; no shebang
  (#offset! @injection.content 0 3 0 -3) ; rm quotes
  (#set! injection.language "bash") ; default to bash
)

(pair
  (bare_key) @key (#eq? @key "run")
  (string) @injection.content

  (#is-mise?)
  (#not-match? @injection.content "^['\"]{3}") ; not multiline
  (#offset! @injection.content 0 1 0 -1) ; rm quotes
  (#set! injection.language "bash") ; default to bash
)
```

To only apply the highlighting on mise files instead of all toml files, the `is-mise?` predicate is used. If you don't care for this distinction, the lines containing `(#is-mise?)` can be removed. Otherwise, make sure to also create the predicate somewhere in your neovim config.

For example, using [`lazy.nvim`](https://github.com/folke/lazy.nvim):

lua

```
{
  "nvim-treesitter/nvim-treesitter",
  init = function()
    require("vim.treesitter.query").add_predicate("is-mise?", function(_, _, bufnr, _)
      local filepath = vim.api.nvim_buf_get_name(tonumber(bufnr) or 0)
      local filename = vim.fn.fnamemodify(filepath, ":t")
      return string.match(filename, ".*mise.*%.toml$") ~= nil
    end, { force = true, all = false })
  end,
},
```

This will consider any `toml` file containing `mise` in its name as a mise file.

## Enable LSP for embedded lang in run commands [​](https://mise.jdx.dev/mise-cookbook/neovim.html\#enable-lsp-for-embedded-lang-in-run-commands)

Use [`otter.nvim`](https://github.com/jmbuhr/otter.nvim) to enable LSP features and code completion for code embedded in your mise files.

Again using [`lazy.nvim`](https://github.com/folke/lazy.nvim):

lua

```
{
  "jmbuhr/otter.nvim",
  dependencies = {
    "nvim-treesitter/nvim-treesitter",
  },
  config = function()
    vim.api.nvim_create_autocmd({ "FileType" }, {
      pattern = { "toml" },
      group = vim.api.nvim_create_augroup("EmbedToml", {}),
      callback = function()
        require("otter").activate()
      end,
    })
  end,
},
```

This will only work if the [TS injection queries](https://mise.jdx.dev/mise-cookbook/neovim.html#code-highlight-for-run-commands) are also set up.

<|firecrawl-page-157-lllmstxt|>
## Node.js Project Management
[Skip to content](https://mise.jdx.dev/mise-cookbook/nodejs.html#VPContent)

Return to top

# Mise + Node.js Cookbook [​](https://mise.jdx.dev/mise-cookbook/nodejs.html\#mise-node-js-cookbook)

Here are some tips on managing [Node.js](https://mise.jdx.dev/lang/node.html) projects with mise.

## Getting started with Node.js [​](https://mise.jdx.dev/mise-cookbook/nodejs.html\#getting-started-with-node-js)

To install Node.JS, in a directory, you can use the following command:

shell

```
mise use node
```

This will install the latest version of Node.js and create a `mise.toml` file with the following content:

toml

```
node = "latest"
```

If you want to install Node.JS globally instead (for example, node v22), you can use the following command:

shell

```
mise use -g node@22
```

## Add node modules binaries to the PATH [​](https://mise.jdx.dev/mise-cookbook/nodejs.html\#add-node-modules-binaries-to-the-path)

When installing Node.js packages specified in `package.json`, you typically need to use `npx` or the full path to the binary. For example:

shell

```
npm install --save eslint
eslint --version # doesn't work
npx eslint --version # works
```

Thanks to `mise`, you can add the node modules binaries to the `PATH`. This will make CLIs installed with npm available without `npx`.

mise.toml

toml

```
[env]
_.path = ['{{config_root}}/node_modules/.bin']
```

Example:

shell

```
npm install --save eslint
eslint --version # works
```

## Example Node.js Project [​](https://mise.jdx.dev/mise-cookbook/nodejs.html\#example-node-js-project)

mise.toml

toml

```
min_version = "2024.9.5"

[env]
_.path = ['{{config_root}}/node_modules/.bin']

# Use the project name derived from the current directory
PROJECT_NAME = "{{ config_root | basename }}"

# Set up the path for node module binaries
BIN_PATH = "{{ config_root }}/node_modules/.bin"

NODE_ENV = "{{ env.NODE_ENV | default(value='development') }}"

[tools]
# Install Node.js using the specified version
node = "{{ env['NODE_VERSION'] | default(value='lts') }}"

# Install some npm packages globally if needed
"npm:typescript" = "latest"
"npm:eslint" = "latest"
"npm:jest" = "latest"

[tasks.install]
alias = "i"
description = "Install npm dependencies"
run = "npm install"

[tasks.start]
alias = "s"
description = "Start the development server"
run = "npm run start"

[tasks.lint]
alias = "l"
description = "Run ESLint"
run = "eslint src/"

[tasks.test]
description = "Run tests"
alias = "t"
run = "jest"

[tasks.build]
description = "Build the project"
alias = "b"
run = "npm run build"

[tasks.info]
description = "Print project information"
run = '''
echo "Project: $PROJECT_NAME"
echo "NODE_ENV: $NODE_ENV"
'''
```

## Example with `pnpm` [​](https://mise.jdx.dev/mise-cookbook/nodejs.html\#example-with-pnpm)

This example uses `pnpm` as the package manager. This will skip installing dependencies if the lock file hasn't changed.

mise.toml

toml

```
[tools]
node = '22'

[hooks]
# Enabling corepack will install the `pnpm` package manager specified in your package.json
# alternatively, you can also install `pnpm` with mise
postinstall = 'npx corepack enable'

[settings]
# This must be enabled to make the hooks work
experimental = true

[env]
_.path = ['./node_modules/.bin']

[tasks.pnpm-install]
description = 'Installs dependencies with pnpm'
run = 'pnpm install'
sources = ['package.json', 'pnpm-lock.yaml', 'mise.toml']
outputs = ['node_modules/.pnpm/lock.yaml']

[tasks.dev]
description = 'Calls your dev script in `package.json`'
run = 'node --run dev'
depends = ['pnpm-install']
```

With this setup, getting started in a NodeJS project is as simple as running `mise dev`:

- `mise` will install the correct version of NodeJS
- `mise` will enable `corepack`
- `pnpm install` will be run before `node --run dev`

<|firecrawl-page-158-lllmstxt|>
## Custom Project Presets
[Skip to content](https://mise.jdx.dev/mise-cookbook/presets.html#VPContent)

Return to top

# Presets [​](https://mise.jdx.dev/mise-cookbook/presets.html\#presets)

You can create your own presets by leveraging [mise tasks](https://mise.jdx.dev/tasks/) to reduce boilerplate and make it easier to set up new projects.

## Example python preset [​](https://mise.jdx.dev/mise-cookbook/presets.html\#example-python-preset)

Here is an example of how to create your python preset that creates a `mise.toml` file to work with `python` and `pdm`

~/.config/mise/tasks/preset/python

shell

```
#!/usr/bin/env bash
#MISE dir="{{cwd}}"

mise use pre-commit
mise config set env._.python.venv.path .venv
mise config set env._.python.venv.create true -t bool
mise tasks add lint -- pre-commit run -a
```

~/.config/mise/tasks/preset/pdm

shell

```
#!/usr/bin/env bash
#MISE dir="{{cwd}}"
#MISE depends=["preset:python"]
#USAGE arg "<version>"

mise use python@$usage_version
mise use pdm@latest
mise config set hooks.postinstall "pdm sync"
```

Then in any directory, you can run `mise preset:pdm 3.10` to scaffold a new project with `python` and `pdm`:

shell

```
cd my-project
mise preset:pdm 3.10
# [preset:python] $ ~/.config/mise/tasks/preset/python
# mise WARN  No untrusted config files found.
# mise ~/my-project/mise.toml tools: pre-commit@4.0.1
# [preset:pdm] $ ~/.config/mise/tasks/preset/pdm 3.10
# mise WARN  No untrusted config files found.
# mise ~/my-project/mise.toml tools: python@3.10.15
# mise ~/my-project/mise.toml tools: pdm@2.21.0
# mise creating venv with uv at: ~/my-project/.venv
# Using CPython 3.10.15 interpreter at: /Users/simon/.local/share/mise/installs/python/3.10.15/bin/python
# Creating virtual environment at: .venv
# Activate with: source .venv/bin/activate.fish

~/my-project via 🐍 v3.10.15 (.venv)
# we are in the virtual environment ^
```

Here is the generated `mise.toml` file:

mise.toml

toml

```
[tools]
pdm = "latest"
pre-commit = "latest"
python = "3.10"

[hooks]
postinstall = "pdm sync"

[env]
[env._]
[env._.python]
[env._.python.venv]
path = ".venv"
create = true

[tasks.lint]
run = "pre-commit run -a"
```

<|firecrawl-page-159-lllmstxt|>
## Mise Python Cookbook
[Skip to content](https://mise.jdx.dev/mise-cookbook/python.html#VPContent)

Return to top

# Mise + Python Cookbook [​](https://mise.jdx.dev/mise-cookbook/python.html\#mise-python-cookbook)

Here are some tips on managing [Python](https://mise.jdx.dev/lang/python.html) projects with mise.

## A Python Project with virtualenv [​](https://mise.jdx.dev/mise-cookbook/python.html\#a-python-project-with-virtualenv)

Here is an example python project with a `requirements.txt` file.

mise.toml

toml

```
min_version = "2024.9.5"

[env]
# Use the project name derived from the current directory
PROJECT_NAME = "{{ config_root | basename }}"

# Automatic virtualenv activation
_.python.venv = { path = ".venv", create = true }

[tools]
python = "{{ get_env(name='PYTHON_VERSION', default='3.11') }}"
ruff = "latest"

[tasks.install]
description = "Install dependencies"
alias = "i"
run = "uv pip install -r requirements.txt"

[tasks.run]
description = "Run the application"
run = "python app.py"

[tasks.test]
description = "Run tests"
run = "pytest tests/"

[tasks.lint]
description = "Lint the code"
run = "ruff src/"

[tasks.info]
description = "Print project information"
run = '''
echo "Project: $PROJECT_NAME"
echo "Virtual Environment: $VIRTUAL_ENV"
'''
```

## mise + uv [​](https://mise.jdx.dev/mise-cookbook/python.html\#mise-uv)

If you are using a `uv` project initialized with `uv init .`, here is how you can use it with mise.

Here is how the `uv` project will look like:

uv-project

shell

```
.
├── .gitignore
├── .python-version
├── hello.py
├── pyproject.toml
└── README.md

cat .python-version
# 3.12
```

If you run `uv run hello.py` in the `uv` project, `uv` will automatically create a virtual environment for you using the python version specified in the `.python-version` file. This will also create a `uv.lock` file.

`mise` will detect the python version in `.python-version`, however, it won't use the virtual env created by `uv` by default. So, using `which python` will show a global python installation from `mise`.

shell

```
mise i
which python
# ~/.local/share/mise/installs/python/3.12.4/bin/python
```

If you want `mise` to use the virtual environment created by `uv`, you can set the [`python.uv_venv_auto`](https://mise.jdx.dev/lang/python.html#python.uv_venv_auto) setting to `true` in your `mise.toml` file.

mise.toml

toml

```
[settings]
python.uv_venv_auto = true
```

Using `which python` will now show the python version from the virtual environment created by `uv`.

shell

```
which python
# ./uv-project/.venv/bin/python
```

Another option is to use `_.python.venv` in your `mise.toml` file to specify the path to the virtual environment created by `uv`.

mise.toml

toml

```
[env]
_.python.venv = { path = ".venv" }
```

### Syncing python versions installed by mise and uv [​](https://mise.jdx.dev/mise-cookbook/python.html\#syncing-python-versions-installed-by-mise-and-uv)

You can use [mise sync python --uv](https://mise.jdx.dev/cli/sync/python.html#uv) to sync the python version installed by `mise` with the python version specified in the `.python-version` file in the `uv` project.

### uv scripts [​](https://mise.jdx.dev/mise-cookbook/python.html\#uv-scripts)

You can take advantage of `uv run` in [`shebang`](https://mise.jdx.dev/tasks/toml-tasks.html#shell-shebang) in toml or file tasks. Note that using `--script` is required if the filename does not end in `.py`.

Here is an example toml task:

mise.toml

toml

```
[tools]
uv = 'latest'

[tasks.print_peps]
run = """
#!/usr/bin/env -S uv run --script
# /// script
# dependencies = ["requests<3", "rich"]
# ///

import requests
from rich.pretty import pprint

resp = requests.get("https://peps.python.org/api/peps.json")
data = resp.json()
pprint([(k, v["title"]) for k, v in data.items()][:10])
"""
```

Or as a file task:

mise-tasks/print\_peps.py

python

```
#!/usr/bin/env -S uv run --script
# /// script
# dependencies = ["requests<3", "rich"]
# ///

import requests
from rich.pretty import pprint

resp = requests.get("https://peps.python.org/api/peps.json")
data = resp.json()
pprint([(k, v["title"]) for k, v in data.items()][:10])
```

You can then run it with `mise run print_peps`:

shell

```
❯ mise run print_peps
[print_peps] $ ~/uv-project/mise-tasks/print_peps.py
Installed 9 packages in 8ms
[\
│   ('1', 'PEP Purpose and Guidelines'),\
│   ('2', 'Procedure for Adding New Modules'),\
    #...\
]
```

<|firecrawl-page-160-lllmstxt|>
## Mise Ruby Cookbook
[Skip to content](https://mise.jdx.dev/mise-cookbook/ruby.html#VPContent)

Return to top

# Mise + Ruby Cookbook [​](https://mise.jdx.dev/mise-cookbook/ruby.html\#mise-ruby-cookbook)

Here are some tips on managing Ruby projects with mise.

## A Ruby on Rails Project [​](https://mise.jdx.dev/mise-cookbook/ruby.html\#a-ruby-on-rails-project)

mise.toml

toml

```
min_version = "2024.9.5"

[env]
# Project information
PROJECT_NAME = "{{ config_root | basename }}"

[tools]
# Install Ruby with the specified version
ruby = "{{ get_env(name='RUBY_VERSION', default='3.3.3') }}"

[tasks."bundle:install"]
description = "Install gem dependencies"
run = "bundle install"

[tasks.server]
description = "Start the Rails server"
alias = "s"
run = "rails server"

[tasks.test]
description = "Run tests"
alias = "t"
run = "rails test"

[tasks.lint]
description = "Run lint using Rubocop"
alias = "l"
run = "rubocop"
```

<|firecrawl-page-161-lllmstxt|>
## Shell Tricks for Mise
[Skip to content](https://mise.jdx.dev/mise-cookbook/shell-tricks.html#VPContent)

Return to top

# Shell tricks [​](https://mise.jdx.dev/mise-cookbook/shell-tricks.html\#shell-tricks)

A collection of shell utities leveraging mise.

## Prompt colouring [​](https://mise.jdx.dev/mise-cookbook/shell-tricks.html\#prompt-colouring)

In ZSH to set the prompt colour whenever mise updates the environment (e.g. on cd into a project, or due to modification of the .mise\*.toml):

shell

```
# activate mise like normal
source <(command mise activate zsh)

typeset -i _mise_updated

# replace default mise hook
function _mise_hook {
  local diff=${__MISE_DIFF}
  source <(command mise hook-env -s zsh)
  [[ ${diff} == ${__MISE_DIFF} ]]
  _mise_updated=$?
}

_PROMPT="❱ "  # or _PROMPT=${PROMPT} to keep the default

function _prompt {
  if (( ${_mise_updated} )); then
    PROMPT='%F{blue}${_PROMPT}%f'
  else
    PROMPT='%(?.%F{green}${_PROMPT}%f.%F{red}${_PROMPT}%f)'
  fi
}

add-zsh-hook precmd _prompt
```

Now, when mise makes any updates to the environment the prompt will go blue.

## Current configuration environment in powerline-go prompt [​](https://mise.jdx.dev/mise-cookbook/shell-tricks.html\#current-configuration-environment-in-powerline-go-prompt)

[powerline-go](https://github.com/justjanne/powerline-go)'s `shell-var` segment can be used to display the value of an environment variable in the prompt. The current mise [configuration environment](https://mise.jdx.dev/configuration/environments.html), `MISE_ENV` is a good candidate for this.

Mostly, it is as one would expect: include `shell-var` in `-modules`, and `-shell-var MISE_ENV -shell-var-no-warn-empty` in arguments, and make sure `MISE_ENV` is exported so `powerline-go` can "see" it.

A gotcha as of February 2025 is that the `shell-var` module does not tolerate _unset_ (as opposed to empty) environment variables. To work around this, set `MISE_ENV` to an empty value early in the shell startup scripts, and avoid manually `unset` ing it. For example for bash, typically in `~/.bashrc`:

bash

```
export MISE_ENV=
```

## Inspect what changed after mise hook [​](https://mise.jdx.dev/mise-cookbook/shell-tricks.html\#inspect-what-changed-after-mise-hook)

Using record-query you can inspect the `__MISE_DIFF` and `__MISE_SESSION` variables to see what's changing in your environment due to the mise hook.

~/.config/mise/config.toml

toml

```
[tools]
"cargo:record-query" = "latest"
```

shell

```
function mise_parse_env {
  rq -m < <(
    zcat -q < <(
      printf $'\x1f\x8b\x08\x00\x00\x00\x00\x00'
      base64 -d <<< "$1"
    )
  )
}
```

shell

```
$ mise_parse_env "${__MISE_DIFF}"
{
  "new": {
    ...
  },
  "old": {
    ...
  },
  "path": [\
    ...\
  ]
}
```

<|firecrawl-page-162-lllmstxt|>
## Mise Terraform Cookbook
[Skip to content](https://mise.jdx.dev/mise-cookbook/terraform.html#VPContent)

Return to top

# Mise + Terraform/Opentofu Cookbook [​](https://mise.jdx.dev/mise-cookbook/terraform.html\#mise-terraform-opentofu-cookbook)

Here are some tips on managing Terraform projects with mise.

## Managing `terraform`/ `opentofu` Projects [​](https://mise.jdx.dev/mise-cookbook/terraform.html\#managing-terraform-opentofu-projects)

It is often necessary to have your terraform configuration in a `terraform/` subdirectory. This necessitates the use of syntax like `terraform -chdir=terraform plan` to use appropriate terraform command. The following config allows you to invoke all of them from `mise`, leveraging `mise` tasks.

mise.toml

toml

```
[tools]
terraform = "1"

[tasks."terraform:init"]
description = "Initializes a Terraform working directory"
run = "terraform -chdir=terraform init"

[tasks."terraform:plan"]
description = "Generates an execution plan for Terraform"
run = "terraform -chdir=terraform plan"

[tasks."terraform:apply"]
description = "Applies the changes required to reach the desired state of the configuration"
run = "terraform -chdir=terraform apply"

[tasks."terraform:destroy"]
description = "Destroy Terraform-managed infrastructure"
run = "terraform -chdir=terraform destroy"

[tasks."terraform:validate"]
description = "Validates the Terraform files"
run = "terraform -chdir=terraform validate"

[tasks."terraform:format"]
description = "Formats the Terraform files"
run = "terraform -chdir=terraform fmt"

[tasks."terraform:check"]
description = "Checks the Terraform files"
depends = ["terraform:format", "terraform:validate"]

[env]
_.file = ".env"
```

<|firecrawl-page-163-lllmstxt|>
## Paranoid Mode Settings
[Skip to content](https://mise.jdx.dev/paranoid.html#VPContent)

Return to top

# Paranoid [​](https://mise.jdx.dev/paranoid.html\#paranoid)

Paranoid is an optional behavior that locks mise down more to make it harder for a bad actor to compromise your system. These are settings that I personally do not use on my own system because I find the behavior too restrictive for the benefits.

Paranoid mode can be enabled with either `MISE_PARANOID=1` or a setting:

sh

```
mise settings paranoid=1
```

## Config files [​](https://mise.jdx.dev/paranoid.html\#config-files)

Normally `mise` will make sure some config files are "trusted" before loading them. This will prompt you to confirm that you want to load the file, e.g.:

sh

```
$ mise install
mise ~/src/mise/.tool-versions is not trusted. Trust it [y/n]?
```

Generally only potentially dangerous config files are checked such as files that use templates (which can execute arbitrary code) or that set env vars. Under paranoid, however, all config files must be trusted first.

Also, in normal mode, a config file only needs to be trusted a single time. In paranoid, the contents of the file are hashed to check if the file changes. If you change your config file, you'll need to trust it again.

## Community plugins [​](https://mise.jdx.dev/paranoid.html\#community-plugins)

Community plugins can not be directly installed via short-name under paranoid. You can install plugins that are either core, maintained by the mise team, or plugins that mise has marked as "first-party"—meaning plugins developed by the same team that builds the tool the plugin installs.

Other than that, say for "shfmt", you'll need to specify the full git repo to install:

sh

```
mise plugin install shfmt https://github.com/luizm/asdf-shfmt
```

Unlike in normal mode where `mise plugin install shfmt` would be sufficient.

## Always uses HTTPS [​](https://mise.jdx.dev/paranoid.html\#always-uses-https)

Some endpoints in mise are fetched over HTTP such as checking for the latest mise version and pulling version lists of tools. These are not security risks and a malicious actor injecting false data would not introduce a security risk. Normally mise uses HTTP because loading the TLS module takes about 10ms and this affects commonly used commands so it is a noticeably delay. In paranoid mode, all endpoints will be fetched over HTTPS.

## More? [​](https://mise.jdx.dev/paranoid.html\#more)

If you have suggestions for more that could be added to paranoid, please let me know.

<|firecrawl-page-164-lllmstxt|>
## Plugin Lua Modules
[Skip to content](https://mise.jdx.dev/plugin-lua-modules.html#VPContent)

Return to top

# Plugin Lua Modules [​](https://mise.jdx.dev/plugin-lua-modules.html\#plugin-lua-modules)

mise plugins have access to a comprehensive set of built-in Lua modules that provide common functionality. These modules are available in both backend plugins and tool plugins, making it easy to perform common operations like HTTP requests, JSON parsing, file operations, and more.

## Available Modules [​](https://mise.jdx.dev/plugin-lua-modules.html\#available-modules)

### Core Modules [​](https://mise.jdx.dev/plugin-lua-modules.html\#core-modules)

- **`cmd`** \- Execute shell commands
- **`json`** \- Parse and generate JSON
- **`http`** \- Make HTTP requests and downloads
- **`file`** \- File system operations
- **`env`** \- Environment variable operations
- **`strings`** \- String manipulation utilities
- **`html`** \- HTML parsing and manipulation
- **`archiver`** \- Archive extraction

## HTTP Module [​](https://mise.jdx.dev/plugin-lua-modules.html\#http-module)

The HTTP module provides functionality for making web requests and downloading files.

### Basic HTTP Requests [​](https://mise.jdx.dev/plugin-lua-modules.html\#basic-http-requests)

lua

```
local http = require("http")

-- GET request
local resp, err = http.get({
    url = "https://api.github.com/repos/owner/repo/releases",
    headers = {
        ['User-Agent'] = "mise-plugin",
        ['Accept'] = "application/json"
    }
})

if err ~= nil then
    error("Request failed: " .. err)
end

if resp.status_code ~= 200 then
    error("HTTP error: " .. resp.status_code)
end

local body = resp.body
```

### HEAD Requests [​](https://mise.jdx.dev/plugin-lua-modules.html\#head-requests)

lua

```
local http = require("http")

-- HEAD request to check file info
local resp, err = http.head({
    url = "https://example.com/file.tar.gz"
})

if err ~= nil then
    error("HEAD request failed: " .. err)
end

local content_length = resp.headers['content-length']
local content_type = resp.headers['content-type']
```

### File Downloads [​](https://mise.jdx.dev/plugin-lua-modules.html\#file-downloads)

lua

```
local http = require("http")

-- Download file
local err = http.download_file({
    url = "https://github.com/owner/repo/archive/v1.0.0.tar.gz",
    headers = {
        ['User-Agent'] = "mise-plugin"
    }
}, "/path/to/download.tar.gz")

if err ~= nil then
    error("Download failed: " .. err)
end
```

### Response Object [​](https://mise.jdx.dev/plugin-lua-modules.html\#response-object)

HTTP responses contain the following fields:

lua

```
{
    status_code = 200,
    headers = {
        ['content-type'] = "application/json",
        ['content-length'] = "1234"
    },
    body = "response content"
}
```

## JSON Module [​](https://mise.jdx.dev/plugin-lua-modules.html\#json-module)

The JSON module provides encoding and decoding functionality.

### Basic Usage [​](https://mise.jdx.dev/plugin-lua-modules.html\#basic-usage)

lua

```
local json = require("json")

-- Encode table to JSON string
local obj = {
    name = "mise-plugin",
    version = "1.0.0",
    tools = {"prettier", "eslint"}
}
local jsonStr = json.encode(obj)
-- Result: '{"name":"mise-plugin","version":"1.0.0","tools":["prettier","eslint"]}'

-- Decode JSON string to table
local decoded = json.decode(jsonStr)
print(decoded.name)  -- "mise-plugin"
print(decoded.tools[1])  -- "prettier"
```

### Error Handling (Lua) [​](https://mise.jdx.dev/plugin-lua-modules.html\#error-handling-lua)

lua

```
local json = require("json")

-- Safe JSON parsing
local success, result = pcall(json.decode, response_body)
if not success then
    error("Failed to parse JSON: " .. result)
end

-- Use the parsed data
for _, item in ipairs(result) do
    print(item.version)
end
```

## Strings Module [​](https://mise.jdx.dev/plugin-lua-modules.html\#strings-module)

The strings module provides various string manipulation utilities.

### String Operations [​](https://mise.jdx.dev/plugin-lua-modules.html\#string-operations)

lua

```
local strings = require("strings")

-- Split string into parts
local parts = strings.split("hello,world,test", ",")
print(parts[1])  -- "hello"
print(parts[2])  -- "world"
print(parts[3])  -- "test"

-- Join strings
local joined = strings.join({"hello", "world", "test"}, " - ")
print(joined)  -- "hello - world - test"

-- Trim whitespace
local trimmed = strings.trim_space("  hello world  ")
print(trimmed)  -- "hello world"
```

### String Checks [​](https://mise.jdx.dev/plugin-lua-modules.html\#string-checks)

lua

```
local strings = require("strings")

-- Check prefixes and suffixes
local text = "hello world"
print(strings.has_prefix(text, "hello"))  -- true
print(strings.has_suffix(text, "world"))  -- true
print(strings.contains(text, "lo wo"))    -- true

-- Trim specific characters
local trimmed = strings.trim("hello world", "world")
print(trimmed)  -- "hello "
```

### Version String Utilities [​](https://mise.jdx.dev/plugin-lua-modules.html\#version-string-utilities)

lua

```
local strings = require("strings")

-- Common version string operations
local function normalize_version(version)
    -- Remove 'v' prefix if present
    version = strings.trim_prefix(version, "v")

    -- Remove pre-release suffixes
    local parts = strings.split(version, "-")
    return parts[1]
end

local version = normalize_version("v1.2.3-beta.1")  -- "1.2.3"
```

## HTML Module [​](https://mise.jdx.dev/plugin-lua-modules.html\#html-module)

The HTML module provides HTML parsing capabilities.

### Basic HTML Parsing [​](https://mise.jdx.dev/plugin-lua-modules.html\#basic-html-parsing)

lua

```
local html = require("html")

-- Parse HTML document
local doc = html.parse([[\
    <html>\
        <body>\
            <div id="version" class="info">1.2.3</div>\
            <ul class="downloads">\
                <li><a href="/download/v1.2.3.tar.gz">Source</a></li>\
                <li><a href="/download/v1.2.3.zip">Windows</a></li>\
            </ul>\
        </body>\
    </html>\
]])

-- Extract text content
local version = doc:find("#version"):text()  -- "1.2.3"

-- Extract attributes
local links = doc:find("a")
for _, link in ipairs(links) do
    local href = link:attr("href")
    local text = link:text()
    print(text .. ": " .. href)
end
```

### CSS Selectors [​](https://mise.jdx.dev/plugin-lua-modules.html\#css-selectors)

lua

```
local html = require("html")

local doc = html.parse(html_content)

-- Find by ID
local element = doc:find("#version")

-- Find by class
local elements = doc:find(".download-link")

-- Find by tag
local links = doc:find("a")

-- Complex selectors
local specific_links = doc:find("ul.downloads a[href$='.tar.gz']")
```

### Real-World Example: Scraping Releases [​](https://mise.jdx.dev/plugin-lua-modules.html\#real-world-example-scraping-releases)

lua

```
local html = require("html")
local http = require("http")

function get_github_releases(owner, repo)
    local resp, err = http.get({
        url = "https://github.com/" .. owner .. "/" .. repo .. "/releases"
    })

    if err ~= nil then
        error("Failed to fetch releases: " .. err)
    end

    local doc = html.parse(resp.body)
    local releases = {}

    -- Find all release tags
    local release_elements = doc:find("a[href*='/releases/tag/']")
    for _, element in ipairs(release_elements) do
        local href = element:attr("href")
        local version = href:match("/releases/tag/(.+)")
        if version then
            table.insert(releases, {
                version = version,
                url = "https://github.com" .. href
            })
        end
    end

    return releases
end
```

## Archiver Module [​](https://mise.jdx.dev/plugin-lua-modules.html\#archiver-module)

The archiver module provides functionality for extracting compressed archives.

### Supported Formats [​](https://mise.jdx.dev/plugin-lua-modules.html\#supported-formats)

- **tar.gz** \- Gzipped tar archives
- **tar.xz** \- XZ compressed tar archives
- **tar.bz2** \- Bzip2 compressed tar archives
- **zip** \- ZIP archives

### Basic Extraction [​](https://mise.jdx.dev/plugin-lua-modules.html\#basic-extraction)

lua

```
local archiver = require("archiver")

-- Extract archive to directory
local err = archiver.decompress("archive.tar.gz", "extracted/")
if err ~= nil then
    error("Extraction failed: " .. err)
end

-- Extract ZIP file
local err = archiver.decompress("package.zip", "destination/")
if err ~= nil then
    error("ZIP extraction failed: " .. err)
end
```

### Real-World Example: Plugin Installation [​](https://mise.jdx.dev/plugin-lua-modules.html\#real-world-example-plugin-installation)

lua

```
local archiver = require("archiver")
local http = require("http")

function install_from_archive(download_url, install_path)
    -- Download the archive
    local archive_path = install_path .. "/download.tar.gz"
    local err = http.download_file({
        url = download_url
    }, archive_path)

    if err ~= nil then
        error("Download failed: " .. err)
    end

    -- Extract to installation directory
    local err = archiver.decompress(archive_path, install_path)
    if err ~= nil then
        error("Extraction failed: " .. err)
    end

    -- Clean up archive
    os.remove(archive_path)
end
```

## File Module [​](https://mise.jdx.dev/plugin-lua-modules.html\#file-module)

The file module provides file system operations.

### Path Joining [​](https://mise.jdx.dev/plugin-lua-modules.html\#path-joining)

lua

```
local file = require("file")

-- Join path segments using the OS-specific separator
local full_path = file.join_path("/foo", "bar", "baz.txt")
print(full_path)  -- On Unix: /foo/bar/baz.txt, on Windows: \foo\bar\baz.txt
```

The `file.join_path(...)` function joins any number of path segments using the correct separator for the current operating system. This is the recommended way to construct file paths in cross-platform plugins.

### Create Symbolic Links [​](https://mise.jdx.dev/plugin-lua-modules.html\#create-symbolic-links)

lua

```
local file = require("file")
file.symlink("/path/to/source", "/path/to/new-symlink")
```

## Environment Module [​](https://mise.jdx.dev/plugin-lua-modules.html\#environment-module)

The env module provides environment variable operations.

### Set Environment Variable [​](https://mise.jdx.dev/plugin-lua-modules.html\#set-environment-variable)

lua

```
local env = require("env")

-- Set environment variable
env.setenv("MY_VAR", "my_value")
```

### Get Environment Variable [​](https://mise.jdx.dev/plugin-lua-modules.html\#get-environment-variable)

> To read variables in Lua, use `os.getenv("MY_VAR")`.

### Path Operations [​](https://mise.jdx.dev/plugin-lua-modules.html\#path-operations)

lua

```
local env = require("env")

-- Get current PATH
local current_path = os.getenv("PATH")

-- Add to PATH
local new_path = "/usr/local/bin:" .. current_path
env.setenv("PATH", new_path)

-- Platform-specific PATH separator
local separator = package.config:sub(1,1) == '\\' and ";" or ":"
local paths = {"/usr/local/bin", "/opt/bin", current_path}
env.setenv("PATH", table.concat(paths, separator))
```

## Command Module [​](https://mise.jdx.dev/plugin-lua-modules.html\#command-module)

The cmd module provides shell command execution.

### Basic Command Execution [​](https://mise.jdx.dev/plugin-lua-modules.html\#basic-command-execution)

lua

```
local cmd = require("cmd")

-- Execute command and get output
local output = cmd.exec("ls -la")
print("Directory listing:", output)

-- Execute command with error handling
local success, output = pcall(cmd.exec, "some-command")
if not success then
    error("Command failed: " .. output)
end
```

### Command Execution with Options [​](https://mise.jdx.dev/plugin-lua-modules.html\#command-execution-with-options)

lua

```
local cmd = require("cmd")

-- Execute command in a specific directory
local output = cmd.exec("pwd", {cwd = "/tmp"})
print("Current directory:", output)

-- Execute command with custom environment variables
local result = cmd.exec("echo $TEST_VAR", {
    cwd = "/path/to/project",
    env = {TEST_VAR = "hello", NODE_ENV = "production"}
})

-- Install package in specific directory
local result = cmd.exec("npm install package-name", {cwd = "/path/to/project"})
```

### Available Options [​](https://mise.jdx.dev/plugin-lua-modules.html\#available-options)

The options table supports the following keys:

- **`cwd`** (string): Set the working directory for the command
- **`env`** (table): Set environment variables for the command execution
- **`timeout`** (number): Set a timeout for command execution (future feature)

### Platform-Specific Commands [​](https://mise.jdx.dev/plugin-lua-modules.html\#platform-specific-commands)

lua

```
local cmd = require("cmd")

-- Cross-platform command execution
local function is_windows()
    return package.config:sub(1,1) == '\\'
end

local function get_os_info()
    if is_windows() then
        return cmd.exec("systeminfo")
    else
        return cmd.exec("uname -a")
    end
end

local os_info = get_os_info()
print("OS Info:", os_info)
```

## Practical Examples [​](https://mise.jdx.dev/plugin-lua-modules.html\#practical-examples)

### Version Fetching from API [​](https://mise.jdx.dev/plugin-lua-modules.html\#version-fetching-from-api)

lua

```
local http = require("http")
local json = require("json")

function fetch_npm_versions(package_name)
    local resp, err = http.get({
        url = "https://registry.npmjs.org/" .. package_name,
        headers = {
            ['User-Agent'] = "mise-plugin"
        }
    })

    if err ~= nil then
        error("Failed to fetch package info: " .. err)
    end

    local package_info = json.decode(resp.body)
    local versions = {}

    for version, _ in pairs(package_info.versions) do
        table.insert(versions, version)
    end

    -- Sort versions (simple string sort)
    table.sort(versions)

    return versions
end
```

### File Download with Progress [​](https://mise.jdx.dev/plugin-lua-modules.html\#file-download-with-progress)

lua

```
local http = require("http")
local file = require("file")

function download_with_verification(url, dest_path, expected_sha256)
    -- Download file
    local err = http.download_file({
        url = url,
        headers = {
            ['User-Agent'] = "mise-plugin"
        }
    }, dest_path)

    if err ~= nil then
        error("Download failed: " .. err)
    end

    -- Verify file exists
    if not file.exists(dest_path) then
        error("Downloaded file not found")
    end

    -- Note: SHA256 verification would need additional implementation
    -- This is a simplified example
    print("Downloaded successfully to: " .. dest_path)
end
```

### Configuration File Parsing [​](https://mise.jdx.dev/plugin-lua-modules.html\#configuration-file-parsing)

lua

```
local file = require("file")
local json = require("json")
local strings = require("strings")

function parse_config_file(config_path)
    if not file.exists(config_path) then
        return {}  -- Return empty config
    end

    local content = file.read(config_path)
    if not content then
        error("Failed to read config file: " .. config_path)
    end

    -- Trim whitespace
    content = strings.trim_space(content)

    -- Parse JSON
    local success, config = pcall(json.decode, content)
    if not success then
        error("Invalid JSON in config file: " .. config_path)
    end

    return config
end
```

### Web Scraping for Versions [​](https://mise.jdx.dev/plugin-lua-modules.html\#web-scraping-for-versions)

lua

```
local http = require("http")
local html = require("html")
local strings = require("strings")

function scrape_versions_from_releases(base_url)
    local resp, err = http.get({
        url = base_url .. "/releases"
    })

    if err ~= nil then
        error("Failed to fetch releases page: " .. err)
    end

    local doc = html.parse(resp.body)
    local versions = {}

    -- Find version tags
    local version_elements = doc:find("h2 a[href*='/releases/tag/']")
    for _, element in ipairs(version_elements) do
        local version_text = element:text()
        local version = strings.trim_space(version_text)

        -- Remove 'v' prefix if present
        version = strings.trim_prefix(version, "v")

        if version and version ~= "" then
            table.insert(versions, {
                version = version,
                url = base_url .. element:attr("href")
            })
        end
    end

    return versions
end
```

## Best Practices [​](https://mise.jdx.dev/plugin-lua-modules.html\#best-practices)

### Error Handling [​](https://mise.jdx.dev/plugin-lua-modules.html\#error-handling)

Always handle errors gracefully:

lua

```
local http = require("http")
local json = require("json")

function safe_api_call(url)
    local resp, err = http.get({url = url})

    if err ~= nil then
        error("HTTP request failed: " .. err)
    end

    if resp.status_code ~= 200 then
        error("API returned error: " .. resp.status_code .. " " .. resp.body)
    end

    local success, data = pcall(json.decode, resp.body)
    if not success then
        error("Failed to parse JSON response: " .. data)
    end

    return data
end
```

### Caching [​](https://mise.jdx.dev/plugin-lua-modules.html\#caching)

Implement caching for expensive operations:

lua

```
local cache = {}
local cache_ttl = 3600  -- 1 hour

function cached_http_get(url)
    local now = os.time()
    local cache_key = url

    -- Check cache
    if cache[cache_key] and (now - cache[cache_key].timestamp) < cache_ttl then
        return cache[cache_key].data
    end

    -- Fetch fresh data
    local http = require("http")
    local resp, err = http.get({url = url})

    if err ~= nil then
        error("HTTP request failed: " .. err)
    end

    -- Cache the result
    cache[cache_key] = {
        data = resp,
        timestamp = now
    }

    return resp
end
```

### Platform Detection [​](https://mise.jdx.dev/plugin-lua-modules.html\#platform-detection)

Handle cross-platform differences:

lua

```
local function get_platform_info()
    local is_windows = package.config:sub(1,1) == '\\'
    local cmd = require("cmd")

    if is_windows then
        return {
            os = "windows",
            arch = os.getenv("PROCESSOR_ARCHITECTURE") or "x64",
            path_sep = "\\",
            env_sep = ";"
        }
    else
        local uname = cmd.exec("uname -s"):lower()
        local arch = cmd.exec("uname -m")

        return {
            os = uname,
            arch = arch,
            path_sep = "/",
            env_sep = ":"
        }
    end
end
```

## Next Steps [​](https://mise.jdx.dev/plugin-lua-modules.html\#next-steps)

- [Backend Plugin Development](https://mise.jdx.dev/backend-plugin-development.html)
- [Tool Plugin Development](https://mise.jdx.dev/tool-plugin-development.html)
- [Publishing your plugin](https://mise.jdx.dev/plugin-publishing.html)

<|firecrawl-page-165-lllmstxt|>
## Plugin Publishing Guide
[Skip to content](https://mise.jdx.dev/plugin-publishing.html#VPContent)

Return to top

# Plugin Publishing [​](https://mise.jdx.dev/plugin-publishing.html\#plugin-publishing)

This guide shows how to publish and distribute your plugins, whether they are backend plugins or tool plugins. Publishing makes your plugins available to other users and ensures they can be easily installed and maintained.

## Publishing Checklist [​](https://mise.jdx.dev/plugin-publishing.html\#publishing-checklist)

Before publishing your plugin, ensure you have:

### Essential Files [​](https://mise.jdx.dev/plugin-publishing.html\#essential-files)

- **`metadata.lua`** \- Plugin metadata with name, version, description, and author
- **Plugin implementation** \- Either backend methods or hook functions
- **Test coverage** \- Automated tests to verify functionality

### Optional but Recommended [​](https://mise.jdx.dev/plugin-publishing.html\#optional-but-recommended)

- **`README.md`** \- Basic usage instructions and examples
- **`test/`** directory - Test scripts for verification
- **Version control** \- Git repository with proper versioning

## Repository Setup [​](https://mise.jdx.dev/plugin-publishing.html\#repository-setup)

### 1\. Initialize Repository [​](https://mise.jdx.dev/plugin-publishing.html\#_1-initialize-repository)

Create a Git repository for your plugin:

bash

```
# Create plugin directory
mkdir my-plugin
cd my-plugin

# Initialize git repository
git init
git remote add origin https://github.com/username/my-plugin.git

# Create initial structure
touch metadata.lua
mkdir -p test
echo "# My Plugin" > README.md
```

### 2\. Basic Directory Structure [​](https://mise.jdx.dev/plugin-publishing.html\#_2-basic-directory-structure)

Organize your plugin with this structure:

```
my-plugin/
├── metadata.lua          # Plugin metadata
├── README.md            # Basic documentation
├── test/                # Test scripts
│   └── test.sh
├── .gitignore           # Git ignore rules
└── [implementation files]
```

For backend plugins:

```
backend-plugin/
├── metadata.lua          # Backend methods implementation
├── README.md
└── test/
    └── test.sh
```

For tool plugins:

```
tool-plugin/
├── metadata.lua          # Plugin metadata
├── hooks/               # Hook implementations
│   ├── available.lua
│   ├── pre_install.lua
│   └── env_keys.lua
├── lib/                 # Helper libraries
│   └── helper.lua
├── README.md
└── test/
    └── test.sh
```

### 3\. Git Ignore Configuration [​](https://mise.jdx.dev/plugin-publishing.html\#_3-git-ignore-configuration)

Create a `.gitignore` file:

gitignore

```
# Temporary files
*.tmp
*.temp
.DS_Store
Thumbs.db

# Test artifacts
test/tmp/
test/output/

# IDE files
.vscode/
.idea/
*.swp
*.swo

# OS files
*.log
```

## Versioning Strategy [​](https://mise.jdx.dev/plugin-publishing.html\#versioning-strategy)

### Semantic Versioning [​](https://mise.jdx.dev/plugin-publishing.html\#semantic-versioning)

Use semantic versioning (SemVer) for your plugin releases:

- **Major version** (1.0.0 → 2.0.0): Breaking changes
- **Minor version** (1.0.0 → 1.1.0): New features, backward compatible
- **Patch version** (1.0.0 → 1.0.1): Bug fixes, backward compatible

### Version Management [​](https://mise.jdx.dev/plugin-publishing.html\#version-management)

Update version in `metadata.lua`:

lua

```
PLUGIN = {
    name = "my-plugin",
    version = "1.2.3",  -- Update this for each release
    description = "My awesome plugin",
    author = "Your Name"
}
```

Create git tags for releases:

bash

```
# Tag the current commit
git tag -a v1.2.3 -m "Release version 1.2.3"

# Push tags to repository
git push origin --tags
```

## Testing Before Publication [​](https://mise.jdx.dev/plugin-publishing.html\#testing-before-publication)

### Automated Testing [​](https://mise.jdx.dev/plugin-publishing.html\#automated-testing)

Create comprehensive test scripts:

bash

```
#!/bin/bash
# test/test.sh
set -e

echo "Testing plugin functionality..."

# Install plugin locally
mise plugin install my-plugin .

# Test basic functionality
if [[ "$(mise ls-remote my-plugin)" == "" ]]; then
    echo "ERROR: No versions available"
    exit 1
fi

# Test installation
mise install my-plugin@latest

# Test execution
mise exec my-plugin:tool -- --version

# Clean up
mise plugin remove my-plugin

echo "All tests passed!"
```

### Manual Testing [​](https://mise.jdx.dev/plugin-publishing.html\#manual-testing)

Test your plugin manually:

bash

```
# Link for development
mise plugin link my-plugin /path/to/plugin

# Test all functionality
mise ls-remote my-plugin
mise install my-plugin@latest
mise use my-plugin@latest

# Test in different environments
docker run --rm -it ubuntu:latest bash -c "
    curl -fsSL https://mise.jdx.dev/install.sh | sh
    mise plugin install my-plugin https://github.com/username/my-plugin
    mise install my-plugin@latest
"
```

## Publishing Process [​](https://mise.jdx.dev/plugin-publishing.html\#publishing-process)

### 1\. Prepare for Release [​](https://mise.jdx.dev/plugin-publishing.html\#_1-prepare-for-release)

Before publishing, ensure everything is ready:

bash

```
# Run tests
./test/test.sh

# Check git status
git status

# Update version in metadata.lua
vim metadata.lua

# Commit changes
git add .
git commit -m "Prepare release v1.2.3"
```

### 2\. Create Release [​](https://mise.jdx.dev/plugin-publishing.html\#_2-create-release)

Create a tagged release:

bash

```
# Create and push tag
git tag -a v1.2.3 -m "Release version 1.2.3"
git push origin v1.2.3
git push origin main
```

### 3\. GitHub Releases (Recommended) [​](https://mise.jdx.dev/plugin-publishing.html\#_3-github-releases-recommended)

Create a GitHub release for better discoverability:

1. Go to your repository on GitHub
2. Click "Releases" → "Create a new release"
3. Choose your tag (v1.2.3)
4. Write release notes describing changes
5. Publish the release

### 4\. Release Notes Template [​](https://mise.jdx.dev/plugin-publishing.html\#_4-release-notes-template)

markdown

````
## Changes in v1.2.3

### Added
- New feature X
- Support for Y

### Changed
- Improved performance of Z
- Updated dependencies

### Fixed
- Fixed issue with A
- Resolved bug in B

### Installation
```bash
mise plugin install my-plugin https://github.com/username/my-plugin
````

````

## Distribution Methods

### 1. Direct Git Installation

Users can install directly from your repository:

```bash
# Install from GitHub
mise plugin install my-plugin https://github.com/username/my-plugin

# Install specific version
mise plugin install my-plugin https://github.com/username/my-plugin@v1.2.3

# Install from other Git providers
mise plugin install my-plugin https://gitlab.com/username/my-plugin
````

### 2\. Private Repository Access [​](https://mise.jdx.dev/plugin-publishing.html\#_2-private-repository-access)

For private repositories, users need access:

bash

```
# SSH access (recommended)
mise plugin install my-plugin git@github.com:username/private-plugin.git

# HTTPS with token
mise plugin install my-plugin https://username:token@github.com/username/private-plugin.git
```

### 3\. Archive Distribution [​](https://mise.jdx.dev/plugin-publishing.html\#_3-archive-distribution)

You can also distribute as archives:

bash

```
# Create release archive
git archive --format=zip --output=my-plugin-v1.2.3.zip v1.2.3

# Users can install from archive
mise plugin install my-plugin https://github.com/username/my-plugin/releases/download/v1.2.3/my-plugin-v1.2.3.zip
```

## Maintenance and Updates [​](https://mise.jdx.dev/plugin-publishing.html\#maintenance-and-updates)

### 1\. Update Workflow [​](https://mise.jdx.dev/plugin-publishing.html\#_1-update-workflow)

Establish a regular update process:

bash

```
# Development workflow
git checkout -b feature/new-feature
# ... make changes ...
git commit -m "Add new feature"
git push origin feature/new-feature

# After review and merge
git checkout main
git pull origin main
git tag -a v1.3.0 -m "Release v1.3.0"
git push origin v1.3.0
```

### 2\. Backward Compatibility [​](https://mise.jdx.dev/plugin-publishing.html\#_2-backward-compatibility)

Maintain backward compatibility when possible:

- Keep existing plugin interface unchanged
- Add new features as optional
- Deprecate old features gradually
- Document breaking changes clearly

### 3\. User Communication [​](https://mise.jdx.dev/plugin-publishing.html\#_3-user-communication)

Keep users informed about updates:

- Use clear release notes
- Announce major changes
- Provide migration guides for breaking changes
- Maintain documentation

## Security Considerations [​](https://mise.jdx.dev/plugin-publishing.html\#security-considerations)

### 1\. Code Review [​](https://mise.jdx.dev/plugin-publishing.html\#_1-code-review)

- Review all code changes before publishing
- Check for security vulnerabilities
- Validate external dependencies
- Test with untrusted inputs

### 2\. Dependency Management [​](https://mise.jdx.dev/plugin-publishing.html\#_2-dependency-management)

- Pin dependency versions where possible
- Regularly update dependencies
- Monitor for security advisories
- Use trusted sources only

### 3\. Access Control [​](https://mise.jdx.dev/plugin-publishing.html\#_3-access-control)

- Limit repository access appropriately
- Use strong authentication
- Regularly audit access permissions
- Consider signed releases for sensitive plugins

## Best Practices [​](https://mise.jdx.dev/plugin-publishing.html\#best-practices)

### 1\. Documentation [​](https://mise.jdx.dev/plugin-publishing.html\#_1-documentation)

- Keep README.md concise but complete
- Include usage examples
- Document configuration options
- Provide troubleshooting guide

### 2\. Testing [​](https://mise.jdx.dev/plugin-publishing.html\#_2-testing)

- Test on multiple platforms
- Include edge cases
- Test upgrade scenarios
- Automate testing where possible

### 3\. Community [​](https://mise.jdx.dev/plugin-publishing.html\#_3-community)

- Respond to issues promptly
- Accept contributions gracefully
- Maintain consistent code style
- Be helpful and respectful

### 4\. Release Management [​](https://mise.jdx.dev/plugin-publishing.html\#_4-release-management)

- Follow semantic versioning
- Create clear release notes
- Test releases thoroughly
- Maintain stable branches

## Troubleshooting [​](https://mise.jdx.dev/plugin-publishing.html\#troubleshooting)

### Common Issues [​](https://mise.jdx.dev/plugin-publishing.html\#common-issues)

**Plugin not installing:**

bash

```
# Check repository URL
git clone https://github.com/username/my-plugin.git

# Verify metadata.lua exists
ls -la my-plugin/metadata.lua

# Test locally
mise plugin link my-plugin ./my-plugin
```

**Version conflicts:**

bash

```
# Check version in metadata.lua
grep version my-plugin/metadata.lua

# Verify git tags
git tag -l
```

**Permission issues:**

bash

```
# Check repository permissions
git ls-remote https://github.com/username/my-plugin.git

# For private repos, verify access
ssh -T git@github.com
```

## Next Steps [​](https://mise.jdx.dev/plugin-publishing.html\#next-steps)

- [Backend Plugin Development](https://mise.jdx.dev/backend-plugin-development.html)
- [Tool Plugin Development](https://mise.jdx.dev/tool-plugin-development.html)
- [Plugin Lua Modules](https://mise.jdx.dev/plugin-lua-modules.html)

## Examples [​](https://mise.jdx.dev/plugin-publishing.html\#examples)

### Simple Backend Plugin Release [​](https://mise.jdx.dev/plugin-publishing.html\#simple-backend-plugin-release)

bash

```
# 1. Prepare plugin
cd my-backend-plugin
echo "Updated backend methods" > metadata.lua

# 2. Test locally
mise plugin link my-plugin .
mise ls-remote my-plugin:tool

# 3. Release
git add .
git commit -m "v1.0.0: Initial release"
git tag -a v1.0.0 -m "Initial release"
git push origin v1.0.0
```

### Tool Plugin with Hooks [​](https://mise.jdx.dev/plugin-publishing.html\#tool-plugin-with-hooks)

bash

```
# 1. Prepare plugin
cd my-tool-plugin
./test/test.sh  # Run tests

# 2. Update version
sed -i 's/version = "1.0.0"/version = "1.1.0"/' metadata.lua

# 3. Release
git add .
git commit -m "v1.1.0: Add new hook functionality"
git tag -a v1.1.0 -m "Add new hook functionality"
git push origin v1.1.0
```

<|firecrawl-page-166-lllmstxt|>
## Plugin Usage Guide
[Skip to content](https://mise.jdx.dev/plugin-usage.html#VPContent)

Return to top

# Using Plugins [​](https://mise.jdx.dev/plugin-usage.html\#using-plugins)

mise supports plugins that extend its functionality, allowing you to install tools that aren't available in the standard registry. This is particularly useful for:

- Installing tools from private repositories
- Using experimental or niche tools
- Creating custom tool installations for your team

## What Are Plugins? [​](https://mise.jdx.dev/plugin-usage.html\#what-are-plugins)

Plugins are extensions that can install and manage tools not included in mise's built-in registry. They are written in Lua and come in two main types:

### Backend Plugins [​](https://mise.jdx.dev/plugin-usage.html\#backend-plugins)

Backend plugins use enhanced backend methods and support the `plugin:tool` format:

- **Multiple Tools**: A single plugin can manage multiple tools
- **Enhanced Methods**: Backend methods for listing, installing, and environment setup
- **Format**: Use the `plugin:tool` format (e.g., `vfox-npm:prettier`)

### Tool Plugins [​](https://mise.jdx.dev/plugin-usage.html\#tool-plugins)

Tool plugins use the traditional hook-based approach:

- **Single Tool**: Each plugin manages one tool
- **Hook-based**: Use hooks like `PreInstall`, `PostInstall`, `Available`, etc.
- **Format**: Use the tool name directly (e.g., `my-tool`)

Both types:

- Install tools from any source (npm packages, GitHub releases, custom builds)
- Set up environment variables and PATH entries
- Handle version management and listing
- Work across all platforms (Windows, macOS, Linux)

## Installing Plugins [​](https://mise.jdx.dev/plugin-usage.html\#installing-plugins)

### From a Git Repository [​](https://mise.jdx.dev/plugin-usage.html\#from-a-git-repository)

bash

```
# Install a plugin from a repository
mise plugin install <plugin-name> <repository-url>

# Example: Installing the vfox-npm plugin
mise plugin install vfox-npm https://github.com/jdx/vfox-npm
```

### From Local Directory [​](https://mise.jdx.dev/plugin-usage.html\#from-local-directory)

bash

```
# Link a local plugin for development
mise plugin link <plugin-name> /path/to/plugin/directory
```

## Using Plugins (Advanced) [​](https://mise.jdx.dev/plugin-usage.html\#using-plugins-advanced)

Once a plugin is installed, you can use it with the `plugin:tool` format:

bash

```
# Install a specific tool using the plugin
mise install vfox-npm:prettier@latest

# Use the tool
mise use vfox-npm:prettier@3.0.0

# Execute the tool
mise exec vfox-npm:prettier -- --version

# List available versions
mise ls-remote vfox-npm:prettier
```

## Plugin:Tool Format [​](https://mise.jdx.dev/plugin-usage.html\#plugin-tool-format)

The `plugin:tool` format allows a single plugin to manage multiple tools. This is particularly useful for:

- **Package managers**: Install different npm packages, Python packages, etc.
- **Tool families**: Manage related tools from the same ecosystem
- **Custom builds**: Install different variants of the same tool

### Example: npm packages [​](https://mise.jdx.dev/plugin-usage.html\#example-npm-packages)

bash

```
# Install different npm packages using the same plugin
mise install vfox-npm:prettier@latest
mise install vfox-npm:eslint@8.0.0
mise install vfox-npm:typescript@latest

# Use them in your project
mise use vfox-npm:prettier@latest vfox-npm:eslint@8.0.0
```

## Managing Plugins [​](https://mise.jdx.dev/plugin-usage.html\#managing-plugins)

### List installed plugins [​](https://mise.jdx.dev/plugin-usage.html\#list-installed-plugins)

bash

```
# Show all plugins
mise plugins ls

# Show plugin URLs
mise plugins ls --urls
```

### Update plugins [​](https://mise.jdx.dev/plugin-usage.html\#update-plugins)

bash

```
# Update a specific plugin
mise plugin update vfox-npm

# Update all plugins
mise plugin update --all
```

### Remove plugins [​](https://mise.jdx.dev/plugin-usage.html\#remove-plugins)

bash

```
# Remove a plugin
mise plugin remove vfox-npm

# This will also remove all tools installed by the plugin
```

## Configuration [​](https://mise.jdx.dev/plugin-usage.html\#configuration)

Plugins can be configured in your `mise.toml` file:

toml

```
[plugins]
vfox-npm = "https://github.com/jdx/vfox-npm"

[tools]
"vfox-npm:prettier" = "latest"
"vfox-npm:eslint" = "8.0.0"
```

## Finding Plugins [​](https://mise.jdx.dev/plugin-usage.html\#finding-plugins)

While mise doesn't have a centralized registry for community plugins, you can find them:

- **GitHub**: Search for repositories with "vfox-" prefix
- **Community**: Check mise community discussions and Discord
- **Company internal**: Your organization may have private plugins

## Plugin Examples [​](https://mise.jdx.dev/plugin-usage.html\#plugin-examples)

### vfox-npm (Example Plugin) [​](https://mise.jdx.dev/plugin-usage.html\#vfox-npm-example-plugin)

The `vfox-npm` plugin demonstrates how to create a plugin that installs npm packages:

bash

```
# Install the plugin
mise plugin install vfox-npm https://github.com/jdx/vfox-npm

# Install tools
mise install vfox-npm:prettier@latest
mise install vfox-npm:eslint@latest

# Use them
mise use vfox-npm:prettier@latest
mise exec vfox-npm:prettier -- --check .
```

INFO

This is just an example plugin for testing. mise already has built-in npm support that you should use instead: `mise install npm:prettier@latest`

## Backend Plugins (Advanced) [​](https://mise.jdx.dev/plugin-usage.html\#backend-plugins-advanced)

Backend plugins use enhanced backend methods that provide better performance and support for the `plugin:tool` format:

- **BackendListVersions**: Lists available versions of a tool
- **BackendInstall**: Installs a specific version
- **BackendExecEnv**: Sets up environment variables

This architecture allows plugins to manage multiple tools efficiently while providing a consistent interface.

## Tool Plugins (Advanced) [​](https://mise.jdx.dev/plugin-usage.html\#tool-plugins-advanced)

Tool plugins use the traditional hook-based approach:

- **Available**: Lists available versions
- **PreInstall/PostInstall**: Installation hooks
- **EnvKeys**: Environment variable setup
- **Parse**: Version parsing and validation

Both architectures provide a flexible plugin system that can handle diverse installation and management needs.

## Security Considerations [​](https://mise.jdx.dev/plugin-usage.html\#security-considerations)

DANGER

When using plugins, be aware that:

- **Plugins execute arbitrary code** during installation and use
- **Only install plugins from trusted sources**
- **Review plugin code** before installation when possible
- **Use version pinning** to avoid unexpected updates like [`mise.lock`](https://mise.jdx.dev/dev-tools/mise-lock.html)

## Troubleshooting [​](https://mise.jdx.dev/plugin-usage.html\#troubleshooting)

### Plugin installation fails [​](https://mise.jdx.dev/plugin-usage.html\#plugin-installation-fails)

bash

```
# Check if the repository URL is correct
mise plugin install vfox-npm https://github.com/jdx/vfox-npm

# Check plugin directory
ls ~/.local/share/mise/plugins/
```

### Tool installation fails [​](https://mise.jdx.dev/plugin-usage.html\#tool-installation-fails)

bash

```
# Check plugin logs
mise install vfox-npm:prettier@latest --verbose

# Verify plugin is installed
mise plugins ls
```

### Environment issues [​](https://mise.jdx.dev/plugin-usage.html\#environment-issues)

bash

```
# Check if PATH is set correctly
mise exec vfox-npm:prettier env | grep PATH

# Verify tool is installed
ls ~/.local/share/mise/installs/vfox-npm/prettier/
```

## Next Steps [​](https://mise.jdx.dev/plugin-usage.html\#next-steps)

- [Learn how to create backend plugins](https://mise.jdx.dev/backend-plugin-development.html)
- [Learn how to create tool plugins](https://mise.jdx.dev/tool-plugin-development.html)
- [Explore built-in backends](https://mise.jdx.dev/dev-tools/backends/)
- [Check the community registry](https://mise.jdx.dev/registry.html)

<|firecrawl-page-167-lllmstxt|>
## Mise Plugin Management
[Skip to content](https://mise.jdx.dev/plugins.html#VPContent)

Return to top

# Plugins [​](https://mise.jdx.dev/plugins.html\#plugins)

Plugins in mise are a way to extend `mise` with new functionality like extra tools or environment variable management.

Historically it was the only way to add new tools (as the only backend was [asdf](https://mise.jdx.dev/dev-tools/backends/asdf.html)).

The way that backend works is every tool has its own plugin which needs to be manually installed. However, now with [core tools](https://mise.jdx.dev/core-tools.html) and backends like [aqua](https://mise.jdx.dev/dev-tools/backends/aqua.html)/ [ubi](https://mise.jdx.dev/dev-tools/backends/ubi.html), plugins are no longer necessary to run most tools in mise.

Tool plugins should be avoided for security reasons. New tools will not be accepted into mise built with asdf/plugins unless they are very popular and aqua/ubi is not an option for some reason.

The only exception is if the tool needs to set env vars or has a complex installation process, as plugins can provide functionality like [setting env vars globally](https://mise.jdx.dev/environments/#plugin-provided-env-directives) without relying on a tool being installed. They can also provide [aliases for versions](https://mise.jdx.dev/dev-tools/aliases.html#aliased-versions).

If you want to integrate a new tool into mise, you should either try to get it into the [aqua registry](https://mise.jdx.dev/dev-tools/backends/aqua.html) or see if it can be installed with [ubi](https://mise.jdx.dev/dev-tools/backends/ubi.html). Then add it to the [registry](https://github.com/jdx/mise/blob/main/registry.toml). Aqua is definitely preferred to ubi as it has better UX and more features like slsa verification and the ability to use different logic for older versions.

You can manage all installed plugins in `mise` with [`mise plugins`](https://mise.jdx.dev/cli/plugins.html).

shell

```
mise plugins ls --urls
# Plugin                          Url                                                     Ref  Sha
# 1password                       https://github.com/mise-plugins/mise-1password-cli.git  HEAD f5d5aab
# vfox-mise-plugins-vfox-dart     https://github.com/mise-plugins/vfox-dart               HEAD 1424253
# ...
```

## Backend Plugins [​](https://mise.jdx.dev/plugins.html\#backend-plugins)

Backend plugins provide enhanced functionality with modern backend methods. These plugins use the `plugin:tool` format and offer advantages over traditional plugins:

- **Multiple Tools**: A single plugin can manage multiple tools
- **Enhanced Methods**: Backend methods for listing versions, installing, and setting environment variables
- **Cross-platform**: Work on Windows, macOS, and Linux
- **Performance**: Faster execution than shell-based plugins

Example usage:

bash

```
# Install a backend plugin
mise plugin install my-plugin https://github.com/username/my-plugin

# Use the plugin:tool format
mise install my-plugin:some-tool@1.0.0
mise use my-plugin:some-tool@latest
```

See [Backend Plugin Development](https://mise.jdx.dev/backend-plugin-development.html) for creating backend plugins.

## Tool Plugins [​](https://mise.jdx.dev/plugins.html\#tool-plugins)

Tool plugins use the traditional hook-based approach with Lua scripts. These plugins provide:

- **Hook-based**: Use hooks like `PreInstall`, `PostInstall`, `Available`, etc.
- **Single Tool**: Each plugin manages one tool
- **Cross-platform**: Work on Windows, macOS, and Linux
- **Flexible**: Full control over installation and environment setup

Example usage:

bash

```
# Install a tool plugin
mise plugin install my-tool https://github.com/username/my-tool-plugin

# Use the tool directly
mise install my-tool@1.0.0
mise use my-tool@latest
```

See [Tool Plugin Development](https://mise.jdx.dev/tool-plugin-development.html) for creating tool plugins.

## General Plugin Usage [​](https://mise.jdx.dev/plugins.html\#general-plugin-usage)

For end-user documentation on installing and using both backend and tool plugins, see [Using Plugins](https://mise.jdx.dev/plugin-usage.html).

## asdf (Legacy) Plugins [​](https://mise.jdx.dev/plugins.html\#asdf-legacy-plugins)

mise can use asdf's plugin ecosystem under the hood for backward compatibility. These plugins contain shell scripts like `bin/install` (for installing) and `bin/list-all` (for listing all of the available versions).

asdf plugins have limitations compared to modern backends and should only be used when necessary. They only work on Linux/macOS and are slower than native backends.

See [asdf (Legacy) Plugins](https://mise.jdx.dev/asdf-legacy-plugins.html) for comprehensive documentation on using and creating these plugins.

## Plugin Authors [​](https://mise.jdx.dev/plugins.html\#plugin-authors)

[https://github.com/mise-plugins](https://github.com/mise-plugins) is a GitHub organization for community-developed plugins. See [SECURITY.md](https://github.com/jdx/mise/blob/main/SECURITY.md) for more details on how plugins here are treated differently.

If you'd like your plugin to be hosted here please let me know (GH discussion or discord is fine) and I'd be happy to host it for you.

## Tool Options [​](https://mise.jdx.dev/plugins.html\#tool-options)

mise has support for "tool options" which is configuration specified in `mise.toml` to change behavior of tools. One example of this is virtualenv on python runtimes:

toml

```
[tools]
python = { version='3.11', virtualenv='.venv' }
```

This will be passed to all plugin scripts as `MISE_TOOL_OPTS__VIRTUALENV=.venv`. The user can specify any option, and it will be passed to the plugin in that format.

Currently, this only supports simple strings, but we can make it compatible with more complex types (arrays, tables) fairly easily if there is a need for it.

## Templates [​](https://mise.jdx.dev/plugins.html\#templates)

Plugin custom repository values can be templates, see [Templates](https://mise.jdx.dev/templates.html) for details.

toml

```
[plugins]
my-plugin = "https://{{ get_env(name='GIT_USR', default='empty') }}:{{ get_env(name='GIT_PWD', default='empty') }}@github.com/foo/my-plugin.git"
```

<|firecrawl-page-168-lllmstxt|>
## Mise Development Roadmap
[Skip to content](https://mise.jdx.dev/roadmap.html#VPContent)

Return to top

# Roadmap [​](https://mise.jdx.dev/roadmap.html\#roadmap)

Issues marked ["enhancements"](https://github.com/jdx/mise/issues?q=is%3Aissue+is%3Aopen+label%3Aenhancement) are the best way to read about ideas for future functionality. As far as general scope however, these are likely going to be focuses for 2025:

- Removing experimental flag on features - several features are still marked as experimental. My hope is all features will be GA by the end of 2025.
- Supply chain hardening - much progress was made here by adopting ubi and aqua and switching to those backends for the majority of tools. In 2025, we'll continue migrating more tools where possible away from asdf. Aqua tools also can benefit from further hardening through the use of slsa-verify, cosign and other verification methods.
- Tasks improvements - tasks came out of experimental at the end of 2024 but there are still features that I'd like to see from tasks such as prompts and error handling.
- Hook improvements - hooks are very new in mise and still experimental. I suspect the design of hooks will change a bit as we learn more about how they are used. It's unclear what exactly will happen here right now.
- Improved python development - python improved a lot with better venv support and the precompiled binaries provided by Astral. As users are adopting this more we're learning about how mise can still be further improved for python development—which is the most complicated tool to support in mise by far. Where possible, the plan is to leverage uv as much as we can since they're the real experts when it comes to the python ecosystem.
- Further Windows support - non-WSL Windows support was added in 2024 but it is not heavily used. There are definitely bugs and gaps with Windows remaining but we should be able to get Windows much closer to UNIX by the end of the year. More testing on Windows would be a big help here.
- GUI/TUI - A few commands in mise make use of a TUI like `mise run`, `mise use`, and `mise up -i`, I'd like to see more done with these type of UIs in 2025.

## Versioning [​](https://mise.jdx.dev/roadmap.html\#versioning)

mise uses [Calver](https://calver.org/) versioning ( `2024.1.0`). Breaking changes will be few but when they do happen, they will be communicated in the CLI with plenty of notice whenever possible.

Rather than have SemVer major releases to communicate change in large releases, new functionality and changes can be opted-into with settings like `experimental = true`. This way plugin authors and users can test out new functionality immediately without waiting for a major release.

The numbers in Calver (YYYY.MM.RELEASE) simply represent the date of the release—not compatibility or how many new features were added. Each release will be small and incremental.

## Anti-goals [​](https://mise.jdx.dev/roadmap.html\#anti-goals)

- Dependency management - mise expects you to have system dependencies (like openssl or readline) already setup and configured. This makes it different than tools like nix which manage all dependencies for you. While this seems like an obvious downside, it actually ends up making mise far easier to use than nix. That said, we would like to make managing system dependencies easier where we can but this is likely going to be simply via better docs and error messages.
- DevOps tooling - mise is designed with local development in mind. While there are certainly many devs using it for production/server roles which we support and encourage, that will never be the our focus on the roadmap. Building a better ansible/terraform/kubernetes just isn't the goal.
- Remote task caching - turbopack, moonrepo, and many others are trying to solve this (major) problem. mise's task runner will likely always just be a simple convenience around executing scripts.

<|firecrawl-page-169-lllmstxt|>
## RTX to MISE Migration
[Skip to content](https://mise.jdx.dev/rtx.html#VPContent)

Return to top

# Coming from rtx [​](https://mise.jdx.dev/rtx.html\#coming-from-rtx)

`mise` was formerly called `rtx`. The name was changed to avoid confusion with Nvidia's line of graphics cards. This wasn't a legal issue, but just general confusion. When people first hear about the project or see it posted they wouldn't realize it was talking about a CLI tool. It was a bit difficult to search for on Google but also places like Twitter and in Slack searches and things. This was the top complaint about `rtx` and many people were fairly outspoken about disliking the name for this reason. `rtx` was supposed to be a working title that I intended to change but never got around to doing. This change should've happened earlier when there were fewer users and I apologize for not having done that sooner knowing that this was likely going to be necessary at some point.

To upgrade from `rtx` to `mise`, simply install `mise` and it should automatically migrate its internal directories, moving `~/.local/share/rtx/installs/*` to `~/.local/share/mise/installs/*` (skipping python & ruby which cannot be moved), `~/.local/share/rtx/plugins` to `~/.local/share/mise/plugins`, and `~/.config/rtx` to `~/.config/mise` (if the destination does not exist). Python and Ruby installs will need to be reinstalled with `mise install`.

`mise` will continue reading `.rtx.toml` files for some time but that eventually will be deprecated so please rename them to `mise.toml`. `mise` will not read from `RTX_*` env vars so those will need to be changed to `MISE_*`. Anything using a local `.rtx` or `.config/rtx` directory will need to be moved to `.mise`/ `.config/mise`.

I apologize if this migration is not seamless however I think moving to a name that is easier to search for and avoids confusion is better for everyone. I also apologize for it being abrupt—I simply couldn't think of a way to "slow roll" this change out while also keeping the GitHub repo.

Users of the `rtx-action` GitHub action will need to switch to `mise-action` (and also bump the major version to v2).

If you build infrastructure where users may still be calling `rtx activate` in their shell rc scripts, you can create a symlink `ln -s /path/to/mise /path/to/rtx` so `rtx activate` still functions.

For [https://mise.run](https://mise.run/), we're using `~/.local/bin/mise` as the executable PATH instead of the old directory `~/.local/share/rtx/bin/mise` to keep things a bit cleaner. You can still use the old style if you like by setting `MISE_INSTALL_PATH`.

If you use shims, a `mise reshim` will be necessary to update the shims.

Thanks for trying out my little CLI tool by the way. I find this project incredibly fulfilling to work on and seeing people have success using. I have tremendous passion for building dev tools and the ideas in `mise` are the product of me thinking about building a tool like this for over a decade.

If you aren't happy with `mise` or the way I'm running this project, even in a tiny way, please let me know. You can [contact me privately](https://mise.jdx.dev/about.html#contact) if you like. I certainly won't take offense and I would prefer you say something rather than nothing. Otherwise I'll never know.

<|firecrawl-page-170-lllmstxt|>
## Task System Architecture
[Skip to content](https://mise.jdx.dev/tasks/architecture.html#VPContent)

Return to top

# Task System Architecture [​](https://mise.jdx.dev/tasks/architecture.html\#task-system-architecture)

Understanding how mise's task system works helps you write more efficient tasks and troubleshoot dependency issues.

## Task Dependency System [​](https://mise.jdx.dev/tasks/architecture.html\#task-dependency-system)

mise uses a sophisticated dependency graph system to manage task execution order and parallelism. This ensures tasks run in the correct order while maximizing performance through parallel execution.

### Dependency Graph Resolution [​](https://mise.jdx.dev/tasks/architecture.html\#dependency-graph-resolution)

When you run `mise run build`, mise creates a directed acyclic graph (DAG) of all tasks and their dependencies:

This graph ensures that:

- Dependencies run before dependents
- Independent tasks run in parallel
- No circular dependencies exist
- Failed dependencies prevent dependents from running

### Dependency Types [​](https://mise.jdx.dev/tasks/architecture.html\#dependency-types)

mise supports three types of task dependencies:

#### `depends` \- Prerequisites [​](https://mise.jdx.dev/tasks/architecture.html\#depends-prerequisites)

Tasks that must complete successfully before this task runs:

toml

```
[tasks.test]
depends = ["lint", "build"]
run = "npm test"
```

#### `depends_post` \- Cleanup Tasks [​](https://mise.jdx.dev/tasks/architecture.html\#depends-post-cleanup-tasks)

Tasks that run after this task completes (whether successful or failed):

toml

```
[tasks.deploy]
depends = ["build", "test"]
depends_post = ["cleanup", "notify"]
run = "kubectl apply -f deployment.yaml"
```

#### `wait_for` \- Soft Dependencies [​](https://mise.jdx.dev/tasks/architecture.html\#wait-for-soft-dependencies)

Tasks that should run first if they're in the current execution, but don't fail if they're not available:

toml

```
[tasks.integration-test]
wait_for = ["start-services"]  # Only waits if start-services is also being run
run = "npm run test:integration"
```

## Parallel Execution Engine [​](https://mise.jdx.dev/tasks/architecture.html\#parallel-execution-engine)

### Job Control [​](https://mise.jdx.dev/tasks/architecture.html\#job-control)

mise executes tasks in parallel up to the configured job limit:

bash

```
mise run test --jobs 8        # Use 8 parallel jobs
mise run test -j 1            # Force sequential execution
```

The default is 4 parallel jobs, but you can configure this globally:

toml

```
# ~/.config/mise/config.toml
[settings]
jobs = 8
```

### Example Execution Flow [​](https://mise.jdx.dev/tasks/architecture.html\#example-execution-flow)

Given these tasks:

toml

```
[tasks.lint]
run = "eslint src/"

[tasks.test-unit]
depends = ["lint"]
run = "npm run test:unit"

[tasks.test-integration]
depends = ["lint"]
run = "npm run test:integration"

[tasks.build]
depends = ["test-unit", "test-integration"]
run = "npm run build"
```

Execution with `--jobs 2`:

```
Time →
0s:   [lint]
5s:   [test-unit] [test-integration]  # Run in parallel after lint
15s:  [build]                        # Waits for both tests
```

## Task Discovery and Resolution [​](https://mise.jdx.dev/tasks/architecture.html\#task-discovery-and-resolution)

### Task Sources [​](https://mise.jdx.dev/tasks/architecture.html\#task-sources)

mise discovers tasks from multiple sources in this order:

1. **File tasks**: Executable files in task directories
2. **TOML tasks**: Defined in `mise.toml` files
3. **Inherited tasks**: From parent directories

### Task Resolution Process [​](https://mise.jdx.dev/tasks/architecture.html\#task-resolution-process)

When you run `mise run build`, mise:

1. **Discovers all tasks** from all configuration sources
2. **Resolves the task name** (handles aliases and partial matches)
3. **Builds dependency graph** including all dependencies
4. **Validates graph** (checks for circular dependencies)
5. **Executes in dependency order** with parallelism

### Task Inheritance [​](https://mise.jdx.dev/tasks/architecture.html\#task-inheritance)

Tasks are inherited from parent directories but can be overridden:

```
project/
├── mise.toml              # defines: lint, test, build
└── frontend/
    └── mise.toml          # overrides: test, adds: bundle
```

In `frontend/`, you have access to: `lint` (inherited), `test` (overridden), `build` (inherited), `bundle` (local).

## Advanced Dependency Features [​](https://mise.jdx.dev/tasks/architecture.html\#advanced-dependency-features)

### Conditional Dependencies [​](https://mise.jdx.dev/tasks/architecture.html\#conditional-dependencies)

Use task arguments for conditional behavior:

toml

```
[tasks.test]
depends = ["build"]
run = '''
if [ "$1" = "--with-lint" ]; then
  mise run lint
fi
npm test
'''
```

### Dynamic Dependencies [​](https://mise.jdx.dev/tasks/architecture.html\#dynamic-dependencies)

Tasks can specify dependencies at runtime:

bash

```
#!/usr/bin/env bash
#MISE depends=["setup"]

# Additional conditional dependency
if [ ! -f ".env" ]; then
  mise run generate-env
fi

npm start
```

### Cross-Project Dependencies [​](https://mise.jdx.dev/tasks/architecture.html\#cross-project-dependencies)

Reference tasks from other directories:

toml

```
[tasks.deploy-all]
depends = [\
  "../api:build",\
  "../frontend:build",\
  "deploy-infrastructure"\
]
run = "echo 'All services deployed'"
```

## Performance Optimizations [​](https://mise.jdx.dev/tasks/architecture.html\#performance-optimizations)

### Source and Output Tracking [​](https://mise.jdx.dev/tasks/architecture.html\#source-and-output-tracking)

Tasks can skip execution if sources haven't changed:

toml

```
[tasks.build]
sources = ["src/**/*.ts", "package.json"]
outputs = ["dist/**/*"]
run = "npm run build"
```

mise will only run the task if:

- Source files are newer than output files
- The task has never been run
- Dependencies have changed

### Incremental Execution [​](https://mise.jdx.dev/tasks/architecture.html\#incremental-execution)

Use `mise run --force` to ignore source/output checking:

bash

```
mise run build --force     # Always run, ignore source changes
mise run --changed         # Only run tasks with source changes
```

### Parallel File Watching [​](https://mise.jdx.dev/tasks/architecture.html\#parallel-file-watching)

Use `mise watch` for continuous development:

bash

```
mise watch              # Watch all task sources
mise watch build test   # Watch specific tasks
```

This automatically reruns tasks when their source files change.

## Debugging Task Dependencies [​](https://mise.jdx.dev/tasks/architecture.html\#debugging-task-dependencies)

### Visualize Dependencies [​](https://mise.jdx.dev/tasks/architecture.html\#visualize-dependencies)

bash

```
mise task deps build           # Show build's dependencies
mise task deps --dot > deps.dot # Generate graphviz diagram
```

### Execution Tracing [​](https://mise.jdx.dev/tasks/architecture.html\#execution-tracing)

bash

```
mise run build --verbose       # Show task execution details
mise run build --dry-run       # Show what would run without executing
```

### Common Issues [​](https://mise.jdx.dev/tasks/architecture.html\#common-issues)

**Circular Dependencies**:

```
Error: Circular dependency detected: test → build → test
```

Solution: Remove the circular reference or use `wait_for` instead of `depends`.

**Missing Dependencies**:

```
Error: Task 'build' depends on 'lint' but 'lint' was not found
```

Solution: Define the missing task or remove the dependency.

**Slow Parallel Execution**:

- Check if tasks have unnecessary dependencies
- Use `mise task deps` to verify dependency graph
- Consider increasing `--jobs` if you have CPU cores available

The task architecture is designed to scale from simple single-task projects to complex multi-service applications with intricate build dependencies.

<|firecrawl-page-171-lllmstxt|>
## File Task Configuration
[Skip to content](https://mise.jdx.dev/tasks/file-tasks.html#VPContent)

Return to top

# File Tasks [​](https://mise.jdx.dev/tasks/file-tasks.html\#file-tasks)

In addition to defining tasks through the configuration, they can also be defined as standalone script files in one of the following directories:

- `mise-tasks/:task_name`
- `.mise-tasks/:task_name`
- `mise/tasks/:task_name`
- `.mise/tasks/:task_name`
- `.config/mise/tasks/:task_name`

Note that you can include additional directories using the [task\_config](https://mise.jdx.dev/tasks/task-configuration.html#task-config-options) section.

Here is an example of a file task that builds a Rust CLI:

mise-tasks/build

bash

```
#!/usr/bin/env bash
#MISE description="Build the CLI"
cargo build
```

Important

Ensure that the file is executable, otherwise mise will not be able to detect it.

shell

```
chmod +x mise-tasks/build
```

Having the code in a bash file and not TOML helps make it work better in editors since they can do syntax highlighting and linting more easily.

They also still work great for non-mise users—though of course they'll need to find a different way to install their dev tools the tasks might use.

## Task Configuration [​](https://mise.jdx.dev/tasks/file-tasks.html\#task-configuration)

All configuration options can be found here [task configuration](https://mise.jdx.dev/tasks/task-configuration.html) You can provide additional configuration for file tasks by adding `#MISE` comments at the top of the file.

bash

```
#MISE description="Build the CLI"
#MISE alias="b"
#MISE sources=["Cargo.toml", "src/**/*.rs"]
#MISE outputs=["target/debug/mycli"]
#MISE env={RUST_BACKTRACE = "1"}
#MISE depends=["lint", "test"]
```

Assuming that file was located in `mise-tasks/build`, it can then be run with `mise run build` (or with its alias: `mise run b`).

## Shebang [​](https://mise.jdx.dev/tasks/file-tasks.html\#shebang)

The shebang line is optional, but if it is present, it will be used to determine the shell to run the script with. You can also use it to run the script with various programming languages.

nodepythondenopowershell

js

```
#!/usr/bin/env node
//MISE description="Hello, World in Node.js"

console.log("Hello, World!");
```

python

```
#!/usr/bin/env python
#MISE description="Hello, World in Python"

print('Hello, World!')
```

ts

```
#!/usr/bin/env -S deno run --allow-env
//MISE description="Hello, World in Deno"

console.log(`PATH, ${Deno.env.get("PATH")}`);
```

powershell

```
#!/usr/bin/env pwsh
#MISE description="Hello, World in Powershell"

$current_directory = Get-Location
Write-Host "Hello from Powershell, current directory is $current_directory"
```

## Editing tasks [​](https://mise.jdx.dev/tasks/file-tasks.html\#editing-tasks)

This script can be edited with by running `mise task edit build` (using `$EDITOR`). If it doesn't exist it will be created. This is convenient for quickly editing or creating new scripts.

## Task Grouping [​](https://mise.jdx.dev/tasks/file-tasks.html\#task-grouping)

File tasks in `mise-tasks`, `.mise/tasks`, `mise/tasks`, or `.config/mise/tasks` can be grouped into sub-directories which will automatically apply prefixes to their names when loaded.

**Example**: With a folder structure like below:

text

```
mise-tasks
├── build
└── test
    ├── _default
    ├── integration
    └── units
```

Running `mise tasks` will give the below output:

text

```
$ mise tasks
Name              Description Source
build                         ./mise-tasks/build
test                          ./mise-tasks/test/_default
test:integration              ./mise-tasks/test/integration
test:units                    ./mise-tasks/test/units
```

## Arguments [​](https://mise.jdx.dev/tasks/file-tasks.html\#arguments)

[usage](https://usage.jdx.dev/) spec can be used within these files to provide argument parsing, autocompletion, documentation when running mise and can be exported to markdown. Essentially this turns tasks into fully-fledged CLIs.

TIP

The `usage` CLI is not required to execute mise tasks with the usage spec. However, for completions to work, the `usage` CLI must be installed and available in the PATH.

### Example file task with arguments [​](https://mise.jdx.dev/tasks/file-tasks.html\#example-file-task-with-arguments)

Here is an example of a file task that builds a Rust CLI using some of the features of usage:

mise-tasks/build

bash

```
#!/usr/bin/env bash
set -e

#USAGE flag "-c --clean" help="Clean the build directory before building"
#USAGE flag "-p --profile <profile>" help="Build with the specified profile" {
#USAGE   choices "debug" "release"
#USAGE }
#USAGE flag "-u --user <user>" help="The user to build for"
#USAGE complete "user" run="mycli users"
#USAGE arg "<target>" help="The target to build"

if [ "$usage_clean" = "true" ]; then
  cargo clean
fi

cargo build --profile "${usage_profile:-debug}" --target "$usage_target"
```

If you have installed `usage`, completions will be enabled for your task. In this example,

- `mise run build --profile <tab><tab>` will show `debug` and `release` as options.
- The `--user` flag will also show completions generated by the output of `mycli users`.

(Note that cli and markdown help for tasks is not yet implemented in mise as of this writing but that is planned.)

TIP

If you don't get any autocomplete suggestions, use the `-v` (verbose) flag to see what's going on. For example, if you use `mise run build -v` and have an invalid `usage` spec, you will see an error message such as `DEBUG failed to parse task file with usage`

### Example of a NodeJS file task with arguments [​](https://mise.jdx.dev/tasks/file-tasks.html\#example-of-a-nodejs-file-task-with-arguments)

Here is how you can use [usage](https://usage.jdx.dev/cli/scripts#usage-scripts) to parse arguments in a Node.js script:

mise-tasks/greet

js

```
#!/usr/bin/env -S node
//MISE description="Write a greeting to a file"
//USAGE flag "-f --force" help="Overwrite existing <file>"
//USAGE flag "-u --user <user>" help="User to run as"
//USAGE arg "<output_file>" help="The file to write" default="file.txt" {
//USAGE   choices "greeting.txt" "file.txt"
//USAGE }

const fs = require("fs");

const { usage_user, usage_force, usage_output_file } = process.env;

if (usage_force === "true") {
  fs.rmSync(usage_output_file, { force: true });
}

const user = usage_user ?? "world";
fs.appendFileSync(usage_output_file, `Hello, ${user}\n`);
console.log(`Greeting written to ${usage_output_file}`);
```

Run it with:

shell

```
mise run greet greeting.txt --user Alice
# Greeting written to greeting.txt
```

If you pass an invalid argument, you will get an error message:

shell

```
mise run greet invalid.txt --user Alice
# [greet] ERROR
#   0: Invalid choice for arg output_file: invalid.txt, expected one of greeting.txt, file.txt
```

Autocomplete will show the available choices for the `output_file` argument if `usage` is installed.

shell

```
mise run greet <TAB>
# > greeting.txt
#   file.txt
```

## CWD [​](https://mise.jdx.dev/tasks/file-tasks.html\#cwd)

mise sets the current working directory to the directory of `mise.toml` before running tasks. This can be overridden by setting `dir="{{cwd}}"` in the task header:

bash

```
#!/usr/bin/env bash
#MISE dir="{{cwd}}"
```

Also, the original working directory is available in the `MISE_ORIGINAL_CWD` environment variable:

bash

```
#!/usr/bin/env bash
cd "$MISE_ORIGINAL_CWD"
```

## Running tasks directly [​](https://mise.jdx.dev/tasks/file-tasks.html\#running-tasks-directly)

Tasks don't need to be configured as part of a config, you can just run them directly by passing the path to the script:

bash

```
mise run ./path/to/script.sh
```

Note that the path must start with `/` or `./` to be considered a file path. (On Windows it can be `C:\` or `.\`)

<|firecrawl-page-172-lllmstxt|>
## Running Tasks Guide
[Skip to content](https://mise.jdx.dev/tasks/running-tasks.html#VPContent)

Return to top

# Running Tasks [​](https://mise.jdx.dev/tasks/running-tasks.html\#running-tasks)

See available tasks with `mise tasks`. To show tasks hidden with property `hide=true`, use the option `--hidden`.

List dependencies of tasks with `mise task deps [tasks]...`.

Run a task with `mise task run <task>`, `mise run <task>`, `mise r <task>`, or just `mise <task>`—however that last one you should never put into scripts or documentation because if mise ever adds a command with that name in a future mise version, the task will be shadowed and must be run with one of the other forms.

Most mise users will have an alias for `mise run` like `alias mr='mise run'`.

By default, tasks will execute with a maximum of 4 parallel jobs. Customize this with the `--jobs` option, `jobs` setting or `MISE_JOBS` environment variable. The output normally will be by line, prefixed with the task label. By printing line-by-line we avoid interleaving output from parallel executions. However, if --jobs == 1, the output will be set to `interleave`.

To just print stdout/stderr directly, use `--interleave`, the `task_output` setting, or `MISE_TASK_OUTPUT=interleave`.

Stdin is not read by default. To enable this, set `raw = true` on the task that needs it. This will prevent it running in parallel with any other task-a RWMutex will get a write lock in this case. This also prevents redactions applied to the output.

Extra arguments will be passed to the task, for example, if we want to run in release mode:

bash

```
mise run build --release
```

If there are multiple commands, the args are only passed to the last command.

TIP

You can define arguments/flags for tasks which will provide validation, parsing, autocomplete, and documentation.

- [Arguments in File Tasks](https://mise.jdx.dev/tasks/file-tasks.html#arguments)
- [Arguments in TOML Tasks](https://mise.jdx.dev/tasks/toml-tasks.html#arguments)

Autocomplete will work automatically for tasks if the `usage` CLI is installed and mise completions are working.

Markdown documentation can be generated with [`mise generate task-docs`](https://mise.jdx.dev/cli/generate/task-docs.html).

Multiple tasks/arguments can be separated with this `:::` delimiter:

bash

```
mise run build arg1 arg2 ::: test arg3 arg4
```

mise will run the task named "default" if no task is specified—and you've created one named "default". You can also alias a different task to "default".

bash

```
mise run
```

## Task Grouping [​](https://mise.jdx.dev/tasks/running-tasks.html\#task-grouping)

Tasks can be grouped semantically by using name prefixes separated with `:` s. For example all testing related tasks may begin with `test:`. Nested grouping can also be used to further refine groups and simplify pattern matching. For example running `mise run test:**:local` will match `test:units:local`, `test:integration:local` and `test:e2e:happy:local` (See [Wildcards](https://mise.jdx.dev/tasks/running-tasks.html#wildcards) for more information).

## Wildcards [​](https://mise.jdx.dev/tasks/running-tasks.html\#wildcards)

Glob style wildcards are supported when running tasks or specifying tasks dependencies.

Available Wildcard Patterns:

- `?` matches any single character
- `*` matches 0 or more characters
- `**` matches 0 or more groups
- `{glob1,glob2,...}` matches any of the comma-separated glob patterns
- `[ab,...]` matches any of the characters or ranges `[a-z]`
- `[!ab,...]` matches any character not in the character set

### Examples [​](https://mise.jdx.dev/tasks/running-tasks.html\#examples)

`mise run generate:{completions,docs:*}`

And with dependencies:

toml

```
[tasks."lint:eslint"] # using a ":" means we need to add quotes
run = "eslint ."
[tasks."lint:prettier"]
run = "prettier --check ."
[tasks.lint]
depends = ["lint:*"]
wait_for = ["render"] # does not add as a dependency, but if it is already running, wait for it to finish
```

## Running on file changes [​](https://mise.jdx.dev/tasks/running-tasks.html\#running-on-file-changes)

It's often handy to only execute a task if the files it uses changes. For example, we might only want to run `cargo build` if an ".rs" file changes. This can be done with the following config:

toml

```
[tasks.build]
description = 'Build the CLI'
run = "cargo build"
sources = ['Cargo.toml', 'src/**/*.rs'] # skip running if these files haven't changed
outputs = ['target/debug/mycli']
```

Now if `target/debug/mycli` is newer than `Cargo.toml` or any ".rs" file, the task will be skipped. This uses last modified timestamps. It wouldn't be hard to add checksum support.

## Watching files [​](https://mise.jdx.dev/tasks/running-tasks.html\#watching-files)

Run a task when the source changes with [`mise watch`](https://mise.jdx.dev/cli/watch.html)

bash

```
mise watch build
```

Currently, this just shells out to `watchexec` (which you can install however you want including with mise: `mise use -g watchexec@latest`. This may change in the future.)

## `mise run` shorthand [​](https://mise.jdx.dev/tasks/running-tasks.html\#mise-run-shorthand)

Tasks can be run with `mise run <TASK>` or `mise <TASK>`—if the name doesn't conflict with a mise command. Because mise may later add a command with a conflicting name, it's recommended to use `mise run <TASK>` in scripts and documentation.

## Execution order [​](https://mise.jdx.dev/tasks/running-tasks.html\#execution-order)

You can use [depends](https://mise.jdx.dev/tasks/task-configuration.html#depends), [wait\_for](https://mise.jdx.dev/tasks/task-configuration.html#wait-for) and [depends\_post](https://mise.jdx.dev/tasks/task-configuration.html#depends-post) to control the order of execution.

toml

```
[tasks.build]
run = "echo 'build'"

[tasks.test]
run = "echo 'test'"
depends = ["build"]
```

This will ensure that the `build` task is run before the `test` task.

You can also define a mise task to run other tasks sequentially (or in series). You can do this by calling `mise run <task>` in the `run` property of a task.

toml

```
[tasks.example1]
run = "echo 'example1'"

[tasks.example2]
run = "mise example2"

[tasks.one_by_one]
run = [\
    'mise run example1',\
    'mise run example2',\
]
```

This assumes that `mise` is in your `PATH`. If you are using [mise generate bootstrap](https://mise.jdx.dev/cli/generate/bootstrap.html) or if `mise` is not on `PATH`, it's better to use [`{{mise_bin}}`](https://mise.jdx.dev/templates.html#variables) instead of `mise` in the task definition.

toml

```
[tasks.one_by_one]
run = [\
    '{{mise_bin}} run example1',\
    '{{mise_bin}} run example2',\
]
```

<|firecrawl-page-173-lllmstxt|>
## Task Configuration Options
[Skip to content](https://mise.jdx.dev/tasks/task-configuration.html#VPContent)

Return to top

# Task Configuration [​](https://mise.jdx.dev/tasks/task-configuration.html\#task-configuration)

This is an exhaustive list of all the configuration options available for tasks in `mise.toml` or as file tasks.

## Task properties [​](https://mise.jdx.dev/tasks/task-configuration.html\#task-properties)

All examples are in toml-task format instead of file, however they apply in both except where otherwise noted.

### `run` [​](https://mise.jdx.dev/tasks/task-configuration.html\#run)

- **Type**: `string | string[]`

The command to run. This is the only required property for a task. Note that tasks can be defined in `mise.toml` in various ways in order to simplify the config, e.g.: these are all equal:

toml

```
tasks.a = "echo hello"
tasks.b = ["echo hello"]
tasks.c.run = "echo hello"
[tasks.d]
run = "echo hello"
[tasks.e]
run = ["echo hello"]
```

### `run_windows` [​](https://mise.jdx.dev/tasks/task-configuration.html\#run-windows)

An alternative script to run when `mise run` is executed on windows:

toml

```
[tasks.build]
run = "cargo build"
run_windows = "cargo build --features windows"
```

### `description` [​](https://mise.jdx.dev/tasks/task-configuration.html\#description)

- **Type**: `string`

A description of the task. This is used in (among other places) the help output, completions, `mise run` (without arguments), and `mise tasks`.

toml

```
[tasks.build]
description = "Build the CLI"
run = "cargo build"
```

### `alias` [​](https://mise.jdx.dev/tasks/task-configuration.html\#alias)

- **Type**: `string | string[]`

An alias for the task so you can run it with `mise run <alias>` instead of the full task name.

toml

```
[tasks.build]
alias = "b" # run with `mise run b` or `mise b`
run = "cargo build"
```

### `depends` [​](https://mise.jdx.dev/tasks/task-configuration.html\#depends)

- **Type**: `string | string[]`

Tasks that must be run before this task. This is a list of task names or aliases. Arguments can be passed to the task, e.g.: `depends = ["build --release"]`. If multiple tasks have the same dependency, that dependency will only be run once. mise will run whatever it can in parallel (up to [`--jobs`](https://mise.jdx.dev/cli/run.html)) through the use of `depends` and related properties.

toml

```
[tasks.build]
run = "cargo build"
[tasks.test]
depends = ["build"]
run = "cargo test"
```

### `depends_post` [​](https://mise.jdx.dev/tasks/task-configuration.html\#depends-post)

- **Type**: `string | string[]`

Like `depends` but these tasks run _after_ this task and its dependencies complete. For example, you may want a `postlint` task that you can run individually without also running `lint`:

toml

```
[tasks.lint]
run = "eslint ."
depends_post = ["postlint"]
[tasks.postlint]
run = "echo 'linting complete'"
```

### `wait_for` [​](https://mise.jdx.dev/tasks/task-configuration.html\#wait-for)

- **Type**: `string | string[]`

Similar to `depends`, it will wait for these tasks to complete before running however they won't be added to the list of tasks to run. This is essentially optional dependencies.

toml

```
[tasks.lint]
wait_for = ["render"] # creates some js files, so if it's running, wait for it to finish
run = "eslint ."
```

### `env` [​](https://mise.jdx.dev/tasks/task-configuration.html\#env)

- **Type**: `{ [key]: string | int | bool }`

Environment variables specific to this task. These will not be passed to `depends` tasks.

toml

```
[tasks.test]
env.TEST_ENV_VAR = "ABC"
run = [\
    "echo $TEST_ENV_VAR",\
    "mise run some-other-task", # running tasks like this _will_ have TEST_ENV_VAR set of course\
]
```

### `tools` [​](https://mise.jdx.dev/tasks/task-configuration.html\#tools)

- **Type**: `{ [key]: string }`

Tools to install and activate before running the task. This is useful for tasks that require a specific tool to be installed or a tool with a different version. It will only be used for that task, not dependencies.

toml

```
[tasks.build]
tools.rust = "1.50.0"
run = "cargo build"
```

### `dir` [​](https://mise.jdx.dev/tasks/task-configuration.html\#dir)

- **Type**: `string`
- **Default**: `"{{ config_root }}"` \- the directory containing `mise.toml`, or in the case of something like `~/src/myproj/.config/mise.toml`, it will be `~/src/myproj`.

The directory to run the task from. The most common way this is used is when you want the task to execute in the user's current directory:

toml

```
[tasks.test]
dir = "{{cwd}}"
run = "cargo test"
```

### `hide` [​](https://mise.jdx.dev/tasks/task-configuration.html\#hide)

- **Type**: `bool`
- **Default**: `false`

Hide the task from help, completion, and other output like `mise tasks`. Useful for deprecated or internal tasks you don't want others to easily see.

toml

```
[tasks.internal]
hide = true
run = "echo my internal task"
```

### `confirm` [​](https://mise.jdx.dev/tasks/task-configuration.html\#confirm)

- **Type**: `string`

A message to show before running the task. This is useful for tasks that are destructive or take a long time to run. The user will be prompted to confirm before the task is run.

toml

```
[tasks.release]
confirm = "Are you sure you want to cut a release?"
description = 'Cut a new release'
file = 'scripts/release.sh'
```

### `raw` [​](https://mise.jdx.dev/tasks/task-configuration.html\#raw)

- **Type**: `bool`
- **Default**: `false`

Connects the task directly to the shell's stdin/stdout/stderr. This is useful for tasks that need to accept input or output in a way that mise's normal task handling doesn't support. This is not recommended to use because it really screws up the output whenever mise runs tasks in parallel. Ensure when using this that no other tasks are running at the same time.

In the future we could have a property like `single = true` or something that prevents multiple tasks from running at the same time. If that sounds useful, search/file a ticket.

### `sources` [​](https://mise.jdx.dev/tasks/task-configuration.html\#sources)

- **Type**: `string | string[]`

Files or directories that this task uses as input, if this and `outputs` is defined, mise will skip executing tasks where the modification time of the oldest output file is newer than the modification time of the newest source file. This is useful for tasks that are expensive to run and only need to be run when their inputs change.

The task itself will be automatically added as a source, so if you edit the definition that will also cause the task to be run.

This is also used in `mise watch` to know which files/directories to watch.

This can be specified with relative paths to the config file and/or with glob patterns, e.g.: `src/**/*.rs`. Ensure you don't go crazy with adding a ton of files in a glob though—mise has to scan each and every one to check the timestamp.

toml

```
[tasks.build]
run = "cargo build"
sources = ["Cargo.toml", "src/**/*.rs"]
outputs = ["target/debug/mycli"]
```

Running the above will only execute `cargo build` if `mise.toml`, `Cargo.toml`, or any ".rs" file in the `src` directory has changed since the last build.

### `outputs` [​](https://mise.jdx.dev/tasks/task-configuration.html\#outputs)

- **Type**: `string | string[] | { auto = true }`

The counterpart to `sources`, these are the files or directories that the task will create/modify after it executes.

`auto = true` is an alternative to specifying output files manually. In that case, mise will touch an internally tracked file based on the hash of the task definition (stored in `~/.local/state/mise/task-outputs/<hash>` if you're curious). This is useful if you want `mise run` to execute when sources change but don't want to have to manually `touch` a file for `sources` to work.

toml

```
[tasks.build]
run = "cargo build"
sources = ["Cargo.toml", "src/**/*.rs"]
outputs = { auto = true }
```

### `shell` [​](https://mise.jdx.dev/tasks/task-configuration.html\#shell)

- **Type**: `string`
- **Default**: [`unix_default_inline_shell_args`](https://mise.jdx.dev/configuration/settings.html#unix_default_inline_shell_args) or [`windows_default_inline_shell_args`](https://mise.jdx.dev/configuration/settings.html#windows_default_inline_shell_args)
- **Note**: Only applies to toml-tasks.

The shell to use to run the task. This is useful if you want to run a task with a different shell than the default such as `fish`, `zsh`, or `pwsh`. Generally though, it's recommended to use a [shebang](https://mise.jdx.dev/tasks/toml-tasks.html#shell-shebang) instead because that will allow IDEs with mise support to show syntax highlighting and linting for the script.

toml

```
[tasks.hello]
run = '''
#!/usr/bin/env node
console.log('hello world')
'''
```

### `quiet` [​](https://mise.jdx.dev/tasks/task-configuration.html\#quiet)

- **Type**: `bool`
- **Default**: `false`

Suppress mise's output for the task such as showing the command that is run, e.g.: `[build] $ cargo build`. When this is set, mise won't show any output other than what the script itself outputs. If you'd also like to hide even the output that the task emits, use [`silent`](https://mise.jdx.dev/tasks/task-configuration.html#silent).

### `silent` [​](https://mise.jdx.dev/tasks/task-configuration.html\#silent)

- **Type**: `bool | "stdout" | "stderr"`
- **Default**: `false`

Suppress all output from the task. If set to `"stdout"` or `"stderr"`, only that stream will be suppressed.

### `usage` [​](https://mise.jdx.dev/tasks/task-configuration.html\#usage)

- **Type**: `string`

More advanced usage specs can be added to the task's `usage` field. This only applies to toml-tasks.

toml

```
[tasks.test]
usage = '''
arg "file" description="The file to test" default="src/main.rs"
'''
run = 'cargo test {{arg(name="file")}}'
```

## Vars [​](https://mise.jdx.dev/tasks/task-configuration.html\#vars)

Vars are variables that can be shared between tasks like environment variables but they are not passed as environment variables to the scripts. They are defined in the `vars` section of the `mise.toml` file.

toml

```
[vars]
e2e_args = '--headless'

[tasks.test]
run = './scripts/test-e2e.sh {{vars.e2e_args}}'
```

Like most configuration in mise, vars can be defined across several files. So for example, you could put some vars in your global mise config `~/.config/mise/config.toml`, use them in a task at `~/src/work/myproject/mise.toml`. You can also override those vars in "later" config files such as `~/src/work/myproject/mise.local.toml` and they will be used inside tasks of any config file.

As of this writing vars are only supported in TOML tasks. I want to add support for file tasks, but I don't want to turn all file tasks into tera templates just for this feature.

## `[task_config]` options [​](https://mise.jdx.dev/tasks/task-configuration.html\#task-config-options)

Options available in the top-level `mise.toml` `[task_config]` section. These apply to all tasks which are included by that config file or use the same root directory, e.g.: `~/src/myprojec/mise.toml`'s `[task_config]` applies to file tasks like `~/src/myproject/mise-tasks/mytask` but not to tasks in `~/src/myproject/subproj/mise.toml`.

### `task_config.dir` [​](https://mise.jdx.dev/tasks/task-configuration.html\#task-config-dir)

Change the default directory tasks are run from.

toml

```
[task_config]
dir = "{{cwd}}"
```

### `task_config.includes` [​](https://mise.jdx.dev/tasks/task-configuration.html\#task-config-includes)

Add toml files containing toml tasks, or file tasks to include when looking for tasks.

toml

```
[task_config]
includes = [\
    "tasks.toml", # a task toml file\
    "mytasks"     # a directory containing file tasks (in addition to the default file tasks directories)\
]
```

If using included task toml files, note that they have a different format than the `mise.toml` file. They are just a list of tasks. The file should be the same format as the `[tasks]` section of `mise.toml` but without the `[task]` prefix:

tasks.toml

toml

```
task1 = "echo task1"
task2 = "echo task2"
task3 = "echo task3"

[task4]
run = "echo task4"
```

If you want auto-completion/validation in included toml tasks files, you can use the following JSON schema: [https://mise.jdx.dev/schema/mise-task.json](https://mise.jdx.dev/schema/mise-task.json)

## `redactions` experimental [​](https://mise.jdx.dev/tasks/task-configuration.html\#redactions)

- **Type**: `string[]`

Redactions are a way to hide sensitive information from the output of tasks. This is useful for things like API keys, passwords, or other sensitive information that you don't want to accidentally leak in logs or other output.

A list of environment variables to redact from the output.

toml

```
redactions = ["API_KEY", "PASSWORD"]
```

Running the above task will output `echo [redacted]` instead.

You can also specify these as a glob pattern, e.g.: `redactions.env = ["SECRETS_*"]`.

## `[vars]` options [​](https://mise.jdx.dev/tasks/task-configuration.html\#vars-options)

Vars are variables that can be shared between tasks like environment variables but they are not passed as environment variables to the scripts. They are defined in the `vars` section of the `mise.toml` file.

toml

```
[vars]
e2e_args = '--headless'
[tasks.test]
run = './scripts/test-e2e.sh {{vars.e2e_args}}'
```

Like `[env]`, vars can also be read in as a file:

toml

```
[vars]
_.file = ".env"
```

[Secrets](https://mise.jdx.dev/environments/secrets.html) are also supported as vars.

<|firecrawl-page-174-lllmstxt|>
## Meet Our Team
[Skip to content](https://mise.jdx.dev/team.html#VPContent)

Return to top

# Team [​](https://mise.jdx.dev/team.html\#team)

Jeff Dickey is the primary developer behind mise. He does the bulk of development for the project.

![Jeff Dickey](https://www.github.com/jdx.png)

# Jeff Dickey

BDFL

[github](https://github.com/jdx)[twitter](https://twitter.com/jdxcode)[mastodon](https://fosstodon.org/@jdx)

## Advisory Board [​](https://mise.jdx.dev/team.html\#advisory-board)

The advisory board helps make important decisions about the project such as:

- What features should be on the roadmap
- When should functionality move from experimental to stable
- If/when/how features should be deprecated

![Justin "J.R." Hill](https://www.github.com/booniepepper.png)

# Justin "J.R." Hill

[github](https://github.com/booniepepper)

![Pedro Piñera Buendía](https://www.github.com/pepicrft.png)

# Pedro Piñera Buendía

[github](https://github.com/pepicrft)

![Chad Crawford](https://www.github.com/chadac.png)

# Chad Crawford

[github](https://github.com/chadac)

## Contributors [​](https://mise.jdx.dev/team.html\#contributors)

mise is an open source project which welcomes [contributions](https://github.com/jdx/mise/graphs/contributors). We're grateful for those that have volunteered their work for the project.

<|firecrawl-page-175-lllmstxt|>
## Mise Template Configuration
[Skip to content](https://mise.jdx.dev/templates.html#VPContent)

Return to top

# Templates [​](https://mise.jdx.dev/templates.html\#templates)

Templates in mise provide a powerful way to configure different aspects of your environment and project settings.

A template is a string that contains variables, expressions, and control structures. When rendered, the template engine ( `tera`) replaces the variables with their values.

You can define and use templates in the following locations:

- Most `mise.toml` configuration values
  - The `mise.toml` file itself is not templated and must be valid toml
- `.tool-versions` files
- _(Submit a ticket if you want to see it used elsewhere!)_

## Example [​](https://mise.jdx.dev/templates.html\#example)

Here is an example of a `mise.toml` file that uses templates:

toml

```
[env]
PROJECT_NAME = "{{ cwd | basename }}"

[tools]
node = "{{ get_env(name='NODE_VERSION', default='20') }}"
```

You will find more examples in the [cookbook](https://mise.jdx.dev/mise-cookbook/).

## Template Rendering [​](https://mise.jdx.dev/templates.html\#template-rendering)

Mise uses [tera](https://keats.github.io/tera/docs/) to provide the template feature. In the template, there are 3 kinds of delimiters:

- `{{` and `}}` for expressions
- `{%` and `%}` for statements
- `{#` and `#}` for comments

Additionally, use `raw` block to skip rendering tera delimiters:

```
{% raw %}
  Hello {{ name }}
{% endraw %}
```

This will become `Hello {{name}}`.

Tera supports [literals](https://keats.github.io/tera/docs/#literals), including:

- booleans: `true` (or `True`) and `false` (or `False`)
- integers
- floats
- strings: text delimited by `""`, `''` or ``` `` ```
- arrays: a comma-separated list of literals and/or ident surrounded by `[` and `]` (trailing comma allowed)

You can render a variable by using the `{{ name }}`. For complex attributes, use:

- dot `.`, e.g. `{{ product.name }}`
- square brackets `[]`, e.g. `{{ product["name"] }}`

Tera also supports powerful [expressions](https://keats.github.io/tera/docs/#expressions):

- mathematical expressions
  - `+`
  - `-`
  - `/`
  - `*`
  - `%`
- comparisons
  - `==`
  - `!=`
  - `>=`
  - `<=`
  - `<`
  - `>`
- logic
  - `and`
  - `or`
  - `not`
- concatenation `~`, e.g. ``{{ "hello " ~ 'world' ~ `!` }``
- in checking, e.g. `{{ some_var in [1, 2, 3] }}`

Tera also supports control structures such as `if` and `for`. [Read more](https://keats.github.io/tera/docs/#control-structures).

### Tera Filters [​](https://mise.jdx.dev/templates.html\#tera-filters)

You can modify variables using [filters](https://keats.github.io/tera/docs/#filters). You can filter a variable by a pipe symbol ( `|`) and may have named arguments in parentheses. You can also chain multiple filters. e.g. `{{ "Doctor Who" | lower | replace(from="doctor", to="Dr.") }}` will output `Dr. who`.

### Tera Functions [​](https://mise.jdx.dev/templates.html\#tera-functions)

[Functions](https://keats.github.io/tera/docs/#functions) provide additional features to templates.

### Tera Tests [​](https://mise.jdx.dev/templates.html\#tera-tests)

You can also uses [tests](https://keats.github.io/tera/docs/#tests) to examine variables.

```
{% if my_number is not odd %}
  Even
{% endif %}
```

## Mise Template Features [​](https://mise.jdx.dev/templates.html\#mise-template-features)

Mise provides additional variables, functions, filters and tests on top of tera features.

### Variables [​](https://mise.jdx.dev/templates.html\#variables)

Mise exposes several [variables](https://keats.github.io/tera/docs/#variables). These variables offer key information about the current environment:

- `env: HashMap<String, String>` – Accesses current environment variables as a key-value map.
- `cwd: PathBuf` – Points to the current working directory.
- `config_root: PathBuf` – Locates the directory containing your `mise.toml` file, or in the case of something like `~/src/myproj/.config/mise.toml`, it will point to `~/src/myproj`.
- `mise_bin: String` \- Points to the path to the current mise executable
- `mise_pid: String` \- Points to the pid of the current mise process
- `mise_env: String` \- The configuration environment as specified by `MISE_ENV`, `-E`, or `--env`. Will be undefined if the configuration environment is not set.
- `xdg_cache_home: PathBuf` \- Points to the directory of XDG cache home
- `xdg_config_home: PathBuf` \- Points to the directory of XDG config home
- `xdg_data_home: PathBuf` \- Points to the directory of XDG data home
- `xdg_state_home: PathBuf` \- Points to the directory of XDG state home

### Functions [​](https://mise.jdx.dev/templates.html\#functions)

Tera offers many [built-in functions](https://keats.github.io/tera/docs/#built-in-functions). `[]` indicates an optional function argument. Some functions:

- `range(end, [start], [step_by])` \- Returns an array of integers created using the arguments given.
  - `end: usize`: stop before `end`, mandatory
  - `start: usize`: where to start from, defaults to `0`
  - `step_by: usize`: with what number do we increment, defaults to `1`
- `now([timestamp], [utc])` \- Returns the local datetime as string or the timestamp as integer.
  - `timestamp: bool`: whether to return the timestamp instead of the datetime
  - `utc: bool`: whether to return the UTC datetime instead of the local one
  - Tip: use date filter to format date string. e.g. `{{ now() | date(format="%Y") }}` gets the current year.
- `throw(message)` \- Throws with the message.
- `get_random(end, [start])` \- Returns a random integer in a range.
  - `end: usize`: upper end of the range
  - `start: usize`: defaults to 0
- `get_env(name, [default])`: Returns the environment variable value by name. Prefer `env` variable than this function.
  - `name: String`: the name of the environment variable
  - `default: String`: a default value in case the environment variable is not found. Throws when can't find the environment variable and `default` is not set.

Tera offers more functions. Read more on [tera documentation](https://keats.github.io/tera/docs/#functions).

Mise offers additional functions:

- `exec(command) -> String` – Runs a shell command and returns its output as a string.
- `arch() -> String` – Retrieves the system architecture, such as `x86_64` or `arm64`.
- `os() -> String` – Returns the name of the operating system, e.g. linux, macos, windows.
- `os_family() -> String` – Returns the operating system family, e.g. `unix`, `windows`.
- `num_cpus() -> usize` – Gets the number of CPUs available on the system.
- `choice(n, alphabet)` \- Generate a string of `n` with random sample with replacement of `alphabet`. For example, `choice(64, HEX)` will generate a random 64-character lowercase hex string.

An example of function using `exec`:

toml

```
[alias.node.versions]
current = "{{ exec(command='node --version') }}"
```

### Exec Options [​](https://mise.jdx.dev/templates.html\#exec-options)

The `exec` function supports the following options:

- `command: String` – \[required\] The command to run.
- `cache_key: String` – The cache key to store the result. If the cache key is provided, the result will be cached and reused for subsequent calls.
- `cache_duration: String` – The duration to cache the result. The duration is in seconds, minutes, hours, days, or weeks. e.g. `cache_duration="1d"` will cache the result for 1 day.

### Filters [​](https://mise.jdx.dev/templates.html\#filters)

Tera offers many [built-in filters](https://keats.github.io/tera/docs/#built-in-filters). `[]` indicates an optional filter argument. Some filters:

- `str | lower -> String` – Converts a string to lowercase.
- `str | upper -> String` – Converts a string to uppercase.
- `str | capitalize -> String` – Converts a string with all its characters lowercased apart from the first char which is uppercased.
- `str | replace(from, to) -> String` – Replaces a string with all instances of `from` to `to`. e.g., `{{ name | replace(from="Robert", to="Bob")}}`
- `str | title -> String` – Capitalizes each word inside a sentence. e.g., `{{ "foo bar" | title }}` becomes `Foo Bar`.
- `str | trim -> String` – Removes leading and trailing whitespace.
- `str | trim_start -> String` – Removes leading whitespace.
- `str | trim_end -> String` – Removes trailing whitespace.
- `str | truncate -> String` – Truncates a string to the indicated length.
- `str | first -> String` – Returns the first element in an array or string.
- `str | last -> String` – Returns the last element in an array or string.
- `str | join(sep) -> String` – Joins an array of strings with a separator, such as `{{ ["a", "b", "c"] | join(sep=", ") }}` to produce `a, b, c`.
- `str | length -> usize` – Returns the length of a string or array.
- `str | reverse -> String` – Reverses the order of characters in a string or elements in an array.
- `str | urlencode -> String` – Encodes a string to be safely used in URLs, converting special characters to percent-encoded values.
- `arr | map(attribute) -> Array` – Extracts an attribute from each object in an array.
- `arr | concat(with) -> Array` – Appends values to an array.
- `num | abs -> Number` – Returns the absolute value of a number.
- `num | filesizeformat -> String` – Converts an integer into a human-readable file size (e.g., 110 MB).
- `str | date(format) -> String` – Converts a timestamp to a formatted date string using the provided format, such as `{{ ts | date(format="%Y-%m-%d") }}`. Find a list of time format on [`chrono` documentation](https://docs.rs/chrono/latest/chrono/format/strftime/index.html).
- `str | split(pat) -> Array` – Splits a string by the given pattern and returns an array of substrings.
- `str | default(value) -> String` – Returns the default value if the variable is not defined or is empty.

Tera offers more filters. Read more on [tera documentation](https://keats.github.io/tera/docs/#built-in-filters).

#### Hash [​](https://mise.jdx.dev/templates.html\#hash)

- `str | hash([len]) -> String` – Generates a SHA256 hash for the input string.
  - `len: usize`: truncates the hash string to the given size
- `path | hash_file([len]) -> String` – Returns the SHA256 hash of the file at the given path.
  - `len: usize`: truncates the hash string to the given size

#### Path Manipulation [​](https://mise.jdx.dev/templates.html\#path-manipulation)

- `path | canonicalize -> String` – Converts the input path into absolute input path version. Throws if path doesn't exist.
- `path | basename -> String` – Extracts the file name from a path, e.g. `/foo/bar/baz.txt` becomes `baz.txt`.
- `path | file_size -> String` – Returns the size of a file in bytes.
- `path | dirname -> String` – Returns the directory path for a file, e.g. `/foo/bar/baz.txt` becomes `/foo/bar`.
- `path | basename -> String` – Returns the base name of a file, e.g. `/foo/bar/baz.txt` becomes `baz.txt`.
- `path | extname -> String` – Returns the extension of a file, e.g. `/foo/bar/baz.txt` becomes `.txt`.
- `path | file_stem -> String` – Returns the file name without the extension, e.g. `/foo/bar/baz.txt` becomes `baz`.
- `path | file_size -> String` – Returns the size of a file in bytes.
- `path | last_modified -> String` – Returns the last modified time of a file.
- `path[] | join_path -> String` – Joins an array of paths into a single path.

For example, you can use `split()`, `concat()`, and `join_path` filters to construct a file path:

toml

```
[env]
PROJECT_CONFIG = "{{ [config_root] | concat(with='bar.txt') | join_path }}"
```

#### String Manipulation [​](https://mise.jdx.dev/templates.html\#string-manipulation)

- `str | quote -> String` – Quotes a string. Converts `'` to `\'` and then quotes str, e.g `'it\'s str'`.
- `str | kebabcase -> String` – Converts a string to kebab-case
- `str | lowercamelcase -> String` – Converts a string to lowerCamelCase
- `str | uppercamelcase -> String` – Converts a string to UpperCamelCase
- `str | snakecase -> String` – Converts a string to snake\_case
- `str | shoutysnakecase -> String` – Converts a string to SHOUTY\_SNAKE\_CASE

### Tests [​](https://mise.jdx.dev/templates.html\#tests)

Tera offers many [built-in tests](https://keats.github.io/tera/docs/#built-in-tests). Some tests:

- `defined` \- Returns `true` if the given variable is defined.
- `string` \- Returns `true` if the given variable is a string.
- `number` \- Returns `true` if the given variable is a number.
- `starting_with` \- Returns `true` if the given variable is a string and starts with the arg given.
- `ending_with` \- Returns `true` if the given variable is a string and ends with the arg given.
- `containing` \- Returns `true` if the given variable contains the arg given.
- `matching` \- Returns `true` if the given variable is a string and matches the regex in the argument.

Tera offers more tests. Read more on [tera documentation](https://keats.github.io/tera/docs/#built-in-tests).

Mise offers additional tests:

- `if path is dir` – Checks if the provided path is a directory.
- `if path is file` – Checks if the path points to a file.
- `if path is exists` – Checks if the path exists.

<|firecrawl-page-176-lllmstxt|>
## Mise Tips and Tricks
[Skip to content](https://mise.jdx.dev/tips-and-tricks.html#VPContent)

Return to top

# Tips & Tricks [​](https://mise.jdx.dev/tips-and-tricks.html\#tips-tricks)

An assortment of helpful tips for using `mise`.

## macOS Rosetta [​](https://mise.jdx.dev/tips-and-tricks.html\#macos-rosetta)

If you have a need to run tools as x86\_64 on Apple Silicon, this can be done with mise however you'll currently need to use the x86\_64 version of mise itself. A common reason for doing this is to support compiling node <=14.

You can do this either with the [`MISE_ARCH`](https://mise.jdx.dev/configuration/settings.html#arch) setting or by using a dedicated rosetta mise bin as described below:

First, you'll need a copy of mise that's built for x86\_64:

sh

```
$ curl https://mise.run | MISE_INSTALL_PATH=~/.local/bin/mise-x64 MISE_INSTALL_ARCH=x64 sh
$ ~/.local/bin/mise-x64 --version
mise 2024.x.x
```

WARNING

If `~/.local/bin` is not in PATH, you'll need to prefix all commands with `~/.local/bin/mise-x64`.

Now you can use `mise-x64` to install tools:

sh

```
mise-x64 use -g node@20
```

## Shebang [​](https://mise.jdx.dev/tips-and-tricks.html\#shebang)

You can specify a tool and its version in a shebang without needing to first set up a `mise.toml`/ `.tool-versions` config:

typescript

```
#!/usr/bin/env -S mise x node@20 -- node
// "env -S" allows multiple arguments in a shebang
console.log(`Running node: ${process.version}`);
```

This can also be useful in environments where mise isn't activated (such as a non-interactive session).

## Bootstrap script [​](https://mise.jdx.dev/tips-and-tricks.html\#bootstrap-script)

You can download the [https://mise.run](https://mise.run/) script to use in a project bootstrap script:

sh

```
curl https://mise.run > setup-mise.sh
chmod +x setup-mise.sh
./setup-mise.sh
```

TIP

This file contains checksums so it's more secure to commit it into your project rather than calling `curl https://mise.run` dynamically—though of course this means it will only fetch the version of mise that was current when the script was created.

## Installation via zsh zinit [​](https://mise.jdx.dev/tips-and-tricks.html\#installation-via-zsh-zinit)

[Zinit](https://github.com/zdharma-continuum/zinit) is a plugin manager for ZSH, which this snippet you will get mise (and usage for shell completion):

sh

```
zinit as="command" lucid from="gh-r" for \
    id-as="usage" \
    atpull="%atclone" \
    jdx/usage
    #atload='eval "$(mise activate zsh)"' \

zinit as="command" lucid from="gh-r" for \
    id-as="mise" mv="mise* -> mise" \
    atclone="./mise* completion zsh > _mise" \
    atpull="%atclone" \
    atload='eval "$(mise activate zsh)"' \
    jdx/mise
```

## CI/CD [​](https://mise.jdx.dev/tips-and-tricks.html\#ci-cd)

Using mise in CI/CD is a great way to synchronize tool versions for dev/build.

### GitHub Actions [​](https://mise.jdx.dev/tips-and-tricks.html\#github-actions)

mise is pretty easy to use without an action:

yaml

```
jobs:
  build:
    steps:
      - run: |
          curl https://mise.run | sh
          echo "$HOME/.local/bin" >> $GITHUB_PATH
          echo "$HOME/.local/share/mise/shims" >> $GITHUB_PATH
```

Or you can use the custom action [`jdx/mise-action`](https://github.com/jdx/mise-action):

yaml

```
jobs:
  lint:
    runs-on: ubuntu-latest
    steps:
      - uses: jdx/mise-action@v2
      - run: node -v # will be the node version from `mise.toml`/`.tool-versions`
```

## `mise set` [​](https://mise.jdx.dev/tips-and-tricks.html\#mise-set)

Instead of manually editing `mise.toml` to add env vars, you can use [`mise set`](https://mise.jdx.dev/cli/set.html) instead:

sh

```
mise set NODE_ENV=production
```

## [`mise run`](https://mise.jdx.dev/cli/run.html) shorthand [​](https://mise.jdx.dev/tips-and-tricks.html\#mise-run-shorthand)

As long as the task name doesn't conflict with a mise-provided command you can skip the `run` part:

sh

```
mise test
```

WARNING

Don't do this inside of scripts because mise may add a command in a future version and could conflict with your task.

## Software verification [​](https://mise.jdx.dev/tips-and-tricks.html\#software-verification)

Install cosign, slsa-verifier, and gpg (cosign and slsa-verifier can be installed with mise) in order to verify tools automatically.

sh

```
brew install gpg
mise use -g cosign slsa-verifier
```

## [`mise up --bump`](https://mise.jdx.dev/cli/upgrade.html) [​](https://mise.jdx.dev/tips-and-tricks.html\#mise-up-bump)

Use `mise up --bump` to upgrade all software to the latest version and update `mise.toml` files. This keeps the same semver range as before, so if you had `node = "20"` and node 22 is the latest, `mise up --bump node` will change `mise.toml` to `node = "22"`.

## cargo-binstall [​](https://mise.jdx.dev/tips-and-tricks.html\#cargo-binstall)

cargo-binstall is sort of like ubi but specific to rust tools. It fetches binaries for cargo releases. mise will use this automatically for `cargo:` tools if it is installed so if you use `cargo:` you should add this to make `mise i` go much faster.

sh

```
mise use -g cargo-binstall
```

## [`mise cache clear`](https://mise.jdx.dev/cli/cache.html) [​](https://mise.jdx.dev/tips-and-tricks.html\#mise-cache-clear)

mise caches things for obvious reasons but sometimes you want it to use fresh data (maybe it's not noticing a new release). Run `mise cache clear` to remove the cache which basically just run `rm -rf ~/.cache/mise/*`.

## [`mise en`](https://mise.jdx.dev/cli/en.html) [​](https://mise.jdx.dev/tips-and-tricks.html\#mise-en)

`mise en` is a great alternative to `mise activate` if you don't want to always be using mise for some reason. It sets up the mise environment in your current directory but doesn't keep running and updating the env vars after that.

## Auto-install when entering a project [​](https://mise.jdx.dev/tips-and-tricks.html\#auto-install-when-entering-a-project)

Auto-install tools when entering a project by adding the following to `mise.toml`:

toml

```
[hooks]
enter = "mise i -q"
```

## [`mise tool [TOOL]`](https://mise.jdx.dev/cli/tool.html) [​](https://mise.jdx.dev/tips-and-tricks.html\#mise-tool-tool)

Get information about what backend a tool is using and other information with `mise tool [TOOL]`:

sh

```
❯ mise tool ripgrep
Backend:            aqua:BurntSushi/ripgrep
Installed Versions: 14.1.1
Active Version:     14.1.1
Requested Version:  latest
Config Source:      ~/src/mise/mise.toml
Tool Options:       [none]
```

## [`mise cfg`](https://mise.jdx.dev/cli/config.html) [​](https://mise.jdx.dev/tips-and-tricks.html\#mise-cfg)

List the config files mise is reading in a particular directory with `mise cfg`:

sh

```
❯ mise cfg
Path                                    Tools
~/.config/mise/config.toml              (none)
~/.mise/config.toml                     (none)
~/src/mise.toml                         (none)
~/src/mise/.config/mise/conf.d/foo.toml (none)
~/src/mise/mise.toml                    actionlint, bun, cargo-binstall, cargo:…
~/src/mise/mise.local.toml              (none)
```

This is helpful figuring out which order the config files are loaded in to figure out which one is overriding.

## `mise.lock` [​](https://mise.jdx.dev/tips-and-tricks.html\#mise-lock)

If you enable experimental mode, mise will update `mise.lock` with full versions and tarball checksums (if supported by the backend). These can be updated with [`mise up`](https://mise.jdx.dev/cli/upgrade.html). You need to manually create the lockfile, then mise will add the tools to it:

sh

```
touch mise.lock
mise i
```

The lockfile uses a consolidated format with `[tools.name.assets]` sections to organize asset information under each tool. Asset information includes checksums, file sizes, and optional download URLs. Legacy lockfiles with separate `[tools.name.checksums]` and `[tools.name.sizes]` sections are automatically migrated to the new format.

Note that at least currently mise needs to actually install the tool to get the tarball checksum (otherwise it would need to download the tarball just to get the checksum of it since normally that gets deleted). So you may need to run something like `mise uninstall --all` first in order to have it reinstall everything. It will store the full versions even if it doesn't know the checksum though so it'll still lock the version just not have a checksum to go with it.

## Lockfile URL Tracking (Avoiding Rate Limits) [​](https://mise.jdx.dev/tips-and-tricks.html\#lockfile-url-tracking-avoiding-rate-limits)

When you use a lockfile ( `mise.lock`), mise stores the exact download URLs for each tool asset. This means that after the initial install, future `mise install` runs will use the URLs from the lockfile instead of making API calls to GitHub (or other providers). This has several benefits:

- **Avoids GitHub API rate limits**: No need to make repeated API calls for every install, which can quickly exhaust your rate limit, especially in CI or large teams.
- **No need for GITHUB\_TOKEN**: Since the URLs are already known, you don’t need to set up a `GITHUB_TOKEN` for simple installs.
- **Faster installs**: Skipping API lookups speeds up repeated installs.

This is especially useful in CI/CD or when working in environments with strict network or authentication requirements.

<|firecrawl-page-177-lllmstxt|>
## Tool Plugin Development
[Skip to content](https://mise.jdx.dev/tool-plugin-development.html#VPContent)

Return to top

# Tool Plugin Development [​](https://mise.jdx.dev/tool-plugin-development.html\#tool-plugin-development)

Tool plugins use a hook-based architecture to manage individual tools. They are compatible with the standard vfox ecosystem and are perfect for tools that need complex installation logic, environment configuration, or legacy file parsing.

## What are Tool Plugins? [​](https://mise.jdx.dev/tool-plugin-development.html\#what-are-tool-plugins)

Tool plugins use traditional hook functions to manage a single tool. They provide:

- **Standard vfox Compatibility**: Works with both mise and vfox
- **Complex Installation Logic**: Handle source compilation, custom builds, and complex setups
- **Environment Configuration**: Set up complex environment variables beyond just PATH
- **Legacy File Support**: Parse version files from other tools ( `.nvmrc`, `.tool-version`, etc.)
- **Cross-Platform Support**: Works on Windows, macOS, and Linux

## Plugin Architecture [​](https://mise.jdx.dev/tool-plugin-development.html\#plugin-architecture)

Tool plugins use a hook-based architecture with specific functions for different lifecycle events:

## Hook Functions [​](https://mise.jdx.dev/tool-plugin-development.html\#hook-functions)

### Required Hooks [​](https://mise.jdx.dev/tool-plugin-development.html\#required-hooks)

These hooks must be implemented for a functional plugin:

#### Available Hook [​](https://mise.jdx.dev/tool-plugin-development.html\#available-hook)

Lists all available versions of the tool:

lua

```
-- hooks/available.lua
function PLUGIN:Available(ctx)
    local args = ctx.args  -- User arguments

    -- Return array of available versions
    return {
        {
            version = "20.0.0",
            note = "Latest"
        },
        {
            version = "18.18.0",
            note = "LTS",
            addition = {
                {
                    name = "npm",
                    version = "9.8.1"
                }
            }
        }
    }
end
```

#### PreInstall Hook [​](https://mise.jdx.dev/tool-plugin-development.html\#preinstall-hook)

Handles pre-installation logic and returns download information:

lua

```
-- hooks/pre_install.lua
function PLUGIN:PreInstall(ctx)
    local version = ctx.version
    local runtimeVersion = ctx.runtimeVersion

    -- Determine download URL and checksums
    local url = "https://nodejs.org/dist/v" .. version .. "/node-v" .. version .. "-linux-x64.tar.gz"

    return {
        version = version,
        url = url,
        sha256 = "abc123...",  -- Optional checksum
        note = "Installing Node.js " .. version,
        -- Additional files can be specified
        addition = {
            {
                name = "npm",
                url = "https://registry.npmjs.org/npm/-/npm-" .. npm_version .. ".tgz"
            }
        }
    }
end
```

#### EnvKeys Hook [​](https://mise.jdx.dev/tool-plugin-development.html\#envkeys-hook)

Configures environment variables for the installed tool:

lua

```
-- hooks/env_keys.lua
function PLUGIN:EnvKeys(ctx)
    local mainPath = ctx.path
    local runtimeVersion = ctx.runtimeVersion
    local sdkInfo = ctx.sdkInfo['nodejs']
    local path = sdkInfo.path
    local version = sdkInfo.version
    local name = sdkInfo.name

    return {
        {
            key = "NODE_HOME",
            value = mainPath
        },
        {
            key = "PATH",
            value = mainPath .. "/bin"
        },
        -- Multiple PATH entries are automatically merged
        {
            key = "PATH",
            value = mainPath .. "/lib/node_modules/.bin"
        }
    }
end
```

### Optional Hooks [​](https://mise.jdx.dev/tool-plugin-development.html\#optional-hooks)

These hooks provide additional functionality:

#### PostInstall Hook [​](https://mise.jdx.dev/tool-plugin-development.html\#postinstall-hook)

Performs additional setup after installation:

lua

```
-- hooks/post_install.lua
function PLUGIN:PostInstall(ctx)
    local rootPath = ctx.rootPath
    local runtimeVersion = ctx.runtimeVersion
    local sdkInfo = ctx.sdkInfo['nodejs']
    local path = sdkInfo.path
    local version = sdkInfo.version

    -- Compile native modules, set permissions, etc.
    local result = os.execute("chmod +x " .. path .. "/bin/*")
    if result ~= 0 then
        error("Failed to set permissions")
    end

    -- No return value needed
end
```

#### PreUse Hook [​](https://mise.jdx.dev/tool-plugin-development.html\#preuse-hook)

Modifies version before use:

lua

```
-- hooks/pre_use.lua
function PLUGIN:PreUse(ctx)
    local version = ctx.version
    local previousVersion = ctx.previousVersion
    local installedSdks = ctx.installedSdks
    local cwd = ctx.cwd
    local scope = ctx.scope  -- global/project/session

    -- Optionally modify the version
    if version == "latest" then
        version = "20.0.0"  -- Resolve to specific version
    end

    return {
        version = version
    }
end
```

#### ParseLegacyFile Hook [​](https://mise.jdx.dev/tool-plugin-development.html\#parselegacyfile-hook)

Parses version files from other tools:

lua

```
-- hooks/parse_legacy_file.lua
function PLUGIN:ParseLegacyFile(ctx)
    local filename = ctx.filename
    local filepath = ctx.filepath
    local versions = ctx:getInstalledVersions()

    -- Read and parse the file
    local file = require("file")
    local content = file.read(filepath)
    local version = content:match("v?([%d%.]+)")

    return {
        version = version
    }
end
```

## Creating a Tool Plugin [​](https://mise.jdx.dev/tool-plugin-development.html\#creating-a-tool-plugin)

### 1\. Plugin Structure [​](https://mise.jdx.dev/tool-plugin-development.html\#_1-plugin-structure)

Create a directory with this structure:

```
nodejs-plugin/
├── metadata.lua          # Plugin metadata and configuration
├── hooks/               # Hook functions directory
│   ├── available.lua    # List available versions [required]
│   ├── pre_install.lua  # Pre-installation hook [required]
│   ├── env_keys.lua     # Environment configuration [required]
│   ├── post_install.lua # Post-installation hook [optional]
│   ├── pre_use.lua      # Pre-use hook [optional]
│   └── parse_legacy_file.lua # Legacy file parser [optional]
├── lib/                 # Shared library code [optional]
│   └── helper.lua       # Helper functions
└── test/               # Test scripts [optional]
    └── test.sh
```

### 2\. metadata.lua [​](https://mise.jdx.dev/tool-plugin-development.html\#_2-metadata-lua)

Configure plugin metadata and legacy file support:

lua

```
-- metadata.lua
PLUGIN = {
    name = "nodejs",
    version = "1.0.0",
    description = "Node.js runtime environment",
    author = "Plugin Author",

    -- Legacy version files this plugin can parse
    legacyFilenames = {
        '.nvmrc',
        '.node-version'
    }
}
```

### 3\. Helper Libraries [​](https://mise.jdx.dev/tool-plugin-development.html\#_3-helper-libraries)

Create shared functions in the `lib/` directory:

lua

```
-- lib/helper.lua
local M = {}

function M.get_arch()
    local arch = os.getenv("PROCESSOR_ARCHITECTURE") or os.capture("uname -m")
    if arch:match("x86_64") or arch:match("AMD64") then
        return "x64"
    elseif arch:match("i386") or arch:match("i686") then
        return "x86"
    elseif arch:match("arm64") or arch:match("aarch64") then
        return "arm64"
    else
        return "x64"  -- default
    end
end

function M.get_os()
    if package.config:sub(1,1) == '\\' then
        return "win"
    else
        local os_name = os.capture("uname"):lower()
        if os_name:find("darwin") then
            return "darwin"
        else
            return "linux"
        end
    end
end

function M.get_platform()
    return M.get_os() .. "-" .. M.get_arch()
end

return M
```

## Real-World Example: vfox-nodejs [​](https://mise.jdx.dev/tool-plugin-development.html\#real-world-example-vfox-nodejs)

Here's a complete example based on the vfox-nodejs plugin that demonstrates all the concepts:

### Available Hook Example [​](https://mise.jdx.dev/tool-plugin-development.html\#available-hook-example)

lua

```
-- hooks/available.lua
function PLUGIN:Available(ctx)
    local http = require("http")
    local json = require("json")

    -- Fetch versions from Node.js API
    local resp, err = http.get({
        url = "https://nodejs.org/dist/index.json"
    })

    if err ~= nil then
        error("Failed to fetch versions: " .. err)
    end

    local versions = json.decode(resp.body)
    local result = {}

    for i, v in ipairs(versions) do
        local version = v.version:gsub("^v", "")  -- Remove 'v' prefix
        local note = nil

        if v.lts then
            note = "LTS"
        end

        table.insert(result, {
            version = version,
            note = note,
            addition = {
                {
                    name = "npm",
                    version = v.npm
                }
            }
        })
    end

    return result
end
```

### PreInstall Hook Example [​](https://mise.jdx.dev/tool-plugin-development.html\#preinstall-hook-example)

lua

```
-- hooks/pre_install.lua
function PLUGIN:PreInstall(ctx)
    local version = ctx.version
    local helper = require("lib/helper")

    -- Determine platform
    local platform = helper.get_platform()
    local extension = platform:match("win") and "zip" or "tar.gz"

    -- Build download URL
    local filename = "node-v" .. version .. "-" .. platform .. "." .. extension
    local url = "https://nodejs.org/dist/v" .. version .. "/" .. filename

    -- Fetch checksum
    local http = require("http")
    local shasums_url = "https://nodejs.org/dist/v" .. version .. "/SHASUMS256.txt"
    local resp, err = http.get({ url = shasums_url })

    local sha256 = nil
    if err == nil then
        -- Extract SHA256 for our file
        for line in resp.body:gmatch("[^\n]+") do
            if line:match(filename) then
                sha256 = line:match("^(%w+)")
                break
            end
        end
    end

    return {
        version = version,
        url = url,
        sha256 = sha256,
        note = "Installing Node.js " .. version .. " (" .. platform .. ")"
    }
end
```

### EnvKeys Hook Example [​](https://mise.jdx.dev/tool-plugin-development.html\#envkeys-hook-example)

lua

```
-- hooks/env_keys.lua
function PLUGIN:EnvKeys(ctx)
    local mainPath = ctx.path
    local helper = require("lib/helper")
    local os_type = helper.get_os()

    local env_vars = {
        {
            key = "NODE_HOME",
            value = mainPath
        },
        {
            key = "PATH",
            value = mainPath .. "/bin"
        }
    }

    -- Add npm global modules to PATH
    local npm_global_path = mainPath .. "/lib/node_modules/.bin"
    if os_type == "win" then
        npm_global_path = mainPath .. "/node_modules/.bin"
    end

    table.insert(env_vars, {
        key = "PATH",
        value = npm_global_path
    })

    return env_vars
end
```

### PostInstall Hook Example [​](https://mise.jdx.dev/tool-plugin-development.html\#postinstall-hook-example)

lua

```
-- hooks/post_install.lua
function PLUGIN:PostInstall(ctx)
    local sdkInfo = ctx.sdkInfo['nodejs']
    local path = sdkInfo.path
    local helper = require("lib/helper")

    -- Set executable permissions on Unix systems
    if helper.get_os() ~= "win" then
        os.execute("chmod +x " .. path .. "/bin/*")
    end

    -- Create npm cache directory
    local npm_cache_dir = path .. "/.npm"
    os.execute("mkdir -p " .. npm_cache_dir)

    -- Configure npm to use local cache
    local npm_cmd = path .. "/bin/npm"
    if helper.get_os() == "win" then
        npm_cmd = path .. "/npm.cmd"
    end

    os.execute(npm_cmd .. " config set cache " .. npm_cache_dir)
    os.execute(npm_cmd .. " config set prefix " .. path)
end
```

### Legacy File Support [​](https://mise.jdx.dev/tool-plugin-development.html\#legacy-file-support)

lua

```
-- hooks/parse_legacy_file.lua
function PLUGIN:ParseLegacyFile(ctx)
    local filename = ctx.filename
    local filepath = ctx.filepath
    local file = require("file")

    -- Read file content
    local content = file.read(filepath)
    if not content then
        error("Failed to read " .. filepath)
    end

    -- Parse version from different file formats
    local version = nil

    if filename == ".nvmrc" then
        -- .nvmrc can contain version with or without 'v' prefix
        version = content:match("v?([%d%.]+)")
    elseif filename == ".node-version" then
        -- .node-version typically contains just the version number
        version = content:match("([%d%.]+)")
    end

    -- Remove any whitespace
    if version then
        version = version:gsub("%s+", "")
    end

    return {
        version = version
    }
end
```

## Testing Your Plugin [​](https://mise.jdx.dev/tool-plugin-development.html\#testing-your-plugin)

### Local Development [​](https://mise.jdx.dev/tool-plugin-development.html\#local-development)

bash

```
# Link your plugin for development
mise plugin link nodejs /path/to/nodejs-plugin

# Test listing versions
mise ls-remote nodejs

# Test installation
mise install nodejs@20.0.0

# Test environment setup
mise use nodejs@20.0.0
node --version

# Test legacy file parsing
echo "18.18.0" > .nvmrc
mise use nodejs
```

### Debug Mode [​](https://mise.jdx.dev/tool-plugin-development.html\#debug-mode)

Use debug mode to see detailed plugin execution:

bash

```
mise --debug install nodejs@20.0.0
```

### Plugin Test Script [​](https://mise.jdx.dev/tool-plugin-development.html\#plugin-test-script)

Create a comprehensive test script:

bash

```
#!/bin/bash
# test/test.sh
set -e

echo "Testing nodejs plugin..."

# Install the plugin
mise plugin install nodejs .

# Test basic functionality
mise install nodejs@18.18.0
mise use nodejs@18.18.0

# Verify installation
node --version | grep "18.18.0"
npm --version

# Test legacy file support
echo "20.0.0" > .nvmrc
mise use nodejs
node --version | grep "20.0.0"

# Clean up
rm -f .nvmrc
mise plugin remove nodejs

echo "All tests passed!"
```

## Best Practices [​](https://mise.jdx.dev/tool-plugin-development.html\#best-practices)

### Error Handling [​](https://mise.jdx.dev/tool-plugin-development.html\#error-handling)

Always provide meaningful error messages:

lua

```
function PLUGIN:Available(ctx)
    local http = require("http")
    local resp, err = http.get({
        url = "https://api.example.com/versions"
    })

    if err ~= nil then
        error("Failed to fetch versions from API: " .. err)
    end

    if resp.status_code ~= 200 then
        error("API returned status " .. resp.status_code .. ": " .. resp.body)
    end

    -- Process response...
end
```

### Platform Detection [​](https://mise.jdx.dev/tool-plugin-development.html\#platform-detection)

Handle different operating systems properly:

lua

```
-- lib/platform.lua
local M = {}

function M.is_windows()
    return package.config:sub(1,1) == '\\'
end

function M.get_exe_extension()
    return M.is_windows() and ".exe" or ""
end

function M.get_path_separator()
    return M.is_windows() and "\\" or "/"
end

return M
```

### Version Normalization [​](https://mise.jdx.dev/tool-plugin-development.html\#version-normalization)

Normalize versions consistently:

lua

```
local function normalize_version(version)
    -- Remove 'v' prefix if present
    version = version:gsub("^v", "")

    -- Remove pre-release suffixes
    version = version:gsub("%-.*", "")

    return version
end
```

### Caching [​](https://mise.jdx.dev/tool-plugin-development.html\#caching)

Cache expensive operations:

lua

```
-- Cache versions for 12 hours
local cache = {}
local cache_ttl = 12 * 60 * 60  -- 12 hours in seconds

function PLUGIN:Available(ctx)
    local now = os.time()

    -- Check cache first
    if cache.versions and cache.timestamp and (now - cache.timestamp) < cache_ttl then
        return cache.versions
    end

    -- Fetch fresh data
    local versions = fetch_versions_from_api()

    -- Update cache
    cache.versions = versions
    cache.timestamp = now

    return versions
end
```

## Advanced Features [​](https://mise.jdx.dev/tool-plugin-development.html\#advanced-features)

### Conditional Installation [​](https://mise.jdx.dev/tool-plugin-development.html\#conditional-installation)

Different installation logic based on platform or version:

lua

```
function PLUGIN:PreInstall(ctx)
    local version = ctx.version
    local helper = require("lib/helper")
    local platform = helper.get_platform()

    -- Different logic for different platforms
    if platform:match("win") then
        -- Windows-specific installation
        return install_windows(version)
    elseif platform:match("darwin") then
        -- macOS-specific installation
        return install_macos(version)
    else
        -- Linux installation
        return install_linux(version)
    end
end
```

### Source Compilation [​](https://mise.jdx.dev/tool-plugin-development.html\#source-compilation)

For plugins that need to compile from source:

lua

```
-- hooks/post_install.lua
function PLUGIN:PostInstall(ctx)
    local sdkInfo = ctx.sdkInfo['tool-name']
    local path = sdkInfo.path
    local version = sdkInfo.version

    -- Change to source directory
    local build_dir = path .. "/src"

    -- Configure build
    local configure_result = os.execute("cd " .. build_dir .. " && ./configure --prefix=" .. path)
    if configure_result ~= 0 then
        error("Configure failed")
    end

    -- Compile
    local make_result = os.execute("cd " .. build_dir .. " && make -j$(nproc)")
    if make_result ~= 0 then
        error("Compilation failed")
    end

    -- Install
    local install_result = os.execute("cd " .. build_dir .. " && make install")
    if install_result ~= 0 then
        error("Installation failed")
    end
end
```

### Environment Configuration [​](https://mise.jdx.dev/tool-plugin-development.html\#environment-configuration)

Complex environment variable setup:

lua

```
function PLUGIN:EnvKeys(ctx)
    local mainPath = ctx.path
    local version = ctx.sdkInfo['tool-name'].version

    local env_vars = {
        -- Standard environment variables
        {
            key = "TOOL_HOME",
            value = mainPath
        },
        {
            key = "TOOL_VERSION",
            value = version
        },

        -- PATH entries
        {
            key = "PATH",
            value = mainPath .. "/bin"
        },
        {
            key = "PATH",
            value = mainPath .. "/scripts"
        },

        -- Library paths
        {
            key = "LD_LIBRARY_PATH",
            value = mainPath .. "/lib"
        },
        {
            key = "PKG_CONFIG_PATH",
            value = mainPath .. "/lib/pkgconfig"
        }
    }

    -- Platform-specific additions
    local helper = require("lib/helper")
    if helper.get_os() == "darwin" then
        table.insert(env_vars, {
            key = "DYLD_LIBRARY_PATH",
            value = mainPath .. "/lib"
        })
    end

    return env_vars
end
```

## Next Steps [​](https://mise.jdx.dev/tool-plugin-development.html\#next-steps)

- [Learn about Backend Plugin Development](https://mise.jdx.dev/backend-plugin-development.html)
- [Explore available Lua modules](https://mise.jdx.dev/plugin-lua-modules.html)
- [Publishing your plugin](https://mise.jdx.dev/plugin-publishing.html)
- [View the vfox-nodejs plugin source](https://github.com/version-fox/vfox-nodejs)

<|firecrawl-page-178-lllmstxt|>
## Mise Troubleshooting Guide
[Skip to content](https://mise.jdx.dev/troubleshooting.html#VPContent)

Return to top

# Troubleshooting [​](https://mise.jdx.dev/troubleshooting.html\#troubleshooting)

## `mise activate` doesn't work in `~/.profile`, `~/.bash_profile`, `~/.zprofile` [​](https://mise.jdx.dev/troubleshooting.html\#mise-activate-doesn-t-work-in-profile-bash-profile-zprofile)

`mise activate` should only be used in `rc` files. These are the interactive ones used when a real user is using the terminal. (As opposed to being executed by an IDE or something). The prompt isn't displayed in non-interactive environments so PATH won't be modified.

For non-interactive setups, consider using shims instead which will route calls to the correct directory by looking at `PWD` every time they're executed. You can also call `mise exec` instead of expecting things to be directly on PATH. You can also run `mise env` in a non-interactive shell, however that will only setup the global tools. It won't modify the environment variables when entering into a different project.

WARNING

`mise activate --shims` does not support all the features of `mise activate`.

See [shims vs path](https://mise.jdx.dev/dev-tools/shims.html#shims-vs-path) for more info.

Also see the [shebang](https://mise.jdx.dev/tips-and-tricks.html#shebang) example for a way to make scripts call mise to get the runtime. That is another way to use mise without activation.

## mise is failing or not working right [​](https://mise.jdx.dev/troubleshooting.html\#mise-is-failing-or-not-working-right)

First try setting `MISE_DEBUG=1` or `MISE_TRACE=1` and see if that gives you more information. You can also set `MISE_LOG_FILE_LEVEL=debug MISE_LOG_FILE=/path/to/logfile` to write logs to a file.

If something is happening with the activate hook, you can try disabling it and calling `eval "$(mise hook-env)"` manually. It can also be helpful to use `mise env` which will just output environment variables that would be set. Also consider using [shims](https://mise.jdx.dev/dev-tools/shims.html) which can be more compatible.

If runtime installation isn't working right, try using the `--raw` flag which will install things in series and connect stdin/stdout/stderr directly to the terminal. If a plugin is trying to interact with you for some reason this will make it work.

Of course check the version of mise with `mise --version` and make sure it is the latest. Use `mise self-update` to update it. `mise cache clean` can be used to wipe the internal cache and `mise implode` can be used to remove everything except config.

Lastly, there is `mise doctor` which will show diagnostic information and any warnings about issues detected with your setup. If you submit a bug report, please include the output of `mise doctor`.

## The wrong version of a tool is being used [​](https://mise.jdx.dev/troubleshooting.html\#the-wrong-version-of-a-tool-is-being-used)

Likely this means that mise isn't first in PATH—using shims or `mise activate`. You can verify if this is the case by calling `which -a`, for example, if node@20.0.0 is being used but mise specifies node@22.0.0, first make sure that mise has this version installed and active by running `mise ls node`. It should not say missing and have the correct "Requested" version:

bash

```
$ mise ls node
Plugin  Version  Config Source       Requested
node    22.0.0  ~/.mise/config.toml  22.0.0
```

If `node -v` isn't showing the right version, make sure mise is activated by running `mise doctor`. It should not have a "problem" listed about mise not being activated. Lastly, run `which -a node`. If the directory listed is not a mise directory, then mise is not first in PATH. Whichever node is being run first needs to have its directory set before mise is. Typically this means setting PATH for mise shims at the end of bashrc/zshrc.

If using `mise activate`, you have another option of enabling `MISE_ACTIVATE_AGGRESSIVE=1` which will have mise always prepend its tools to be first in PATH. If you're using something that also modifies paths dynamically like `mise activate` does, this may not work because the other tool may be modifying PATH after mise does.

If nothing else, you can run things with [`mise x --`](https://mise.jdx.dev/cli/exec.html) to ensure that the correct version is being used.

## New version of a tool is not available [​](https://mise.jdx.dev/troubleshooting.html\#new-version-of-a-tool-is-not-available)

There are 2 places that versions are cached so a brand new release might not appear right away.

The first is that the mise CLI caches versions for. The cache can be cleared with `mise cache clear`.

The second uses the [https://mise-versions.jdx.dev](https://mise-versions.jdx.dev/) host as a centralized place to list all of the versions of most plugins. This is intended to speed up mise and also get around GitHub rate limits when querying for new versions. Check that repo for your plugin to see if it has an updated version. This service can be disabled by setting `MISE_USE_VERSIONS_HOST=0`.

mise-versions itself also struggles with rate limits but you can help it to fetch more frequently by authenticating with its [GitHub app](https://github.com/apps/mise-versions). It does not require any permissions since it simply fetches public repository information. The more people do this, the quicker mise will be able to fetch new versions of tools.

## Windows problems [​](https://mise.jdx.dev/troubleshooting.html\#windows-problems)

WARNING

Very basic support for windows is currently available, however because Windows can't support asdf plugins, they must use core and vfox only—which means only a handful of tools are available on Windows.

### Path limits [​](https://mise.jdx.dev/troubleshooting.html\#path-limits)

If you have many tools defined in your `mise.toml` hierarchy, then it is possible that `mise x` will produce a `Path` environment variable that is too long for certain tools to handle, most notably, `cmd.exe`. This will affect `mise` tools that invoke `cmd.exe` (like `npm install`).

You have a few options:

1. Set the `MISE_INSTALLS_DIR` environment variable to a shorter location, e.g. `C:\.mise-installs`.
2. Use `powershell.exe` or `pwsh.exe` instead of `cmd.exe`, since they can handle a longer `Path`.
3. Re-organise the `mise.toml` files in your monorepo, to specify only the tools they need.

You can run the following command to test whether you have hit the `cmd.exe` `Path` limitation:

powershell

```
# Path is within limits
❯ mise x -- cmd.exe /d /s /c "where.exe where"
C:\Windows\System32\where.exe
# Path exceeds cmd.exe limits
❯ mise x -- cmd.exe /d /s /c "where.exe where"
'where.exe' is not recognized as an internal or external command,
operable program or batch file.
mise ERROR command failed: exit code 1
mise ERROR Run with --verbose or MISE_VERBOSE=1 for more information
```

## mise isn't working when calling from tmux or another shell initialization script [​](https://mise.jdx.dev/troubleshooting.html\#mise-isn-t-working-when-calling-from-tmux-or-another-shell-initialization-script)

`mise activate` will not update PATH until the shell prompt is displayed. So if you need to access a tool provided by mise before the prompt is displayed you can either [add the shims to your PATH](https://mise.jdx.dev/dev-tools/shims.html#how-to-add-mise-shims-to-path) e.g.

bash

```
export PATH="$HOME/.local/share/mise/shims:$PATH"
python --version # will work after adding shims to PATH
```

Or you can manually call `hook-env`:

bash

```
eval "$(mise activate bash)"
eval "$(mise hook-env)"
python --version # will work only after calling hook-env explicitly
```

For more information, see [What does `mise activate` do?](https://mise.jdx.dev/faq.html#what-does-mise-activate-do)

## Is mise secure? [​](https://mise.jdx.dev/troubleshooting.html\#is-mise-secure)

Providing a secure supply chain is incredibly important. mise already provides a more secure experience when compared to asdf. Security-oriented evaluations and contributions are welcome. We also urge users to look after the plugins they use, and urge plugin authors to look after the users they serve.

For more details see [SECURITY.md](https://github.com/jdx/mise/blob/main/SECURITY.md).

## 403 Forbidden when installing a tool [​](https://mise.jdx.dev/troubleshooting.html\#_403-forbidden-when-installing-a-tool)

You may get an error like one of the following:

text

```
HTTP status client error (403 Forbidden) for url
403 API rate limit exceeded for
```

This can happen if the tool is hosted on GitHub, and you've hit the API rate limit. This is especially common running mise in a CI environment like GitHub Actions. If you don't have a `GITHUB_TOKEN` set, the rate limit is quite low. You can fix this by creating a GitHub token (which needs no scopes) by going to [https://github.com/settings/tokens/new](https://github.com/settings/tokens/new?description=MISE_GITHUB_TOKEN) and setting it as an environment variable. You can use any of the following (in order of preference):

- `MISE_GITHUB_TOKEN`
- `GITHUB_TOKEN`
- `GITHUB_API_TOKEN`

## Auto-install on command not found handler does not work for new tools [​](https://mise.jdx.dev/troubleshooting.html\#auto-install-on-command-not-found-handler-does-not-work-for-new-tools)

If you are expecting mise to automatically install a tool when you run a command that is not found (using the [`not_found_auto_install`](https://mise.jdx.dev/configuration/settings.html#not_found_auto_install) feature), be aware of an important limitation:

**mise can only auto-install missing versions of tools that already have at least one version installed.**

This is because mise does not have a way of knowing which binaries a tool provides unless there is already an installed (even inactive) version of that tool. If you have never installed any version of a tool, mise cannot determine which tool is responsible for a given binary name, and so it cannot auto-install it on demand.

**Workarounds:**

- Manually install at least one version of the tool you want to be auto-installed in the future. After that, the auto-install feature will work for missing versions of that tool.
- Use [`mise x|exec`](https://mise.jdx.dev/cli/exec.html) or [`mise r|run`](https://mise.jdx.dev/cli/run.html) to trigger auto-install for missing tools, even if no version is currently installed. These commands will attempt to install the required tool versions automatically.

<|firecrawl-page-179-lllmstxt|>
## Mise Walkthrough Guide
[Skip to content](https://mise.jdx.dev/walkthrough.html#VPContent)

Return to top

# Walkthrough [​](https://mise.jdx.dev/walkthrough.html\#walkthrough)

Once you've completed the [Getting Started](https://mise.jdx.dev/getting-started.html) guide, you're ready to start using mise. This document offers a quick overview on some initial things you may want to try out.

## Installing Dev Tools [​](https://mise.jdx.dev/walkthrough.html\#installing-dev-tools)

The main command for working with tools in mise is [`mise u|use`](https://mise.jdx.dev/cli/use.html). This does 2 main things:

- Installs tools (if not already installed)
- Adds the tool to the `mise.toml` configuration file—in mise I say the tool is "active" if it's in `mise.toml`

WARNING

Both of these are required to use a tool. If you simply install a tool via `mise install`, it won't be available in your shell. It must also be added to `mise.toml`—which is why I promote using `mise use` since it does both.

You use it like so (note that `mise` must be [activated](https://mise.jdx.dev/getting-started.html#activate-mise) for this example to work):

bash

```
mkdir example-project && cd example-project
mise use node@22
node -v
# v22.0.0
```

And you'll also note that you now have a `mise.toml` file with the following content:

mise.toml

toml

```
[tools]
node = "22"
```

- If this file is in the root of a project, `node` will be installed whenever someone runs [`mise install|i`](https://mise.jdx.dev/cli/install.html).
- This is the command you want to run when you first clone a project or when you want to update installed tools.

## `mise.toml` Configuration [​](https://mise.jdx.dev/walkthrough.html\#mise-toml-configuration)

Use [`mise.toml`](https://mise.jdx.dev/configuration.html#mise-toml) to share your tool configurations with others. This file should be committed to version control and contains the common toolset needed for your project.

For tools or settings you want to keep private, use [`mise.local.toml`](https://mise.jdx.dev/configuration.html#mise-toml). This file should be added to `.gitignore` and is perfect for personal preferences or configurations.

`mise` supports nested configuration files that cascade from broad to specific settings:

1. `~/.config/mise/config.toml` \- Global settings for all projects
2. `~/work/mise.toml` \- Work-specific settings
3. `~/work/project/mise.toml` \- Project-specific settings
4. `~/work/project/mise.local.toml` \- Project-specific settings that should not be shared

`mise` will use all the parent directories together to determine the set of tools—overriding configuration as it goes lower in the hierarchy.

TIP

Use [`mise config ls`](https://mise.jdx.dev/cli/config/ls.html) to see the configuration files currently used by `mise`.

In general, it's preferred to use loose versions like this in `mise` so that other people working on a project don't have to worry about the exact version of a tool you're using. If you'd like to pin the version to enforce a specific version, use `mise use --pin` or the [`lockfile`](https://mise.jdx.dev/configuration/settings.html#lockfile) setting.

If you leave out the version, then mise will default to `node@latest`.

## Dev Tool Backends [​](https://mise.jdx.dev/walkthrough.html\#dev-tool-backends)

Tools are installed with a variety of backends like `asdf`, `ubi`, or `vfox`. See [registry](https://mise.jdx.dev/registry.html) for the full list of shorthands like `node` you can use.

You can also use other backends like `npm` or `cargo` which can install any package from their respective registries:

bash

```
mise use npm:@antfu/ni
mise use cargo:starship
```

## Upgrading Dev Tools [​](https://mise.jdx.dev/walkthrough.html\#upgrading-dev-tools)

Upgrading tool versions can be done with [`mise up|upgrade`](https://mise.jdx.dev/cli/upgrade.html). By default, it will respect the version prefix in `mise.toml`. If a [lockfile](https://mise.jdx.dev/configuration/settings.html#lockfile) exists, mise will update `mise.lock` to the latest version of the tool with the prefix from `mise.toml`.

So if you have `node = "22"` in `mise.toml`, then `mise upgrade node` will upgrade to the latest version of `node 22`.

If you'd like to upgrade to the latest version of node, you can use `mise upgrade --bump node`. It will set the version at the same specificity as the current version, so if you have `node = "22"`, but use `mise upgrade --bump node` to update to `node@24`, then it will set `node = "24"` in `mise.toml`.

_See [Dev Tools](https://mise.jdx.dev/dev-tools/) for more information on working with tools._

## Setting Environment Variables [​](https://mise.jdx.dev/walkthrough.html\#setting-environment-variables)

mise can also be used to set environment variables for your project. You can set environment variables with the CLI:

bash

```
mise set MY_VAR=123
echo $MY_VAR
# 123
```

Or by directly modifying `mise.toml`:

toml

```
[env]
MY_VAR = "123"
```

Some examples on where this can be used:

- Setting `NODE_ENV` for a Node.js project
- Setting `DATABASE_URL` for a database connection
- Setting `AWS_ACCESS_KEY_ID` and `AWS_SECRET_ACCESS_KEY` for AWS
- Setting `RUST_TEST_THREADS=1` to run cargo tests in series

You can also modify `PATH` with `mise.toml`. This example makes CLIs installed with `npm` available:

toml

```
[env]
_.path = "./node_modules/.bin"
```

This will add `./node_modules/.bin` to the PATH for the project—with "." here referring to the directory the `mise.toml` file is in so if you enter a subdirectory, it will still work.

_See [Environments](https://mise.jdx.dev/environments/) for more information on working with environment variables._

## Tasks [​](https://mise.jdx.dev/walkthrough.html\#tasks)

Tasks are defined in a project to execute commands.

You can define tasks in a `mise.toml`:

mise.toml

toml

```
[tasks]
build = "npm run build"
test = "npm test"
```

Or in a `mise-tasks` directory as a standalone file, such as `mise-tasks/build`:

mise-tasks/build

bash

```
#!/bin/bash
npm run build
```

Tasks are executed with [`mise r|run`](https://mise.jdx.dev/cli/run.html):

bash

```
mise run build
mise run test
```

TIP

`mise run` sets up the "mise environment" before running the task (tools and environment variables). So if you'd rather not activate mise in your shell, you can use `mise run` to run tasks, and it will have the tools in PATH and the environment variables from `mise.toml` set.

`mise` is paired with [usage](https://usage.jdx.dev/) which provides lots of features for documenting and running tasks.

Here is an example of a task with usage spec:

mise-tasks/greet

bash

```
#!/usr/bin/env bash
set -e

#MISE description="Greet a user with a message"
#USAGE flag "-g --greeting <greeting>" help="The greeting word to use" {
#USAGE   choices "hi" "hello" "hey"
#USAGE }
#USAGE flag "-u --user <user>" help="The user to greet"
#USAGE flag "--dir <dir>" help="The directory to greet from" default="."
#USAGE complete "dir" run="find . -maxdepth 1 -type d"
#USAGE arg "<message>" help="Greeting message"

echo "all available options are in the env with the prefix 'usage_'"
env | grep usage_

echo "$usage_greeting, $usage_user! Your message is: $usage_message"
```

This task can be run like so:

shell

```
mise run greet --user jdx -g "hey" "How are you?"
```

- The options will all be passed as environment variables prefixed with `usage_` like `usage_user`.
- Help is available with `mise run greet --help` and will show the options defined in the task.
- Completions are available like you'd expect, so typing `mise run greet --greeting <tag>` will show `hi`, `hello`, and `hey` as options.
- [Custom completion](https://usage.jdx.dev/spec/reference/complete) can be provided by a CLI. `mise run greet --dir <tab>` will execute `find . -maxdepth 1 -type d` to provide completions.

To get the autocopletion working, set up [mise autocompletions](https://mise.jdx.dev/installing-mise.html#autocompletion).

_See [Tasks](https://mise.jdx.dev/tasks/) for more information on working with tasks._

## Common Commands [​](https://mise.jdx.dev/walkthrough.html\#common-commands)

Since there are a lot of commands available in mise, here are what I consider the most important:

- [`mise completion`](https://mise.jdx.dev/cli/completion.html) – Set up completions for your shell.
- [`mise cfg|config`](https://mise.jdx.dev/cli/config.html) – A bunch of commands for working with `mise.toml` files via the CLI.
- [`mise x|exec`](https://mise.jdx.dev/cli/exec.html) – Execute a command in the mise environment without activating mise.
- [`mise g|generate`](https://mise.jdx.dev/cli/generate.html) – Generates things like git hooks, task documentation, GitHub actions, and more for your project.
- [`mise i|install`](https://mise.jdx.dev/cli/install.html) – Install tools.
- [`mise link`](https://mise.jdx.dev/cli/link.html) – Symlink a tool installed by some other means into the mise.
- [`mise ls-remote`](https://mise.jdx.dev/cli/ls-remote.html) – List all available versions of a tool.
- [`mise ls`](https://mise.jdx.dev/cli/ls.html) – Lists information about installed/active tools.
- [`mise outdated`](https://mise.jdx.dev/cli/outdated.html) – Informs you of any tools with newer versions available.
- [`mise plugin`](https://mise.jdx.dev/cli/plugins.html) – Plugins can extend mise with new functionality like extra tools or environment variable management. Commonly, these are simply asdf plugins or modern plugins.
- [`mise r|run`](https://mise.jdx.dev/cli/run.html) – Run a task defined in `mise.toml` or `mise-tasks`.
- [`mise self-update`](https://mise.jdx.dev/cli/self-update.html) – Update mise to the latest version. Don't use this if you installed mise via a package manager.
- [`mise settings`](https://mise.jdx.dev/cli/settings.html) – CLI access to get/set configuration settings.
- [`mise rm|uninstall`](https://mise.jdx.dev/cli/uninstall.html) – Uninstall a tool.
- [`mise up|upgrade`](https://mise.jdx.dev/cli/upgrade.html) – Upgrade tool versions.
- [`mise u|use`](https://mise.jdx.dev/cli/use.html) – Install and activate tools.
- [`mise w|watch`](https://mise.jdx.dev/cli/watch.html) – Watch for changes in a project and run tasks when they occur.

## Final Thoughts [​](https://mise.jdx.dev/walkthrough.html\#final-thoughts)

Dev tools, env vars, and tasks work together to make managing your development environment easier—especially when working with others. The goal is to have a consistent UX to interface with projects regardless of the programming languages or tools used on it.

For further reading:

- [Dev Tools](https://mise.jdx.dev/dev-tools/) – A deeper overview of working with dev tools
- [Environments](https://mise.jdx.dev/environments/) – A deeper overview of working with environment variables
- [Tasks](https://mise.jdx.dev/tasks/) – A deeper overview of working with tasks
- [Configuration](https://mise.jdx.dev/configuration.html) – More information on `mise.toml` files
- [Settings](https://mise.jdx.dev/configuration/settings.html) – All the configuration settings available in mise
- [Backends](https://mise.jdx.dev/dev-tools/backends/) – An index of all the backends available in mise
- [Registry](https://mise.jdx.dev/registry.html) – Every "shorthand" available for tools in mise like `node`, `terraform`, or `watchexec` which point to `core:node`, `asdf:asdf-community/asdf-hashicorp`, and `ubi:watchexec/watchexec` respectively
- [CLI](https://mise.jdx.dev/cli/) – The full list of commands available in mise

<|firecrawl-page-180-lllmstxt|>
## Lockfile Update Tool
[Skip to content](https://mise.jdx.dev/cli/lock#VPContent)

Return to top

# `mise lock` [​](https://mise.jdx.dev/cli/lock\#mise-lock)

- **Usage**: `mise lock [FLAGS] [TOOL]…`
- **Source code**: [`src/cli/lock.rs`](https://github.com/jdx/mise/blob/main/src/cli/lock.rs)

Update lockfile checksums and URLs for all specified platforms

Updates checksums and download URLs for all platforms already specified in the lockfile. If no lockfile exists, shows what would be created based on the current configuration. This allows you to refresh lockfile data for platforms other than the one you're currently on. Operates on the lockfile in the current config root. Use TOOL arguments to target specific tools.

## Arguments [​](https://mise.jdx.dev/cli/lock\#arguments)

### `[TOOL]…` [​](https://mise.jdx.dev/cli/lock\#tool)

Tool(s) to update in lockfile e.g.: node python If not specified, all tools in lockfile will be updated

## Flags [​](https://mise.jdx.dev/cli/lock\#flags)

### `-p --platform… <PLATFORM>` [​](https://mise.jdx.dev/cli/lock\#p-platform-platform)

Comma-separated list of platforms to target e.g.: linux-x64,macos-arm64,windows-x64 If not specified, all platforms already in lockfile will be updated

### `-f --force` [​](https://mise.jdx.dev/cli/lock\#f-force)

Update all tools even if lockfile data already exists

### `-n --dry-run` [​](https://mise.jdx.dev/cli/lock\#n-dry-run)

Show what would be updated without making changes

### `-j --jobs <JOBS>` [​](https://mise.jdx.dev/cli/lock\#j-jobs-jobs)

Number of jobs to run in parallel \[default: 4\]

Examples:

$ mise lock Update lockfile in current directory for all platforms $ mise lock node python Update only node and python $ mise lock --platform linux-x64 Update only linux-x64 platform $ mise lock --dry-run Show what would be updated or created $ mise lock --force Re-download and update even if data exists

<|firecrawl-page-181-lllmstxt|>
## Tool Stub Execution
[Skip to content](https://mise.jdx.dev/cli/tool-stub#VPContent)

Return to top

# `mise tool-stub` [​](https://mise.jdx.dev/cli/tool-stub\#mise-tool-stub)

- **Usage**: `mise tool-stub <FILE> [ARGS]…`
- **Source code**: [`src/cli/tool_stub.rs`](https://github.com/jdx/mise/blob/main/src/cli/tool_stub.rs)

Execute a tool stub

Tool stubs are executable files containing TOML configuration that specify which tool to run and how to run it. They provide a convenient way to create portable, self-contained executables that automatically manage tool installation and execution.

A tool stub consists of: - A shebang line: #!/usr/bin/env -S mise tool-stub - TOML configuration specifying the tool, version, and options - Optional comments describing the tool's purpose

Example stub file: #!/usr/bin/env -S mise tool-stub # Node.js v20 development environment

tool = "node" version = "20.0.0" bin = "node"

The stub will automatically install the specified tool version if missing and execute it with any arguments passed to the stub.

For more information, see: [https://mise.jdx.dev/dev-tools/tool-stubs.html](https://mise.jdx.dev/dev-tools/tool-stubs.html)

## Arguments [​](https://mise.jdx.dev/cli/tool-stub\#arguments)

### `<FILE>` [​](https://mise.jdx.dev/cli/tool-stub\#file)

Path to the TOML tool stub file to execute

The stub file must contain TOML configuration specifying the tool and version to run. At minimum, it should specify a 'version' field. Other common fields include 'tool', 'bin', and backend-specific options.

### `[ARGS]…` [​](https://mise.jdx.dev/cli/tool-stub\#args)

Arguments to pass to the tool

All arguments after the stub file path will be forwarded to the underlying tool. Use '--' to separate mise arguments from tool arguments if needed.

<|firecrawl-page-182-lllmstxt|>
## PPA Publishing Setup
[Skip to content](https://mise.jdx.dev/ppa-setup.html#VPContent)

Return to top

# PPA Publishing Setup [​](https://mise.jdx.dev/ppa-setup.html\#ppa-publishing-setup)

This document explains how to set up and use the GitHub Actions workflow for publishing mise to Ubuntu PPAs (Personal Package Archives).

## Prerequisites [​](https://mise.jdx.dev/ppa-setup.html\#prerequisites)

1. **Launchpad Account**: You need a Launchpad account with PPA access
2. **GPG Key**: A GPG key for signing packages
3. **GitHub Repository Secrets**: Required secrets configured in GitHub

## Setting up Launchpad and PPA [​](https://mise.jdx.dev/ppa-setup.html\#setting-up-launchpad-and-ppa)

1. Create a Launchpad account at [https://launchpad.net](https://launchpad.net/)
2. Create a new PPA for your project (e.g., `ppa:jdxcode/mise`)
3. Generate and upload your GPG public key to Launchpad

## GPG Key Setup [​](https://mise.jdx.dev/ppa-setup.html\#gpg-key-setup)

Generate a GPG key if you don't have one:

bash

```
gpg --gen-key
```

Export your private key:

bash

```
gpg --armor --export-secret-keys YOUR_EMAIL > private-key.asc
```

Export your public key and upload it to Launchpad:

bash

```
gpg --armor --export YOUR_EMAIL > public-key.asc
```

## GitHub Repository Configuration [​](https://mise.jdx.dev/ppa-setup.html\#github-repository-configuration)

### Required Secrets [​](https://mise.jdx.dev/ppa-setup.html\#required-secrets)

Configure the following secrets in your GitHub repository settings:

- `MISE_GPG_KEY`: Your GPG private key (entire content of private-key.asc)
  - This follows the same pattern as other mise workflows

### Repository Variables [​](https://mise.jdx.dev/ppa-setup.html\#repository-variables)

Configure these variables in your GitHub repository settings:

- `PPA_MAINTAINER_NAME`: Your name (e.g., "John Doe")
- `PPA_MAINTAINER_EMAIL`: Your email address (must match GPG key)
- `PPA_NAME`: Your PPA identifier (e.g., "ppa:jdxcode/mise")

### Environment Protection [​](https://mise.jdx.dev/ppa-setup.html\#environment-protection)

The workflow uses a `ppa-publishing` environment for additional security. Configure this in your repository settings under Environments.

## How the Workflow Works [​](https://mise.jdx.dev/ppa-setup.html\#how-the-workflow-works)

The workflow follows the Rust PPA packaging guide and:

1. **Triggers**: Runs on new GitHub releases or manual workflow dispatch
2. **Versioning**: Uses `scripts/get-version.sh` to get the current version (same as other workflows)
3. **Submodules**: Includes the `aqua-registry` submodule in the source package
4. **Vendoring**: Uses `cargo vendor` to bundle all dependencies
5. **Debian Packaging**: Creates proper Debian source packages with:
   - `debian/control` \- Package metadata
   - `debian/rules` \- Build instructions
   - `debian/changelog` \- Version history
   - `debian/copyright` \- License information
6. **Multi-distribution**: Builds packages for multiple Ubuntu versions (jammy, noble)
7. **Signing**: Signs packages with your GPG key using the same pattern as other workflows
8. **Upload**: Uploads source packages to your PPA using `dput`

## Usage [​](https://mise.jdx.dev/ppa-setup.html\#usage)

### Automatic Release Publishing [​](https://mise.jdx.dev/ppa-setup.html\#automatic-release-publishing)

The workflow automatically triggers when you create a new GitHub release:

1. Create a new release on GitHub
2. The workflow will automatically package and upload to your PPA
3. Monitor the Actions tab for progress

### Manual Publishing [​](https://mise.jdx.dev/ppa-setup.html\#manual-publishing)

You can manually trigger the workflow via GitHub Actions:

1. Go to the Actions tab in your repository
2. Select "Publish to PPA" workflow
3. Click "Run workflow"
4. Specify the target distributions (optional)
5. Optionally enable the "serious" profile for optimized builds with LTO

### Supported Ubuntu Distributions [​](https://mise.jdx.dev/ppa-setup.html\#supported-ubuntu-distributions)

By default, the workflow targets:

- Ubuntu 22.04 LTS (jammy)
- Ubuntu 24.04 LTS (noble)

You can customize this by modifying the `distributions` input when manually running the workflow.

## Package Installation [​](https://mise.jdx.dev/ppa-setup.html\#package-installation)

Once published, users can install your package:

bash

```
sudo add-apt-repository ppa:jdxcode/mise
sudo apt update
sudo apt install mise
```

## Troubleshooting [​](https://mise.jdx.dev/ppa-setup.html\#troubleshooting)

### Common Issues [​](https://mise.jdx.dev/ppa-setup.html\#common-issues)

1. **GPG Signing Failures**:

   - Ensure your GPG private key is correctly stored in the `MISE_GPG_KEY` secret
   - The workflow uses the same GPG setup as other mise workflows
2. **Build Failures**:

   - Verify all Rust dependencies can be vendored
   - Check that the project builds successfully with `cargo build --release`
3. **Upload Failures**:

   - Confirm your PPA name is correct in variables
   - Ensure your GPG public key is uploaded to Launchpad

### Debugging [​](https://mise.jdx.dev/ppa-setup.html\#debugging)

The workflow creates artifacts containing the generated source packages. Download these to inspect the generated Debian files if issues occur.

## Security Considerations [​](https://mise.jdx.dev/ppa-setup.html\#security-considerations)

- Store GPG private keys securely in GitHub Secrets
- Use environment protection rules for the `ppa-publishing` environment
- Regularly rotate GPG keys and update secrets accordingly
- Monitor PPA uploads for unauthorized changes

## Customization [​](https://mise.jdx.dev/ppa-setup.html\#customization)

To customize the packaging:

1. Modify the `debian/control` generation in the workflow for different dependencies
2. Adjust the `debian/rules` section for custom build steps
3. Update the package description and metadata
4. Add additional files like systemd services or configuration files

The workflow is designed to be generic enough for most Rust CLI tools but can be adapted for specific needs.

<|firecrawl-page-183-lllmstxt|>
## GitHub Backend Installation
[Skip to content](https://mise.jdx.dev/dev-tools/backends/github#VPContent)

On this page

# GitHub Backend [​](https://mise.jdx.dev/dev-tools/backends/github\#github-backend)

You may install GitHub release assets directly using the `github` backend. This backend downloads release assets from GitHub repositories and is ideal for tools that distribute pre-built binaries through GitHub releases.

The code for this is inside of the mise repository at [`./src/backend/github.rs`](https://github.com/jdx/mise/blob/main/src/backend/github.rs).

## Usage [​](https://mise.jdx.dev/dev-tools/backends/github\#usage)

The following installs the latest version of ripgrep from GitHub releases and sets it as the active version on PATH:

sh

```
$ mise use -g github:BurntSushi/ripgrep
$ rg --version
ripgrep 14.1.1
```

The version will be set in `~/.config/mise/config.toml` with the following format:

toml

```
[tools]
"github:BurntSushi/ripgrep" = "latest"
```

## Tool Options [​](https://mise.jdx.dev/dev-tools/backends/github\#tool-options)

The following [tool-options](https://mise.jdx.dev/dev-tools/#tool-options) are available for the `github` backend—these go in `[tools]` in `mise.toml`.

### Asset Autodetection [​](https://mise.jdx.dev/dev-tools/backends/github\#asset-autodetection)

When no `asset_pattern` is specified, mise automatically selects the best asset for your platform. The system scores assets based on:

- **OS compatibility** (linux, macos, windows)
- **Architecture compatibility** (x64, arm64, x86, arm)
- **Libc variant** (gnu or musl, for Linux)
- **Archive format preference** (tar.gz, zip, etc.)
- **Build type** (avoids debug/test builds)

For most tools, you can simply install without specifying patterns:

sh

```
mise install github:user/repo
```

TIP

The autodetection logic is implemented in [`src/backend/asset_detector.rs`](https://github.com/jdx/mise/blob/main/src/backend/asset_detector.rs), which is shared by both the GitHub and GitLab backends.

### `asset_pattern` [​](https://mise.jdx.dev/dev-tools/backends/github\#asset-pattern)

Specifies the pattern to match against release asset names. This is useful when there are multiple assets for your OS/arch combination or when you need to override autodetection.

toml

```
[tools]
"github:cli/cli" = { version = "latest", asset_pattern = "gh_*_linux_x64.tar.gz" }
```

### `version_prefix` [​](https://mise.jdx.dev/dev-tools/backends/github\#version-prefix)

Specifies a custom version prefix for release tags. By default, mise handles the common `v` prefix (e.g., `v1.0.0`), but some repositories use different prefixes like `release-`, `version-`, or no prefix at all.

When `version_prefix` is configured, mise will:

- Strip the prefix when listing available versions
- Add the prefix when searching for releases
- Try both prefixed and non-prefixed versions during installation

toml

```
[tools]
"github:user/repo" = { version = "latest", version_prefix = "release-" }
```

**Examples:**

- With `version_prefix = "release-"`:
  - User specifies `1.0.0` → mise searches for `release-1.0.0` tag
  - Available versions show as `1.0.0` (prefix stripped)
- With `version_prefix = ""` (empty string):
  - User specifies `1.0.0` → mise searches for `1.0.0` tag (no prefix)
  - Useful for repositories that don't use any prefix

### Platform-specific Asset Patterns [​](https://mise.jdx.dev/dev-tools/backends/github\#platform-specific-asset-patterns)

For different asset patterns per platform:

toml

```
[tools."github:cli/cli"]
version = "latest"

[tools."github:cli/cli".platforms]
linux-x64 = { asset_pattern = "gh_*_linux_x64.tar.gz" }
macos-arm64 = { asset_pattern = "gh_*_macOS_arm64.tar.gz" }
```

### `checksum` [​](https://mise.jdx.dev/dev-tools/backends/github\#checksum)

Verify the downloaded file with a checksum:

toml

```
[tools."github:owner/repo"]
version = "1.0.0"
asset_pattern = "tool-1.0.0-x64.tar.gz"
checksum = "sha256:a1b2c3d4e5f6789..."
```

_Instead of specifying the checksum here, you can use [mise.lock](https://mise.jdx.dev/dev-tools/mise-lock.html) to manage checksums._

### Platform-specific Checksums [​](https://mise.jdx.dev/dev-tools/backends/github\#platform-specific-checksums)

toml

```
[tools."github:cli/cli"]
version = "latest"

[tools."github:cli/cli".platforms]
linux-x64 = { asset_pattern = "gh_*_linux_x64.tar.gz", checksum = "sha256:a1b2c3d4e5f6789..." }
macos-arm64 = { asset_pattern = "gh_*_macOS_arm64.tar.gz", checksum = "sha256:b2c3d4e5f6789..." }
```

### `size` [​](https://mise.jdx.dev/dev-tools/backends/github\#size)

Verify the downloaded asset size:

toml

```
[tools]
"github:cli/cli" = { version = "latest", size = "12345678" }
```

### `strip_components` [​](https://mise.jdx.dev/dev-tools/backends/github\#strip-components)

Number of directory components to strip when extracting archives:

toml

```
[tools]
"github:cli/cli" = { version = "latest", strip_components = 1 }
```

INFO

If `strip_components` is not explicitly set, mise will automatically detect when to apply `strip_components = 1`. This happens when the extracted archive contains exactly one directory at the root level and no files. This is common with tools like ripgrep that package their binaries in a versioned directory (e.g., `ripgrep-14.1.0-x86_64-unknown-linux-musl/rg`). The auto-detection ensures the binary is placed directly in the install path where mise expects it.

### `bin_path` [​](https://mise.jdx.dev/dev-tools/backends/github\#bin-path)

Specify the directory containing binaries within the extracted archive, or where to place the downloaded file. This supports templating with `{name}`, `{version}`, `{os}`, `{arch}`, and `{ext}`:

toml

```
[tools."github:cli/cli"]
version = "latest"
bin_path = "{name}-{version}/bin" # expands to cli-1.0.0/bin
```

**Binary path lookup order:**

1. If `bin_path` is specified, use that directory
2. If `bin_path` is not set, look for a `bin/` directory in the install path
3. If no `bin/` directory exists, search subdirectories for `bin/` directories
4. If no `bin/` directories are found, use the root of the extracted directory

### `api_url` [​](https://mise.jdx.dev/dev-tools/backends/github\#api-url)

For GitHub Enterprise or self-hosted GitHub instances, specify the API URL:

toml

```
[tools]
"github:myorg/mytool" = { version = "latest", api_url = "https://github.mycompany.com/api/v3" }
```

## Self-hosted GitHub [​](https://mise.jdx.dev/dev-tools/backends/github\#self-hosted-github)

If you are using a self-hosted GitHub instance, set the `api_url` tool option and optionally the `MISE_GITHUB_ENTERPRISE_TOKEN` environment variable for authentication:

sh

```
export MISE_GITHUB_ENTERPRISE_TOKEN="your-token"
```

## Supported GitHub Syntax [​](https://mise.jdx.dev/dev-tools/backends/github\#supported-github-syntax)

- **GitHub shorthand for latest release version:** `github:cli/cli`
- **GitHub shorthand for specific release version:** `github:cli/cli@2.40.1`

## Settings [​](https://mise.jdx.dev/dev-tools/backends/github\#settings)

No settings available.

<|firecrawl-page-184-lllmstxt|>
## Generate Tool Stub
[Skip to content](https://mise.jdx.dev/cli/generate/tool-stub#VPContent)

Return to top

# `mise generate tool-stub` [​](https://mise.jdx.dev/cli/generate/tool-stub\#mise-generate-tool-stub)

- **Usage**: `mise generate tool-stub [FLAGS] <OUTPUT>`
- **Source code**: [`src/cli/generate/tool_stub.rs`](https://github.com/jdx/mise/blob/main/src/cli/generate/tool_stub.rs)

\[experimental\] Generate a tool stub for HTTP-based tools

This command generates tool stubs that can automatically download and execute tools from HTTP URLs. It can detect checksums, file sizes, and binary paths automatically by downloading and analyzing the tool.

When generating stubs with platform-specific URLs, the command will append new platforms to existing stub files rather than overwriting them. This allows you to incrementally build cross-platform tool stubs.

## Arguments [​](https://mise.jdx.dev/cli/generate/tool-stub\#arguments)

### `<OUTPUT>` [​](https://mise.jdx.dev/cli/generate/tool-stub\#output)

Output file path for the tool stub

## Flags [​](https://mise.jdx.dev/cli/generate/tool-stub\#flags)

### `--version <VERSION>` [​](https://mise.jdx.dev/cli/generate/tool-stub\#version-version)

Version of the tool

### `-u --url <URL>` [​](https://mise.jdx.dev/cli/generate/tool-stub\#u-url-url)

URL for downloading the tool

Example: [https://github.com/owner/repo/releases/download/v2.0.0/tool-linux-x64.tar.gz](https://github.com/owner/repo/releases/download/v2.0.0/tool-linux-x64.tar.gz)

### `--platform-url… <PLATFORM_URL>` [​](https://mise.jdx.dev/cli/generate/tool-stub\#platform-url-platform-url)

Platform-specific URLs in the format platform:url or just url (auto-detect platform)

When the output file already exists, new platforms will be appended to the existing platforms table. Existing platform URLs will be updated if specified again.

If only a URL is provided (without platform:), the platform will be automatically detected from the URL filename.

Examples: --platform-url linux-x64:https://... --platform-url [https://nodejs.org/dist/v22.17.1/node-v22.17.1-darwin-arm64.tar.gz](https://nodejs.org/dist/v22.17.1/node-v22.17.1-darwin-arm64.tar.gz)

### `--platform-bin… <PLATFORM_BIN>` [​](https://mise.jdx.dev/cli/generate/tool-stub\#platform-bin-platform-bin)

Platform-specific binary paths in the format platform:path

Examples: --platform-bin windows-x64:tool.exe --platform-bin linux-x64:bin/tool

### `-b --bin <BIN>` [​](https://mise.jdx.dev/cli/generate/tool-stub\#b-bin-bin)

Binary path within the extracted archive

If not specified and the archive is downloaded, will auto-detect the most likely binary

### `--skip-download` [​](https://mise.jdx.dev/cli/generate/tool-stub\#skip-download)

Skip downloading for checksum and binary path detection (faster but less informative)

### `--fetch` [​](https://mise.jdx.dev/cli/generate/tool-stub\#fetch)

Fetch checksums and sizes for an existing tool stub file

This reads an existing stub file and fills in any missing checksum/size fields by downloading the files. URLs must already be present in the stub.

### `--http <HTTP>` [​](https://mise.jdx.dev/cli/generate/tool-stub\#http-http)

HTTP backend type to use

Examples:

```
Generate a tool stub for a single URL:
$ mise generate tool-stub ./bin/gh --url "https://github.com/cli/cli/releases/download/v2.336.0/gh_2.336.0_linux_amd64.tar.gz"

Generate a tool stub with platform-specific URLs:
$ mise generate tool-stub ./bin/rg \
    --platform-url linux-x64:https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-x86_64-unknown-linux-musl.tar.gz \
    --platform-url darwin-arm64:https://github.com/BurntSushi/ripgrep/releases/download/14.0.3/ripgrep-14.0.3-aarch64-apple-darwin.tar.gz

Append additional platforms to an existing stub:
$ mise generate tool-stub ./bin/rg \
    --platform-url linux-x64:https://example.com/rg-linux.tar.gz
$ mise generate tool-stub ./bin/rg \
    --platform-url darwin-arm64:https://example.com/rg-darwin.tar.gz
# The stub now contains both platforms

Use auto-detection for platform from URL:
$ mise generate tool-stub ./bin/node \
    --platform-url https://nodejs.org/dist/v22.17.1/node-v22.17.1-darwin-arm64.tar.gz
# Platform 'macos-arm64' will be auto-detected from the URL

Generate with platform-specific binary paths:
$ mise generate tool-stub ./bin/tool \
    --platform-url linux-x64:https://example.com/tool-linux.tar.gz \
    --platform-url windows-x64:https://example.com/tool-windows.zip \
    --platform-bin windows-x64:tool.exe

Generate without downloading (faster):
$ mise generate tool-stub ./bin/tool --url "https://example.com/tool.tar.gz" --skip-download

Fetch checksums for an existing stub:
$ mise generate tool-stub ./bin/jq --fetch
# This will read the existing stub and download files to fill in any missing checksums/sizes
```