# Can mise Manage Go Versions? Yes—Here’s How It Works for Toolchains and Packages

> Discover how mise effectively manages Go versions for toolchains and packages. Learn to simplify your Go development workflow with this powerful tool.

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

---

**Yes, mise manages both the Go compiler toolchain and individual Go packages through distinct backend implementations that handle version resolution, installation, and environment configuration.**

The [jdx/mise](https://github.com/jdx/mise) repository provides first-class Go support through two complementary systems. You can pin and switch between Go runtime versions for different projects, while also treating Go-based CLI tools as version-locked dependencies managed through the same interface.

## How mise Handles the Go Toolchain

The **core Go plugin** located in [`src/plugins/core/go.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/go.rs) manages the Go compiler itself. This plugin implements the `Backend` trait and provides full lifecycle management for the language runtime.

### Version Discovery and Installation

The plugin discovers available versions by filtering tags from the official Go repository in the `list_remote_versions` function【src/plugins/core/go.rs†L22-L84】. When you request a specific version, mise downloads the official binary tarball via the `get_tarball_url` function【src/plugins/core/go.rs†L147-L176】, which constructs URLs pointing to the configured mirror.

### Environment Configuration

After installation, the plugin automatically configures critical Go environment variables:

- **`GOROOT`** – Points to the installed Go directory
- **`GOPATH`** – Manages the workspace location
- **`GOBIN`** – Sets the binary output directory

Additionally, the plugin supports `install_default_packages` for pre-installing global tools whenever you switch Go versions【src/plugins/core/go.rs†L67-L100】.

## Installing Go Packages as Tools

Beyond the compiler, mise can install arbitrary Go modules directly via the **Go backend** in [`src/backend/go.rs`](https://github.com/jdx/mise/blob/main/src/backend/go.rs). This allows you to version-lock CLI tools built with Go without manual `go install` commands.

### Module Resolution Process

The backend resolves module versions through the Go proxy protocol, falling back to `go list -m -versions` when necessary【src/plugins/core/go.rs†L58-L89】. It then executes installations using `go install` with support for build constraints.

### Build Tag Support

You can pass environment variables and build tags during installation through the `install_env` and `tags` options【src/backend/go.rs†L140-L176】. This is essential for packages with conditional compilation or external dependencies.

## Practical Installation Commands

Install and manage Go versions using the `mise use` command:

```bash

# Install latest Go 1.21.x and set as global default

mise use -g go@1.21

# Install specific version using prefix matching

mise use -g go@prefix:1.20

# Install a Go-based CLI tool directly

mise use -g go:github.com/DarthSim/hivemind

# Install with specific build tags

mise use -g go:github.com/golang-migrate/migrate/v4/cmd/migrate tags=postgres

```

List available versions before installing:

```bash

# List all Go runtime versions

mise ls-remote go

# List versions for a specific Go module

mise ls-remote go:github.com/DarthSim/hivemind

```

## Configuring Go in mise.toml

Pin versions declaratively in your project configuration:

```toml
[tools]

# Pin specific Go version

go = "1.22.0"

# Pin Go module with pseudo-version

"go:github.com/grafana/oats" = "v0.7.1-0.20260703092802-96201f1b8136"

# Configure install environment variables

"go:github.com/grafana/oats" = { version = "v0.7.1-0.20260703092802-96201f1b8136",
                                 install_env = { GOPROXY = "direct", 
                                                 GONOSUMDB = "github.com/grafana/oats" } }

```

## Summary

- **mise manages Go** through two distinct backends: the core plugin for the toolchain ([`src/plugins/core/go.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/go.rs)) and the Go backend for packages ([`src/backend/go.rs`](https://github.com/jdx/mise/blob/main/src/backend/go.rs)).
- **Automatic environment setup** configures `GOROOT`, `GOPATH`, and `GOBIN` when activating Go versions.
- **Direct module installation** treats Go packages as version-locked tools, supporting build tags and custom proxy settings.
- **Flexible version specification** supports exact versions, prefixes, and pseudo-versions for both the compiler and individual modules.

## Frequently Asked Questions

### Can mise install specific patch versions of Go?

Yes, you can install exact versions like `go@1.21.5` or use prefix matching to get the latest patch release within a minor version using `go@prefix:1.21`. The version resolution logic in [`src/plugins/core/go.rs`](https://github.com/jdx/mise/blob/main/src/plugins/core/go.rs) filters available tags from the official Go repository to match your specification.

### How does mise handle private Go modules?

The Go backend in [`src/backend/go.rs`](https://github.com/jdx/mise/blob/main/src/backend/go.rs) respects standard Go environment variables. Configure `GOPROXY`, `GONOSUMDB`, and other authentication settings through the `install_env` option in your [`mise.toml`](https://github.com/jdx/mise/blob/main/mise.toml) or via environment variables before running `mise install`.

### What is the difference between `go:` and `go@` in mise commands?

`go@` refers to the Go compiler toolchain itself (e.g., `go@1.22`), while `go:` prefixes a module path for installing specific Go packages (e.g., `go:github.com/user/tool`). The former uses the core plugin, while the latter uses the Go backend for module installation.

### Does mise support cross-compilation when installing Go tools?

While mise handles the installation of Go packages via `go install`, it respects the `GOOS`, `GOARCH`, and build tag settings you provide through `install_env`. For pure cross-compilation workflows, install the desired Go version first, then use standard Go build commands within your project directory.