A história da linguagem Rust

Rust começou num hobby de 2006: Graydon Hoare, engenheiro da Mozilla, irritado com o elevador do prédio que caía por software em C. O nome veio do fungo — “superengenheirado para sobreviver”. A Mozilla patrocinou em 2009. A 0.1 pública saiu em 20 de janeiro de 2012. A 1.0, em 15 de maio de 2015. Em 3 de setembro de 2026 a estável é a 1.98.1. Sem coletor de lixo. Sem data race. O kernel Linux 6.1 (dezembro de 2022) aceitou a segunda língua da história do projeto: Rust, ao lado de C.

2006: o elevador e o OCaml

Hoare tinha 29 anos e trabalhava na Mozilla. O elevador do apartamento travava; ele atribuiu a bugs de memória no controlador. A tese: dá para ter desempenho de C++ sem o undefined behavior. Entre 2006 e 2009 o projeto ficou no tempo livre. O primeiro compilador tinha umas 38 mil linhas de OCaml. Tinha coisas que depois sumiram: OOP explícito com obj, análise de typestate, um coletor de lixo.

As influências, nas palavras dele, eram “tecnologia do passado para salvar o futuro de si mesmo”: CLU, Erlang, Newsqueak, Limbo, Mesa, Sather, Alef. Manish Goregaokar resumiu: pesquisa de décadas, não moda.

O nome rust é o da ferrugem dos fungos, não o da chapa. Superfície hostil, organismo teimoso.

A ideia central: ownership e o borrow checker

Antes de seguir a cronologia, vale entender o que o Rust realmente inventou — porque não é sintaxe, é uma regra de contabilidade que o compilador cobra.

Em C você aloca e libera na mão, e erra: usar depois de liberar, liberar duas vezes, estourar o buffer. Em Java ou Go, um coletor de lixo resolve isso em troca de pausas e de memória extra. O Rust escolheu a terceira porta: nenhum dos dois. Cada valor tem um único dono; quando o dono sai de escopo, a memória é liberada — em tempo de compilação, sem runtime nenhum.

fn main() {
    let s1 = String::from("olá");
    let s2 = s1;              // a posse MOVE de s1 para s2
    println!("{s1}");          // erro de compilação: s1 não é mais dono
}

Para usar sem transferir a posse, você empresta — e aqui entra a regra que dá nome ao borrow checker: ou você tem vários empréstimos só de leitura, or um único de escrita, nunca os dois ao mesmo tempo.

let mut v = vec![1, 2, 3];
let primeiro = &v[0];      // empréstimo de leitura
v.push(4);                  // erro: precisaria de empréstimo de escrita
println!("{primeiro}");

Parece implicância — e é exatamente esse o passo em que quem vem de C++ desiste na primeira semana. Mas essa mesma regra, aplicada entre threads, é o que elimina data race em tempo de compilação. Não é convenção, não é boa prática, não é revisão de código: o programa não compila. É por isso que o kernel se interessou.

2009–2012: a nerd cave

Em 2009 a Mozilla oficializou. Brendan Eich (então CTO) e a Research viram um motor de browser seguro. Entraram Patrick Walton, Niko Matsakis, Felix Klock, Goregaokar. A sala virou “nerd cave”, com placa na porta — apelido de Dave Herman. Ownership já estava no desenho por volta de 2010. O logo, em 2011, saiu de uma coroa de bicicleta (chainring): o R dentro da engrenagem.

O compilador passou a se auto-hospedar, alvo LLVM. Em 20 de janeiro de 2012 saiu a 0.1 para Linux, Windows e macOS — a primeira pública. Bootstrap em 2011 levava horas.

Até a 1.0: o GC some, Graydon sai

De 2012 a 2015 o sistema de tipos virou o Rust de hoje. O GC, raro em 2013, foi removido. Sumiram o typestate, o pure, os ponteiros especiais e a sintaxe de canal. Quem vinha de C++ puxou desempenho; quem vinha de script, o Cargo; quem vinha de ML, o tipo.

Em 2013 Hoare saiu do dia a dia. A governança virou federada: core team de seis, depois nove, RFCs a partir de março de 2014. Andrew Binstock no Dr. Dobb’s (jan/2014): língua elegante, adoção lenta porque mudava a cada nightly.

Under 15 de maio de 2015 a 1.0. Compromisso de compatibilidade. Steve Klabnik escreveu dezenas de páginas de docs na reta final. Um ano depois: 1.400 contribuidores no compilador, 5 mil crates. O cargo já era o gerenciador oficial (2014).

Servo, Firefox, o teste de fogo

