Curso de Rust 2026: Aprenda do Zero ao Avançado | Rust Brasil

Sim, existe um curso de Rust completo, gratuito e em português — e é exatamente este roteiro. Em 2026, você não precisa pagar uma bootcamp internacional para aprender a linguagem mais amada do Stack Overflow pelo décimo primeiro ano seguido: aqui no Rust Brasil reunimos um percurso estruturado, do zero ao avançado, com instalação, fundamentos, ownership, concorrência, async runtime, APIs web e projetos práticos. Cada módulo aponta para tutoriais aprofundados, exemplos de código que rodam de verdade e exercícios que vão do hello world a uma API REST publicável.

A diferença entre “tentar aprender Rust” e seguir um curso de Rust é o roteiro. Quem começa sem plano costuma travar no borrow checker, pular entre vídeos aleatórios e nunca terminar um projeto. Este guia resolve isso: são 12 módulos sequenciais, com critérios claros de “pronto para avançar”, pensados para quem fala português e quer entrar no mercado brasileiro. Se você já leu nosso guia de carreira Rust em 2026 ou o salário de desenvolvedor Rust no Brasil, sabe que a demanda existe — falta gente preparada. Antes de começar, confira também por que aprender Rust e o guia de como aprender Rust em 2026.

Por que fazer um curso de Rust em 2026

Rust resolve o problema clássico da programação de sistemas: performance de C e C++ sem os bugs de memória. O compilador garante segurança de memória e de concorrência em tempo de compilação, sem garbage collector. Na prática, isso significa aplicações rápidas, com latência previsível e consumo de memória baixo — exatamente o que fintechs, plataformas de infraestrutura, ferramentas de desenvolvimento e sistemas embarcados procuram.

Três fatos concretos explicam o momento:

1. Ferramentas que você já usa são escritas em Rust. O bundler do JavaScript swc, o resolver oxc, o linter Biome, partes do Firefox, do Discord, do Cloudflare e do Linux kernel (drivers e subsystemos desde 2022) são em Rust. Aprender a linguagem é entender o que roda por baixo do seu dia a dia.
2. O ecossistema amadureceu. Com o gerenciador de pacotes Cargo, frameworks web maduros como Axum e Actix-web, o runtime assíncrono Tokio e bibliotecas como serde, sqlx e clap, dá-se para construir aplicações de produção sem reinventar a roda.
3. O mercado brasileiro paga bem. Profissionais com Rust sólido estão concentrados em vagas de backend, infraestrutura e segurança, frequentemente com salários acima da média de linguagens mais populares — e com bem menos concorrência por posição.

Antes de começar: o ambiente

O primeiro passo de qualquer curso de Rust é configurar o ambiente. O caminho oficial é o rustup, que instala o compilador, o Cargo e permite trocar de versão (stable, beta, nightly) com um comando.

# Linux e macOS
curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh

# Windows: baixe rustup-init.exe em https://rustup.rs

Depois de instalar, verifique:

rustc --version   # compilador
cargo --version   # gerenciador de pacotes e build

Recomendamos o guia de instalação do Rust e a seção completa de instalação por sistema (Ubuntu, Debian, Fedora, Arch, macOS, Windows, WSL e Docker), além da referência do rustup. Para o editor, o guia de VS Code para Rust cobre rust-analyzer, formatação e debugging.

Crie seu primeiro projeto:

cargo new meu_primeiro_projeto
cd meu_primeiro_projeto
cargo run

Se apareceu Hello, world!, seu curso de Rust já começou. 🦀

O roteiro completo do curso

A seguir, os 12 módulos. Em cada um há um critério de conclusão — só avance quando conseguir cumpri-lo sem copiar a resposta.

Módulo 0 — Configuração e primeiros passos

Instale o Rust, configure o editor e rode o primeiro binário. Entenda o que são cargo new, cargo build, cargo run e cargo check. Acesse o tutorial de primeiros passos e mantenha a cheatsheet de Rust aberta como referência rápida.

