Equipe Rust Brasil 4 min de leitura

Instalar Rust com Nix e NixOS

Guia completo para instalar Rust com Nix, NixOS, flakes e rust-overlay. Aprenda a criar ambientes reproduzíveis para desenvolvimento Rust.

rust instalação nix nixos flakes rust-overlay

O Nix é um gerenciador de pacotes funcional que garante builds reproduzíveis e isolamento perfeito de ambientes. Se você usa NixOS ou Nix em qualquer distribuição, este guia mostra como configurar o Rust com nix-shell, flakes e rust-overlay para ambientes de desenvolvimento reproduzíveis.

Por Que Usar Nix para Rust?

  • Reprodutibilidade: Cada membro da equipe terá exatamente o mesmo ambiente
  • Isolamento: Diferentes projetos podem usar diferentes versões do Rust
  • Declarativo: A configuração do ambiente está versionada no repositório
  • Sem conflitos: Nenhuma poluição do sistema global

Instalar Nix (se ainda não tem)

Se você não usa NixOS, instale o Nix em qualquer Linux ou macOS:

sh <(curl -L https://nixos.org/nix/install) --daemon

Habilite flakes e o novo CLI (recomendado):

mkdir -p ~/.config/nix
echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf

Método 1: nix-shell (Tradicional)

Shell Temporário

Para ter Rust disponível rapidamente:

nix-shell -p rustc cargo rustfmt clippy

Isso abre um shell com Rust disponível, sem instalar nada permanentemente.

shell.nix para Projetos

Crie um shell.nix na raiz do projeto:

{ pkgs ? import <nixpkgs> {} }:

pkgs.mkShell {
  buildInputs = with pkgs; [
    rustc
    cargo
    rustfmt
    clippy
    rust-analyzer

    # Dependências de compilação comuns
    pkg-config
    openssl
  ];

  RUST_SRC_PATH = "${pkgs.rust.packages.stable.rustPlatform.rustLibSrc}";
}

Entre no ambiente:

cd meu-projeto
nix-shell
rustc --version
cargo build

Método 2: Flakes com rust-overlay (Recomendado)

O rust-overlay (anteriormente nixpkgs-mozilla) fornece builds nightly e controle fino sobre a versão do Rust.

Configurar o flake.nix

Crie um flake.nix na raiz do projeto:

{
  description = "Projeto Rust com Nix Flakes";

  inputs = {
    nixpkgs.url = "github:NixOS/nixpkgs/nixpkgs-unstable";
    rust-overlay.url = "github:oxalica/rust-overlay";
    flake-utils.url = "github:numtide/flake-utils";
  };

  outputs = { self, nixpkgs, rust-overlay, flake-utils }:
    flake-utils.lib.eachDefaultSystem (system:
      let
        overlays = [ (import rust-overlay) ];
        pkgs = import nixpkgs {
          inherit system overlays;
        };

        rustToolchain = pkgs.rust-bin.stable.latest.default.override {
          extensions = [ "rust-src" "rust-analyzer" ];
          targets = [ "wasm32-unknown-unknown" ];
        };
      in
      {
        devShells.default = pkgs.mkShell {
          buildInputs = with pkgs; [
            rustToolchain
            pkg-config
            openssl
          ];
        };
      }
    );
}

Usar o Flake

# Entrar no ambiente de desenvolvimento
nix develop

# Ou executar um comando único
nix develop --command cargo build

# Verificar a versão
nix develop --command rustc --version

Usar Nightly com Flakes

Para usar a toolchain nightly, altere a linha do rustToolchain:

# Nightly mais recente
rustToolchain = pkgs.rust-bin.nightly.latest.default.override {
  extensions = [ "rust-src" "rust-analyzer" ];
};

# Nightly de uma data específica
rustToolchain = pkgs.rust-bin.nightly."2026-02-20".default.override {
  extensions = [ "rust-src" "rust-analyzer" ];
};

# Beta
rustToolchain = pkgs.rust-bin.beta.latest.default;

Método 3: NixOS System Configuration

Se você usa NixOS como sistema operacional, adicione o Rust à configuração do sistema:

# /etc/nixos/configuration.nix
{ config, pkgs, ... }:

{
  environment.systemPackages = with pkgs; [
    rustc
    cargo
    rustfmt
    clippy
    rust-analyzer
  ];
}

Aplique a configuração:

sudo nixos-rebuild switch

Nota: Para desenvolvimento, prefira nix develop (flakes) ou nix-shell para ter ambientes isolados por projeto, em vez de instalar globalmente.

Integrar com direnv

O direnv ativa automaticamente o ambiente Nix ao entrar no diretório do projeto:

# Instalar direnv
nix-env -iA nixpkgs.direnv nixpkgs.nix-direnv

Crie um .envrc na raiz do projeto:

# Para flakes
use flake

# Para shell.nix tradicional
# use nix

Permita o direnv:

direnv allow

Agora, ao entrar no diretório, o ambiente Rust é ativado automaticamente. Isso funciona perfeitamente com o VS Code (veja o guia de VS Code para Rust) e Neovim (veja o guia de Neovim para Rust).

Compilar Pacotes Nix em Rust

Para empacotar um projeto Rust como derivação Nix:

# No flake.nix, adicione ao outputs:
packages.default = pkgs.rustPlatform.buildRustPackage {
  pname = "meu-app";
  version = "0.1.0";
  src = ./.;

  cargoLock = {
    lockFile = ./Cargo.lock;
  };

  nativeBuildInputs = with pkgs; [ pkg-config ];
  buildInputs = with pkgs; [ openssl ];
};

Build:

nix build
./result/bin/meu-app

Solução de Problemas

Erro: “error: experimental Nix feature ‘flakes’ is disabled”

Habilite flakes na configuração do Nix:

echo "experimental-features = nix-command flakes" >> ~/.config/nix/nix.conf

No NixOS, adicione à configuração:

nix.settings.experimental-features = [ "nix-command" "flakes" ];

rust-analyzer não encontra a stdlib

Certifique-se de incluir rust-src nas extensões:

rustToolchain = pkgs.rust-bin.stable.latest.default.override {
  extensions = [ "rust-src" ];
};

E defina a variável RUST_SRC_PATH se necessário.

Conflito entre rustup e Nix

Não use rustup junto com Nix. Escolha um ou outro para gerenciar o Rust. Se tiver rustup instalado, remova-o antes de usar Nix:

rustup self uninstall

Para detalhes sobre rustup, consulte o Guia Completo do Rustup.

Próximos Passos

Com Rust configurado via Nix:

Se você também usa Nix para Go, confira o golang.com.br para guias de configuração similares.

Última atualização: 23 de fevereiro de 2026. Para remover o Rust, veja Como Desinstalar Rust.