A Mozilla e a Samsung financiaram o Servo (2012 em diante): motor de browser em Rust, laboratório da língua. Firefox 45 (2016) já embarcava código Rust. Componentes do Servo chegaram no 57 (setembro de 2017), projeto Quantum. Sem o browser, a 1.0 teria sido outra língua.

Fora da Mozilla, cedo: Samsung, Facebook, Dropbox, Tilde (Ember). AWS em 2020. O argumento repetido: desempenho, sem GC, sem data race, experiência de compilador que empurra o código seguro.

Edições: 2018, 2021, 2024

Rust não quebra crate velha no compilador novo. A crate declara a edition no Cargo.toml e convive com a toolchain atual.

• 2015 — a 1.0.
• 2018 (1.31) — módulo, ? mais ergonômico, non-lexical lifetimes.
• 2021 (1.56, out/2021) — disjoint capture em closures, resolver de prelude.
• 2024 — com a 1.85.0, em 20 de fevereiro de 2025.

async/await estabilizou na 1.39 (7 de novembro de 2019). Sem isso, o Rust de servidor web não existiria como existe.

2020: a Mozilla corta, nasce a Foundation

Em agosto de 2020 a Mozilla demitiu 250 pessoas — cerca de um quarto do quadro. O time do Servo se dissolveu. O core team anunciou uma fundação independente para marcas e domínio. Em 8 de fevereiro de 2021 nasceu a Rust Foundation: AWS, Google, Huawei, Microsoft, Mozilla. Meta e ARM entraram no mesmo ano. Google, em abril de 2021, anunciou Rust no Android Open Source Project.

Em junho de 2026 a OpenAI entrou na Foundation. Marcas e política de trademark geraram briga em 2023 (o rascunho foi mal recebido). Governança federada não é paz eterna — em novembro de 2021 o time de moderação renunciou em protesto. A língua sobreviveu aos dois.

O kernel: da experiência de 2022 ao veredito de 2025

Linus puxou a infra Rust no merge da 6.1 (Phoronix, 3 de outubro de 2022; estável em 11 de dezembro). Cerca de 12 mil linhas: build, crates mínimos, “hello world” de módulo. Segunda língua do kernel depois de C — mas entrou declaradamente como experimento: se não desse certo, sairia.

Em dezembro de 2025, no Maintainers Summit, a sessão conduzida por Miguel Ojeda declarou o experimento um sucesso, e o Rust passou a linguagem central do kernel ao lado de C e assembly. Os números que sustentaram a decisão:

• O driver Nova, para GPUs NVIDIA, com peças já na linha principal; Tyr para Mali e o driver do Asahi para Apple Silicon na mesma trilha.
• The binder do Android reescrito em Rust, integrado na 6.18.
• The ashmem em Rust rodando no Android 16 sobre o kernel 6.12 — milhões de aparelhos reais com código Rust no kernel.
• O Debian habilitou Rust nas builds do kernel, o que aparece a partir do “forky”.
• A quantidade de código Rust no kernel quintuplicou em um ano.

Duas frentes de compilador também andaram: o rustc_codegen_gcc, que enxerta o gerador de código do GCC no rustc, e o gccrs, o compilador Rust do próprio GCC — que já consegue compilar o código Rust do kernel. Isso importa porque tira o kernel da dependência de um único compilador, velha exigência da comunidade.

A política de versão ficou pragmática: o kernel se compromete a compilar com a versão do Rust que estiver no Debian estável, subindo o mínimo de 6 a 12 meses depois de cada release do Debian. Para este blog, o recado é o de sempre: o C do kernel deixou de ser dogma.

Onde o Rust já está na sua distro

A parte que surpreende quem não acompanhou: o Rust deixou de ser “linguagem de projeto novo” e entrou no caminho crítico do sistema que você usa.

• Ubuntu 25.10 passou a entregar o sudo pelo sudo-rs, a reimplementação em Rust — com o sudo original ainda disponível como alternativa no update-alternatives.
• Ubuntu 26.04 LTS é o primeiro LTS a trazer os utilitários básicos do uutils/coreutils em Rust no lugar dos do GNU: ls, cp, mv e dezenas de outros. A estratégia da Canonical foi a correta — testar nas versões intermediárias antes de promover ao LTS.
• No kernel, os drivers em Rust citados acima; no Android, o binder e o ashmem.

Não é consenso: parte da comunidade acha que trocar o coreutils do GNU por uma reimplementação de licença permissiva é decisão política, não técnica. O argumento do outro lado é direto — ls and cp processam entrada não confiável há cinquenta anos em C.

Instalando no Linux

A série estável em 3 de setembro de 2026 é a 1.98.1. O caminho oficial é o rustup, não o apt atrasado da distro — o Rust lança a cada seis semanas e o pacote da distro fica velho rápido:

