# mise-en-place

> Dev tools, env vars, and tasks in one CLI

## Start here

- [Getting started](https://mise.jdx.dev/getting-started.html): Install mise, then give a project its own Node.js version, an environment variable and a task. Steps 1 to 3 work without changing your shell configuration; step 4 adds optional shell activation.
- [Installing mise](https://mise.jdx.dev/installing-mise.html): Pick an installation method for your platform, check the executable, then set up your shell. For a guided first project, see Getting started.
- [Shell setup](https://mise.jdx.dev/shell-setup.html): Shell activation hooks your interactive shell so that the current project's tools are on PATH and its environment variables are set each time you change directories or a prompt appears.
- [Existing projects](https://mise.jdx.dev/walkthrough.html): Bring mise into a project you already work on: declare its tools, keep personal settings out of the shared config, share the setup with your team, and run the project's commands through mise.
- [Editors and IDEs](https://mise.jdx.dev/ide-integration.html): An editor's integrated terminal, language servers, debugger and extensions can each run with a different environment. Find out which process needs the tool or variable, then pick an integration.
- [Continuous integration](https://mise.jdx.dev/continuous-integration.html): Use the same mise.toml in CI and development so both environments select the same tools. Run commands with mise exec or mise run to load those tools and the project's environment variables.
- [Docker](https://mise.jdx.dev/mise-cookbook/docker.html): Run mise in a container in one of two ways: build on the -debian image, which has mise, curl and git ready for CI jobs and development containers, or copy the static binary from the scratch image into…
- [AI assistants (MCP)](https://mise.jdx.dev/mcp.html): mise mcp runs a Model Context Protocol server that lets an AI assistant read a project's tools, tasks, environment variables and config files, and run its tasks.

## Dev tools

- [Overview](https://mise.jdx.dev/dev-tools/): mise installs tools such as Node.js, Python, and Go, and selects their versions for each project. Declare the versions a project uses in mise.toml, and mise puts them on PATH while you work in that…
- [Version requests and version files](https://mise.jdx.dev/dev-tools/versions.html): A version request is the value you give a tool in mise.toml, such as "24" in node = "24". mise resolves each request to a concrete version when it runs; record the resolved versions in a lockfile when…
- [Registry](https://mise.jdx.dev/registry.html): The registry maps short tool names such as jq or aws-cli to the backends that install them, so mise use jq works without a full backend identifier.
- [Backends](https://mise.jdx.dev/dev-tools/backends/): A backend is the source mise installs a tool from. It lists the tool's versions, downloads or builds the version you ask for, and tells mise where the executables are.
- [aqua](https://mise.jdx.dev/dev-tools/backends/aqua.html): The aqua backend installs prebuilt release binaries using package recipes from the aqua registry, for example aqua:hashicorp/terraform.
- [asdf (legacy)](https://mise.jdx.dev/dev-tools/backends/asdf.html): The asdf backend installs tools with asdf plugins: Git repositories of shell scripts that list a tool's versions and install them. Use it when an existing plugin does something no other backend can.
- [cargo](https://mise.jdx.dev/dev-tools/backends/cargo.html): The cargo backend installs Rust command-line tools from crates.io or a Git repository. It downloads a prebuilt binary when cargo-binstall can find one and builds the crate with Cargo otherwise.
- [conda](https://mise.jdx.dev/dev-tools/backends/conda.html): The conda backend installs command-line packages and their dependencies from conda-forge or another conda channel.
- [dotnet](https://mise.jdx.dev/dev-tools/backends/dotnet.html): The dotnet backend installs .NET command-line tool packages from NuGet with dotnet tool install. The unprefixed dotnet tool installs the SDK itself; see the .NET guide for SDK versions and…
- [forgejo](https://mise.jdx.dev/dev-tools/backends/forgejo.html): The forgejo backend installs a tool from the release assets of a Forgejo repository. It uses Codeberg unless you set api_url for another Forgejo or Gitea server.
- [gem](https://mise.jdx.dev/dev-tools/backends/gem.html): The gem backend installs Ruby command-line applications from RubyGems, or another gem registry, with gem install. Each tool gets its own directory.
- [github](https://mise.jdx.dev/dev-tools/backends/github.html): The github backend installs a tool from the files attached to a GitHub repository's releases. mise picks the asset for your OS and architecture, verifies it, and extracts it.
- [gitlab](https://mise.jdx.dev/dev-tools/backends/gitlab.html): The gitlab backend installs a tool from the files linked in a GitLab project's releases, on gitlab.com or a self-managed instance.
- [go](https://mise.jdx.dev/dev-tools/backends/go.html): The go backend builds Go command-line packages with go install. Use the import path of the executable package, which may end in /cmd/<name> or include a major-version suffix such as /v4.
- [http](https://mise.jdx.dev/dev-tools/backends/http.html): The http backend installs a binary, script or archive from a download URL. Use it when a tool has no release backend, or for artifacts you host yourself.
- [npm](https://mise.jdx.dev/dev-tools/backends/npm.html): The npm backend installs command-line packages from npm registries, each into its own directory. It installs them with mise's embedded aube package manager, so you need Node.js only to run the tools.
- [packslip](https://mise.jdx.dev/dev-tools/backends/packslip.html): The packslip: backend installs tools from release manifests that their publishers sign with packslip. mise verifies the publisher and the download, picks the build for your platform, and installs its…
- [Verification and policy](https://mise.jdx.dev/dev-tools/packslip-verification.html): The packslip backend uses signed metadata to find releases, verify the publisher, and pick a build for your platform, and mise self-update uses the same checks for mise itself.
- [Man pages, completions, and skills](https://mise.jdx.dev/dev-tools/packslip-resources.html): Tools installed with the packslip backend can ship man pages, shell completions, and agent skills that follow the tool version active in each project.
- [pypi](https://mise.jdx.dev/dev-tools/backends/pypi.html): The pypi backend installs Python command-line applications from PyPI or a Git repository, each into its own virtual environment with its own dependencies.
- [s3](https://mise.jdx.dev/dev-tools/backends/s3.html): The s3 backend installs a binary or archive from Amazon S3 or S3-compatible storage such as MinIO. Use it when access should follow your AWS credentials, or when versions come from listing a bucket;…
- [spinel (experimental)](https://mise.jdx.dev/dev-tools/backends/spinel.html): The spinel backend compiles a Ruby command-line tool from a GitHub repository into a native executable with Spinel, Matz's Ruby ahead-of-time compiler.
- [spm](https://mise.jdx.dev/dev-tools/backends/spm.html): The spm backend installs command-line executables from Swift Package Manager packages hosted on GitHub or GitLab.
- [ubi (deprecated)](https://mise.jdx.dev/dev-tools/backends/ubi.html): The ubi backend installed single executables from GitHub and GitLab releases with the ubi library. It is deprecated: move each ubi: tool to the github, gitlab or http backend.
- [vfox](https://mise.jdx.dev/dev-tools/backends/vfox.html): The vfox backend runs vfox plugins: Lua plugins that list a tool's versions and install it. The Lua runtime is built into mise, so vfox plugins can run on Windows as well as Linux and macOS.
- [Shims](https://mise.jdx.dev/dev-tools/shims.html): A shim is a small executable named after a tool's command, such as node. When a program runs it, the shim asks mise which version the current directory selects, loads that project's environment, and…
- [Tool aliases](https://mise.jdx.dev/dev-tools/aliases.html): Use [tool_alias] to point a tool name at a different backend or to give a version request a name. Put shared aliases in the project's mise.toml, so teammates get the alias along with the tool…
- [Tool stubs](https://mise.jdx.dev/dev-tools/tool-stubs.html): A tool stub is an executable file that records how to get and run one tool. Commit it to a repository so that a command such as ./bin/py runs the intended version and passes its arguments along.
- [Lockfile (mise.lock)](https://mise.jdx.dev/dev-tools/mise-lock.html): mise.lock records the exact versions that the requests in mise.toml resolved to, with download URLs and checksums where the backend provides them.
- [mise.lock reference](https://mise.jdx.dev/dev-tools/mise-lock-reference.html): mise.lock is a TOML file that mise lock and other lockfile-aware commands write. Generate entries with mise lock rather than writing them by hand.
- [Git provider tokens](https://mise.jdx.dev/dev-tools/github-tokens.html): mise reads public GitHub release metadata through mise-versions, so most installs need no token. Set one when mise calls a forge's API itself: for private repositories, GitHub Enterprise, self-managed…
- [System installs](https://mise.jdx.dev/dev-tools/system-installs.html): Use a system install when several user accounts, or a container image built as root, should share one copy of a tool.
- [OCI images (experimental)](https://mise.jdx.dev/dev-tools/mise-oci.html): mise oci build packages the tools a project's mise.toml declares into a container image with one OCI layer per tool, so changing one tool's version rebuilds only that tool's layer.
- [Identity install layout (experimental)](https://mise.jdx.dev/dev-tools/install-layout.html): By default, mise installs a tool into installs/<tool>/<version>, the legacy layout. That path cannot say which backend produced the files, which platform build they are, or which install options were…
- [Migrating from asdf](https://mise.jdx.dev/dev-tools/comparison-to-asdf.html): mise reads .tool-versions files and can run asdf plugins, so you can move one project at a time while teammates keep using asdf.

## Languages

- [Core tools overview](https://mise.jdx.dev/core-tools.html): Core tools are languages whose installers are built into mise, so they need no plugin. Each guide covers platform support, how mise installs the language, version files, and language-specific options.
- [Bun](https://mise.jdx.dev/lang/bun.html): mise installs Bun release binaries, including bunx, and selects a version per project.
- [Deno](https://mise.jdx.dev/lang/deno.html): mise installs Deno release binaries and selects a version per project.
- [.NET](https://mise.jdx.dev/lang/dotnet.html): mise installs .NET SDKs, or only a .NET runtime, with Microsoft's dotnet-install script. By default all SDKs share one DOTNET_ROOT, and .NET picks an SDK using the project's global.json.
- [Elixir](https://mise.jdx.dev/lang/elixir.html): mise installs precompiled Elixir releases from Hex. Elixir runs on Erlang/OTP, so install Erlang as well.
- [Erlang](https://mise.jdx.dev/lang/erlang.html): mise installs Erlang/OTP from a precompiled build when one exists for your platform and compiles it from source with kerl otherwise.
- [Go](https://mise.jdx.dev/lang/go.html): mise installs the official Go distributions and sets GOROOT and GOBIN for the selected version.
- [Java](https://mise.jdx.dev/lang/java.html): mise installs JDKs from many vendors and sets JAVA_HOME to the one your project selects.
- [Node.js](https://mise.jdx.dev/lang/node.html): mise installs Node.js from the official nodejs.org builds and selects a version per project. It can also read .nvmrc, .node-version and package.json, so projects set up for other version managers keep…
- [Python](https://mise.jdx.dev/lang/python.html): mise installs Python from precompiled python-build-standalone builds, or with python-build, and selects a version per project. It can also create and activate a project virtualenv, with or without uv.
- [Ruby](https://mise.jdx.dev/lang/ruby.html): mise installs Ruby from precompiled binaries where they exist and compiles it with ruby-build otherwise. On Windows it installs RubyInstaller2 builds.
- [Rust](https://mise.jdx.dev/lang/rust.html): mise installs Rust toolchains through rustup, installing rustup first if needed, and sets RUSTUP_TOOLCHAIN so cargo and rustc use the toolchain your config selects.
- [Swift](https://mise.jdx.dev/lang/swift.html): mise installs the Swift toolchains published on swift.org for macOS and Linux. Windows is not supported.
- [Zig](https://mise.jdx.dev/lang/zig.html): mise installs Zig from ziglang.org or its community mirrors and verifies each download against the Zig Software Foundation's signing key.

## Environments

- [Environment variables](https://mise.jdx.dev/environments/): Set project environment variables under [env] in mise.toml. mise applies them to commands run with mise exec, to tasks, to shims, and to shells where mise is activated.
- [Secrets](https://mise.jdx.dev/environments/secrets/): Keep secret values out of plaintext config. mise can fetch them from a secret manager through fnox, or decrypt files and values that you commit, and it masks values you mark as sensitive in the output…
- [fnox (experimental)](https://mise.jdx.dev/environments/secrets/fnox.html): fnox can supply a project's secrets. A task lists the keys it needs in secrets = [...]. Just before the task starts, mise fetches those values from fnox, passes them to that task only as environment…
- [SOPS files](https://mise.jdx.dev/environments/secrets/sops.html): Commit a SOPS-encrypted .env.json, .env.yaml or .env.toml file and load it with env._.file. mise decrypts it each time it loads the environment.
- [age values (experimental)](https://mise.jdx.dev/environments/secrets/age.html): Store individual secrets in mise.toml as age encrypted values. mise encrypts and decrypts them itself, so you need only an age identity or an SSH key.
- [Shell aliases](https://mise.jdx.dev/shell-aliases.html): Define shell aliases in mise.toml. In a Bash, Zsh or Fish shell where mise is activated, mise sets them when you enter the directory and removes them when you leave.
- [Hooks](https://mise.jdx.dev/hooks.html): Hooks run commands when something happens: a shell with mise activate changes directory (including entering or leaving a project) or detects a change to a watched file, or mise installs tools.
- [Migrating from direnv](https://mise.jdx.dev/direnv.html): mise sets environment variables, loads dotenv files and adds PATH entries when you enter a directory, so a project that uses direnv for those things can drop it.

## Tasks

- [Overview](https://mise.jdx.dev/tasks/): A task is a named command or script that runs with your project's tools and environment variables. Use tasks for builds, tests, linters, development servers, and other commands that teammates and CI…
- [TOML tasks](https://mise.jdx.dev/tasks/toml-tasks.html): Define a task in mise.toml when its command fits on a line or two, or when it mostly runs other tasks. Move longer scripts to file tasks so your editor can highlight and lint them.
- [File tasks](https://mise.jdx.dev/tasks/file-tasks.html): A file task is an executable script in a task directory. Its path is the task name, and #MISE comments at the top hold its configuration.
- [Task arguments](https://mise.jdx.dev/tasks/task-arguments.html): Define arguments when a task needs named inputs, validation, --help output, or shell completions. mise parses the command line against the task's usage spec and passes each value to the script as a…
- [Running tasks](https://mise.jdx.dev/tasks/running-tasks.html): Run a task with mise run. mise loads the task's tools and environment, runs its dependencies first, and runs independent tasks in parallel.
- [Task discovery and precedence](https://mise.jdx.dev/tasks/task-discovery.html): mise collects tasks from config files, from task files you include, and from executable scripts in task directories, in the current directory and each of its parents.
- [Dependencies and execution order](https://mise.jdx.dev/tasks/architecture.html): When you run a task, mise builds a graph of that task and everything it depends on, then starts each task as soon as its prerequisites succeed, up to the job limit.
- [Task templates](https://mise.jdx.dev/tasks/templates.html): Define a task template when several tasks share commands, tools, environment variables, or dependencies. Each task names its template with extends and sets only what differs.
- [Task caching](https://mise.jdx.dev/tasks/caching.html): mise can skip a task whose inputs have not changed in two ways. Freshness checks compare file modification times and need only sources and outputs.
- [Remote task cache](https://mise.jdx.dev/tasks/remote-cache.html): A remote cache lets CI jobs and developer machines reuse each other's task results. mise looks up entries on the server when the local artifact cache misses, and uploads new results from trusted CI…
- [Remote cache protocol](https://mise.jdx.dev/tasks/remote-cache-protocol.html): This page specifies version 1 of the protocol between mise and a remote task cache. It is for people who implement a cache server or client. To use a remote cache, see Remote task cache.
- [Monorepo tasks](https://mise.jdx.dev/tasks/monorepo.html): Use monorepo mode when one repository holds several projects that each need their own tools, environment variables, or tasks. Mark the root config as a monorepo root and list the project directories.
- [Workspace project graph (experimental)](https://mise.jdx.dev/tasks/workspace-graph.html): mise can read Cargo, uv, Go, and Node.js workspace manifests to learn which projects a monorepo contains and how they depend on each other.
- [Project dependencies (experimental)](https://mise.jdx.dev/dev-tools/deps.html): mise deps installs a project's packages, such as node_modules or a Python virtual environment, by running the package manager's install command when the files it tracks change or its outputs go…
- [OpenTelemetry (experimental)](https://mise.jdx.dev/tasks/opentelemetry.html): mise can export a trace of each mise run to any backend that accepts OTLP over HTTP, such as Jaeger, Grafana Tempo, or SigNoz.
- [Task configuration reference](https://mise.jdx.dev/tasks/task-configuration.html): Find every property a task accepts, the [task_config] options that set defaults for a config root, the environment variables mise gives each task, and the settings that change how tasks run.

## Daemons (experimental)

- [Overview](https://mise.jdx.dev/daemons.html): A daemon is a process that keeps running between commands, such as a database, a message broker, or a development server.
- [Set up a development stack](https://mise.jdx.dev/daemons/development-stack.html): This guide sets up a Node.js API and its PostgreSQL database so that opening https://api.shop.localhost starts both, each Git worktree gets its own database and URL, and idle stacks stop on their own.…
- [Service presets](https://mise.jdx.dev/daemons/presets.html): A service preset runs a common server for local development. It supplies the command, the tool to install, a readiness check, a data directory, and the connection variables your application reads.
- [Ports, URLs, and worktrees](https://mise.jdx.dev/daemons/worktrees.html): Run the same daemons in several Git worktrees of one project at once. Each checkout gets its own daemon IDs, ports, and data, and pitchfork's proxy gives each HTTP daemon a hostname that stays the…
- [Share daemons across projects](https://mise.jdx.dev/daemons/sharing.html): A project reference runs a daemon that another repository declares, as one process for every project that uses it.
- [Data and cleanup](https://mise.jdx.dev/daemons/data.html): By default, mise keeps each project's daemon state and preset data outside the project, under $MISE_STATE_DIR/daemons/, and never deletes it on its own.

## Bootstrap

- [Overview](https://mise.jdx.dev/bootstrap.html): mise bootstrap sets up a machine from your mise configuration: host packages, system files, services, Git repositories, dotfiles, shell activation, tools, and your bootstrap task.
- [Set up a machine](https://mise.jdx.dev/bootstrap/setup.html): This tutorial takes one machine from a single tracked file to a declared setup, then brings a second machine to the same state with one command. You keep editing your files where they are.
- [Bootstrap from a repository](https://mise.jdx.dev/bootstrap/from-repository.html): mise bootstrap can clone a repository and run from the configuration in it. Use --from for a bootstrap project that lives apart from your global config, and --adopt to make a repository your global…
- [Machine modules](https://mise.jdx.dev/bootstrap/modules.html): A module is a config environment file that holds one piece of machine setup, such as SSH or GPG, with its packages, dotfiles, and services together.
- [Remote hosts](https://mise.jdx.dev/bootstrap/remote.html): mise bootstrap remote sends a bootstrap project to other machines over SSH, stages mise on each one, and runs mise bootstrap there.
- [GitHub relay (mise ssh)](https://mise.jdx.dev/bootstrap/github-relay.html): mise ssh opens an SSH session like ssh. With --github-relay-read-only, Git and mise on the remote host can read the private GitHub repositories you name, using this machine's GitHub credentials, until…
- [Packages](https://mise.jdx.dev/bootstrap/packages/): [bootstrap.packages] declares machine-wide software, such as native libraries, build dependencies, and desktop apps, and installs it with the host's package managers.
- [apk](https://mise.jdx.dev/bootstrap/packages/apk.html): The apk manager installs Alpine Linux packages with apk add. It uses sudo when mise is not running as root.
- [apt](https://mise.jdx.dev/bootstrap/packages/apt.html): The apt manager installs packages on Debian, Ubuntu, and other Debian-based distributions with apt-get. It checks installed state with dpkg-query and uses sudo when mise is not running as root.
- [aur](https://mise.jdx.dev/bootstrap/packages/aur.html): The aur manager builds and installs packages from the Arch User Repository with the yay or paru helper. For packages from the official Arch repositories, use pacman.
- [brew](https://mise.jdx.dev/bootstrap/packages/brew.html): The brew manager installs Homebrew formulae into the standard Homebrew prefix. mise downloads and installs them itself, so Homebrew does not need to be installed, and an existing Homebrew installation…
- [brew-cask](https://mise.jdx.dev/bootstrap/packages/brew-cask.html): The brew-cask manager installs Homebrew casks, mostly macOS apps and fonts, without Homebrew. mise reads each cask from Homebrew's API, downloads its artifact, checks the sha256 when the cask provides…
- [dnf](https://mise.jdx.dev/bootstrap/packages/dnf.html): The dnf manager installs packages on Fedora, RHEL, CentOS Stream, Rocky Linux, AlmaLinux, and other distributions that use dnf. It uses sudo when mise is not running as root.
- [flatpak](https://mise.jdx.dev/bootstrap/packages/flatpak.html): The flatpak manager installs Flatpak apps and runtimes into the system-wide installation, and flatpak-user installs them for the current user. Both use the flatpak command.
- [macos-app](https://mise.jdx.dev/bootstrap/packages/macos-app.html): The macos-app manager installs an app bundle from a download you declare, for a vendor or internal app that has no Homebrew cask.
- [mas](https://mise.jdx.dev/bootstrap/packages/mas.html): The mas manager installs Mac App Store apps with the mas command. Each package name is the app's numeric App Store ID, such as 497799835 for Xcode.
- [nix](https://mise.jdx.dev/bootstrap/packages/nix.html): The nix manager installs packages into your user's Nix profile with nix profile install. It works on Linux and macOS, on NixOS or not.
- [pacman](https://mise.jdx.dev/bootstrap/packages/pacman.html): The pacman manager installs and removes packages on Arch Linux, Manjaro, EndeavourOS, and other Arch-based distributions. It uses sudo when mise is not running as root. For AUR packages, use aur.
- [scoop](https://mise.jdx.dev/bootstrap/packages/scoop.html): The scoop manager installs, pins, and removes Windows apps with Scoop in your user scope.
- [winget](https://mise.jdx.dev/bootstrap/packages/winget.html): The winget manager installs and upgrades Windows packages with the Windows Package Manager, winget.
- [zypper](https://mise.jdx.dev/bootstrap/packages/zypper.html): The zypper manager installs and removes packages on openSUSE and SUSE Linux Enterprise with zypper. It uses sudo when mise is not running as root.
- [Package manager plugins](https://mise.jdx.dev/bootstrap/packages/plugins.html): Package manager plugins add managers to [bootstrap.packages] for machine-wide state that another program owns, such as VS Code extensions, Helm plugins, krew plugins, and GitHub CLI extensions.
- [Linux users and groups](https://mise.jdx.dev/bootstrap/accounts.html): [bootstrap.groups] and [bootstrap.users] declare local Linux accounts, such as a service user and its groups.
- [System files and directories](https://mise.jdx.dev/bootstrap/files.html): Use [bootstrap.files] and [bootstrap.directories] for paths that need specific content, an owner, a group, or a mode, such as configuration under /etc or a service's data directory.
- [Secret inputs](https://mise.jdx.dev/bootstrap/secrets.html): [bootstrap.secrets] names the secret values your bootstrap needs, such as tokens and passwords, without storing them in mise configuration.
- [Services](https://mise.jdx.dev/bootstrap/services.html): Use [bootstrap.services] to keep a program running in the background as your user on Linux, macOS, and Windows, or to start, stop, and enable the Linux systemd units that a package installed.
- [Linux firewall](https://mise.jdx.dev/bootstrap/firewall.html): Declare a Linux host firewall in [bootstrap.linux.firewall] and mise applies it with nftables, firewalld, or UFW.
- [Docker Compose projects](https://mise.jdx.dev/bootstrap/compose.html): Use [bootstrap.compose] to keep a Docker Compose project running, stopped, or removed on a host. The same config can install Docker and write the project's files, which suits self-hosted services.
- [Git repositories](https://mise.jdx.dev/bootstrap/repos.html): Declare Git checkouts in [bootstrap.repos], keyed by where each one should live. mise bootstrap clones missing ones before it applies dotfiles, so a new machine can clone your dotfiles repository and…
- [Shell activation and login shell](https://mise.jdx.dev/bootstrap/shell.html): [bootstrap.mise_shell_activate] writes mise activation into your shell startup files, and [bootstrap.user] sets your login shell.
- [macOS defaults](https://mise.jdx.dev/bootstrap/macos-defaults.html): Declare macOS preferences in mise.toml, and mise bootstrap, or mise bootstrap macos defaults apply, writes them the way the defaults command does.
- [macOS LaunchAgents](https://mise.jdx.dev/bootstrap/launchd.html): Declare LaunchAgents for your macOS user in [bootstrap.macos.launchd.agents]. mise bootstrap, or mise bootstrap macos launchd-agents apply, writes each agent to…
- [systemd user units](https://mise.jdx.dev/bootstrap/systemd.html): Declare systemd user services and timers in [bootstrap.linux.systemd.units]. mise bootstrap, or mise bootstrap linux systemd-units apply, writes each to ~/.config/systemd/user/dev.mise.<name>.service…

## Dotfiles

- [Overview](https://mise.jdx.dev/dotfiles.html): mise saves the history of the configuration files you edit in place, or deploys them from a dotfiles repository as links, copies, and templates.
- [Managed files](https://mise.jdx.dev/dotfiles/managed.html): A managed file is a target that mise creates from a source you maintain: a link to the source, a copy of it, a rendered template, or content written in the config itself.
- [Groups](https://mise.jdx.dev/dotfiles/groups.html): A group is a named directory tree of dotfiles, such as one per application or one per machine role. mise deploys every file in the tree without a list of entries, and each machine chooses which groups…
- [Edit part of a file](https://mise.jdx.dev/dotfiles/edits.html): An edit entry manages one piece of a file and leaves the rest alone: a block between marker comments, a single line, or a few keys of a JSON, TOML, or YAML file.
- [History](https://mise.jdx.dev/dotfiles/history.html): mise saves versions of the files you track in a local Git repository, so you can compare them, restore an earlier version, and undo a change.
- [Sync across machines](https://mise.jdx.dev/dotfiles/sync.html): Connect a private Git repository, called the origin, and mise shares the history of your tracked files with every machine that uses it.
- [Encrypted files](https://mise.jdx.dev/dotfiles/encryption.html): mise can encrypt a tracked file with age before it saves the file to Git, so the history and your origin hold only ciphertext while the file you edit stays readable.
- [Dotfiles reference](https://mise.jdx.dev/dotfiles/reference.html): Look up [dotfiles] entry keys, the keys each mode accepts, variant selectors, pattern syntax, status states, and the state that mise keeps for dotfiles and their history.

## Configuration

- [mise.toml](https://mise.jdx.dev/configuration.html): A project's mise.toml declares the tools, environment variables, and tasks the project needs. mise combines it with your global config and with config files in parent directories.
- [Config environments](https://mise.jdx.dev/configuration/environments.html): A config environment loads extra config files, such as mise.development.toml or mise.production.toml, on top of mise.toml.
- [Settings](https://mise.jdx.dev/configuration/settings.html): Settings change how mise itself behaves, such as how many jobs run at once, how downloads are verified and how tasks print output.
- [Config variables](https://mise.jdx.dev/configuration/vars.html): Define shared values in [vars] and reference them with {{ vars.NAME }} in a Tera template. Use vars for values that mise needs to render config; use [env] for values that commands need as environment…
- [Tera templates](https://mise.jdx.dev/templates.html): mise renders Tera templates in config values, so a value can come from the project directory, the environment, [vars], or a command's output.
- [MISE_* variables](https://mise.jdx.dev/configuration/environment-variables.html): Every setting except the write_targets tables also has a MISE_* environment variable, listed in its entry on the Settings page; for example, MISE_JOBS=4 sets jobs.
- [Directories](https://mise.jdx.dev/directories.html): mise keeps config, installed tools, cache, and machine-local state in separate directories. The defaults below apply when no MISE_*_DIR or XDG_* variable overrides them.
- [Caches](https://mise.jdx.dev/cache-behavior.html): mise caches tool metadata, computed environments, and task results separately. Start with the cache that matches the symptom: clearing a version list does not reinstall a tool, and clearing the…
- [URL replacements](https://mise.jdx.dev/url-replacements.html): The url_replacements setting rewrites the URLs that mise's HTTP client requests, so release metadata and artifact downloads can go through an internal mirror or proxy.
- [Project diagnostics](https://mise.jdx.dev/configuration/project-diagnostics.html): mise doctor project runs the checks a project declares in [doctor.checks] and reports every result. Use it for requirements that tool versions alone do not cover, such as whether a compiler can find a…

## Security

- [Security overview](https://mise.jdx.dev/security.html): Each mise security control covers one stage, from loading a project's config to running the commands it starts.
- [Paranoid mode](https://mise.jdx.dev/paranoid.html): Paranoid mode requires your approval before mise loads any project config file, and again whenever that file changes.
- [Sandboxing](https://mise.jdx.dev/sandboxing.html): mise exec and mise run can limit what the command they start may read, write, reach on the network and see in its environment. Add a --deny-* or --allow-* flag, or set the matching property on a task.

## Plugins

- [Plugins](https://mise.jdx.dev/plugins.html): A plugin is a directory of scripts, usually Lua, that teaches mise to install a tool, set environment variables or manage another program's packages.
- [Tool plugins](https://mise.jdx.dev/tool-plugin-development.html): A tool plugin is a set of Lua hooks that tells mise how to list a tool's versions, download and verify one, and set up its environment.
- [Backend plugins](https://mise.jdx.dev/backend-plugin-development.html): A backend plugin is a set of Lua hooks that installs many tools under one prefix. Users write my-backend:some-tool, where my-backend is the name they installed the plugin under.
- [Environment plugins](https://mise.jdx.dev/env-plugin-development.html): An environment plugin adds a directive to [env] whose Lua hooks return environment variables and PATH entries.
- [Package manager plugins](https://mise.jdx.dev/package-plugin-development.html): A package manager plugin adds a manager to [bootstrap.packages] for packages that belong to another program, such as VS Code extensions, gh extensions or Helm plugins.
- [Plugin Lua reference](https://mise.jdx.dev/plugin-lua-modules.html): mise runs every Lua plugin hook (tool, backend, environment and package plugins) in an embedded Lua 5.1 interpreter.
- [Publishing plugins](https://mise.jdx.dev/plugin-publishing.html): You publish a mise plugin by putting it where users can fetch it: a Git repository pinned by tag, or a signed packslip archive.
- [asdf plugins (legacy)](https://mise.jdx.dev/asdf-legacy-plugins.html): asdf plugins are Git repositories of shell scripts (bin/list-all, bin/install and others) that follow the asdf plugin interface.

## Help

- [Troubleshooting](https://mise.jdx.dev/troubleshooting.html): Fix common problems with shell activation, tool versions, downloads, tasks, and Windows setups, grouped by symptom. To look up a message that mise printed, see Error messages.
- [Error messages](https://mise.jdx.dev/errors.html): Look up a message that mise printed to see what causes it and how to fix it. Problems without a clear message, such as the wrong tool version running, are in Troubleshooting.
- [FAQ](https://mise.jdx.dev/faq.html): If a command fails, see Troubleshooting, or look up the message in Error messages.
- [Glossary](https://mise.jdx.dev/glossary.html): Each term links to the page that explains it.

## Cookbook

- [Cookbook overview](https://mise.jdx.dev/mise-cookbook/): Each recipe gives the config and commands for one kind of project or workflow. Start from the closest one and change its versions, paths and commands to match your project.
- [Tips and tricks](https://mise.jdx.dev/tips-and-tricks.html): Short recipes for everyday mise use. Each one links to the full guide.
- [Bazel](https://mise.jdx.dev/mise-cookbook/bazel.html): Install the Bazel version declared in a project's .bazelversion file, so the version is not repeated in mise.toml.
- [C++ and CMake](https://mise.jdx.dev/mise-cookbook/cpp.html): Pin CMake for a C++ project and run its configure, build and clean steps as tasks. A C or C++ compiler must already be installed, for example through your operating system's development tools;…
- [Neovim](https://mise.jdx.dev/mise-cookbook/neovim.html): Highlight the scripts embedded in mise.toml and the metadata comments in file tasks with Treesitter, then add language-server features to embedded scripts with otter.nvim.
- [Node.js](https://mise.jdx.dev/mise-cookbook/nodejs.html): Pin Node.js and your package manager for a project, and run its package scripts as mise tasks. For installing and selecting Node.js itself, see Node.js.
- [Python](https://mise.jdx.dev/mise-cookbook/python.html): Set up a Python project with mise: a requirements.txt project with a virtualenv, a uv project, or scripts with inline dependencies. For installing Python and the virtualenv settings, see Python.
- [Ruby on Rails](https://mise.jdx.dev/mise-cookbook/ruby.html): Pin Ruby for an existing Rails app from its .ruby-version file, and run the app's Bundler and Rails commands as tasks.
- [Scaffolding tasks](https://mise.jdx.dev/mise-cookbook/presets.html): A scaffolding task is a file task in your global config that sets up a project with mise use and mise tasks add.
- [Terraform and OpenTofu](https://mise.jdx.dev/mise-cookbook/terraform.html): Pin Terraform or OpenTofu for a project and run init, validate, plan and apply as tasks. The recipe assumes a terraform/ directory that holds your configuration, with provider credentials already set…

## About

- [About mise](https://mise.jdx.dev/about.html): mise is pronounced "meez". The name is short for mise-en-place, the French kitchen practice of setting out every ingredient and utensil before you start cooking.
- [Releases](https://mise.jdx.dev/releases.html): mise ships several releases a week, numbered by year and month, such as 2026.10.4. To update, run mise self-update or use the package manager that installed mise; see Updating mise.
- [Contact](https://mise.jdx.dev/contact.html): Report bugs in GitHub Issues and ask questions in GitHub Discussions, where answers stay searchable for other users.
- [Demo](https://mise.jdx.dev/demo.html): This recording runs one-off commands with mise exec, installs global tools with mise use --global, and switches Node.js versions between a global default and a project.
- [mise run: the song](https://mise.jdx.dev/mise-en-place.html): mise run is the mise theme song, and this is its music video. Captions are available from the player. You can also download the video in 1080p or 4K (HEVC), both at 120 fps, or download the MP3.
- [External resources](https://mise.jdx.dev/external-resources.html): Older community posts about mise may use commands or options that have since changed; check the configuration and CLI reference when you adapt them.

## Contributing

- [Contributing](https://mise.jdx.dev/contributing.html): mise welcomes bug fixes, documentation improvements, and registry entries for widely used tools. Agree on the direction of anything larger before you write code.
- [Adding tools to the registry](https://mise.jdx.dev/contributing/registry.html): A registry entry gives a widely used tool a short name, so mise use ripgrep works without a backend identifier.
- [Codebase architecture](https://mise.jdx.dev/architecture.html): Use this map to find the code that owns a behavior before you change it. For setup, checks, and how to submit a change, see Contributing.
- [Packaging mise](https://mise.jdx.dev/packaging.html): A package manager that installs mise should own its updates, so turn off mise self-update in your package and tell users how to update instead.

## CLI reference

- [CLI overview](https://mise.jdx.dev/cli/): Usage: mise [FLAGS] [COMMAND | TASK] [ARGS]…
- [mise activate](https://mise.jdx.dev/cli/activate.html): Print the script to activate mise in an interactive shell
- [mise backends](https://mise.jdx.dev/cli/backends.html): Manage backends
- [mise backends ls](https://mise.jdx.dev/cli/backends/ls.html): List built-in backends
- [mise backends switch](https://mise.jdx.dev/cli/backends/switch.html): Switch tools to the backend the registry now installs them from
- [mise bin-paths](https://mise.jdx.dev/cli/bin-paths.html): List the bin directories of the active tools
- [mise bootstrap](https://mise.jdx.dev/cli/bootstrap.html): Set up this machine from your mise config
- [mise bootstrap accounts](https://mise.jdx.dev/cli/bootstrap/accounts.html): Manage Linux users and groups
- [mise bootstrap accounts apply](https://mise.jdx.dev/cli/bootstrap/accounts/apply.html): Create, update, or remove the configured Linux users and groups
- [mise bootstrap accounts status](https://mise.jdx.dev/cli/bootstrap/accounts/status.html): Show the state of the configured Linux users and groups
- [mise bootstrap compose](https://mise.jdx.dev/cli/bootstrap/compose.html): Manage Docker Compose projects from [bootstrap.compose]
- [mise bootstrap compose apply](https://mise.jdx.dev/cli/bootstrap/compose/apply.html): Apply Docker Compose projects from [bootstrap.compose]
- [mise bootstrap compose status](https://mise.jdx.dev/cli/bootstrap/compose/status.html): Show the state of Docker Compose projects from [bootstrap.compose]
- [mise bootstrap files](https://mise.jdx.dev/cli/bootstrap/files.html): Manage system files and directories declared in [bootstrap]
- [mise bootstrap files apply](https://mise.jdx.dev/cli/bootstrap/files/apply.html): Create, update, or remove the configured system files and directories
- [mise bootstrap files status](https://mise.jdx.dev/cli/bootstrap/files/status.html): Show the state of the configured system files and directories
- [mise bootstrap firewall](https://mise.jdx.dev/cli/bootstrap/firewall.html): Manage the Linux host firewall from [bootstrap.linux.firewall]
- [mise bootstrap firewall apply](https://mise.jdx.dev/cli/bootstrap/firewall/apply.html): Apply the firewall from [bootstrap.linux.firewall]
- [mise bootstrap firewall status](https://mise.jdx.dev/cli/bootstrap/firewall/status.html): Show the state of the firewall from [bootstrap.linux.firewall]
- [mise bootstrap linux](https://mise.jdx.dev/cli/bootstrap/linux.html): Manage systemd user units from [bootstrap.linux.systemd.units]
- [mise bootstrap linux systemd-units](https://mise.jdx.dev/cli/bootstrap/linux/systemd-units.html): Manage systemd user units from [bootstrap.linux.systemd.units]
- [mise bootstrap linux systemd-units apply](https://mise.jdx.dev/cli/bootstrap/linux/systemd-units/apply.html): Install and start the configured systemd user units
- [mise bootstrap linux systemd-units status](https://mise.jdx.dev/cli/bootstrap/linux/systemd-units/status.html): Show the state of the configured systemd user units
- [mise bootstrap macos](https://mise.jdx.dev/cli/bootstrap/macos.html): Manage macOS preferences and LaunchAgents from [bootstrap.macos]
- [mise bootstrap macos defaults](https://mise.jdx.dev/cli/bootstrap/macos/defaults.html): Manage macOS preferences such as Dock, Finder, and keyboard settings
- [mise bootstrap macos defaults apply](https://mise.jdx.dev/cli/bootstrap/macos/defaults/apply.html): Write the configured macOS preferences
- [mise bootstrap macos defaults status](https://mise.jdx.dev/cli/bootstrap/macos/defaults/status.html): Show the state of the configured macOS preferences
- [mise bootstrap macos launchd-agents](https://mise.jdx.dev/cli/bootstrap/macos/launchd-agents.html): Manage macOS LaunchAgents from [bootstrap.macos.launchd.agents]
- [mise bootstrap macos launchd-agents apply](https://mise.jdx.dev/cli/bootstrap/macos/launchd-agents/apply.html): Install and load LaunchAgents from [bootstrap.macos.launchd.agents]
- [mise bootstrap macos launchd-agents status](https://mise.jdx.dev/cli/bootstrap/macos/launchd-agents/status.html): Show the state of the configured LaunchAgents
- [mise bootstrap mise-shell-activate](https://mise.jdx.dev/cli/bootstrap/mise-shell-activate.html): Manage mise shell activation from [bootstrap.mise_shell_activate]
- [mise bootstrap mise-shell-activate apply](https://mise.jdx.dev/cli/bootstrap/mise-shell-activate/apply.html): Write mise activation into the configured shell startup files
- [mise bootstrap mise-shell-activate status](https://mise.jdx.dev/cli/bootstrap/mise-shell-activate/status.html): Show the state of the configured shell activation
- [mise bootstrap packages](https://mise.jdx.dev/cli/bootstrap/packages.html): Manage packages from [bootstrap.packages]
- [mise bootstrap packages apply](https://mise.jdx.dev/cli/bootstrap/packages/apply.html): Install or remove packages to match [bootstrap.packages]
- [mise bootstrap packages brew](https://mise.jdx.dev/cli/bootstrap/packages/brew.html): Manage Homebrew tap URLs in [bootstrap.brew.taps]
- [mise bootstrap packages brew tap](https://mise.jdx.dev/cli/bootstrap/packages/brew/tap.html): Add a Homebrew tap URL to the global [bootstrap.brew.taps]
- [mise bootstrap packages brew untap](https://mise.jdx.dev/cli/bootstrap/packages/brew/untap.html): Remove Homebrew tap URLs from [bootstrap.brew.taps]
- [mise bootstrap packages export](https://mise.jdx.dev/cli/bootstrap/packages/export.html): Print the configured nix: packages as a NixOS module
- [mise bootstrap packages import](https://mise.jdx.dev/cli/bootstrap/packages/import.html): Record installed Homebrew formulae in [bootstrap.packages]
- [mise bootstrap packages prune](https://mise.jdx.dev/cli/bootstrap/packages/prune.html): Uninstall packages that no config declares
- [mise bootstrap packages status](https://mise.jdx.dev/cli/bootstrap/packages/status.html): Show the state of packages from [bootstrap.packages]
- [mise bootstrap packages upgrade](https://mise.jdx.dev/cli/bootstrap/packages/upgrade.html): Upgrade installed packages from [bootstrap.packages]
- [mise bootstrap packages use](https://mise.jdx.dev/cli/bootstrap/packages/use.html): Add packages to [bootstrap.packages] and install them
- [mise bootstrap packages where](https://mise.jdx.dev/cli/bootstrap/packages/where.html): Print the opt path of an installed Homebrew formula
- [mise bootstrap plan](https://mise.jdx.dev/cli/bootstrap/plan.html): Show what applying bootstrap resources would change
- [mise bootstrap plugins](https://mise.jdx.dev/cli/bootstrap/plugins.html): Manage package manager plugins declared in [bootstrap.plugins]
- [mise bootstrap plugins apply](https://mise.jdx.dev/cli/bootstrap/plugins/apply.html): Install package manager plugins declared in [bootstrap.plugins]
- [mise bootstrap plugins status](https://mise.jdx.dev/cli/bootstrap/plugins/status.html): Show whether declared package manager plugins are installed
- [mise bootstrap remote](https://mise.jdx.dev/cli/bootstrap/remote.html): Bootstrap one or more machines over SSH
- [mise bootstrap repos](https://mise.jdx.dev/cli/bootstrap/repos.html): Manage Git repositories from [bootstrap.repos]
- [mise bootstrap repos apply](https://mise.jdx.dev/cli/bootstrap/repos/apply.html): Clone missing Git repositories and check out configured refs
- [mise bootstrap repos exec](https://mise.jdx.dev/cli/bootstrap/repos/exec.html): Run a command in each configured Git repository
- [mise bootstrap repos status](https://mise.jdx.dev/cli/bootstrap/repos/status.html): Show the state of Git repositories from [bootstrap.repos]
- [mise bootstrap repos update](https://mise.jdx.dev/cli/bootstrap/repos/update.html): Clone missing Git repositories and fast-forward the rest
- [mise bootstrap secrets](https://mise.jdx.dev/cli/bootstrap/secrets.html): Inspect bootstrap secret inputs without revealing their values
- [mise bootstrap secrets status](https://mise.jdx.dev/cli/bootstrap/secrets/status.html): Show whether declared bootstrap secret inputs are available
- [mise bootstrap services](https://mise.jdx.dev/cli/bootstrap/services.html): Manage services from [bootstrap.services]
- [mise bootstrap services apply](https://mise.jdx.dev/cli/bootstrap/services/apply.html): Apply the service state declared in [bootstrap.services]
- [mise bootstrap services remove](https://mise.jdx.dev/cli/bootstrap/services/remove.html): Uninstall a user-scope service
- [mise bootstrap services status](https://mise.jdx.dev/cli/bootstrap/services/status.html): Show the state of services from [bootstrap.services]
- [mise bootstrap status](https://mise.jdx.dev/cli/bootstrap/status.html): Show the state of every configured bootstrap part
- [mise bootstrap unapply](https://mise.jdx.dev/cli/bootstrap/unapply.html): Remove what a config environment's bootstrap sections created
- [mise bootstrap user](https://mise.jdx.dev/cli/bootstrap/user.html): Manage your login shell from [bootstrap.user]
- [mise bootstrap user apply](https://mise.jdx.dev/cli/bootstrap/user/apply.html): Set your login shell from [bootstrap.user]
- [mise bootstrap user status](https://mise.jdx.dev/cli/bootstrap/user/status.html): Show whether your login shell matches [bootstrap.user]
- [mise cache](https://mise.jdx.dev/cli/cache.html): Manage the mise cache
- [mise cache clear](https://mise.jdx.dev/cli/cache/clear.html): Delete cached data
- [mise cache path](https://mise.jdx.dev/cli/cache/path.html): Print the cache directory path
- [mise cache prune](https://mise.jdx.dev/cli/cache/prune.html): Remove cache files that have not been accessed recently
- [mise cache task](https://mise.jdx.dev/cli/cache/task.html): [experimental] Inspect artifact cache entries for a task
- [mise completion](https://mise.jdx.dev/cli/completion.html): Generate shell completions
- [mise config](https://mise.jdx.dev/cli/config.html): Manage config files
- [mise config get](https://mise.jdx.dev/cli/config/get.html): Print a value from one mise TOML file
- [mise config ls](https://mise.jdx.dev/cli/config/ls.html): List config files currently in use, from lowest to highest precedence
- [mise config set](https://mise.jdx.dev/cli/config/set.html): Set a value in one mise TOML file
- [mise daemons](https://mise.jdx.dev/cli/daemons.html): [experimental] Manage project daemons with pitchfork
- [mise daemons logs](https://mise.jdx.dev/cli/daemons/logs.html): [experimental] Show the output of project daemons
- [mise daemons ls](https://mise.jdx.dev/cli/daemons/ls.html): [experimental] List project daemons
- [mise daemons providers](https://mise.jdx.dev/cli/daemons/providers.html): [experimental] Manage shared servers from global [daemon_providers]
- [mise daemons providers ls](https://mise.jdx.dev/cli/daemons/providers/ls.html): [experimental] List shared servers
- [mise daemons providers restart](https://mise.jdx.dev/cli/daemons/providers/restart.html): [experimental] Restart shared servers with their current configuration
- [mise daemons providers start](https://mise.jdx.dev/cli/daemons/providers/start.html): [experimental] Start shared servers
- [mise daemons providers stop](https://mise.jdx.dev/cli/daemons/providers/stop.html): [experimental] Stop shared servers (data is kept)
- [mise daemons prune](https://mise.jdx.dev/cli/daemons/prune.html): [experimental] Remove daemon state left by deleted projects
- [mise daemons register](https://mise.jdx.dev/cli/daemons/register.html): [experimental] Register project daemons for on-demand startup
- [mise daemons restart](https://mise.jdx.dev/cli/daemons/restart.html): [experimental] Restart project daemons
- [mise daemons start](https://mise.jdx.dev/cli/daemons/start.html): [experimental] Start project daemons and the daemons they depend on
- [mise daemons status](https://mise.jdx.dev/cli/daemons/status.html): [experimental] Show the status of project daemons
- [mise daemons stop](https://mise.jdx.dev/cli/daemons/stop.html): [experimental] Stop project daemons
- [mise daemons tui](https://mise.jdx.dev/cli/daemons/tui.html): [experimental] Open the pitchfork dashboard
- [mise daemons urls](https://mise.jdx.dev/cli/daemons/urls.html): [experimental] Show each daemon's URL and port
- [mise deactivate](https://mise.jdx.dev/cli/deactivate.html): Print the script to disable mise in the current shell session
- [mise deps](https://mise.jdx.dev/cli/deps.html): [experimental] Manage project dependencies
- [mise deps add](https://mise.jdx.dev/cli/deps/add.html): Add packages to the project's dependencies
- [mise deps install](https://mise.jdx.dev/cli/deps/install.html): Install project dependencies
- [mise deps remove](https://mise.jdx.dev/cli/deps/remove.html): Remove packages from the project's dependencies
- [mise doctor](https://mise.jdx.dev/cli/doctor.html): Check your mise setup for problems
- [mise doctor path](https://mise.jdx.dev/cli/doctor/path.html): Print the directories mise adds to PATH
- [mise doctor project](https://mise.jdx.dev/cli/doctor/project.html): Run the project's diagnostic checks
- [mise dotfiles](https://mise.jdx.dev/cli/dotfiles.html): Deploy, track, and sync dotfiles
- [mise dotfiles add](https://mise.jdx.dev/cli/dotfiles/add.html): Start deploying a file, or copy its edits back to the source
- [mise dotfiles apply](https://mise.jdx.dev/cli/dotfiles/apply.html): Deploy [dotfiles] entries to their targets
- [mise dotfiles capture](https://mise.jdx.dev/cli/dotfiles/capture.html): Run a command and save tracked files before and after it
- [mise dotfiles conflicts](https://mise.jdx.dev/cli/dotfiles/conflicts.html): Compare both sides of a sync conflict
- [mise dotfiles diff](https://mise.jdx.dev/cli/dotfiles/diff.html): Show what mise dot apply would change
- [mise dotfiles edit](https://mise.jdx.dev/cli/dotfiles/edit.html): Open a dotfile's source in your editor
- [mise dotfiles exclude](https://mise.jdx.dev/cli/dotfiles/exclude.html): Never save paths matching a glob
- [mise dotfiles history](https://mise.jdx.dev/cli/dotfiles/history.html): Browse saved versions of your tracked files
- [mise dotfiles history describe](https://mise.jdx.dev/cli/dotfiles/history/describe.html): Set the description of a checkpoint
- [mise dotfiles history diff](https://mise.jdx.dev/cli/dotfiles/history/diff.html): Compare checkpoints, or your files against one
- [mise dotfiles history ls](https://mise.jdx.dev/cli/dotfiles/history/ls.html): List checkpoints, newest first
- [mise dotfiles history show](https://mise.jdx.dev/cli/dotfiles/history/show.html): Show a checkpoint: its trigger, changes, and operation journal
- [mise dotfiles include](https://mise.jdx.dev/cli/dotfiles/include.html): Stop excluding paths matching a glob
- [mise dotfiles notify](https://mise.jdx.dev/cli/dotfiles/notify.html): Send a test desktop notification
- [mise dotfiles origin](https://mise.jdx.dev/cli/dotfiles/origin.html): Show, connect, or disconnect the origin repository
- [mise dotfiles origin set](https://mise.jdx.dev/cli/dotfiles/origin/set.html): Connect an origin repository
- [mise dotfiles paths](https://mise.jdx.dev/cli/dotfiles/paths.html): List tracked paths and how they are saved
- [mise dotfiles pull](https://mise.jdx.dev/cli/dotfiles/pull.html): Apply incoming changes from the origin to your files
- [mise dotfiles recover](https://mise.jdx.dev/cli/dotfiles/recover.html): Recover an interrupted dotfile operation
- [mise dotfiles rollback](https://mise.jdx.dev/cli/dotfiles/rollback.html): Return files to the version a checkpoint holds
- [mise dotfiles save](https://mise.jdx.dev/cli/dotfiles/save.html): Save a checkpoint of the tracked files now
- [mise dotfiles status](https://mise.jdx.dev/cli/dotfiles/status.html): Show the state of your dotfiles and their history
- [mise dotfiles sync](https://mise.jdx.dev/cli/dotfiles/sync.html): Push saved checkpoints and fetch incoming changes
- [mise dotfiles track](https://mise.jdx.dev/cli/dotfiles/track.html): Track a file or directory in place
- [mise dotfiles unapply](https://mise.jdx.dev/cli/dotfiles/unapply.html): Remove files that mise dot apply deployed
- [mise dotfiles undo](https://mise.jdx.dev/cli/dotfiles/undo.html): Reverse the tracked-file changes from an operation
- [mise dotfiles untrack](https://mise.jdx.dev/cli/dotfiles/untrack.html): Stop tracking a file or directory
- [mise dotfiles watch](https://mise.jdx.dev/cli/dotfiles/watch.html): Save tracked files as they change
- [mise edit](https://mise.jdx.dev/cli/edit.html): Edit mise.toml interactively
- [mise en](https://mise.jdx.dev/cli/en.html): Start a subshell with mise's tools and environment
- [mise env](https://mise.jdx.dev/cli/env.html): Print the environment for the current configuration
- [mise exec](https://mise.jdx.dev/cli/exec.html): Run a command with mise's tools and environment
- [mise fmt](https://mise.jdx.dev/cli/fmt.html): Format mise TOML configuration
- [mise generate](https://mise.jdx.dev/cli/generate.html): Generate project files such as CI workflows, git hooks, and scripts
- [mise generate config](https://mise.jdx.dev/cli/generate/config.html): Generate a mise.toml file
- [mise generate devcontainer](https://mise.jdx.dev/cli/generate/devcontainer.html): Generate a devcontainer configuration that installs mise and the project's tools
- [mise generate git-pre-commit](https://mise.jdx.dev/cli/generate/git-pre-commit.html): Generate a git hook that runs a mise task
- [mise generate github-action](https://mise.jdx.dev/cli/generate/github-action.html): Generate a GitHub Actions workflow that runs a mise task
- [mise generate install-script](https://mise.jdx.dev/cli/generate/install-script.html): Generate a script that downloads and runs a pinned mise
- [mise generate task-docs](https://mise.jdx.dev/cli/generate/task-docs.html): Generate Markdown documentation for project tasks
- [mise generate task-stubs](https://mise.jdx.dev/cli/generate/task-stubs.html): Generate scripts that run mise tasks
- [mise generate tool-stub](https://mise.jdx.dev/cli/generate/tool-stub.html): Generate or update a tool stub
- [mise implode](https://mise.jdx.dev/cli/implode.html): Remove the mise CLI and all related data
- [mise install](https://mise.jdx.dev/cli/install.html): Install the tools in your config, or specific tool versions
- [mise install-into](https://mise.jdx.dev/cli/install-into.html): Install a tool version into a directory outside mise
- [mise installs](https://mise.jdx.dev/cli/installs.html): [experimental] Inspect and choose identity-layout installations
- [mise installs ls](https://mise.jdx.dev/cli/installs/ls.html): List the installations of the identity install layout
- [mise installs migrate](https://mise.jdx.dev/cli/installs/migrate.html): Reinstall legacy installations into the identity install layout
- [mise installs select](https://mise.jdx.dev/cli/installs/select.html): Choose which installation mise uses when no lockfile pins one
- [mise latest](https://mise.jdx.dev/cli/latest.html): Print the latest version that matches a version request
- [mise link](https://mise.jdx.dev/cli/link.html): Symlink a tool version into mise
- [mise lock](https://mise.jdx.dev/cli/lock.html): Create or refresh lockfile versions, checksums, and download URLs
- [mise ls](https://mise.jdx.dev/cli/ls.html): List installed and active tool versions
- [mise ls-remote](https://mise.jdx.dev/cli/ls-remote.html): List tool versions available to install
- [mise mcp](https://mise.jdx.dev/cli/mcp.html): Run the Model Context Protocol server over stdin/stdout
- [mise oci](https://mise.jdx.dev/cli/oci.html): [experimental] Build, push, and run OCI images of a project's tools
- [mise oci build](https://mise.jdx.dev/cli/oci/build.html): [experimental] Build an OCI image from the current mise.toml
- [mise oci push](https://mise.jdx.dev/cli/oci/push.html): [experimental] Build an OCI image and push it to a registry
- [mise oci run](https://mise.jdx.dev/cli/oci/run.html): [experimental] Build the project's image and run a command in it
- [mise outdated](https://mise.jdx.dev/cli/outdated.html): Show outdated tool versions
- [mise packslip](https://mise.jdx.dev/cli/packslip.html): Inspect and reset the signers mise has pinned for packslip tools
- [mise packslip forget](https://mise.jdx.dev/cli/packslip/forget.html): Forget a project's pinned signer so the next accepted release sets it
- [mise packslip pins](https://mise.jdx.dev/cli/packslip/pins.html): List the signer mise has pinned for each packslip project
- [mise patrons](https://mise.jdx.dev/cli/patrons.html): Show the individuals supporting mise as Patron-tier members
- [mise plugins](https://mise.jdx.dev/cli/plugins.html): Manage plugins
- [mise plugins install](https://mise.jdx.dev/cli/plugins/install.html): Install plugins from a configured source, Git URL, or archive
- [mise plugins link](https://mise.jdx.dev/cli/plugins/link.html): Link a local plugin directory into mise for development
- [mise plugins ls](https://mise.jdx.dev/cli/plugins/ls.html): List installed plugins
- [mise plugins ls-remote](https://mise.jdx.dev/cli/plugins/ls-remote.html): List registry tools that have an asdf or vfox plugin backend
- [mise plugins uninstall](https://mise.jdx.dev/cli/plugins/uninstall.html): Remove an installed plugin
- [mise plugins update](https://mise.jdx.dev/cli/plugins/update.html): Update installed plugins
- [mise prune](https://mise.jdx.dev/cli/prune.html): Delete tool versions that nothing uses
- [mise registry](https://mise.jdx.dev/cli/registry.html): List registry shorthand names and their backends
- [mise reshim](https://mise.jdx.dev/cli/reshim.html): Create shims for executables provided by installed tools
- [mise run](https://mise.jdx.dev/cli/run.html): Run tasks and their dependencies
- [mise search](https://mise.jdx.dev/cli/search.html): Search for available tools
- [mise secrets](https://mise.jdx.dev/cli/secrets.html): [experimental] Inspect the project's secrets source
- [mise secrets ls](https://mise.jdx.dev/cli/secrets/ls.html): [experimental] List secret names from the project's secrets source
- [mise self-update](https://mise.jdx.dev/cli/self-update.html): Update mise itself
- [mise set](https://mise.jdx.dev/cli/set.html): Set, show, or list environment variables in mise.toml
- [mise settings](https://mise.jdx.dev/cli/settings.html): Manage settings
- [mise settings add](https://mise.jdx.dev/cli/settings/add.html): Append a value to an array setting
- [mise settings get](https://mise.jdx.dev/cli/settings/get.html): Show the effective value of a setting
- [mise settings ls](https://mise.jdx.dev/cli/settings/ls.html): List configured settings and their sources
- [mise settings set](https://mise.jdx.dev/cli/settings/set.html): Set a setting
- [mise settings unset](https://mise.jdx.dev/cli/settings/unset.html): Remove a setting from the global or project config
- [mise shell](https://mise.jdx.dev/cli/shell.html): Set a tool version for the current shell session
- [mise shell-alias](https://mise.jdx.dev/cli/shell-alias.html): Manage shell aliases
- [mise shell-alias get](https://mise.jdx.dev/cli/shell-alias/get.html): Show the command for a shell alias
- [mise shell-alias ls](https://mise.jdx.dev/cli/shell-alias/ls.html): List shell aliases
- [mise shell-alias set](https://mise.jdx.dev/cli/shell-alias/set.html): Set a shell alias in the global config
- [mise shell-alias unset](https://mise.jdx.dev/cli/shell-alias/unset.html): Remove a shell alias from the global config
- [mise skills](https://mise.jdx.dev/cli/skills.html): List and link the agent skills that active tools ship
- [mise skills ls](https://mise.jdx.dev/cli/skills/ls.html): List the skills the active tools declare
- [mise skills sync](https://mise.jdx.dev/cli/skills/sync.html): Link the active tools' skills where an agent looks for them
- [mise sponsors](https://mise.jdx.dev/cli/sponsors.html): Show the companies sponsoring mise and the jdx.dev open source tools
- [mise ssh](https://mise.jdx.dev/cli/ssh.html): Open an SSH session, optionally borrowing read-only GitHub access
- [mise sync](https://mise.jdx.dev/cli/sync.html): Use tool versions installed by other version managers
- [mise sync node](https://mise.jdx.dev/cli/sync/node.html): Symlink node versions installed by nvm, nodenv, or Homebrew into mise
- [mise sync python](https://mise.jdx.dev/cli/sync/python.html): Symlink python versions installed by pyenv or uv into mise
- [mise sync ruby](https://mise.jdx.dev/cli/sync/ruby.html): Symlink ruby versions installed by Homebrew into mise
- [mise tasks](https://mise.jdx.dev/cli/tasks.html): Manage tasks
- [mise tasks add](https://mise.jdx.dev/cli/tasks/add.html): Add a task
- [mise tasks deps](https://mise.jdx.dev/cli/tasks/deps.html): Show the dependency tree of tasks
- [mise tasks edit](https://mise.jdx.dev/cli/tasks/edit.html): Open a task in your editor
- [mise tasks graph](https://mise.jdx.dev/cli/tasks/graph.html): [experimental] Show the monorepo project graph
- [mise tasks info](https://mise.jdx.dev/cli/tasks/info.html): Show a task's definition
- [mise tasks ls](https://mise.jdx.dev/cli/tasks/ls.html): List available tasks
- [mise tasks validate](https://mise.jdx.dev/cli/tasks/validate.html): Check task definitions for errors
- [mise test-tool](https://mise.jdx.dev/cli/test-tool.html): Test that a tool installs and runs
- [mise token](https://mise.jdx.dev/cli/token.html): Show which Git provider token mise uses
- [mise token forgejo](https://mise.jdx.dev/cli/token/forgejo.html): Show the Forgejo token mise uses for a host
- [mise token github](https://mise.jdx.dev/cli/token/github.html): Show the GitHub token mise uses for a host
- [mise token gitlab](https://mise.jdx.dev/cli/token/gitlab.html): Show the GitLab token mise uses for a host
- [mise tool](https://mise.jdx.dev/cli/tool.html): Show information about a tool
- [mise tool-alias](https://mise.jdx.dev/cli/tool-alias.html): Manage tool backend and version aliases
- [mise tool-alias get](https://mise.jdx.dev/cli/tool-alias/get.html): Show the version a tool's version alias stands for
- [mise tool-alias ls](https://mise.jdx.dev/cli/tool-alias/ls.html): List tool version aliases
- [mise tool-alias set](https://mise.jdx.dev/cli/tool-alias/set.html): Set a backend alias or a version alias in the global config
- [mise tool-alias unset](https://mise.jdx.dev/cli/tool-alias/unset.html): Remove a backend alias or a version alias from the global config
- [mise tool-stub](https://mise.jdx.dev/cli/tool-stub.html): Run a tool stub file
- [mise trust](https://mise.jdx.dev/cli/trust.html): Mark a config file as trusted
- [mise uninstall](https://mise.jdx.dev/cli/uninstall.html): Remove installed tool versions
- [mise unset](https://mise.jdx.dev/cli/unset.html): Remove environment variables from mise.toml
- [mise untrust](https://mise.jdx.dev/cli/untrust.html): Remove explicit trust for a config
- [mise unuse](https://mise.jdx.dev/cli/unuse.html): Remove tool requests from config files and prune unused installations
- [mise upgrade](https://mise.jdx.dev/cli/upgrade.html): Upgrade outdated tools
- [mise use](https://mise.jdx.dev/cli/use.html): Install a tool and add it to configuration
- [mise version](https://mise.jdx.dev/cli/version.html): Show the version of mise
- [mise watch](https://mise.jdx.dev/cli/watch.html): Run tasks and rerun them when files change
- [mise where](https://mise.jdx.dev/cli/where.html): Show the install directory of a tool version
- [mise which](https://mise.jdx.dev/cli/which.html): Show the path a tool's executable resolves to
