settings.toml

# This file generates code and documentation for settings in mise
# When this file is updated, run `mise run render` to update generated files

[activate_aggressive]
description = "Pushes tools' bin-paths to the front of PATH instead of allowing modifications of PATH after activation to take precedence."
docs = """
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.
"""
env = "MISE_ACTIVATE_AGGRESSIVE"
type = "Bool"

[all_compile]
description = "do not use precompiled binaries for any tool"
docs = """
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.
"""
env = "MISE_ALL_COMPILE"
type = "Bool"

[always_keep_download]
description = "should mise keep downloaded files after installation"
env = "MISE_ALWAYS_KEEP_DOWNLOAD"
type = "Bool"

[always_keep_install]
description = "should mise keep install files after installation even if the installation fails"
env = "MISE_ALWAYS_KEEP_INSTALL"
type = "Bool"

[aqua.baked_registry]
default = true
description = "Use baked-in aqua registry."
env = "MISE_AQUA_BAKED_REGISTRY"
type = "Bool"

[aqua.cosign]
default = true
description = "Use cosign to verify aqua tool signatures."
env = "MISE_AQUA_COSIGN"
type = "Bool"

[aqua.cosign_extra_args]
description = "Extra arguments to pass to cosign when verifying aqua tool signatures."
env = "MISE_AQUA_COSIGN_EXTRA_ARGS"
optional = true
rust_type = "Vec<String>"
type = "ListString"

[aqua.github_attestations]
default = true
description = "Enable GitHub Artifact Attestations verification for aqua tools."
docs = """
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.
"""
env = "MISE_AQUA_GITHUB_ATTESTATIONS"
type = "Bool"

[aqua.minisign]
default = true
description = "Use minisign to verify aqua tool signatures."
env = "MISE_AQUA_MINISIGN"
type = "Bool"

[aqua.registry_url]
description = "URL to fetch aqua registry from."
docs = """
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
"""
env = "MISE_AQUA_REGISTRY_URL"
optional = true
type = "Url"

[aqua.slsa]
default = true
description = "Use SLSA to verify aqua tool signatures."
env = "MISE_AQUA_SLSA"
type = "Bool"

[arch]
default_docs = '"x86_64" | "aarch64" | "arm" | "loongarch64" | "riscv64"'
description = "Architecture to use for precompiled binaries."
docs = """
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.
"""
env = "MISE_ARCH"
optional = true
type = "String"

[asdf]
deprecated = "Use disable_backends instead."
description = "use asdf as a default plugin backend"
docs = """
Use asdf as a default plugin backend. This means running something like `mise use cmake` will
default to using an asdf plugin for cmake.
"""
env = "MISE_ASDF"
hide = true
optional = true
type = "Bool"

[asdf_compat]
deprecated = "no longer supported"
description = "set to true to ensure .tool-versions will be compatible with asdf"
docs = """
Only output `.tool-versions` files in `mise local|global` which will be usable by asdf.
This disables mise functionality that would otherwise make these files incompatible with asdf such
as non-pinned versions.

This will also change the default global tool config to be `~/.tool-versions` instead
of `~/.config/mise/config.toml`.
"""
env = "MISE_ASDF_COMPAT"
hide = true
type = "Bool"

[auto_install]
default = true
description = "Automatically install missing tools when running `mise x`, `mise run`, or as part of the 'not found' handler."
env = "MISE_AUTO_INSTALL"
type = "Bool"

[auto_install_disable_tools]
description = "List of tools to skip automatically installing when running `mise x`, `mise run`, or as part of the 'not found' handler."
env = "MISE_AUTO_INSTALL_DISABLE_TOOLS"
optional = true
parse_env = "list_by_comma"
rust_type = "Vec<String>"
type = "ListString"

[cache_prune_age]
default = "30d"
description = "Delete files in cache that have not been accessed in this duration"
docs = """
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.
"""
env = "MISE_CACHE_PRUNE_AGE"
type = "Duration"

[cargo.binstall]
default = true
description = "Use cargo-binstall instead of cargo install if available"
docs = """
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
```
"""
env = "MISE_CARGO_BINSTALL"
type = "Bool"

[cargo.registry_name]
description = "Name of the cargo registry to use."
docs = """
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.
"""
env = "MISE_CARGO_REGISTRY_NAME"
optional = true
type = "String"

[cargo_binstall]
deprecated = "Use cargo.binstall instead."
description = "Use cargo-binstall instead of cargo install if available"
hide = true
optional = true
type = "Bool"

[conda.channel]
default = "conda-forge"
description = "Default channel for conda packages."
docs = """
Default conda channel when installing packages with the conda backend.
Override per-package with `conda:package[channel=bioconda]`.

The most common channels are:
- `conda-forge` - Community-maintained packages (default)
- `bioconda` - Bioinformatics packages
- `nvidia` - NVIDIA CUDA packages
"""
env = "MISE_CONDA_CHANNEL"
type = "String"

[cd]
description = "Path to change to after launching mise"
env = "MISE_CD"
hide = true
optional = true
type = "Path"

[ceiling_paths]
default = []
description = "Directories where mise stops searching for config files."
docs = """
Directories where mise stops searching for config files. By default, mise
will search from the current directory up to the root of the filesystem.

Setting this to a list of directories will stop the search when one of
those directories is reached. This is useful to prevent mise from searching
outside of a project directory.

This is an early-init setting: it must be set in `.miserc.toml`, environment
variables, or CLI flags. Setting it in `mise.toml` will have no effect because
config file discovery has already occurred by the time `mise.toml` is read.
"""
env = "MISE_CEILING_PATHS"
parse_env = "list_by_colon"
rc = true
rust_type = "BTreeSet<PathBuf>"
type = "ListPath"

[ci]
default = "false"
description = "Set to true if running in a CI environment"
deserialize_with = "bool_string"
env = "CI"
hide = true
type = "Bool"

[color]
default = true
description = "Use color in mise terminal output"
env = "MISE_COLOR"
type = "Bool"

