# What is mise? A Unified CLI for Dev Tools, Environment Variables and Tasks

> Discover mise, a unified CLI for dev tools, environment variables, and tasks. Streamline your development workflow with a single declarative configuration.

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

---

**mise** (pronounced "meez") is a Rust-based command-line tool that prepares a project's development environment before any command runs by centralizing dev tools, environment variables, and task execution into a single declarative configuration.

If you have been asking **what is mise** and how it simplifies developer workflows, examining the jdx/mise repository reveals a tool that replaces fragmented version managers with a unified, project-scoped approach. Unlike traditional tools that only handle language versions, mise integrates tool installation, environment variable management, and task running through a single [`mise.toml`](https://github.com/jdx/mise/blob/main/mise.toml) file, ensuring consistent behavior across local development and CI pipelines.

## Three Core Concerns Unified by mise

The jdx/mise codebase addresses three distinct developer pain points that are typically handled by separate utilities.

### Dev Tools Management

mise installs and switches between dozens of development tools—such as Node.js, Python, Go, and Terraform—via version definitions in [`mise.toml`](https://github.com/jdx/mise/blob/main/mise.toml). According to the source code in `src/backend/`, the tool supports multiple back-ends including GitHub releases, the Aqua registry, Cargo, and npm, allowing each tool to define its own notion of "latest", "stable", or channel-specific versions rather than relying on naive semantic-version sorting.

### Environment Variables

The tool loads per-project variables from the `[env]` table in [`mise.toml`](https://github.com/jdx/mise/blob/main/mise.toml) or from `.env` files, making them available to subsequent commands. Users can modify these values on the fly using `mise set`, enabling dynamic configuration without editing configuration files directly.

### Task Runner

mise defines reusable scripts (build, test, deploy) in the same TOML file and executes them with `mise run`. As implemented in [`src/task/task_scheduler.rs`](https://github.com/jdx/mise/blob/main/src/task/task_scheduler.rs), the task system handles dependencies between tasks, inherits environment settings, and can be invoked from CI pipelines, creating a consistent automation layer across environments.

## Architecture and Source Code Organization

The mise source code follows a modular architecture that isolates concerns across specific directories:

- **[`src/main.rs`](https://github.com/jdx/mise/blob/main/src/main.rs)** – The CLI entry point that bootstraps the application, parses arguments, and dispatches commands to appropriate subsystems.
- **[`src/toolset/mod.rs`](https://github.com/jdx/mise/blob/main/src/toolset/mod.rs)** – Core logic for managing tool versions, installation procedures, and environment preparation.
- **[`src/task/task_scheduler.rs`](https://github.com/jdx/mise/blob/main/src/task/task_scheduler.rs)** – Orchestrates task execution, handling dependency resolution and output management.
- **`src/config/`** – Parses [`mise.toml`](https://github.com/jdx/mise/blob/main/mise.toml), `.tool-versions`, and other configuration files to build the project state.
- **`src/backend/`** – Contains backend implementations for fetching and installing tools, isolating version-resolution logic so each tool can implement custom version semantics.

This architecture ensures that tool resolution, environment setup, and task execution remain decoupled while presenting a unified interface to the user.

## Practical mise Usage Examples

The following examples demonstrate how mise works in practice, from installing tools to running complex task pipelines.

### Install and Run Specific Tool Versions

Use `mise exec` to install a tool temporarily for a single command:

```sh

# Install Node 26.x.x (if not already present) and run `node -v`

mise exec node@26 -- node -v

# → mise node@26.x.x ✓ installed

# → v26.x.x

```

### Set Global Defaults

Define default tool versions across your system:

```sh

# Make Node 26 and Go 1 the globally default versions

mise use --global node@26 go@1

```

### Define and Execute Tasks

Configure tasks in [`mise.toml`](https://github.com/jdx/mise/blob/main/mise.toml) and run them with dependency awareness:

```toml

# mise.toml

[tasks.build]
description = "Compile the project"
run = "cargo build --release"

```

```sh

# Execute the task

mise run build

# → Compiling …

```

### Manage Environment Variables

Declare variables in configuration and override them session-wide:

```toml

# mise.toml

[env]
SOME_VAR = "foo"

```

```sh

# Override the value for the current session

mise set SOME_VAR=bar
echo $SOME_VAR

# → bar

```

### Complete Project Configuration

A full project example combining tools, environment, and tasks:

```toml

# mise.toml

[tools]
terraform = "1"
aws-cli   = "2"

[env]
TF_WORKSPACE = "development"
AWS_REGION   = "us-west-2"

[tasks.plan]
description = "Run terraform plan"
run = """
terraform init
terraform workspace select $TF_WORKSPACE
terraform plan
"""

```

```sh

# Install required tools and run the deployment task

mise install        # installs terraform and aws-cli

mise run plan

```

## Summary

- **mise** is a Rust-based CLI tool that unifies dev tools, environment variables, and task running into a single workflow.
- Configuration is centralized in [`mise.toml`](https://github.com/jdx/mise/blob/main/mise.toml), making projects reproducible across local machines and CI environments.
- The architecture separates concerns into `src/toolset/` for tool management, `src/task/` for execution, and `src/backend/` for version resolution.
- Commands like `mise exec`, `mise use`, `mise run`, and `mise set` provide granular control over the development environment.

## Frequently Asked Questions

### How do you pronounce mise?

**mise** is pronounced "meez" (rhyming with "sneeze"). The name reflects the French culinary concept of "mise en place," emphasizing preparation and organization before work begins.

### How does mise differ from asdf or nvm?

While asdf and nvm focus exclusively on language version management, mise extends this capability to environment variables and task running within the same configuration file. Additionally, mise is written in Rust for performance and supports multiple installation back-ends beyond simple version repositories.

### Can mise manage both local and global tool versions?

Yes. Use `mise use` without flags to set project-local versions in [`mise.toml`](https://github.com/jdx/mise/blob/main/mise.toml), or add the `--global` flag to set defaults in your home directory. The tool resolves versions hierarchically, allowing system-wide defaults with project-specific overrides.

### Is mise suitable for CI/CD pipelines?

Absolutely. Because mise reads configuration from [`mise.toml`](https://github.com/jdx/mise/blob/main/mise.toml) and installs tools on demand, it ensures CI environments match local development exactly. Tasks defined in the configuration can be invoked via `mise run` in pipeline scripts, maintaining consistency between developer laptops and production build systems.