What Programming Languages Does Mise Support? Complete Core Plugins Guide

Mise supports 13 programming languages out-of-the-box through core plugins maintained directly in the jdx/mise repository, including Python, Node.js, Ruby, Rust, Go, Java, Swift, Zig, Erlang, Elixir, .NET, Deno, and Bun.

Mise is a polyglot version manager that automates the installation and environment configuration of development tools. According to the jdx/mise source code, the tool ships with first-class core plugins that implement the Backend trait to handle everything from downloading platform-specific binaries to injecting environment variables like VIRTUAL_ENV into the user's shell.

Core Programming Languages Supported by Mise

The following languages are supported via core plugins located in src/plugins/core/. Each plugin is maintained within the main codebase and provides automatic version resolution, lockfile support, and provenance verification.

• Python – Implemented in [src/plugins/core/python.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/python.rs)
• Node.js – Implemented in [src/plugins/core/node.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/node.rs)
• Ruby – Implemented in [src/plugins/core/ruby.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/ruby.rs)
• Rust – Implemented in [src/plugins/core/rust.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/rust.rs)
• Go – Implemented in [src/plugins/core/go.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/go.rs)
• Java – Implemented in [src/plugins/core/java.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/java.rs)
• Swift – Implemented in [src/plugins/core/swift.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/swift.rs)
• Zig – Implemented in [src/plugins/core/zig.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/zig.rs)
• Erlang – Implemented in [src/plugins/core/erlang.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/erlang.rs)
• Elixir – Implemented in [src/plugins/core/elixir.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/elixir.rs)
• .NET (C#, F#, etc.) – Implemented in [src/plugins/core/dotnet.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/dotnet.rs)
• Deno – Implemented in [src/plugins/core/deno.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/deno.rs)
• Bun – Implemented in [src/plugins/core/bun.rs](https://github.com/jdx/mise/blob/main/src/plugins/core/bun.rs)

How Mise Manages Programming Languages Internally

Each language plugin conforms to the Backend trait defined in src/backend/mod.rs. This architecture ensures consistent behavior across all supported programming languages.

The trait requires three critical methods:

• _list_remote_versions – Fetches available releases for the language (e.g., querying CPython build-standalone releases for Python or Node.js official releases).
• install_version_ – Downloads and extracts the selected version, handling platform-specific quirks such as creating python3.exe on Windows.
• exec_env – Constructs environment variables required by the language, such as appending the tool's binary directory to $PATH or setting VIRTUAL_ENV for Python virtual environments.

The plugins leverage shared utilities including crate::http::HTTP_FETCH, crate::file, and crate::git::Git to maintain consistency. Version metadata is cached using helpers in src/backend/static_helpers.rs and src/backend/version_cache.rs, while src/platform.rs detects OS and architecture to select the correct binary.

Practical Usage Examples for Supported Languages

Install a Specific Version

Use the mise use command to install and activate a language version in the current directory:

# Python 3.11.9

mise use python@3.11.9

# Node.js 20.10.0

mise use node@20.10.0

# Go 1.22.3

mise use go@1.22.3

List Available Remote Versions

Query the upstream registries to see installable versions without downloading:

mise ls-remote python   # shows every CPython build-standalone release

mise ls-remote node     # lists Node.js versions from official releases

mise ls-remote rust     # lists Rust toolchains from rustup

Pin Versions in Project Configuration

Define language versions in a .mise.toml file at your project root. Running mise install will fetch the exact versions declared:

[tools]
python = "3.11.9"
node   = "20.10.0"
go     = "1.22.3"

The tool request parser in src/toolset/tool_request.rs handles these specifications, while src/toolset/toolset.rs coordinates the installation of multiple languages.

Execute Commands with Language Shims

Run scripts using the exact version selected by mise, regardless of system defaults:

mise exec python -- my_script.py
mise exec node -- node -v
mise exec go -- go run ./cmd/example

Python Virtual Environment Integration

The Python plugin automatically handles virtual environments. When configured, it sets VIRTUAL_ENV and prepends the venv's bin/ or Scripts/ directory to the path via the exec_env implementation:

mise use python@3.11.9
source .venv/bin/activate   # automatically managed by mise exec

Summary

• Mise supports 13 core programming languages via first-party plugins: Python, Node.js, Ruby, Rust, Go, Java, Swift, Zig, Erlang, Elixir, .NET, Deno, and Bun.
• Each language implements the Backend trait in src/backend/mod.rs, providing standardized methods for version listing, installation, and environment setup.
• Source files are located in src/plugins/core/, with each language having its own .rs file (e.g., python.rs, node.rs).
• Project configuration uses .mise.toml, parsed by src/toolset/tool_request.rs and orchestrated by src/toolset/toolset.rs.
• Lockfile support in src/lockfile.rs ensures reproducible installs with concrete versions and checksums.

Frequently Asked Questions

Which programming languages does mise support out-of-the-box?

Mise ships with core plugins for 13 languages: Python, Node.js, Ruby, Rust, Go, Java, Swift, Zig, Erlang, Elixir, .NET (C# and F#), Deno, and Bun. Each plugin is maintained in the src/plugins/core/ directory of the jdx/mise repository and provides first-class integration with features like automatic version resolution and provenance verification.

How does mise handle language installation internally?

Each language plugin implements the Backend trait defined in src/backend/mod.rs. This interface requires methods such as _list_remote_versions to fetch available releases, install_version_ to download and extract binaries, and exec_env to configure environment variables. The architecture uses src/platform.rs to detect OS/architecture and downloads appropriate binaries automatically.

Can I use multiple programming languages in the same project?

Yes. Define multiple languages in a .mise.toml file under the [tools] section. The toolset orchestrator in src/toolset/toolset.rs coordinates the installation of all specified versions simultaneously. For example, you can pin Python 3.11.9, Node.js 20.10.0, and Go 1.22.3 in the same configuration file.

How do I list available versions for a supported language?

Use the mise ls-remote <language> command. This invokes the _list_remote_versions method of the respective core plugin, which queries upstream registries (such as CPython build-standalone for Python or rustup for Rust) and displays all installable versions without downloading them.

{
  "mcpServers": {
    "instagit": {
      "command": "npx",
      "args": ["-y", "instagit@latest"]
    }
  }
}