[color_theme]
default = "default"
description = "Theme for interactive prompts (default/charm, base16, catppuccin, dracula)"
docs = """
Sets the color theme for interactive prompts like `mise run` task selection.
Available themes:

- `default` or `charm` - Default theme, works well on dark terminals
- `base16` - Base16 theme, works well on light terminals
- `catppuccin` - Catppuccin theme
- `dracula` - Dracula theme

If you're using a light terminal and the default theme is hard to read,
try setting this to `base16`.
"""
enum = [["default"], ["charm"], ["base16"], ["catppuccin"], ["dracula"]]
env = "MISE_COLOR_THEME"
type = "String"

[debug]
description = "Sets log level to debug"
env = "MISE_DEBUG"
hide = true
type = "Bool"

[default_config_filename]
default = "mise.toml"
description = "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."
env = "MISE_DEFAULT_CONFIG_FILENAME"
type = "String"

[default_tool_versions_filename]
default = ".tool-versions"
description = "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."
env = "MISE_DEFAULT_TOOL_VERSIONS_FILENAME"
type = "String"

[disable_backends]
default = []
description = "Backends to disable such as `asdf` or `pipx`"
env = "MISE_DISABLE_BACKENDS"
parse_env = "list_by_comma"
rust_type = "Vec<String>"
type = "ListString"

[disable_default_registry]
description = "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`."
env = "MISE_DISABLE_DEFAULT_REGISTRY"
type = "Bool"

[disable_default_shorthands]
deprecated = "Replaced with `disable_default_registry`"
description = "Disables built-in shorthands to asdf/vfox plugins"
docs = """
Disables the shorthand aliases for installing plugins. You will have to specify full URLs when
installing plugins, e.g.: `mise plugin install node https://github.com/asdf-vm/asdf-node.git`
"""
env = "MISE_DISABLE_DEFAULT_SHORTHANDS"
hide = true
optional = true
type = "Bool"

[disable_hints]
default = []
description = "Turns off helpful hints when using different mise features"
env = "MISE_DISABLE_HINTS"
parse_env = "set_by_comma"
rust_type = "BTreeSet<String>"
type = "SetString"

[disable_tools]
default = []
description = "Tools defined in mise.toml that should be ignored"
env = "MISE_DISABLE_TOOLS"
parse_env = "set_by_comma"
rust_type = "BTreeSet<String>"
type = "SetString"

[dotnet.package_flags]
default = []
description = "Extends dotnet search and install abilities."
docs = """
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
"""
env = "MISE_DOTNET_PACKAGE_FLAGS"
parse_env = "list_by_comma"
rust_type = "Vec<String>"
type = "ListString"

[dotnet.registry_url]
default = "https://api.nuget.org/v3/index.json"
description = "URL to fetch dotnet tools from."
docs = """
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.
"""
env = "MISE_DOTNET_REGISTRY_URL"
type = "Url"

[enable_tools]
default = []
description = "Tools defined in mise.toml that should be used - all other tools are ignored"
env = "MISE_ENABLE_TOOLS"
parse_env = "set_by_comma"
rust_type = "BTreeSet<String>"
type = "SetString"

[env]
default = []
description = "Env to use for mise.<MISE_ENV>.toml files."
docs = """
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](/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.

This is an early-init setting: it must be set in `.miserc.toml`, environment
variables, or CLI flags (`-E`/`--env`). Setting it in `mise.toml` will have no
effect because `MISE_ENV` determines which config files to load.
"""
env = "MISE_ENV"
parse_env = "list_by_comma"
rc = true
type = "ListString"

[env_cache]
default = false
description = "[experimental] Enable environment caching for nested mise invocations"
docs = """
When enabled, mise will cache the computed environment (env vars and PATH) to disk.
This dramatically speeds up nested mise invocations (e.g., `mise x -- mise env`).

The cache is encrypted using a session-scoped key (`__MISE_ENV_CACHE_KEY`) that is
generated when you run `mise activate` or `mise exec`. This means:
- Cache files are encrypted and unreadable by other processes
- When your shell session ends, the key is lost
- Old cache files become unreadable and will be regenerated

Cache invalidation happens when:
- Any config file changes (mise.toml, .tool-versions, etc.)
- Tool versions change
- Settings change
- mise version changes
- TTL expires (configurable via `env_cache_ttl`)
- Any watched files change (from modules or _.source directives)

Modules (vfox plugins) can declare themselves cacheable by returning
`{cacheable = true, watch_files = [...], env = [...]}` from their mise_env hook.
Modules that don't declare cacheability are treated as dynamic and will be
re-executed on each cache hit.

Directives can opt out of caching by setting `cacheable = false`:
```toml
[env]
TIMESTAMP = { value = "{{ now() }}", cacheable = false }
_.source = { file = "dynamic.sh", cacheable = false }
```
"""
env = "MISE_ENV_CACHE"
type = "Bool"

[env_cache_ttl]
default = "1h"
description = "TTL for cached environments"
docs = """
How long cached environments remain valid before being regenerated.
Accepts duration strings like "1h", "30m", "1d".

Even with a valid TTL, caches are still invalidated when config files,
tool versions, settings, or watched files change.
"""
env = "MISE_ENV_CACHE_TTL"
type = "Duration"

[env_file]
description = "Path to a file containing environment variables to automatically load."
env = "MISE_ENV_FILE"
optional = true
type = "Path"

[erlang.compile]
description = "If true, compile erlang from source. If false, use precompiled binaries. If not set, use precompiled binaries if available."
env = "MISE_ERLANG_COMPILE"
optional = true
type = "Bool"

[exec_auto_install]
default = true
description = "Automatically install missing tools when running `mise x`."
env = "MISE_EXEC_AUTO_INSTALL"
type = "Bool"

[experimental]
description = "Enable experimental mise features which are incomplete or unstable—breakings changes may occur"
docs = """
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.
"""
env = "MISE_EXPERIMENTAL"
type = "Bool"

[fetch_remote_versions_cache]
default = "1h"
description = "How long to cache remote versions for tools."
docs = """
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
"""
env = "MISE_FETCH_REMOTE_VERSIONS_CACHE"
type = "Duration"

[fetch_remote_versions_timeout]
aliases = ["fetch_remote_version_timeout"]
default = "20s"
description = "Timeout in seconds for HTTP requests to fetch new tool versions in mise."
env = "MISE_FETCH_REMOTE_VERSIONS_TIMEOUT"
type = "Duration"

