Task Configuration

This is an exhaustive list of all the configuration options available for tasks in mise.toml or as file tasks.

Task properties

All examples are in toml-task format instead of file, however they apply in both except where otherwise noted.

`run`

Type: string | (string | { task: string } | { tasks: string[] })[]

The command(s) to run. This is the only required property for a task.

You can now mix scripts with task references:

toml

[tasks.grouped]
run = [
  { task = "t1" },          # run t1 (with its dependencies)
  { tasks = ["t2", "t3"] }, # run t2 and t3 in parallel (with their dependencies)
  "echo end",               # then run a script
]

Simple forms still work and are equivalent:

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`

Type: string | (string | { task: string } | { tasks: string[] })[]

Windows-specific variant of run supporting the same structured syntax:

toml

[tasks.build]
run = "cargo build"
run_windows = "cargo build --features windows"

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

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`

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) through the use of depends and related properties.

toml

[tasks.build]
run = "cargo build"
[tasks.test]
depends = ["build"]
run = "cargo test"

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

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`

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`

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`

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`

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`

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`

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`

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`

Type: string | string[] | { auto = true }
Default: { 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 } # this is the default when sources is defined

`shell`

Type: string
Default: unix_default_inline_shell_args or 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 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`

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.

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

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

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

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`

Change the default directory tasks are run from.

toml

[task_config]
dir = "{{cwd}}"

`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

Monorepo Support experimental

mise supports monorepo-style task organization with target path syntax. Enable it by setting experimental_monorepo_root = true in your root mise.toml.

For complete documentation on monorepo tasks including:

Task path syntax and wildcards
Tool inheritance from parent configs
Performance tuning
Best practices and troubleshooting

See the dedicated Monorepo Tasks documentation.

`redactions` experimental

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

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 are also supported as vars.

Task Configuration Settings

The following settings control task behavior. These can be set globally in ~/.config/mise/config.toml or per-project in mise.toml:

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

[tools]
node = '20'
python = '3.12'

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

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 php -> asdf:mise-plugins/asdf-php. 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 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: 10s

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

Type: integer
Env: MISE_HTTP_RETRIES
Default: 0

Uses an exponential backoff strategy. The duration is calculated by taking the base (10ms) to the n-th power.

`http_timeout`

Type: Duration
Env: MISE_HTTP_TIMEOUT
Default: 30s

Timeout in seconds for all HTTP requests in mise.

`idiomatic_version_file_enable_tools`

Type: SetString
Env: MISE_IDIOMATIC_VERSION_FILE_ENABLE_TOOLS
Default: []

By default, idiomatic version files are disabled. You can enable them for specific tools with this setting.

For example, to enable idiomatic version files for node and python:

mise settings add idiomatic_version_file_enable_tools node
mise settings add idiomatic_version_file_enable_tools python

See Idiomatic Version Files for more information.

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

[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):

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.

`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 plugin. By default, it uses the shorthands in registry.toml.

The file should be in this toml format:

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

Type: Duration(optional)
Env: MISE_TASK_TIMEOUT
Default: None

Default timeout for tasks. Can be overridden by individual tasks.

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

`terminal_progress`

Type: Bool
Env: MISE_TERMINAL_PROGRESS
Default: true

Enable terminal progress indicators using OSC 9;4 escape sequences. This provides native progress bars in the terminal window chrome for terminals that support it, including Ghostty, VS Code's integrated terminal, Windows Terminal, and VTE-based terminals (GNOME Terminal, Ptyxis, etc.).

When enabled, mise will send progress updates to the terminal during operations like tool installations. The progress bar appears in the terminal's window UI, separate from the text output.

mise automatically detects whether your terminal supports OSC 9;4 and will only send these sequences if supported. Terminals like Alacritty, iTerm2, WezTerm, and kitty do not support OSC 9;4 and will not receive these sequences.

Set to false to disable this feature if you prefer not to see these indicators.

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

`url_replacements`

Type: object(optional)
Env: MISE_URL_REPLACEMENTS
Default: None

Map of URL patterns to replacement URLs. This feature supports both simple hostname replacements and advanced regex-based URL transformations for download mirroring and custom registries.

See URL Replacements for more information.

`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 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. It does not require any permissions since it simply fetches public repository information.

See Troubleshooting 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.

`age`

`age.identity_files`

Type: string[](optional)
Env: MISE_AGE_IDENTITY_FILES
Default: None

[experimental] List of age identity files to use for decryption.

`age.key_file`

Type: Path
Env: MISE_AGE_KEY_FILE
Default: ~/.config/mise/age.txt

[experimental] Path to the age private key file to use for encryption/decryption.

`age.ssh_identity_files`

Type: string[](optional)
Env: MISE_AGE_SSH_IDENTITY_FILES
Default: None

[experimental] List of SSH identity files to use for age decryption.

`aqua`

`aqua.baked_registry`

Type: Bool
Env: MISE_AQUA_BAKED_REGISTRY
Default: true

Use baked-in aqua registry.

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

Type: Bool
Env: MISE_AQUA_GITHUB_ATTESTATIONS
Default: true

Enable/disable GitHub Artifact Attestations verification for aqua tools. When enabled, mise will verify the authenticity and integrity of downloaded tools using GitHub's artifact attestation system.

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

If this is set, the baked-in aqua registry is not used.

By default, the official aqua registry is used: https://github.com/aquaproj/aqua-registry

`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 is installed and on PATH. This makes installing CLIs with cargo much faster by downloading precompiled binaries.

