# What Programming Languages Does Mise Support? Complete Core Plugins Guide

> Discover the 13 programming languages Mise supports natively including Python Nodejs Ruby Rust Go Java Swift Zig Erlang Elixir .NET Deno and Bun. Enhance your workflow today.

- Repository: [jdx/mise](https://github.com/jdx/mise)
- Tags: tutorial
- Published: 2026-08-09

---

**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)](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)](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)](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)](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)](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)](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)](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)](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)](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)](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)](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)](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)](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`](https://github.com/jdx/mise/blob/main/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`](https://github.com/jdx/mise/blob/main/src/backend/static_helpers.rs) and [`src/backend/version_cache.rs`](https://github.com/jdx/mise/blob/main/src/backend/version_cache.rs), while [`src/platform.rs`](https://github.com/jdx/mise/blob/main/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:

```bash

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

```bash
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`](https://github.com/jdx/mise/blob/main/.mise.toml) file at your project root. Running `mise install` will fetch the exact versions declared:

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

```

The tool request parser in [`src/toolset/tool_request.rs`](https://github.com/jdx/mise/blob/main/src/toolset/tool_request.rs) handles these specifications, while [`src/toolset/toolset.rs`](https://github.com/jdx/mise/blob/main/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:

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

```bash
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`](https://github.com/jdx/mise/blob/main/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`](https://github.com/jdx/mise/blob/main/python.rs), [`node.rs`](https://github.com/jdx/mise/blob/main/node.rs)).
- **Project configuration uses [`.mise.toml`](https://github.com/jdx/mise/blob/main/.mise.toml)**, parsed by [`src/toolset/tool_request.rs`](https://github.com/jdx/mise/blob/main/src/toolset/tool_request.rs) and orchestrated by [`src/toolset/toolset.rs`](https://github.com/jdx/mise/blob/main/src/toolset/toolset.rs).
- **Lockfile support** in [`src/lockfile.rs`](https://github.com/jdx/mise/blob/main/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`](https://github.com/jdx/mise/blob/main/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`](https://github.com/jdx/mise/blob/main/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`](https://github.com/jdx/mise/blob/main/.mise.toml) file under the `[tools]` section. The toolset orchestrator in [`src/toolset/toolset.rs`](https://github.com/jdx/mise/blob/main/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.