[gix]
default = true
description = "Use gix for git operations, set to false to shell out to git."
docs = """
Use gix for git operations. This is generally faster but may not be as compatible if the
system's gix is not the same version as the one used by mise.
"""
env = "MISE_GIX"
hide = true
type = "Bool"

[global_config_file]
description = "Path to the global mise config file. Default is `~/.config/mise/config.toml`. This must be an env var."
env = "MISE_GLOBAL_CONFIG_FILE"
optional = true
type = "Path"

[global_config_root]
description = "Path which is used as `{{config_root}}` for the global config file. Default is `$HOME`. This must be an env var."
env = "MISE_GLOBAL_CONFIG_ROOT"
optional = true
type = "Path"

[github.github_attestations]
default = true
description = "Enable GitHub Artifact Attestations verification for github backend tools."
docs = """
Enable/disable GitHub Artifact Attestations verification for github backend tools.
When enabled, mise will verify the authenticity and integrity of downloaded tools
using GitHub's artifact attestation system.
"""
env = "MISE_GITHUB_GITHUB_ATTESTATIONS"
type = "Bool"

[github.slsa]
default = true
description = "Enable SLSA provenance verification for github backend tools."
docs = """
Enable/disable SLSA provenance verification for github backend tools.
When enabled, mise will verify the supply-chain integrity of downloaded tools
using SLSA provenance attestations.
"""
env = "MISE_GITHUB_SLSA"
type = "Bool"

[slsa]
default = true
description = "Enable SLSA provenance verification globally."
docs = """
Enable/disable SLSA provenance verification globally for all backends that support it.
When enabled, mise will verify the supply-chain integrity of downloaded tools
using SLSA provenance attestations.
"""
env = "MISE_SLSA"
type = "Bool"

[go_default_packages_file]
default = "~/.default-go-packages"
description = "Path to a file containing default go packages to install when installing go"
env = "MISE_GO_DEFAULT_PACKAGES_FILE"
type = "Path"

[go_download_mirror]
default = "https://dl.google.com/go"
description = "Mirror to download go sdk tarballs from."
env = "MISE_GO_DOWNLOAD_MIRROR"
type = "String"

[go_repo]
default = "https://github.com/golang/go"
description = "URL to fetch go from."
env = "MISE_GO_REPO"
type = "Url"

[go_set_gobin]
description = "Changes where `go install` installs binaries to."
docs = """
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`).
"""
env = "MISE_GO_SET_GOBIN"
optional = true
type = "Bool"

[go_set_gopath]
deprecated = "Use env._go.set_goroot instead."
description = "[deprecated] Set to true to set GOPATH=~/.local/share/mise/installs/go/.../packages."
env = "MISE_GO_SET_GOPATH"
type = "Bool"

[go_set_goroot]
default = true
description = "Sets GOROOT=~/.local/share/mise/installs/go/.../."
env = "MISE_GO_SET_GOROOT"
type = "Bool"

[go_skip_checksum]
description = "Set to true to skip checksum verification when downloading go sdk tarballs."
env = "MISE_GO_SKIP_CHECKSUM"
type = "Bool"

[gpg_verify]
description = "Use gpg to verify all tool signatures."
env = "MISE_GPG_VERIFY"
optional = true
type = "Bool"

[github_attestations]
default = true
description = "Enable GitHub Artifact Attestations verification for supported tools."
docs = """
Enable/disable GitHub Artifact Attestations verification globally.
When enabled, mise will verify the authenticity and integrity of downloaded tools
using GitHub's artifact attestation system for tools that support it (e.g., Ruby precompiled binaries).

Individual tools can override this setting with their own `<tool>.github_attestations` setting.
"""
env = "MISE_GITHUB_ATTESTATIONS"
type = "Bool"

[http_timeout]
default = "30s"
description = "Timeout in seconds for all HTTP requests in mise."
env = "MISE_HTTP_TIMEOUT"
type = "Duration"

[http_retries]
default = 0
description = "Number of retries for HTTP requests in mise."
docs = """
Uses an exponential backoff strategy. The duration is calculated by taking the base (10ms) to the n-th power.
"""
env = "MISE_HTTP_RETRIES"
type = "Integer"

[hook_env.cache_ttl]
default = "0s"
description = "Cache hook-env directory checks for this duration. Useful for slow filesystems like NFS."
docs = """
On slow filesystems (like NFS with cold cache), mise's hook-env can be slow due to
multiple filesystem stat operations. Setting this to a positive value (e.g., "5s")
will cache the results of directory traversal and only re-check after the TTL expires.

When set to "0s" (default), no caching is performed and every hook-env call will
check the filesystem for changes. This is the safest option but slowest on NFS.

Note: When caching is enabled, newly created config files may not be detected until
the TTL expires. Use `mise hook-env --force` to bypass the cache.
"""
env = "MISE_HOOK_ENV_CACHE_TTL"
type = "Duration"

[hook_env.chpwd_only]
default = false
description = "Only run hook-env checks on directory change, not on every prompt."
docs = """
When enabled, mise will only perform full config file checks when the directory changes
(chpwd), not on every shell prompt (precmd). This significantly reduces filesystem
operations on slow filesystems like NFS.

With this enabled, changes to config files will not be detected until you change
directories. Use `mise hook-env --force` to manually trigger a full update.

This setting is useful when:
- You're working on an NFS filesystem with slow stat operations
- Config files rarely change during a session
- You want the fastest possible shell prompt response time
"""
env = "MISE_HOOK_ENV_CHPWD_ONLY"
type = "Bool"

[idiomatic_version_file]
deprecated = "This has been replaced with the idiomatic_version_file_enable_tools setting."
description = "Set to false to disable the idiomatic version files such as .node-version, .ruby-version, etc."
docs = """
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](/configuration.html#idiomatic-version-files)
for more
information.

Set to "false" to disable idiomatic version file parsing.
"""
env = "MISE_IDIOMATIC_VERSION_FILE"
hide = true
optional = true
type = "Bool"

[idiomatic_version_file_disable_tools]
default = []
deprecated = "This has been replaced with the idiomatic_version_file_enable_tools setting."
description = "Specific tools to disable idiomatic version files for."
env = "MISE_IDIOMATIC_VERSION_FILE_DISABLE_TOOLS"
hide = true
parse_env = "set_by_comma"
rust_type = "BTreeSet<String>"
type = "SetString"

