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

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

[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_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.binstall_only]
default = false
description = "Only use cargo-binstall for installation, fail if not available."
env = "MISE_CARGO_BINSTALL_ONLY"
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"

[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. Config files **in** the ceiling directory
itself are excluded—only directories below it are searched. For example,
if `MISE_CEILING_PATHS="/home/user"`, then `/home/user/mise.toml` is
**not** loaded, but `/home/user/projects/myapp/mise.toml` is.

This follows the same semantics as Git's `GIT_CEILING_DIRECTORIES`.

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"

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

[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_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.cli_telemetry_optout]
description = "Set DOTNET_CLI_TELEMETRY_OPTOUT to opt out of .NET CLI telemetry."
docs = """
When set to true, the `DOTNET_CLI_TELEMETRY_OPTOUT` environment variable is set to `1`,
disabling .NET CLI telemetry. When set to false, it is set to `0`.

When unset (default), mise does not set the variable and .NET uses its own default behavior.
"""
env = "MISE_DOTNET_CLI_TELEMETRY_OPTOUT"
optional = true
type = "Bool"

[dotnet.dotnet_root]
description = "Path to the shared .NET SDK root directory."
docs = """
All .NET SDK versions are installed side-by-side under this directory, matching .NET's native multi-version model.

By default, mise uses `~/.local/share/mise/dotnet-root`. Set this to override the location.
"""
env = "MISE_DOTNET_ROOT"
optional = true
type = "Path"

[dotnet.isolated]
default = false
description = "Install each .NET SDK version in its own isolated directory."
docs = """
When true, each SDK version is installed in its own directory under mise's installs path,
like most other tools. `dotnet --list-sdks` will only show the active version.

When false (default), all SDK versions share a single `DOTNET_ROOT` directory and
`dotnet --list-sdks` shows all installed versions, matching .NET's native side-by-side model.
"""
env = "MISE_DOTNET_ISOLATED"
type = "Bool"

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

[env_shell_expand]
description = "Enable shell-style variable expansion in env values (e.g., $FOO, ${BAR:-default})"
docs = """
Controls shell-style variable expansion in `mise.toml` `[env]` values:

```toml
[env]
FOO = "hello"
BAR = "$FOO-world"        # "hello-world"
BAZ = "${FOO}_suffix"     # "hello_suffix"
QUX = "${UNDEF:-fallback}" # "fallback"
```

- `true` — enable shell expansion
- `false` — disable shell expansion (no warning)
- unset — disable shell expansion but warn if `$` is detected in env values
  (shell expansion will become the default in a future release)

Expansion happens after Tera template rendering, so both syntaxes can be mixed.
Undefined variables are left unexpanded (e.g., `$MISSING` stays as `$MISSING`).
"""
env = "MISE_ENV_SHELL_EXPAND"
optional = true
type = "Bool"

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

[github.credential_command]
default = ""
description = "Shell command to run to obtain a GitHub token for mise."
docs = """
When set, mise executes this command via `sh -c` and reads the token
from stdout. The hostname is passed as `$1`, making the command
host-aware for GitHub Enterprise environments. This replaces the
`git credential fill` fallback and does not require
`github.use_git_credentials` to be enabled.

The command should print a single token to stdout. Trailing whitespace
is trimmed. Results are cached per host per session.

Example: `op read "op://Private/GitHub Token/credential"`
"""
env = "MISE_GITHUB_CREDENTIAL_COMMAND"
type = "String"

[github.gh_cli_tokens]
default = true
description = "Read GitHub tokens from the gh CLI's hosts.yml config."
docs = """
When enabled, mise will read OAuth tokens from the gh CLI config file
(`~/.config/gh/hosts.yml` or `$GH_CONFIG_DIR/hosts.yml`) as a fallback
when no `GITHUB_TOKEN` or `MISE_GITHUB_TOKEN` environment variable is set.

This supports multiple GitHub Enterprise instances since the gh CLI stores
per-host tokens.

Set to `false` to disable this behavior.
"""
env = "MISE_GITHUB_GH_CLI_TOKENS"
type = "Bool"

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

[github.use_git_credentials]
default = false
description = "Use git credential helpers to obtain GitHub tokens."
docs = """
When enabled, mise will run `git credential fill` to obtain GitHub tokens
using the credential helpers configured in your `.gitconfig`.

This covers tokens stored in system keyrings (macOS Keychain, Windows
Credential Manager), and any other git credential helper.

Used as a last resort — after environment variables, `github_tokens.toml`,
and gh CLI tokens are checked. Results are cached per host for the
duration of the session.

Set to `true` to enable this behavior.
"""
env = "MISE_GITHUB_USE_GIT_CREDENTIALS"
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).
"""
env = "MISE_GITHUB_ATTESTATIONS"
type = "Bool"

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

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

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

[go_download_mirror]
deprecated = "Use go.download_mirror instead."
description = "Mirror to download go sdk tarballs from."
hide = true
optional = true
type = "String"

[go_repo]
deprecated = "Use go.repo instead."
description = "URL to fetch go from."
hide = true
optional = true
type = "Url"

[go_set_gobin]
deprecated = "Use go.set_gobin instead."
description = "Changes where `go install` installs binaries to."
hide = true
optional = true
type = "Bool"

[go_set_gopath]
deprecated = "Use go.set_gopath instead."
description = "[deprecated] Set to true to set GOPATH=~/.local/share/mise/installs/go/.../packages."
hide = true
optional = true
type = "Bool"

[go_set_goroot]
deprecated = "Use go.set_goroot instead."
description = "Sets GOROOT=~/.local/share/mise/installs/go/.../."
hide = true
optional = true
type = "Bool"

[go_skip_checksum]
deprecated = "Use go.skip_checksum instead."
description = "Set to true to skip checksum verification when downloading go sdk tarballs."
hide = true
optional = true
type = "Bool"

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

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

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

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

[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 = "Minimum release age / supply chain protection — only install versions released before this date"
docs = """
Filter tool versions by release date to limit supply chain risk. Similar to Renovate's
[minimum release age](https://docs.renovatebot.com/key-concepts/minimum-release-age/),
this ensures newly published versions are ignored until they've been available for a
configurable amount of time — giving the community time to discover compromised releases.

Supports:

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

Example:

```toml
[settings]
install_before = "7d"  # only install versions released more than 7 days ago
```

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

**Behavior**: For most backends, 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 or per-tool with the `install_before` tool option.

```toml
[tools.trivy]
version = "latest"
install_before = "7d"  # override for this tool only
```
"""
env = "MISE_INSTALL_BEFORE"
optional = true
type = "String"

[java.shorthand_vendor]
default = "openjdk"
description = "Shorthand for Java. Used when installing Java without a vendor prefix."
env = "MISE_JAVA_SHORTHAND_VENDOR"
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"

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

> [!NOTE]
> This setting requires [lockfile](#lockfile) 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"

[locked_verify_provenance]
default = false
description = "Re-verify provenance at install time even when the lockfile already has provenance."
docs = """
When enabled, `mise install` will re-verify provenance (SLSA, cosign, minisign,
GitHub artifact attestations) at install time even when the lockfile already
contains both a checksum and a provenance entry.

By default, when a lockfile has a checksum and provenance type recorded,
`mise install` trusts the lockfile and skips re-verification to avoid redundant
API calls (e.g., to GitHub). Enabling this setting forces re-verification every
time, which provides stronger security guarantees at the cost of additional
network requests.

This is automatically enabled when `paranoid` is set to `true`.
"""
env = "MISE_LOCKED_VERIFY_PROVENANCE"
type = "Bool"

[lockfile]
description = "Create and read lockfiles for tool versions."
docs = """
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`

When set to `true`, lockfiles are read and written. When set to `false`, lockfiles are explicitly disabled—this
will cause an error if `locked = true` is also set, since locked mode requires reading lockfiles.
When unset (the default), lockfiles are enabled (same as `true`) but there is no conflict with `locked` mode.
"""
env = "MISE_LOCKFILE"
optional = true
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.cflags]
description = "Additional CFLAGS options (e.g., to override -O3)."
env = "MISE_NODE_CFLAGS"
optional = true
type = "String"

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

[node.concurrency]
default_docs = "Number of physical CPUs (unless ninja is enabled)"
description = "How many jobs should be used in compilation."
docs = """
Number of parallel jobs for node compilation. Defaults to the number of physical CPU cores when using make. When ninja is enabled, this defaults to unset (ninja handles concurrency automatically).
"""
env = "MISE_NODE_CONCURRENCY"
optional = true
type = "Integer"

[node.configure_opts]
description = "Additional ./configure options."
env = "MISE_NODE_CONFIGURE_OPTS"
optional = true
type = "String"

[node.corepack]
description = "Installs the default corepack shims after installing any node version."
env = "MISE_NODE_COREPACK"
type = "Bool"

[node.default_packages_file]
default_docs = "~/.default-npm-packages"
description = "Path to a file containing default npm packages to install."
docs = """
Path to a file containing packages to install with npm after installing a new Node.js version.
Defaults to `~/.default-npm-packages`. Also checks `~/.default-nodejs-packages` and `~/.default-node-packages` for backwards compatibility.

Format: one package per line, with optional version specifier:
```
lodash
typescript@latest
@types/node@^20
```
"""
env = "MISE_NODE_DEFAULT_PACKAGES_FILE"
optional = true
type = "Path"

[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.make]
description = "Make command to use."
env = "MISE_NODE_MAKE"
optional = true
type = "String"

[node.make_install_opts]
description = "Additional make install options."
env = "MISE_NODE_MAKE_INSTALL_OPTS"
optional = true
type = "String"

[node.make_opts]
description = "Additional make options."
env = "MISE_NODE_MAKE_OPTS"
optional = true
type = "String"

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

[node.ninja]
default_docs = "Auto-detected: true if ninja is on PATH"
description = "Use ninja instead of make to compile node."
docs = """
If true, use ninja build system instead of make for faster compilation.
Defaults to true if `ninja` is found on PATH, false otherwise.

Ninja is generally faster than make for incremental builds.
"""
env = "MISE_NODE_NINJA"
optional = true
type = "Bool"

[node.nodenv_root]
default = "~/.nodenv"
description = "Directory for nodenv."
env = "NODENV_ROOT"
type = "Path"

[node.nvm_dir]
default = "~/.nvm"
description = "Directory for nvm."
env = "NVM_DIR"
type = "Path"

[node.verify]
default = true
description = "Verify the downloaded assets using GPG."
env = "MISE_NODE_VERIFY"
type = "Bool"

[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.
"""
enum = ["npm", "bun", "pnpm"]
env = "MISE_NPM_PACKAGE_MANAGER"
rust_type = "NpmPackageManager"
type = "String"

[offline]
description = "Disable all HTTP requests. Tools will only use locally cached data."
docs = """
When enabled, mise will never make HTTP requests. This is useful for air-gapped environments,
VPN issues, or when you want to ensure mise only uses locally cached data.

Note: Commands like `hook-env`, `activate`, `exec`, `env`, and shims already avoid most network
requests via the `prefer_offline` behavior. Set `offline = true` to completely block all
HTTP requests for commands like `mise install` or `mise ls-remote` as well.

Can also be set with the `--offline` CLI flag.
"""
env = "MISE_OFFLINE"
type = "Bool"

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

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

[prefer_offline]
description = "Prefer locally cached data over remote fetches when possible."
docs = """
When enabled, mise will prefer locally cached data and avoid remote version fetching when
possible. Unlike `offline`, this still allows network requests as a fallback.

This is automatically enabled for fast commands like `hook-env`, `activate`, `exec`, `env`,
`ls`, `current`, `where`, and shims.
"""
env = "MISE_PREFER_OFFLINE"
type = "Bool"

[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.github_attestations]
description = "Enable GitHub Artifact Attestations verification for precompiled Python binaries."
docs = """
Override the global `github_attestations` setting for Python precompiled binaries.
When enabled, mise will verify the authenticity of precompiled Python binaries from astral-sh/python-build-standalone.

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

[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 = '"x86_64_v3" | "aarch64"'
description = "Specify the architecture 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_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 = '"apple-darwin" | "unknown-linux-gnu" | "unknown-linux-musl"'
description = "Specify the OS to use for precompiled binaries."
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]
default = false
description = "Integrate with uv to manage project venvs when uv.lock is present."
docs = """
Controls how mise handles uv project venvs when a uv.lock file is present.

The legacy `true` value (will be deprecated in a future release) is treated like "create|source", with one difference:
When using this, mise also exports `UV_PYTHON` to force uv to use the python version managed by mise.
"""
enum = [
  { value = false, description = "disable uv venv integration" },
  { value = "source", description = "only source an existing `.venv`" },
  { value = "create|source", description = "create the venv if missing and source it" },
  { value = true, description = "(create|source) with UV_PYTHON export (legacy)" },
]
env = "MISE_PYTHON_UV_VENV_AUTO"
rust_type = "PythonUvVenvAuto"
type = "BoolOrString"

[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_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"

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

[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 = "Set to true to compile ruby from source, false to use precompiled binaries."
docs = """
Controls whether Ruby is compiled from source or downloaded as precompiled binaries.

- If `false`: Try precompiled binaries first, fall back to compiling if unavailable
- If `true`: Always compile from source using ruby-build
- If unset: Defaults to compiling from source (will change to precompiled in 2026.8.0). Note: if `experimental = true`, precompiled binaries are used when unset.
"""
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.github_attestations]
description = "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.

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

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

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

[ruby.precompiled_url]
default = "jdx/ruby"
description = "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.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.default_host]
description = "Default host triple to pass to `rustup init` via `--default-host`."
env = "MISE_RUST_DEFAULT_HOST"
optional = true
type = "String"

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

[shared_install_dirs]
description = "[experimental] Additional read-only directories to search for installed tool versions."
docs = """
A list of additional directories to search for installed tool versions. These directories
are checked after the primary install directory (`~/.local/share/mise/installs`) when
looking for installed tools. They are read-only—mise will never install tools into these
directories.

The system directory `/usr/local/share/mise/installs` (or `MISE_SYSTEM_DATA_DIR/installs`) is
always checked automatically when it exists—you do not need to add it here. To populate it,
run: `mise install --system node@20`

This is useful for shared environments like Docker containers or bastion hosts where a
base set of tools is pre-installed in a shared location, and users can install additional
tools in their own directory.

Paths are colon-separated when using the environment variable.
"""
env = "MISE_SHARED_INSTALL_DIRS"
optional = true
parse_env = "list_by_colon"
rust_type = "Vec<PathBuf>"
type = "ListPath"

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

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

[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_prepare_stale]
default = true
description = "Show warning when prepare providers have stale dependencies."
env = "MISE_STATUS_SHOW_PREPARE_STALE"
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.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.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"

[task.output]
description = "Change output style when executing tasks."
docs = """
Change output style when executing tasks. This controls the output of `mise run`.
"""
enum = [
  { value = "prefix", description = "(default if jobs > 1) print by line with the prefix of the task name" },
  { value = "interleave", description = "(default if jobs == 1 or all tasks run sequentially) print output as it comes in" },
  { value = "keep-order", description = "stream one task's output live while buffering others, printing in definition order as tasks complete" },
  { value = "replacing", description = "replace stdout each time a line is printed-this uses similar logic as `mise install`" },
  { value = "timed", description = "only show stdout lines that take longer than 1s to complete" },
  { value = "quiet", description = "print only stdout/stderr from tasks and nothing from mise" },
  { value = "silent", description = "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.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"

[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.source_freshness_equal_mtime_is_fresh]
default = false
description = "When source mtime equals output mtime, consider sources fresh (use <=). Default false uses strict < comparison."
env = "MISE_TASK_SOURCE_FRESHNESS_EQUAL_MTIME_IS_FRESH"
type = "Bool"

[task.source_freshness_hash_contents]
default = false
description = "Use content hashing (blake3) instead of metadata for source freshness. More accurate but slower."
env = "MISE_TASK_SOURCE_FRESHNESS_HASH_CONTENTS"
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_disable_paths]
deprecated = "Use task.disable_paths instead."
deprecated_remove_at = "2027.2.0"
deprecated_warn_at = "2026.8.0"
description = "Paths that mise will not look for tasks in."
hide = true
optional = true
rust_type = "BTreeSet<PathBuf>"
type = "ListPath"

[task_output]
deprecated = "Use task.output instead."
deprecated_remove_at = "2027.2.0"
deprecated_warn_at = "2026.8.0"
description = "Change output style when executing tasks."
hide = true
optional = true
rust_type = "crate::task::TaskOutput"
type = "String"

[task_remote_no_cache]
deprecated = "Use task.remote_no_cache instead."
deprecated_remove_at = "2027.2.0"
deprecated_warn_at = "2026.8.0"
description = "Mise will always fetch the latest tasks from the remote, by default the cache is used."
hide = true
optional = true
type = "Bool"

[task_run_auto_install]
deprecated = "Use task.run_auto_install instead."
deprecated_remove_at = "2027.2.0"
deprecated_warn_at = "2026.8.0"
description = "Automatically install missing tools when executing tasks."
hide = true
optional = true
type = "Bool"

[task_show_full_cmd]
deprecated = "Use task.show_full_cmd instead."
deprecated_remove_at = "2027.2.0"
deprecated_warn_at = "2026.8.0"
description = "Disable truncation of command lines in task execution output. When true, the full command line will be shown."
hide = true
optional = true
type = "Bool"

[task_skip]
deprecated = "Use task.skip instead."
deprecated_remove_at = "2027.2.0"
deprecated_warn_at = "2026.8.0"
description = "Tasks to skip when running `mise run`."
hide = true
optional = true
rust_type = "BTreeSet<String>"
type = "SetString"

[task_skip_depends]
deprecated = "Use task.skip_depends instead."
deprecated_remove_at = "2027.2.0"
deprecated_warn_at = "2026.8.0"
description = "Run only specified tasks skipping all dependencies."
hide = true
optional = true
type = "Bool"

[task_timeout]
deprecated = "Use task.timeout instead."
deprecated_remove_at = "2027.2.0"
deprecated_warn_at = "2026.8.0"
description = "Default timeout for tasks. Can be overridden by individual tasks."
hide = true
optional = true
type = "Duration"

[task_timings]
deprecated = "Use task.timings instead."
deprecated_remove_at = "2027.2.0"
deprecated_warn_at = "2026.8.0"
description = "Show completion message with elapsed time for each task on `mise run`. Default shows when output type is `prefix`."
hide = true
optional = true
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"

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

[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 = "exe"
description = "Shim file mode for Windows. Options: `exe`, `file`, `hardlink`, `symlink`."
docs = """
* values:
  * `exe`: Copies a native executable shim (`mise-shim.exe`) as `<tool>.exe`. Recommended. Works with all shells, package managers, and `where.exe`. Requires `mise-shim.exe` alongside `mise.exe`.
  * `file`: Creates a `.cmd` batch file shim and an extensionless bash script for Git Bash/Cygwin.
  * `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"
