Guide complet de Mise : un outil pour remplacer asdf/nvm/pyenv, gérez votre environnement de développement 10 fois plus vite

TL;DR — Mise est un gestionnaire de versions multi-langages écrit en Rust, plus de 20 fois plus rapide qu'asdf. Un seul outil pour basculer entre les versions de Node.js, Python, Ruby, Go, Java et plus de 50 autres outils de développement. Il inclut aussi la gestion des variables d'environnement et un task runner intégré.

Pourquoi avez-vous besoin de Mise ?

Si vous êtes un développeur full-stack, votre quotidien ressemble probablement à ça :

• Le projet A a besoin de Node.js 18, le projet B de Node.js 20
• Le backend tourne sur Python 3.11, mais un ancien projet est coincé sur Python 3.9
• Parfois vous devez aussi coder en Ruby, Go ou Rust

Pour gérer toutes ces versions, vous avez probablement installé :

Le problème : chaque outil a sa propre configuration, ses propres hooks shell, ses propres fichiers .tool-versions ou .nvmrc. Le coût de maintenance est énorme. Et la plupart de ces outils sont écrits en Bash, ce qui les rend lamentablement lents au démarrage.

Mise (prononcé /miːz/, "meez") est là pour mettre fin à tout ça.

Qu'est-ce que Mise ?

Mise (qui signifie "placement" en français) est un gestionnaire d'outils de développement écrit en Rust qui combine les fonctionnalités suivantes :

1. Gestion de versions multi-langages — remplace asdf/nvm/pyenv/rbenv/gvm
2. Gestion des variables d'environnement — remplace direnv
3. Task runner — remplace Makefile/just/task

Avantages clés

Données GitHub : 30 000+ Stars, 1 200+ Forks, licence MIT, mises à jour actives et régulières.

Installer Mise

L'installation de Mise est extrêmement simple et fonctionne sur toutes les plateformes principales.

Linux / macOS (recommandé)

# Installation en une ligne de commande
curl https://mise.run | sh

# Ou avec Homebrew (macOS)
brew install mise

# Ou avec Cargo (écosystème Rust)
cargo install mise

Activer l'intégration shell

Après l'installation, vous devez ajouter la commande d'activation dans votre fichier de configuration shell :

# Bash — à ajouter dans ~/.bashrc
echo 'eval "$(mise activate bash)"' >> ~/.bashrc

# Zsh — à ajouter dans ~/.zshrc
echo 'eval "$(mise activate zsh)"' >> ~/.zshrc

# Fish — à ajouter dans ~/.config/fish/config.fish
echo 'mise activate fish | source' >> ~/.config/fish/config.fish

Rechargez votre shell :

source ~/.bashrc  # ou source ~/.zshrc

Vérifier l'installation

mise --version
# Affiche quelque chose comme : mise 2026.x.x

mise doctor
# Vérifie l'état de l'installation et affiche tous les diagnostics

Prise en main rapide : gérez votre premier outil en 5 minutes

Installer Node.js

# Installer la dernière version LTS
mise use -g node@lts

# Installer une version spécifique
mise use -g node@20

# Voir les versions installées
mise ls node

L'option -g signifie installation globale (écrit dans ~/.config/mise/config.toml). Sans -g, c'est écrit dans le .mise.toml du répertoire courant, pour un verrouillage de version au niveau du projet.

Installer Python

# Installer Python 3.12
mise use -g python@3.12

# Vérifier
python --version
# Python 3.12.x

Installer plusieurs outils en même temps

# Une seule commande pour installer plusieurs outils
mise use -g node@20 python@3.12 go@1.22 ruby@3.3 rust@latest

# Voir tous les outils actuellement activés
mise ls

Verrouillage de version par projet

Allez dans le répertoire du projet et créez un .mise.toml :

cd ~/projects/my-app

# Configurer Node.js 20 et Python 3.11 pour ce projet
mise use node@20 python@3.11

Cela génère un fichier .mise.toml :