You can install it with mise:

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 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 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 is installed and on PATH. This makes installing CLIs faster by using bun as the package manager.

You can install it with mise:

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 is installed and on PATH. This makes installing CLIs much faster by using uv as the package manager.

You can install it with mise:

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

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

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

`task`

`task.monorepo_depth`

Type: integer
Env: MISE_TASK_MONOREPO_DEPTH
Default: 5

When using monorepo mode (experimental_monorepo_root = true), this controls how deep mise will search for task files in subdirectories.

Depth levels:

1 = immediate children only (monorepo_root/projects/)
2 = grandchildren (monorepo_root/projects/frontend/)
5 = default (5 levels deep)

Performance tip: Reduce this value if you have a very large monorepo and notice slow task discovery. For example, if your projects are all at projects/*, set to 2.

Example:

[settings]
task.monorepo_depth = 3  # Only search 3 levels deep

Or via environment variable:

export MISE_TASK_MONOREPO_DEPTH=3

`task.monorepo_exclude_dirs`

Type: string[]
Env: MISE_TASK_MONOREPO_EXCLUDE_DIRS(comma separated)
Default: []

If empty (default), uses default exclusions: node_modules, target, dist, build. If you specify any patterns, ONLY those patterns will be excluded (defaults are NOT included). For example, setting to [".temp", "vendor"] will exclude only those two directories.

`task.monorepo_respect_gitignore`

Type: Bool
Env: MISE_TASK_MONOREPO_RESPECT_GITIGNORE
Default: true

When enabled, mise will skip directories that are ignored by .gitignore files when discovering tasks in a monorepo.

Task Configuration ​

Task properties ​

run ​

run_windows ​

description ​

alias ​

depends ​

depends_post ​

wait_for ​

env ​

tools ​

dir ​

hide ​

confirm ​

raw ​

sources ​

outputs ​

shell ​

quiet ​

silent ​

usage ​

Vars ​

[task_config] options ​

task_config.dir ​

task_config.includes ​

Monorepo Support experimental ​

redactions experimental ​

[vars] options ​

Task Configuration Settings ​

activate_aggressive

all_compile

always_keep_download

always_keep_install

arch

auto_install

auto_install_disable_tools

cache_prune_age

color

default_config_filename

default_tool_versions_filename

disable_backends

disable_default_registry

disable_hints

disable_tools

enable_tools

env

env_file

exec_auto_install

experimental

fetch_remote_versions_cache

fetch_remote_versions_timeout

global_config_file

global_config_root

go_default_packages_file

go_download_mirror

go_repo

go_set_gobin

go_set_gopathdeprecated

go_set_goroot

go_skip_checksum

gpg_verify

http_retries

http_timeout

idiomatic_version_file_enable_tools

ignored_config_paths

jobs

lockfile

not_found_auto_install

os

override_config_filenames

override_tool_versions_filenames

paranoid

pin

plugin_autoupdate_last_check_duration

quiet

raw

shorthands_file

silent

system_config_file

task_disable_paths

Task Configuration

Task properties

`run`

`run_windows`

`description`

`alias`

`depends`

`depends_post`

`wait_for`

`env`

`tools`

`dir`

`hide`

`confirm`

`raw`

`sources`

`outputs`

`shell`

`quiet`

`silent`

`usage`

Vars

`[task_config]` options

`task_config.dir`

`task_config.includes`

Monorepo Support experimental

`redactions` experimental

`[vars]` options

Task Configuration Settings

`activate_aggressive`

`all_compile`

`always_keep_download`

`always_keep_install`

`arch`

`auto_install`

`auto_install_disable_tools`

`cache_prune_age`

`color`

`default_config_filename`

`default_tool_versions_filename`

`disable_backends`

`disable_default_registry`

`disable_hints`

`disable_tools`

`enable_tools`

`env`

`env_file`

`exec_auto_install`

`experimental`

`fetch_remote_versions_cache`

`fetch_remote_versions_timeout`

`global_config_file`

`global_config_root`

`go_default_packages_file`

`go_download_mirror`

`go_repo`

`go_set_gobin`

`go_set_gopath`deprecated

`go_set_goroot`

`go_skip_checksum`

`gpg_verify`

`http_retries`

`http_timeout`

`idiomatic_version_file_enable_tools`

`ignored_config_paths`

`jobs`

`lockfile`

`not_found_auto_install`

`os`

`override_config_filenames`

`override_tool_versions_filenames`

`paranoid`

`pin`

`plugin_autoupdate_last_check_duration`

`quiet`

`raw`

`shorthands_file`

`silent`

`system_config_file`

`task_disable_paths`