---
title: "Instalando Rust: Guia Completo para Linux, macOS e Windows"
url: "https://rustlang.com.br/tutoriais/instalando-rust/"
markdown_url: "https://rustlang.com.br/tutoriais/instalando-rust.MD"
description: "Aprenda a instalar Rust no seu sistema operacional usando rustup. Configure o Cargo, rustc e seu editor de código com rust-analyzer."
date: "2026-02-21"
author: "Equipe Rust Brasil"
---

# Instalando Rust: Guia Completo para Linux, macOS e Windows

Aprenda a instalar Rust no seu sistema operacional usando rustup. Configure o Cargo, rustc e seu editor de código com rust-analyzer.


Neste tutorial, você vai aprender a instalar Rust no seu computador, independente do sistema operacional que você usa. Vamos cobrir a instalação no Linux, macOS e Windows, além de configurar o editor de código para ter a melhor experiência de desenvolvimento possível.

## O que é rustup?

O **rustup** é o instalador oficial e gerenciador de versões do Rust. Com ele, você pode:

- Instalar o compilador Rust (`rustc`)
- Instalar o gerenciador de pacotes e build system (`cargo`)
- Gerenciar múltiplas versões do Rust (stable, beta, nightly)
- Instalar componentes adicionais como `clippy` (linter) e `rustfmt` (formatador de código)

O rustup é a forma recomendada de instalar Rust, e é o método que vamos usar neste tutorial.

## Instalação no Linux e macOS

A instalação no Linux e macOS é praticamente idêntica. Abra o terminal e execute o seguinte comando:

```bash
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
```

Este comando baixa e executa o script de instalação do rustup. Você verá algo como:

```
Welcome to Rust!

This will download and install the official compiler for the Rust
programming language, and its package manager, Cargo.

Rustup metadata and toolchains will be installed into the Rustup
home directory, located at:

  /home/usuario/.rustup

This can be modified with the RUSTUP_HOME environment variable.

The Cargo home directory is located at:

  /home/usuario/.cargo

This can be modified with the CARGO_HOME environment variable.

The cargo, rustc, rustup and other commands will be added to
Cargo's bin directory, located at:

  /home/usuario/.cargo/bin

1) Proceed with standard installation (default - just press enter)
2) Customize installation
3) Cancel installation
```

Para a maioria dos casos, basta pressionar **Enter** para prosseguir com a instalação padrão. O instalador vai baixar e configurar tudo automaticamente.

### Configurando o PATH

Após a instalação, você precisa adicionar o diretório do Cargo ao seu PATH. O instalador geralmente faz isso automaticamente, mas para aplicar as mudanças na sessão atual do terminal, execute:

```bash
source "$HOME/.cargo/env"
```

Se você usa **zsh** (padrão no macOS moderno), adicione essa linha ao seu `~/.zshrc`. Se usa **bash**, adicione ao `~/.bashrc`.

### Dependências no Linux

No Linux, você pode precisar instalar algumas dependências de compilação. No Ubuntu/Debian:

```bash
sudo apt update
sudo apt install build-essential pkg-config libssl-dev
```

No Fedora:

```bash
sudo dnf install gcc pkg-config openssl-devel
```

No Arch Linux:

```bash
sudo pacman -S base-devel openssl
```

## Instalação no Windows

No Windows, você tem duas opções principais:

### Opção 1: Instalador rustup (Recomendado)