[tools]
node = "20"
python = "3.11"

Commitez ce fichier dans Git. Après un clone, chaque membre de l'équipe n'a qu'à exécuter mise install pour installer automatiquement toutes les versions nécessaires.

Compatibilité avec les fichiers de configuration existants

Mise reconnaît automatiquement les fichiers suivants, sans aucune configuration supplémentaire :

Cela signifie que vous pouvez remplacer asdf/nvm/pyenv en douceur, sans modifier la configuration de vos projets existants.

Fonctionnalités avancées

1. Gestion des variables d'environnement (remplace direnv)

Mise intègre la gestion des variables d'environnement et peut les charger/décharger automatiquement selon le répertoire :

# .mise.toml
[env]
DATABASE_URL = "postgres://localhost:5432/myapp"
REDIS_URL = "redis://localhost:6379"
NODE_ENV = "development"
API_KEY = {value = "sk-test-xxx", redact = true}  # Masquage automatique dans les logs

Support des fichiers .env :

[env]
_.file = ".env"                       # Charger depuis un fichier .env
_.path = ["./bin", "./scripts"]       # Ajouter automatiquement au PATH

Différence avec direnv : Les variables d'environnement et les versions d'outils de Mise sont gérées dans le même fichier. Pas besoin de deux configurations séparées.

2. Task runner (remplace Makefile)

Mise dispose d'un task runner puissant intégré :

# .mise.toml
[tasks.build]
description = "Construire le projet"
run = "npm run build"

[tasks.test]
description = "Exécuter les tests"
run = ["npm test", "npm run lint"]

[tasks.dev]
description = "Lancer le serveur de développement"
run = "npm run dev"
depends = ["build"]  # Dépendance : exécuter build d'abord

[tasks."db:migrate"]
description = "Exécuter les migrations de base de données"
run = "python manage.py migrate"

Utilisation :

# Exécuter une tâche
mise run build
mise run test
mise run dev

# Lister toutes les tâches disponibles
mise tasks

# Exécuter avec des arguments
mise run build -- --watch

3. Alias et raccourcis

# .mise.toml
[alias.node]
lts = "20"
latest = "22"

[alias.python]
myproj = "3.11.6"  # Version figée pour le projet

4. Changement de version automatique et parallèle

La magie de Mise, c'est le changement de version automatique. Quand vous faites un cd vers un autre répertoire, Mise lit automatiquement le fichier de configuration et bascule la version de l'outil :

# Le projet A nécessite Node 18
cd ~/projects/project-a
node --version  # v18.x.x (changement automatique)

# Le projet B nécessite Node 20
cd ~/projects/project-b
node --version  # v20.x.x (changement automatique)

Tout cela se passe avec un délai zéro — parce que Mise est écrit en Rust, il n'a pas besoin d'exécuter un script Bash à chaque cd comme nvm.

5. Système de backends

Mise supporte plusieurs backends d'installation, ce qui permet de choisir librement la source des outils :

# Binaire précompilé officiel (par défaut, le plus rapide)
[tools]
node = "20"

# Via l'écosystème de plugins asdf
[tools]
node = "asdf:mise-plugins/mise-node"

# Via ubi (installateur binaire universel)
[tools]
jq = "ubi:jqlang/jq"

# Via go install
[tools]
golangci-lint = "go:golang.org/x/tools/gopls@latest"

# Installation globale via npm
[tools]
typescript = "npm:typescript"

# Installation via pip
[tools]
black = "pip:black"

# Installation via cargo
[tools]
ripgrep = "cargo:ripgrep"

Mise peut donc gérer non seulement les langages runtime, mais aussi n'importe quel outil de développement — linters, formateurs, outils CLI, etc.

Cas pratique : configurer un environnement de développement full-stack avec Mise

Partons de zéro et configurons un projet full-stack typique (frontend Next.js + backend FastAPI) avec Mise.

Étape 1 : Créer la structure du projet