Critério: crie um projeto com Cargo, edite a mensagem e rode com cargo run.

Módulo 1 — Variáveis, tipos e funções

Aprenda let e let mut, imutabilidade por padrão, tipos primitivos (i32, u64, f64, bool, char), strings (String vs &str), inferência de tipos, funções, controle de fluxo (if, loop, while, for) e a importância do match. Veja o tutorial de variáveis, tipos e funções.

fn dobro(x: i32) -> i32 {
    x * 2
}

fn main() {
    let numero = 7;
    let resultado = dobro(numero);
    println!("O dobro de {numero} é {resultado}");
}

Critério: escreva uma função que recebe dois números e retorna o maior.

Módulo 2 — Ownership, borrowing e lifetimes (o coração do curso)

Este é o módulo que separa quem aprende Rust de quem desiste. Ownership é o sistema pelo qual Rust garante segurança de memória sem garbage collector: cada valor tem um dono, e quando o dono sai de escopo o valor é liberado. Borrowing (& e &mut) permite emprestar o valor sem transferir a posse. Lifetimes garantem que referências não sobrevivam aos dados que apontam.

Não pule este módulo. Leia o tutorial completo de ownership e borrowing, faça os exercícios até o compilador parar de reclamar e só então siga em frente.

Critério: explique com suas palavras por que o código abaixo não compila e corrija-o.

// Não compila — entenda o porquê
fn main() {
    let s1 = String::from("rust");
    let s2 = s1;
    println!("{s1}"); // erro: s1 foi movida
}

Módulo 3 — Structs, enums e pattern matching

Estruture dados com struct (registro) e enum (tipo soma), e use match para lidar com cada variante. Entenda Option<T> (ausência de valor sem null) e como enums substituem herança. Tutorial: structs, enums e pattern matching.

Critério: modele uma enum Forma com variantes Circulo(f64), Retangulo { largura: f64, altura: f64 } e uma função que calcula a área com match.

Módulo 4 — Traits e generics

Traits definem comportamento compartilhado (interfaces) e generics permitem escrever código que funciona com qualquer tipo, sem perder a checagem estática. Entenda impl Trait, dyn Trait, trait bounds e os traits da biblioteca padrão (Clone, Debug, Display, Iterator). Tutoriais: traits e generics e o guia completo de traits com exemplos.

Critério: escreva um trait Resumivel com método resumo(&self) -> String e implemente-o para duas structs diferentes.

Módulo 5 — Tratamento de erros

Rust não tem exceções: erros são valores representados por Result<T, E> e o operador ? propaga falhas de forma limpa. Aprenda quando usar a biblioteca padrão e quando adicionar anyhow (erros de aplicação) e thiserror (erros de biblioteca). Tutorial: tratamento de erros e o guia de thiserror e anyhow.

use std::fs;

fn ler_config(caminho: &str) -> Result<String, std::io::Error> {
    let conteudo = fs::read_to_string(caminho)?;
    Ok(conteudo)
}

Critério: escreva uma função que lê um arquivo e retorna Result, propagando o erro com ?.

Módulo 6 — Coleções, iterares e estruturas de dados

Domine Vec<T>, HashMap<K, V>, String, iterares preguiçososos e os métodos de Iterator (map, filter, collect, fold). Para além do básico, estude estruturas de dados em Rust, algoritmos clássicos e padrões de projeto na prática.

Critério: use filter + map + collect para extrair, de um Vec<&str>, apenas as palavras com mais de 4 letras em maiúsculas.

Módulo 7 — Concorrência e programação assíncrona

Rust promete fearless concurrency (“concorrência sem medo”): o compilador impede data races em tempo de compilação. Estude threads, canais (std::sync::mpsc), Mutex e Arc, e depois entre no mundo assíncrono com async/await e o runtime Tokio. Tutoriais: concorrência e as referências de Tokio e crossbeam.