[idiomatic_version_file_enable_tools]
default = []
description = "Specific tools to enable idiomatic version files for like .node-version, .ruby-version, etc."
docs = """
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](/configuration.html#idiomatic-version-files) for more information.
"""
env = "MISE_IDIOMATIC_VERSION_FILE_ENABLE_TOOLS"
parse_env = "set_by_comma"
rust_type = "BTreeSet<String>"
type = "SetString"

[ignored_config_paths]
default = []
description = "This is a list of config paths that mise will ignore."
docs = """
This is a list of config paths that mise will ignore.

This is an early-init setting: it must be set in `.miserc.toml`, environment
variables, or CLI flags. Setting it in `mise.toml` will have no effect because
config file discovery has already occurred by the time `mise.toml` is read.
"""
env = "MISE_IGNORED_CONFIG_PATHS"
parse_env = "list_by_colon"
rc = true
rust_type = "BTreeSet<PathBuf>"
type = "ListPath"

[install_before]
description = "Only install versions released before this date"
docs = """
Filter tool versions by release date. Supports:

- Absolute dates: `2024-06-01`, `2024-06-01T12:00:00Z`
- Relative durations: `90d` (90 days ago), `1y` (1 year ago), `6m` (6 months ago)

This is useful for reproducible builds or security purposes where you want to ensure
you're only installing versions that existed before a certain point in time.

Only affects backends that provide release timestamps (aqua, cargo, npm, pipx, and some core plugins).
Versions without timestamps are included by default.

**Behavior**: This filter only applies when resolving fuzzy version requests like `node@20` or `latest`.
Explicitly pinned versions like `node@22.5.0` are not filtered, allowing you to selectively
use newer versions for specific tools while keeping others behind the cutoff date.

Can be overridden with the `--before` CLI flag.
"""
env = "MISE_INSTALL_BEFORE"
optional = true
type = "String"

[jobs]
default = 8
description = "How many jobs to run concurrently such as tool installs."
env = "MISE_JOBS"
rust_type = "usize"
type = "Integer"

[legacy_version_file]
default = true
deprecated = "Use idiomatic_version_file instead."
description = "Set to false to disable the idiomatic version files such as .node-version, .ruby-version, etc."
env = "MISE_LEGACY_VERSION_FILE"
hide = true
type = "Bool"

[legacy_version_file_disable_tools]
default = []
deprecated = "Use idiomatic_version_file_disable_tools instead."
description = "Specific tools to disable idiomatic version files for."
env = "MISE_LEGACY_VERSION_FILE_DISABLE_TOOLS"
hide = true
parse_env = "set_by_comma"
rust_type = "BTreeSet<String>"
type = "SetString"

[libgit2]
default = true
description = "Use libgit2 for git operations, set to false to shell out to git."
docs = """
Use libgit2 for git operations. This is generally faster but may not be as compatible if the
system's libgit2 is not the same version as the one used by mise.
"""
env = "MISE_LIBGIT2"
hide = true
type = "Bool"

[lockfile]
default = true
description = "Create and read lockfiles for tool versions."
docs = """

> [!NOTE]
> This feature is [experimental](#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`
"""
env = "MISE_LOCKFILE"
type = "Bool"

[locked]
default = false
description = "Require lockfile URLs to be present during installation."
docs = """

> [!NOTE]
> This setting requires both [lockfile](#lockfile) and [experimental](#experimental) to be enabled.

When enabled, `mise install` will fail if tools don't have pre-resolved URLs in the lockfile
for the current platform. This prevents API calls to GitHub, aqua registry, etc. and ensures
reproducible installations.

This is useful in CI/CD environments where you want to:
- Avoid GitHub API rate limits
- Ensure deterministic builds using pre-resolved URLs
- Fail fast if the lockfile is incomplete

To generate lockfile URLs, run:

```sh
mise lock
```

Equivalent to passing `--locked` to `mise install`.
"""
env = "MISE_LOCKED"
type = "Bool"

[log_level]
default = "info"
description = "Show more/less output."
enum = [["trace"], ["debug"], ["info"], ["warn"], ["error"]]
env = "MISE_LOG_LEVEL"
hide = true
type = "String"

[netrc]
default = true
description = "Use a netrc file for HTTP Basic authentication."
docs = """
When enabled, mise will read credentials from the netrc file and apply
HTTP Basic authentication for matching hosts. This is useful for accessing
private artifact repositories like Artifactory or Nexus.

On Unix/macOS, the default path is `~/.netrc`.
On Windows, mise looks for `%USERPROFILE%\\_netrc` first, then falls back to `%USERPROFILE%\\.netrc`.

The netrc file format is:

```
machine artifactory.example.com
  login myuser
  password mytoken
```

You can also specify a custom netrc file path using the `netrc_file` setting.
"""
env = "MISE_NETRC"
type = "Bool"

[netrc_file]
description = "Path to the netrc file to use for HTTP Basic authentication."
docs = """
Override the default netrc file path. This is useful if you want to use a
different netrc file for mise or if your netrc file is in a non-standard location.
"""
env = "MISE_NETRC_FILE"
optional = true
type = "Path"

[no_env]
description = "Do not load environment variables from config files."
env = "MISE_NO_ENV"
optional = true
type = "Bool"

[no_hooks]
description = "Do not execute hooks from config files."
env = "MISE_NO_HOOKS"
optional = true
type = "Bool"

[node.compile]
description = "Compile node from source."
env = "MISE_NODE_COMPILE"
optional = true
type = "Bool"

[node.flavor]
description = "Install a specific node flavor like glibc-217 or musl. Use with unofficial node build repo."
env = "MISE_NODE_FLAVOR"
optional = true
type = "String"

[node.gpg_verify]
description = "Use gpg to verify node tool signatures."
env = "MISE_NODE_GPG_VERIFY"
optional = true
type = "Bool"

[node.mirror_url]
description = "Mirror to download node tarballs from."
env = "MISE_NODE_MIRROR_URL"
optional = true
type = "Url"

[not_found_auto_install]
default = true
description = "Set to false to disable the \"command not found\" handler to autoinstall missing tool versions."
docs = """
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.
"""
env = "MISE_NOT_FOUND_AUTO_INSTALL"
type = "Bool"

