---
title: "Instalar Rust com Nix e NixOS"
url: "https://rustlang.com.br/instalacao/nix/"
markdown_url: "https://rustlang.com.br/instalacao/nix.MD"
description: "Guia completo para instalar Rust com Nix, NixOS, flakes e rust-overlay. Aprenda a criar ambientes reproduzíveis para desenvolvimento Rust."
date: "2026-02-23"
author: "Equipe Rust Brasil"
---

# 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.


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:

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

Habilite flakes e o novo CLI (recomendado):

```bash
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:

```bash
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:

```nix
{ 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:

```bash
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:

```nix
{
  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

```bash
# 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`:

```nix
# 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:

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

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

Aplique a configuração:

```bash
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:

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

Crie um `.envrc` na raiz do projeto:

```bash
# Para flakes
use flake

# Para shell.nix tradicional
# use nix
```

Permita o direnv:

```bash
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](/instalacao/vscode/)) e Neovim (veja o [guia de Neovim para Rust](/instalacao/neovim/)).

## Compilar Pacotes Nix em Rust

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

```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:

```bash
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:

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

No NixOS, adicione à configuração:

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

### rust-analyzer não encontra a stdlib

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

```nix
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:

```bash
rustup self uninstall
```

Para detalhes sobre rustup, consulte o [Guia Completo do Rustup](/instalacao/rustup/).

## Próximos Passos

Com Rust configurado via Nix:

- Siga o tutorial de [Primeiros Passos com Rust](/tutoriais/primeiros-passos/)
- Consulte o [Cheatsheet Rust](/cheatsheet/) para referência rápida
- Explore o [Guia Completo do Cargo](/instalacao/cargo/) para gerenciar projetos
- Configure [CI/CD com GitHub Actions](/instalacao/github-actions/) usando Nix
- Veja as [Perguntas Frequentes](/faq/) para dúvidas comuns

Se você também usa Nix para Go, confira o [golang.com.br](https://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](/instalacao/desinstalar/).*