Mise (antigo rtx): gerencie versões de runtime com um único comando

1. O que é o Mise e por que ele substitui o rtx

O Mise (anteriormente conhecido como rtx) é uma ferramenta unificada e moderna para gerenciar versões de runtime e ferramentas de desenvolvimento. Originalmente lançado como "rtx" (uma brincadeira com "runtime exec"), o projeto foi renomeado para "Mise" em 2024 para evitar confusão com a sigla RTX (Real-Time eXtensions) e para refletir sua missão mais ampla: "mise en place" — o conceito culinário de ter tudo em seu devido lugar antes de começar a cozinhar.

A principal motivação do Mise é eliminar a fragmentação de ferramentas como nvm (Node), pyenv (Python), rbenv (Ruby), sdkman (Java, Scala, Kotlin) e jenv (Java). Em vez de instalar e gerenciar múltiplos gerenciadores de versão, cada um com sua própria sintaxe e arquivos de configuração, o Mise oferece uma interface única e consistente para todos eles.

Comparado às alternativas tradicionais, o Mise se destaca por:
- Velocidade: implementado em Rust, é significativamente mais rápido que ferramentas escritas em shell script.
- Unificação: um único comando para gerenciar Node, Python, Ruby, Java, Go, Rust, Deno, Terraform e centenas de outras ferramentas.
- Configuração declarativa: arquivos .mise.toml simples e versionáveis.
- Plugins: arquitetura extensível que permite adicionar suporte a qualquer runtime ou ferramenta.

2. Instalação e configuração inicial

A instalação do Mise é simples e pode ser feita de várias formas:

Via curl (Linux/macOS):

curl https://mise.run | sh

Via Homebrew (macOS/Linux):

brew install mise

Via winget (Windows):

winget install jdx.mise

Após a instalação, é necessário ativar o Mise no shell. Adicione a seguinte linha ao seu arquivo de inicialização (.bashrc, .zshrc ou config.fish):

Para bash/zsh:

eval "$(mise activate bash)"
eval "$(mise activate zsh)"

Para fish:

mise activate fish | source

Verifique a instalação:

mise --version
mise help

3. Gerenciando runtimes com um único comando

O Mise unifica todos os comandos de gerenciamento de versão em uma única interface. Exemplos práticos:

Instalar versões específicas:

mise install node@18.20.0
mise install python@3.11.9
mise install java@openjdk-21

Listar versões disponíveis e instaladas:

mise ls-remote node    # Versões disponíveis para instalação
mise ls                # Versões instaladas localmente
mise ls --global       # Versões instaladas globalmente

Definir versões padrão (global) e por projeto (local):

mise use --global node@18.20.0    # Versão global
mise use node@20.11.0              # Versão local (cria .mise.toml no diretório atual)

4. O arquivo de configuração .mise.toml

O coração do Mise é o arquivo .mise.toml, que usa a sintaxe TOML para declarar versões de runtime de forma clara e versionável.

Exemplo prático para um projeto Node + Python + Java:

[tools]
node = "18.20.0"
python = "3.11.9"
java = { version = "21", source = "openjdk" }

[env]
NODE_ENV = "development"

Estrutura e herança:
- O arquivo .mise.toml no diretório atual define versões para aquele projeto.
- Arquivos em diretórios pais são herdados (escopo global vs. local).
- É possível ter múltiplos arquivos .mise.toml em diferentes níveis do sistema de arquivos.

Versionamento: Recomenda-se adicionar .mise.toml ao repositório Git para garantir que todos os membros da equipe usem as mesmas versões.

5. Plugins e suporte a múltiplos ecossistemas

O Mise suporta nativamente dezenas de runtimes e ferramentas, incluindo Node.js, Python, Ruby, Java, Go, Rust, Deno, Bun, Elixir, Erlang, Terraform, Packer, e muito mais. Para runtimes não suportados nativamente, o sistema de plugins permite extensão fácil.

Instalar um plugin:

mise plugins install kubectl

Listar runtimes suportados nativamente e via plugins:

mise plugins ls --all

Exemplo de ferramentas não-runtime gerenciáveis:
- Linters: ESLint, Prettier, Ruff
- Formatadores: Black, gofmt
- Bancos de dados: SQLite, PostgreSQL (clientes)
- Infraestrutura: Terraform, Pulumi, AWS CLI

6. Comandos avançados e integração com CI/CD

mise exec e mise run: Execute comandos com runtimes específicos sem ativar o ambiente permanentemente.

# Executar um script Node com versão específica
mise exec node@18.20.0 -- node script.js

# Executar comando usando as versões definidas no .mise.toml local
mise run make build

Integração com Docker: O Mise pode ser usado dentro de containers Docker para garantir versões consistentes:

FROM ubuntu:22.04
RUN curl https://mise.run | sh
RUN eval "$(mise activate bash)" && mise install node@18.20.0

Uso em pipelines CI (GitHub Actions):

- name: Setup Mise
  run: |
    curl https://mise.run | sh
    echo "$HOME/.local/share/mise/bin" >> $GITHUB_PATH
    eval "$(mise activate bash)"
    mise install

7. Fluxo de trabalho com projetos existentes

Migração de nvm/pyenv/rbenv: O Mise consegue importar configurações existentes automaticamente.

# Importar versão de .nvmrc
mise use node --ref .nvmrc

# Importar versão de .python-version
mise use python --ref .python-version

# Importar versão de .ruby-version
mise use ruby --ref .ruby-version

Trabalhando com múltiplos projetos: Cada projeto pode ter seu próprio .mise.toml. O Mise alterna automaticamente as versões ao navegar entre diretórios (graças à ativação no shell).

Cache e desempenho: O Mise faz cache das versões baixadas e dos binários compilados, tornando a alternância entre versões praticamente instantânea.

8. Dicas, limitações e próximos passos

Boas práticas:
- Sempre versionar .mise.toml no repositório.
- Evitar configurar versões globais conflitantes (ex.: Node 18 global e Node 20 local).
- Usar mise trust para marcar arquivos .mise.toml de projetos confiáveis.

Limitações conhecidas:
- Suporte a Windows ainda é experimental (alguns plugins podem não funcionar).
- Plugins da comunidade podem ter qualidade variável.
- A migração de ferramentas legadas (como asdf) requer atenção aos arquivos .tool-versions.

Próximos passos: Explore a documentação oficial, participe do Discord da comunidade e acompanhe o changelog no GitHub para novidades.

Referências