curl --proto '=https' --tlsv1.2 -sSf https://sh.rustup.rs | sh
source "$HOME/.cargo/env"
rustc --version
cargo new ola && cd ola && cargo run

The rustup gerencia toolchains lado a lado — estável, beta e nightly — e é como você troca de canal sem quebrar nada:

rustup update
rustup toolchain install nightly
cargo +nightly build
rustup component add clippy rustfmt   # linter e formatador oficiais

O outro lado

Um post de história que só elogia não serve para decidir nada. O que pesa contra:

• Curva de aprendizado real. O borrow checker não negocia. As primeiras semanas são de brigar com o compilador, e a queixa é legítima — só passa depois que o modelo mental de posse entra.
• Tempo de compilação. Projeto grande com muitas dependências compila devagar, e o build limpo é sofrido. Melhorou muito, ainda incomoda.
• O ecossistema assíncrono é complexo. async/await estabilizou, mas o runtime não vem na biblioteca padrão: você escolhe Tokio ou async-std e vive com a consequência.
• “Reescreve em Rust” virou meme por um motivo. Nem todo software precisa da garantia; boa parte do que se reescreve não tinha bug de memória relevante para começar.
• Governança tem atrito. Em novembro de 2021 o time de moderação renunciou em bloco; em 2023 o rascunho da política de marca foi rejeitado pela comunidade. A língua sobreviveu aos dois, mas não é o projeto sereno que a propaganda sugere.

Dito isso: Dual MIT / Apache-2.0, sem dono único, com fundação. Ferris, o caranguejo, é mascote da comunidade — não é o logo. O logo é a coroa de bicicleta.

Timeline

• 2006 — Graydon Hoare começa o projeto no tempo livre, em OCaml, depois de um elevador que travava por bug de memória.
• 2009 — a Mozilla oficializa o patrocínio; nasce a “nerd cave”.
• 2010 — o modelo de ownership já está no desenho.
• 2011 — o compilador passa a se auto-hospedar, com alvo LLVM; sai o logo da coroa de bicicleta.
• 20 de janeiro de 2012 — a 0.1, primeira versão pública.
• 2012 — começa o Servo, motor de browser em Rust financiado por Mozilla e Samsung.
• 2013 — o coletor de lixo é removido; Hoare sai do dia a dia; a governança vira federada.
• Março de 2014 — começa o processo de RFCs.
• 15 de maio de 2015 — a 1.0, com compromisso de compatibilidade.
• 2016 — o Firefox 45 já embarca código Rust.
• Setembro de 2017 — o Firefox 57 (projeto Quantum) leva componentes do Servo para produção.
• 2018 — edição 2018, na 1.31: módulos, ? ergonômico, non-lexical lifetimes.
• 7 de novembro de 2019 — async/await estabiliza na 1.39.
• Agosto de 2020 — a Mozilla demite 250 pessoas; o time do Servo se dissolve.
• 8 de fevereiro de 2021 — nasce a Rust Foundation, com AWS, Google, Huawei, Microsoft e Mozilla.
• Abril de 2021 — o Google anuncia Rust no Android Open Source Project.
• Outubro de 2021 — edição 2021, na 1.56.
• 11 de dezembro de 2022 — o kernel Linux 6.1 aceita a infraestrutura Rust, como experimento.
• 20 de fevereiro de 2025 — edição 2024, na 1.85.0.
• Maio de 2025 — dez anos de Rust estável.
• Outubro de 2025 — Ubuntu 25.10 entrega o sudo pelo sudo-rs.
• Dezembro de 2025 — o Maintainers Summit declara o experimento do kernel um sucesso; Rust vira linguagem central ao lado de C.
• Junho de 2026 — a OpenAI entra na Rust Foundation.
• 2026 — o Ubuntu 26.04 LTS traz o coreutils em Rust; a estável é a 1.98.1.

Para seguir daqui

O mapa das línguas deste blog: As 7 principais linguagens. O irmão de 2007 no Google, com filosofia oposta: A história da linguagem Go. O kernel que abriu a porta: Linux faz 35 anos and A história de Linus Torvalds. Toolchain no Linux: Go and Swift.

O que ficou

Um elevador, um OCaml, uma nerd cave, uma 1.0 em 2015, um kernel em 2022, uma 1.98.1 em 2026. Graydon descreveu o aniversário de dez anos (maio de 2025) como infra que ele mal reconhece. O recado não mudou: memória segura sem GC, no metal, no Linux.

Site: rust-lang.org · 1.0: 15 mai 2015 · 1.98.1: blog.rust-lang.org/releases · Foundation: rustfoundation.org · dez anos, nas palavras de Hoare: 10 Years of Stable Rust.