1. Acesse [https://rustup.rs](https://rustup.rs)
2. Baixe e execute o instalador `rustup-init.exe`
3. Siga as instruções na tela

**Importante:** O Rust no Windows requer as **Build Tools do Visual Studio**. O instalador vai informar se elas não estiverem presentes. Você pode baixá-las em [https://visualstudio.microsoft.com/visual-cpp-build-tools/](https://visualstudio.microsoft.com/visual-cpp-build-tools/). Durante a instalação das Build Tools, selecione "Desenvolvimento para desktop com C++".

### Opção 2: WSL (Windows Subsystem for Linux)

Se você prefere um ambiente Linux no Windows, pode usar o WSL:

1. Abra o PowerShell como administrador e execute:

```powershell
wsl --install
```

2. Reinicie o computador
3. Abra o terminal do Ubuntu (instalado pelo WSL)
4. Siga as instruções de instalação do Linux acima

O WSL é uma excelente opção para quem quer ter a experiência completa do Linux sem sair do Windows.

## Verificando a Instalação

Após a instalação, abra um **novo** terminal e execute:

```bash
rustc --version
```

Você deve ver algo como:

```
rustc 1.85.0 (4d91de4e4 2025-02-17)
```

Verifique também o Cargo:

```bash
cargo --version
```

Saída esperada:

```
cargo 1.85.0 (d73d2caf9 2024-12-31)
```

E o rustup:

```bash
rustup --version
```

Se todos os três comandos retornaram versões, parabéns! O Rust está instalado corretamente.

## Atualizando o Rust

O Rust lança uma nova versão estável a cada seis semanas. Para atualizar, basta executar:

```bash
rustup update
```

Este comando atualiza o compilador, o Cargo e todos os componentes instalados.

## Configurando o Editor de Código: VS Code

O **Visual Studio Code** é o editor mais popular para desenvolvimento em Rust. Veja como configurá-lo:

### 1. Instale o VS Code

Baixe e instale o VS Code em [https://code.visualstudio.com](https://code.visualstudio.com).

### 2. Instale a extensão rust-analyzer

O **rust-analyzer** é a extensão essencial para desenvolvimento Rust no VS Code. Ele oferece:

- **Autocompletar** inteligente
- **Diagnósticos** em tempo real (erros e avisos)
- **Go to definition** e **Find references**
- **Refatorações** automáticas
- **Inlay hints** (dicas de tipo inline)
- **Formatação** automática com rustfmt

Para instalar:

1. Abra o VS Code
2. Pressione `Ctrl+Shift+X` (ou `Cmd+Shift+X` no macOS) para abrir as extensões
3. Pesquise por "rust-analyzer"
4. Clique em "Install" na extensão oficial (autor: rust-lang)

### 3. Extensões adicionais recomendadas

Algumas extensões que complementam muito bem o desenvolvimento em Rust:

- **Even Better TOML** — Suporte para arquivos TOML (usados pelo Cargo)
- **Error Lens** — Mostra erros e avisos diretamente na linha do código
- **CodeLLDB** — Depurador para Rust (essencial para debugging)
- **crates** — Mostra versões de dependências no Cargo.toml

### 4. Configurações úteis no VS Code

Abra as configurações do VS Code (`Ctrl+,`) e adicione ao `settings.json`:

```json
{
    "rust-analyzer.check.command": "clippy",
    "rust-analyzer.inlayHints.typeHints.enable": true,
    "rust-analyzer.inlayHints.parameterHints.enable": true,
    "[rust]": {
        "editor.formatOnSave": true,
        "editor.defaultFormatter": "rust-lang.rust-analyzer"
    }
}
```

Essas configurações fazem com que:
- O clippy (linter avançado) rode automaticamente ao salvar
- Dicas de tipo apareçam inline no código
- O código seja formatado automaticamente ao salvar

## Outros Editores

Embora o VS Code seja o mais popular, o rust-analyzer funciona com vários editores:

- **Neovim** — Via plugin `nvim-lspconfig` com rust-analyzer
- **Emacs** — Via `lsp-mode` ou `eglot` com rust-analyzer
- **IntelliJ IDEA / CLion** — Plugin oficial "Rust" da JetBrains (usa seu próprio motor, não o rust-analyzer)
- **Helix** — Suporte nativo a LSP, funciona com rust-analyzer sem configuração

## Ferramentas Adicionais

Instale estas ferramentas úteis via rustup e cargo:

```bash
# Clippy - linter com sugestões inteligentes
rustup component add clippy

# Rustfmt - formatador de código
rustup component add rustfmt

# cargo-watch - recompila automaticamente ao salvar
cargo install cargo-watch

# cargo-edit - adiciona dependências pela linha de comando
cargo install cargo-edit
```

Com o `cargo-watch`, você pode recompilar automaticamente ao salvar qualquer arquivo:

```bash
cargo watch -x run
```

E com o `cargo-edit`, adicionar dependências fica mais fácil:

```bash
cargo add serde --features derive
```

## Testando a Instalação com um Programa

Vamos garantir que tudo funciona criando um programa simples:

```bash
cargo new ola-rust
cd ola-rust
cargo run
```

Se você vir a saída `Hello, world!`, sua instalação está perfeita e você está pronto para começar a programar em Rust!

## Solução de Problemas Comuns

### "command not found: rustc"

O PATH não está configurado. Execute:

```bash
source "$HOME/.cargo/env"
```

E adicione essa linha ao seu arquivo de configuração do shell (`~/.bashrc` ou `~/.zshrc`).

### "linker 'cc' not found" no Linux

Instale as ferramentas de compilação:

```bash
sudo apt install build-essential   # Ubuntu/Debian
sudo dnf install gcc               # Fedora
```

### "link.exe not found" no Windows

Instale as Build Tools do Visual Studio com o componente "Desenvolvimento para desktop com C++".

### Problemas com SSL no Linux

Instale as bibliotecas de desenvolvimento SSL:

```bash
sudo apt install libssl-dev        # Ubuntu/Debian
sudo dnf install openssl-devel     # Fedora
```

## Próximos Passos

Agora que o Rust está instalado e configurado, você está pronto para dar seus primeiros passos! No próximo tutorial, vamos criar nosso primeiro projeto Rust e entender como o Cargo funciona.

Acesse o tutorial [Primeiros Passos com Rust](/tutoriais/primeiros-passos/) para continuar sua jornada.

Se você também se interessa por outras linguagens de sistemas modernas, confira o <a href="https://ziglang.com.br/" target="_blank" rel="noopener" onclick="umami.track('portfolio-site-click', { destination: 'ziglang.com.br' })">portal Zig Brasil</a> — Zig é outra linguagem que compete no espaço de programação de sistemas com uma filosofia diferente da Rust.