mkdir ~/projects/fullstack-app && cd ~/projects/fullstack-app
mkdir frontend backend

Étape 2 : Configuration à la racine

Créez un mise.toml à la racine du projet :

# mise.toml
[tools]
node = "20"        # Requis pour le frontend
python = "3.12"    # Requis pour le backend

[env]
_.file = ".env"    # Variables d'environnement globales

[tasks.setup]
description = "Initialiser tout le projet"
run = [
    "cd frontend && npm install",
    "cd backend && pip install -r requirements.txt"
]

[tasks.dev]
description = "Lancer tous les services"
run = [
    "cd frontend && npm run dev &",
    "cd backend && uvicorn main:app --reload"
]

Étape 3 : Initialisation en une commande

# Installer tous les outils
cd ~/projects/fullstack-app
mise install

# Exécuter la tâche d'initialisation
mise run setup

# Lancer l'environnement de développement
mise run dev

Toute l'équipe n'a besoin que de git clone + mise install + mise run dev pour lancer l'environnement de développement. Fini le fameux "mais chez moi ça marche".

Étape 4 : Intégration CI/CD

Utilisez Mise directement dans GitHub Actions :

# .github/workflows/ci.yml
name: CI

on: [push, pull_request]

jobs:
  test:
    runs-on: ubuntu-latest
    steps:
      - uses: actions/checkout@v4

      - name: Install mise
        uses: jdx/mise-action@v2

      - name: Install tools
        run: mise install

      - name: Frontend tests
        run: cd frontend && npm test

      - name: Backend tests
        run: cd backend && pytest

mise-action lit automatiquement le mise.toml et installe tous les outils nécessaires, sans avoir à configurer manuellement actions/setup-node, actions/setup-python, etc.

Migrer d'asdf vers Mise

Si vous êtes déjà utilisateur d'asdf, la migration est très simple :

# Mise est entièrement compatible avec les fichiers .tool-versions
# Vous n'avez même rien à faire, Mise les lit automatiquement

# Mais si vous voulez convertir .tool-versions en mise.toml :
mise migrate asdf

# Après migration, supprimer asdf (optionnel)
# Bash
sed -i '/asdf.sh/d' ~/.bashrc
# Zsh
sed -i '/asdf.sh/d' ~/.zshrc

Avantages clés : - mise install est plus de 20 fois plus rapide que asdf install (téléchargement parallèle + binaires précompilés) - Pas de couche shim, démarrage du shell à délai zéro - Meilleurs messages d'erreur et auto-complétion - Task runner et gestion des variables d'environnement intégrés

Résumé : Mise vs les autres outils

Conclusion

Mise est l'un des outils développeurs les plus utiles que j'ai rencontrés ces dernières années. Il résout les douleurs de la gestion de versions grâce aux performances extrêmes de Rust, et remplace avec un seul outil la dispersion de nvm, pyenv, rbenv, direnv et Makefile.

Pourquoi l'utiliser :

• ⚡ Rapide — Écrit en Rust, 20 fois plus rapide qu'asdf
• 🔧 Unifié — Un seul outil pour gérer les versions de tous vos outils de développement
• 🔄 Compatible — Compatible parfaitement avec .nvmrc, .tool-versions et autres configurations existantes
• 🚀 Écosystème — Supporte plus de 50 langages et outils
• 📦 Task runner intégré — Plus besoin de Makefile supplémentaire
• 🌍 Gestion des variables d'environnement — Plus besoin de direnv
• 🤝 Collaboration d'équipe — Commitez le mise.toml dans Git, les nouveaux membres configurent en une commande

Liens utiles :

• GitHub : jdx/mise
• Documentation : mise.jdx.dev
• Écosystème de plugins : Liste officielle des plugins Mise

Si vous utilisez encore la combinaison nvm + pyenv + asdf, je vous recommande vivement d'essayer Mise. Vous vous direz : "Mais pourquoi je n'ai pas découvert ça plus tôt ? La gestion de l'environnement de développement peut être si simple."