[npm.bun]
deprecated = "Use npm.package_manager instead."
description = "Use bun instead of npm if bun is installed and on PATH."
docs = """
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
```
"""
env = "MISE_NPM_BUN"
hide = true
type = "Bool"

[npm.package_manager]
default = "npm"
description = "Package manager to use for installing npm packages."
docs = """
Package manager to use for installing npm packages.
Can be one of:
- `npm` (default)
- `bun`
- `pnpm`
"""
env = "MISE_NPM_PACKAGE_MANAGER"
type = "String"

[os]
default_docs = '"linux" | "macos" | "windows"'
description = "OS to use for precompiled binaries."
env = "MISE_OS"
optional = true
type = "String"

[override_config_filenames]
default = []
description = "If set, mise will ignore default config files like `mise.toml` and use these filenames instead."
docs = """
If set, mise will ignore default config files like `mise.toml` and use these
filenames instead.

This is an early-init setting: it must be set in `.miserc.toml`, environment
variables, or CLI flags. Setting it in `mise.toml` will have no effect because
config file discovery has already occurred by the time `mise.toml` is read.
"""
env = "MISE_OVERRIDE_CONFIG_FILENAMES"
parse_env = "list_by_colon"
rc = true
type = "ListString"

[override_tool_versions_filenames]
default = []
description = "If set, mise will ignore .tool-versions files and use these filenames instead. Can be set to `none` to disable .tool-versions."
docs = """
If set, mise will ignore .tool-versions files and use these filenames instead.
Can be set to `none` to disable .tool-versions entirely.

This is an early-init setting: it must be set in `.miserc.toml`, environment
variables, or CLI flags. Setting it in `mise.toml` will have no effect because
config file discovery has already occurred by the time `mise.toml` is read.
"""
env = "MISE_OVERRIDE_TOOL_VERSIONS_FILENAMES"
parse_env = "list_by_colon"
rc = true
type = "ListString"

[paranoid]
description = "Enables extra-secure behavior."
docs = """
Enables extra-secure behavior. See [Paranoid](/paranoid.html).
"""
env = "MISE_PARANOID"
type = "Bool"

[pin]
description = "Default to pinning versions when running `mise use` in mise.toml files."
docs = """
This sets `--pin` by default when running `mise use` in mise.toml files. This can be overridden by
passing `--fuzzy` on the command line.
"""
env = "MISE_PIN"
type = "Bool"

[pipx.registry_url]
default = "https://pypi.org/pypi/{}/json"
description = "URL to use for pipx registry."
docs = """
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/{}/`.
"""
env = "MISE_PIPX_REGISTRY_URL"
type = "String"

[pipx.uvx]
default_docs = "true"
description = "Use uvx instead of pipx if uv is installed and on PATH."
docs = """
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
```
"""
env = "MISE_PIPX_UVX"
optional = true
type = "Bool"

[pipx_uvx]
description = "Use uvx instead of pipx if uv is installed and on PATH."
hide = true
optional = true
type = "Bool"

[plugin_autoupdate_last_check_duration]
default = "7d"
description = "How long to wait before updating plugins automatically (note this isn't currently implemented)."
env = "MISE_PLUGIN_AUTOUPDATE_LAST_CHECK_DURATION"
type = "String"

[profile]
deprecated = "Use MISE_ENV_FILE instead."
description = "Profile to use for mise.${MISE_PROFILE}.toml files."
env = "MISE_PROFILE"
hide = true
optional = true
type = "String"

[python.compile]
description = "If true, compile python from source. If false, use precompiled binaries. If not set, use precompiled binaries if available."
docs = """
* Values:
  * `true` - always compile with python-build instead of downloading [precompiled binaries](/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.
"""
env = "MISE_PYTHON_COMPILE"
optional = true
type = "Bool"

[python.default_packages_file]
description = "Path to a file containing default python packages to install when installing a python version."
env = "MISE_PYTHON_DEFAULT_PACKAGES_FILE"
optional = true
type = "Path"

[python.patch_url]
description = "URL to fetch python patches from to pass to python-build."
env = "MISE_PYTHON_PATCH_URL"
optional = true
type = "Url"

[python.patches_directory]
description = "Directory to fetch python patches from."
env = "MISE_PYTHON_PATCHES_DIRECTORY"
optional = true
type = "Path"

[python.precompiled_arch]
default_docs = '"apple-darwin" | "unknown-linux-gnu" | "unknown-linux-musl"'
description = "Specify the architecture to use for precompiled binaries."
env = "MISE_PYTHON_PRECOMPILED_ARCH"
optional = true
type = "String"

[python.precompiled_flavor]
default_docs = "install_only_stripped"
description = "Specify the flavor to use for precompiled binaries."
docs = """
Specify the flavor to use for precompiled binaries.

Options are available here: <https://gregoryszorc.com/docs/python-build-standalone/main/running.html>
"""
env = "MISE_PYTHON_PRECOMPILED_FLAVOR"
optional = true
type = "String"

[python.precompiled_os]
default_docs = '"x86_64_v3" | "aarch64"'
description = "Specify the OS to use for precompiled binaries."
docs = """
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.
"""
env = "MISE_PYTHON_PRECOMPILED_OS"
optional = true
type = "String"

[python.pyenv_repo]
default = "https://github.com/pyenv/pyenv.git"
description = "URL to fetch pyenv from for compiling python with python-build."
env = "MISE_PYENV_REPO"
type = "String"

[python.uv_venv_auto]
description = "Integrate with uv to automatically create/source venvs if uv.lock is present."
env = "MISE_PYTHON_UV_VENV_AUTO"
type = "Bool"

[python.uv_venv_create_args]
description = "Arguments to pass to uv when creating a venv."
env = "MISE_PYTHON_UV_VENV_CREATE_ARGS"
optional = true
parse_env = "list_by_colon"
rust_type = "Vec<String>"
type = "ListString"

[python.venv_auto_create]
deprecated = "Use env._python.venv instead."
description = "Automatically create virtualenvs for python tools."
env = "MISE_PYTHON_VENV_AUTO_CREATE"
hide = true
type = "Bool"

[python.venv_create_args]
description = "Arguments to pass to python when creating a venv. (not used for uv venv creation)"
env = "MISE_PYTHON_VENV_CREATE_ARGS"
optional = true
parse_env = "list_by_colon"
rust_type = "Vec<String>"
type = "ListString"