Critério: escreva um programa que lança duas threads, cada uma incrementa um contador compartilhado em Arc<Mutex<u64>> 1 milhão de vezes, e imprime o total.

Módulo 8 — O ecossistema: Cargo, crates e serde

Aprenda a gerenciar dependências com Cargo, a ler o Cargo.toml, a publicar no crates.io e a serializar dados com serde (JSON, YAML, TOML). Entenda clap para CLIs robustas. Referências: Cargo, serde, clap e o tutorial de CLI com clap.

Critério: adicione serde e serde_json ao projeto, defina uma struct com #[derive(Serialize, Deserialize)] e faça a conversão para JSON e de volta.

Módulo 9 — Web e APIs com Axum

Construa APIs HTTP modernas com Axum, o framework web mais usado na stack Tokio. Aprenda rotas, extratores, handlers async, middleware, estado compartilhado e tratamento de erros HTTP. Tutoriais: API REST com Axum, referência de Axum e conexão com banco via sqlx no tutorial de Rust com PostgreSQL.

Critério: crie uma API com rota GET /saude retornando 200 OK e outra GET /usuarios/:id retornando um JSON.

Módulo 10 — WebAssembly, testes e qualidade

Compile Rust para WebAssembly para rodar no navegador, escreva testes com cargo test e domine boas práticas de validação (proptest, fuzzing). Tutoriais: WebAssembly com Rust, referência de wasm-bindgen e testes em Rust. Consulte também o guia de erros comuns quando o compilador gritar.

Critério: escreva uma função com dois testes unitários (#[test]) e rode com cargo test.

Módulo 11 — Projetos práticos e portfólio

A teoria só vira habilidade com projeto terminado. Escolha um destes, publique no GitHub e coloque no currículo:

• Gerador de arte ASCII, ensinando CLI, strings e clap (veja o projeto de gerador de arte ASCII);
• Emulador de Chip-8, ensinando arquitetura, máquinas de estado e rendering (veja o emulador de Chip-8);
• API REST de tarefas com Axum + sqlx + PostgreSQL (tutorial de API REST CRUD);
• CLI de produtividade, com clap, arquivos e serde.

Termine 2 ou 3 projetos, documente o README, adicione testes e publique. Esse portfólio vale mais que qualquer certificado. Veja também o guia de portfólio no GitHub e o de projetos práticos para aprender Rust.

Quanto tempo leva o curso

Não existe prazo fixo, mas é possível estabelecer um ritmo realista para quem estuda de 1 a 2 horas por dia:

Programadores com bagagem em C, C++, Go, Java ou Python avançam mais rápido na sintaxe, mas travam nos mesmos pontos de borrowing e lifetimes — são conceitos próprios do Rust. Se você vem do JavaScript ou Python, reserve tempo extra no Módulo 2 e confira nossos comparativos: Rust vs JavaScript 2026, Rust vs Python 2026, Rust vs Go 2026 e Rust vs C++ 2026.

Onde praticar e tirar dúvidas

O curso fica mais rápido com comunidade. Participe do Discord da Rust Brasil (/comunidade/), consulte o glossário quando um termo for novo, use a busca do site para achar receitas específicas e explore as receitas de código prontas para copiar e adaptar. Para quem quer vagas, a seção de vagas de Rust reúne oportunidades júnior, pleno e sênior no Brasil e remotas.

Comece agora

Você não precisa de mais nada para iniciar: instale o Rust, abra o tutorial de primeiros passos e rode o primeiro cargo run ainda hoje. Um curso de Rust em português, gratuito e do zero ao avançado existe — e começa no próximo comando que você digitar. Boa jornada, e até no Discord.

Este artigo é atualizado conforme o ecossistema evolui. Para receber novidades sobre novos tutoriais e vagas, acompanhe a comunidade Rust Brasil e o blog.