[python.venv_stdlib]
description = "Prefer to use venv from Python's standard library."
env = "MISE_VENV_STDLIB"
type = "Bool"

[python_compile]
deprecated = "Use python.compile instead."
description = "If true, compile python from source. If false, use precompiled binaries. If not set, use precompiled binaries if available."
hide = true
optional = true
type = "Bool"

[python_default_packages_file]
deprecated = "Use python.default_packages_file instead."
description = "Path to a file containing default python packages to install when installing python."
hide = true
optional = true
type = "Path"

[python_patch_url]
deprecated = "Use python.patch_url instead."
description = "URL to fetch python patches from."
hide = true
optional = true
type = "String"

[python_patches_directory]
deprecated = "Use python.patch_url instead."
description = "Directory to fetch python patches from."
hide = true
optional = true
type = "Path"

[python_precompiled_arch]
deprecated = "Use python.precompiled_arch instead."
description = "Specify the architecture to use for precompiled binaries."
hide = true
optional = true
type = "String"

[python_precompiled_os]
deprecated = "Use python.precompiled_os instead."
description = "Specify the OS to use for precompiled binaries."
hide = true
optional = true
type = "String"

[python_pyenv_repo]
deprecated = "Use python.pyenv_repo instead."
description = "URL to fetch pyenv from for compiling python."
hide = true
optional = true
type = "String"

[python_venv_auto_create]
deprecated = "Use env._python.venv instead."
description = "Automatically create virtualenvs for python tools."
hide = true
optional = true
type = "Bool"

[python_venv_stdlib]
deprecated = "Use python.venv_stdlib instead."
description = "Prefer to use venv from Python's standard library."
hide = true
optional = true
type = "Bool"

[quiet]
description = "Suppress all output except errors."
env = "MISE_QUIET"
type = "Bool"

[raw]
description = "Connect stdin/stdout/stderr to child processes."
env = "MISE_RAW"
type = "Bool"

[terminal_progress]
default = true
description = "Enable terminal progress indicators (OSC 9;4) for compatible terminals."
docs = """
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, iTerm2, 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, 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.
"""
env = "MISE_TERMINAL_PROGRESS"
type = "Bool"

[ruby.apply_patches]
description = "A list of patch files or URLs to apply to ruby source."
env = "MISE_RUBY_APPLY_PATCHES"
optional = true
type = "String"

[ruby.compile]
description = "[experimental] Set to true to always compile ruby from source."
docs = """
Controls whether Ruby is compiled from source or downloaded as precompiled binaries.
Requires `experimental = true` to be enabled.

- If unset or `false`: Try precompiled binaries first, fall back to compiling if unavailable
- If `true`: Always compile from source using ruby-build

Example to force compilation:
```toml
[settings]
experimental = true
ruby.compile = true
```
"""
env = "MISE_RUBY_COMPILE"
optional = true
type = "Bool"

[ruby.default_packages_file]
default = "~/.default-gems"
description = "Path to a file containing default ruby gems to install when installing ruby."
env = "MISE_RUBY_DEFAULT_PACKAGES_FILE"
type = "String"

[ruby.precompiled_arch]
description = "[experimental] Override architecture identifier for precompiled Ruby binaries."
env = "MISE_RUBY_PRECOMPILED_ARCH"
optional = true
type = "String"

[ruby.precompiled_os]
description = "[experimental] Override OS identifier for precompiled Ruby binaries."
env = "MISE_RUBY_PRECOMPILED_OS"
optional = true
type = "String"

[ruby.precompiled_url]
default = "jdx/ruby"
description = "[experimental] URL template or GitHub repo for precompiled Ruby binaries."
docs = """
Can be either:
- A GitHub repo shorthand: `"jdx/ruby"` or `"yourorg/ruby"`
- A full URL template with variables: `{version}`, `{platform}`, `{os}`, `{arch}`

Examples:
```toml
[settings.ruby]
# Use a different GitHub repo
precompiled_url = "yourorg/ruby"

# Or use a custom URL template
precompiled_url = "https://my-mirror.example.com/ruby-{version}.{platform}.tar.gz"
```
"""
env = "MISE_RUBY_PRECOMPILED_URL"
type = "String"

[ruby.github_attestations]
description = "[experimental] Enable GitHub Artifact Attestations verification for precompiled Ruby binaries."
docs = """
Override the global `github_attestations` setting for Ruby precompiled binaries.
When enabled, mise will verify the authenticity of precompiled Ruby binaries from jdx/ruby.
Requires `experimental = true`.

Defaults to the global `github_attestations` setting if not specified.
"""
env = "MISE_RUBY_GITHUB_ATTESTATIONS"
optional = true
type = "Bool"

[ruby.ruby_build_opts]
description = "Options to pass to ruby-build."
env = "MISE_RUBY_BUILD_OPTS"
optional = true
type = "String"

[ruby.ruby_build_repo]
default = "https://github.com/rbenv/ruby-build.git"
description = "The URL used to fetch ruby-build. This accepts either a Git repository or a ZIP archive."
env = "MISE_RUBY_BUILD_REPO"
type = "String"

[ruby.ruby_install]
description = "Use ruby-install instead of ruby-build."
env = "MISE_RUBY_INSTALL"
type = "Bool"

[ruby.ruby_install_opts]
description = "Options to pass to ruby-install."
env = "MISE_RUBY_INSTALL_OPTS"
optional = true
type = "String"

[ruby.ruby_install_repo]
default = "https://github.com/postmodern/ruby-install.git"
description = "The URL used to fetch ruby-install. This accepts either a Git repository or a ZIP archive."
env = "MISE_RUBY_INSTALL_REPO"
type = "String"

[ruby.verbose_install]
description = "Set to true to enable verbose output during ruby installation."
env = "MISE_RUBY_VERBOSE_INSTALL"
optional = true
type = "Bool"

[rust.cargo_home]
description = "Path to the cargo home directory. Defaults to `~/.cargo` or `%USERPROFILE%\\.cargo`"
env = "MISE_CARGO_HOME"
optional = true
type = "Path"

[rust.rustup_home]
description = "Path to the rustup home directory. Defaults to `~/.rustup` or `%USERPROFILE%\\.rustup`"
env = "MISE_RUSTUP_HOME"
optional = true
type = "Path"

[shorthands_file]
description = "Path to a file containing custom tool shorthands."
docs = """
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/`](https://github.com/jdx/mise/blob/main/registry/).

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

"""
env = "MISE_SHORTHANDS_FILE"
optional = true
type = "Path"

[silent]
description = "Suppress all `mise run|watch` output except errors—including what tasks output."
env = "MISE_SILENT"
type = "Bool"

[age.identity_files]
description = "[experimental] List of age identity files to use for decryption."
env = "MISE_AGE_IDENTITY_FILES"
optional = true
rust_type = "Vec<PathBuf>"
type = "ListPath"

[age.key_file]
default_docs = "~/.config/mise/age.txt"
description = "[experimental] Path to the age private key file to use for encryption/decryption."
env = "MISE_AGE_KEY_FILE"
optional = true
type = "Path"

[age.ssh_identity_files]
description = "[experimental] List of SSH identity files to use for age decryption."
env = "MISE_AGE_SSH_IDENTITY_FILES"
optional = true
rust_type = "Vec<PathBuf>"
type = "ListPath"

[age.strict]
default = true
description = "If true, fail when age decryption fails (including when age is not available, the key is missing, or the key is invalid). If false, skip decryption and continue in these cases."
env = "MISE_AGE_STRICT"
type = "Bool"

[sops.age_key]
description = "The age private key to use for sops secret decryption. Takes precedence over standard SOPS_AGE_KEY environment variable."
env = "MISE_SOPS_AGE_KEY"
optional = true
type = "String"

[sops.age_key_file]
default_docs = "~/.config/mise/age.txt"
description = "Path to the age private key file for sops secret decryption. Takes precedence over standard SOPS_AGE_KEY_FILE environment variable."
env = "MISE_SOPS_AGE_KEY_FILE"
optional = true
type = "Path"

[sops.age_recipients]
description = "The age public keys to use for sops secret encryption."
env = "MISE_SOPS_AGE_RECIPIENTS"
optional = true
type = "String"

[sops.rops]
default = true
description = "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."
env = "MISE_SOPS_ROPS"
type = "Bool"

[sops.strict]
default = true
description = "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."
env = "MISE_SOPS_STRICT"
type = "Bool"

[status.missing_tools]
default = "if_other_versions_installed"
description = "Show a warning if tools are not installed when entering a directory with a mise.toml file."
docs = """
| 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`](#disable_tools).
"""
env = "MISE_STATUS_MESSAGE_MISSING_TOOLS"
type = "String"

[status.show_env]
description = "Show configured env vars when entering a directory with a mise.toml file."
env = "MISE_STATUS_MESSAGE_SHOW_ENV"
type = "Bool"

[status.show_tools]
description = "Show configured tools when entering a directory with a mise.toml file."
env = "MISE_STATUS_MESSAGE_SHOW_TOOLS"
type = "Bool"

[status.show_prepare_stale]
default = true
description = "Show warning when prepare providers have stale dependencies."
env = "MISE_STATUS_SHOW_PREPARE_STALE"
type = "Bool"

[status.truncate]
default = true
description = "Truncate status messages."
env = "MISE_STATUS_MESSAGE_TRUNCATE"
type = "Bool"

[swift.gpg_verify]
description = "Use gpg to verify swift tool signatures."
env = "MISE_SWIFT_GPG_VERIFY"
optional = true
type = "Bool"

[swift.platform]
default_docs = '"osx" | "windows10" | "ubuntu20.04" | "ubuntu22.04" | "ubuntu24.04" | "amazonlinux2" | "ubi9" | "fedora39"'
description = "Override the platform to use for precompiled binaries."
env = "MISE_SWIFT_PLATFORM"
optional = true
type = "String"

[system_config_file]
description = "Path to the system mise config file. Default is `/etc/mise/config.toml`. This must be an env var."
env = "MISE_SYSTEM_CONFIG_FILE"
optional = true
type = "Path"

[task_disable_paths]
default = []
description = "Paths that mise will not look for tasks in."
env = "MISE_TASK_DISABLE_PATHS"
parse_env = "list_by_colon"
rust_type = "BTreeSet<PathBuf>"
type = "ListPath"

[task_output]
description = "Change output style when executing tasks."
docs = """
Change output style when executing tasks. This controls the output of `mise run`.
"""
enum = [
  [
    "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",
  ],
]
env = "MISE_TASK_OUTPUT"
optional = true
rust_type = "crate::task::TaskOutput"
type = "String"

[task_remote_no_cache]
description = "Mise will always fetch the latest tasks from the remote, by default the cache is used."
env = "MISE_TASK_REMOTE_NO_CACHE"
optional = true
type = "Bool"

[task_run_auto_install]
default = true
description = "Automatically install missing tools when executing tasks."
env = "MISE_TASK_RUN_AUTO_INSTALL"
type = "Bool"

[task_skip]
default = []
description = "Tasks to skip when running `mise run`."
env = "MISE_TASK_SKIP"
parse_env = "set_by_comma"
rust_type = "BTreeSet<String>"
type = "SetString"

[task_skip_depends]
description = "Run only specified tasks skipping all dependencies."
env = "MISE_TASK_SKIP_DEPENDS"
type = "Bool"

[task_timeout]
description = "Default timeout for tasks. Can be overridden by individual tasks."
env = "MISE_TASK_TIMEOUT"
optional = true
type = "Duration"

[task_timings]
description = "Show completion message with elapsed time for each task on `mise run`. Default shows when output type is `prefix`."
env = "MISE_TASK_TIMINGS"
optional = true
type = "Bool"

[task_show_full_cmd]
description = "Disable truncation of command lines in task execution output. When true, the full command line will be shown."
env = "MISE_TASK_SHOW_CMD_NO_TRUNC"
type = "Bool"

[trace]
description = "Sets log level to trace"
env = "MISE_TRACE"
hide = true
type = "Bool"

[trusted_config_paths]
default = []
description = "This is a list of config paths that mise will automatically mark as trusted."
env = "MISE_TRUSTED_CONFIG_PATHS"
parse_env = "list_by_colon"
rust_type = "BTreeSet<PathBuf>"
type = "ListPath"

[unix_default_file_shell_args]
default = "sh"
description = "Default shell arguments for Unix to be used for file commands. For example, `sh` for sh."
env = "MISE_UNIX_DEFAULT_FILE_SHELL_ARGS"
type = "String"

[unix_default_inline_shell_args]
default = "sh -c -o errexit"
description = "Default shell arguments for Unix to be used for inline commands. For example, `sh -c` for sh."
env = "MISE_UNIX_DEFAULT_INLINE_SHELL_ARGS"
type = "String"

[url_replacements]
description = "Map of URL patterns to replacement URLs applied to all requests."
docs = '''
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](/url-replacements.html) for more information.
'''
env = "MISE_URL_REPLACEMENTS"
optional = true
parse_env = "parse_url_replacements"
type = "IndexMap<String, String>"

[use_file_shell_for_executable_tasks]
default = false
description = "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."
env = "MISE_USE_FILE_SHELL_FOR_EXECUTABLE_TASKS"
type = "Bool"

[use_versions_host]
default = true
description = "Set to false to disable using the mise-versions API as a quick way for mise to query for new versions."
docs = """
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](/troubleshooting.html#new-version-of-a-tool-is-not-available) for more information.
"""
env = "MISE_USE_VERSIONS_HOST"
type = "Bool"

[use_versions_host_track]
default = true
description = "Send anonymous download statistics when installing tools."
docs = """
When enabled, mise sends anonymous download statistics to mise-versions.jdx.dev after
successfully installing a tool. This helps show tool popularity on [mise-versions.jdx.dev](https://mise-versions.jdx.dev).

Data collected:
- Tool name and version
- OS and architecture (from User-Agent)
- Hashed IP address (for daily deduplication, not stored raw)

This is automatically disabled if `use_versions_host` is set to false.
Set to false to opt-out of anonymous statistics collection.
"""
env = "MISE_USE_VERSIONS_HOST_TRACK"
type = "Bool"

[verbose]
description = "Shows more verbose output such as installation logs when installing tools."
env = "MISE_VERBOSE"
type = "Bool"

[vfox]
deprecated = "Use disable_backends instead."
description = "Use vfox as a default plugin backend instead of asdf."
docs = """
Use vfox as a default plugin backend. This means running something like `mise use cmake` will
default to using a vfox plugin for cmake.
"""
env = "MISE_VFOX"
hide = true
optional = true
type = "Bool"

[windows_default_file_shell_args]
default = "cmd /c"
description = "Default shell arguments for Windows to be used for file commands. For example, `cmd /c` for cmd.exe."
env = "MISE_WINDOWS_DEFAULT_FILE_SHELL_ARGS"
type = "String"

[windows_default_inline_shell_args]
default = "cmd /c"
description = "Default shell arguments for Windows to be used for inline commands. For example, `cmd /c` for cmd.exe."
env = "MISE_WINDOWS_DEFAULT_INLINE_SHELL_ARGS"
type = "String"

[windows_executable_extensions]
default = ["exe", "bat", "cmd", "com", "ps1", "vbs"]
description = "List of executable extensions for Windows. For example, `exe` for .exe files, `bat` for .bat files, and so on."
env = "MISE_WINDOWS_EXECUTABLE_EXTENSIONS"
parse_env = "list_by_comma"
rust_type = "Vec<String>"
type = "ListString"

[windows_shim_mode]
default = "file"
description = "Shim file mode for Windows. Options: `file`, `hardlink`, `symlink`."
docs = """
* 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.
"""
env = "MISE_WINDOWS_SHIM_MODE"
type = "String"

[yes]
description = "This will automatically answer yes or no to prompts. This is useful for scripting."
env = "MISE_YES"
type = "Bool"

[zig.use_community_mirrors]
default = true
description = "Download Zig from community-maintained mirrors"
docs = """
This setting allows mise to fetch Zig from one of many community-maintained mirrors.

The ziglang.org website does not offer any uptime or speed guarantees, and it
recommends to use the mirrors. The mirror list is cached and allows the installs
to succeed even if the main server is unavailable.

The downloaded tarballs are always verified against Zig Software Foundation's public
key, so there is no risk of third-party modifications. Read more on [ziglang.org](https://ziglang.org/download/community-mirrors/).

If you don't have the mirror list cached locally, you can place the newline-separated
server list inside `mise cache path`, folder `zig` as `community-mirrors.txt`.
"""
env = "MISE_ZIG_USE_COMMUNITY_MIRRORS"
type = "Bool"

[task.disable_spec_from_run_scripts]
default = false
description = "Opt out of parsing task run scripts to infer the usage spec (arguments and flags). When enabled, mise will derive the usage spec only from the `usage` field, ignoring any `arg()`, `option()`, or `flag()` templates used in run scripts. This can restore previous behavior and avoid the extra template pass over run scripts when collecting specs."
docs = """
When enabled, `arg()`, `option()`, and `flag()` Tera functions in run scripts will not contribute
to the task's usage spec—only the explicit `usage` field is used.

This is useful for:
- Skipping the extra template pass over run scripts (performance)
- Avoiding two-pass parsing quirks where template functions return empty strings during spec collection
- Early opt-out before Tera template arguments are removed in 2026.11.0
"""
env = "MISE_TASK_DISABLE_SPEC_FROM_RUN_SCRIPTS"
type = "Bool"

[task.monorepo_depth]
default = 5
description = "Maximum depth to search for task files in monorepo subdirectories."
docs = """
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:**
```toml
[settings]
task.monorepo_depth = 3  # Only search 3 levels deep
```

Or via environment variable:
```bash
export MISE_TASK_MONOREPO_DEPTH=3
```
"""
env = "MISE_TASK_MONOREPO_DEPTH"
type = "Integer"

[task.monorepo_exclude_dirs]
default = []
description = "Directory patterns to exclude when discovering monorepo subdirectories."
docs = """
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.
"""
env = "MISE_TASK_MONOREPO_EXCLUDE_DIRS"
parse_env = "list_by_comma"
rust_type = "Vec<String>"
type = "ListString"

[task.monorepo_respect_gitignore]
default = true
description = "Whether to respect .gitignore files when discovering monorepo subdirectories."
docs = """
When enabled, mise will skip directories that are ignored by .gitignore files
when discovering tasks in a monorepo.
"""
env = "MISE_TASK_MONOREPO_RESPECT_GITIGNORE"
type = "Bool"