O Que É a Linguagem de Programação Rust? Um Guia Simples da Linguagem Rápida Que Não Deixa Você Travar

Por décadas, os programadores que constroem os softwares mais importantes, como navegadores e sistemas operacionais, enfrentaram uma escolha difícil. Podiam usar linguagens como C e C++, que são rapidíssimas mas deixam pequenos erros com a memória virarem travamentos e brechas de segurança. Ou podiam usar linguagens mais seguras, que protegem a memória mas costumam ser mais lentas ou precisam de um ajudante rodando nos bastidores.

O Rust é uma linguagem de programação que se recusa a escolher. Ele quer ser tão rápido quanto o C e, ao mesmo tempo, pegar os erros de memória antes de o programa rodar. Microsoft, Google, Amazon e o projeto Linux já começaram a usá-lo em partes muito sensíveis do seu código. Este artigo explica, em linguagem simples, o que é o Rust, como ele faz esse truque e por que tanta gente está animada com ele.

Nascido de um elevador quebrado

Em 2006, um programador da Mozilla (a organização por trás do navegador Firefox) chamado Graydon Hoare chegou em casa e encontrou o elevador do prédio quebrado, de novo. O software dele tinha travado. Ele já contou que a frustração de subir 21 andares de escada o fez pensar: por que tanto software é tão frágil?

Naquela noite, ele começou um projeto pessoal para criar uma linguagem em que esse tipo de travamento fosse muito mais difícil de acontecer. Deu a ela o nome de Rust ("ferrugem", em inglês), inspirado numa família de fungos resistentes chamados assim. A Mozilla passou a patrocinar o projeto em 2009, esperando usá-lo para construir um navegador mais rápido e seguro, e o Rust 1.0 foi lançado em 2015.

O problema que o Rust resolve: erros de memória

Todo programa usa a memória do computador para guardar os seus dados: nomes, números, imagens, páginas da web. Imagine a memória como uma parede gigante de armários numerados. Um programa pede alguns armários, usa e deveria devolvê-los quando termina.

No C e no C++, o programador cuida desses armários na mão, e é fácil errar: escrever além do fim dos seus armários, nos armários de outra pessoa; usar um armário depois de devolvê-lo; ou devolver o mesmo armário duas vezes. Esses são os erros de segurança de memória, e eles não causam só travamentos. Invasores podem usá-los para entrar em computadores.

Veja o mesmo tipo de erro em C e em Rust:

No programa em C, o nome "Christopher" não coube na caixa de 8 letras, então as letras a mais transbordaram para o armário vizinho, onde ficava o saldo da conta. O saldo mudou em silêncio de 100 para 7.497.064, sem nenhum erro. No Rust, um erro parecido para o programa na hora, com uma mensagem clara, em vez de estragar outros dados sem ninguém perceber.

Qual o tamanho desse problema? Maior do que você imagina:

A Microsoft e a equipe do Chrome, do Google, já relataram que cerca de 70% das suas falhas graves de segurança vêm de problemas de memória. No Android, o Google passou a escrever código novo em linguagens seguras para a memória, incluindo o Rust, e relatou que a parcela de vulnerabilidades de memória caiu de 76% em 2019 para 24% em 2024.

Como outras linguagens resolvem isso, e como o Rust resolve

Linguagens como Java, Go, Python e JavaScript evitam a maioria desses erros com um coletor de lixo: um ajudante que roda junto com o programa, como um zelador, procurando armários que ninguém usa mais e esvaziando-os. Funciona bem, mas o zelador custa um pouco de velocidade e de memória, e de vez em quando faz o programa pausar por um instante.

O Rust segue um terceiro caminho:

Em vez de um zelador que limpa enquanto o programa roda, o Rust tem um compilador muito rigoroso, a ferramenta que traduz o seu código num programa, que confere como cada pedaço de memória é usado antes de o programa ser criado. Se as regras puderem ser quebradas, ele se recusa a criar o programa. Sem zelador, e sem erros de segurança de memória no código Rust normal.

Posse: a grande ideia do Rust

As regras do Rust se chamam posse (ownership), e funcionam muito parecido com pegar livros numa biblioteca:

1. Todo valor tem exatamente um dono. Se você dá o seu livro a um amigo, agora ele é do amigo. Você não pode continuar lendo.
2. Você pode emprestar. Ou para várias pessoas que só leem, ou para exatamente uma pessoa que pode escrever nele, mas nunca os dois ao mesmo tempo. Assim ninguém lê uma página enquanto outra pessoa a está reescrevendo.
3. Quando o dono termina, tudo é limpo automaticamente. O livro volta para a estante no momento em que o dono vai embora, então a memória nunca é esquecida nem devolvida duas vezes.

Veja o que acontece quando você quebra a regra 1:

let livro = String::from("Rust para Iniciantes");
let amigo = livro;   // o livro é dado a outro
println!("{livro}"); // ...mas ainda tentamos lê-lo

O compilador se recusa, com uma mensagem que parece de um professor prestativo:

O programa nem chega a rodar. O compilador aponta a linha exata, explica (em inglês) que o livro foi "movido" (dado a outro) e até sugere uma correção: fazer uma cópia com .clone(). As mensagens de erro do Rust são famosas por serem assim, prestativas.

Emprestar fica assim. O & quer dizer "deixe esta função pegar o livro emprestado, mas ele continua sendo meu":

1fn contar_letras(texto: &String) -> usize {
2    texto.chars().count()
3}
4
5fn main() {
6    let livro = String::from("Rust para Iniciantes");
7    let letras = contar_letras(&livro);
8    println!("\"{livro}\" tem {letras} caracteres");
9}

Ele mostra "Rust para Iniciantes" tem 20 caracteres. O livro foi emprestado, devolvido e continua sendo nosso.

Mais um pouco de Rust

Veja o clássico primeiro programa:

fn main() {
    println!("Olá, mundo!");
}

O fn começa uma função, main é onde o programa começa, e println! mostra uma linha. E aqui está um pequeno carro, descrito com uma struct (um pacote de valores com nome) e um bloco impl que dá habilidades a ele:

1struct Carro {
2    cor: String,
3    velocidade: u32,
4}
5
6impl Carro {
7    fn acelerar(&mut self) {
8        self.velocidade += 10;
9    }
10}
11
12fn main() {
13    let mut meu_carro = Carro {
14        cor: String::from("vermelho"),
15        velocidade: 0,
16    };
17    meu_carro.acelerar();
18    meu_carro.acelerar();
19    println!(
20        "O meu carro {} anda a {} km/h",
21        meu_carro.cor, meu_carro.velocidade
22    );
23}

Isso mostra O meu carro vermelho anda a 20 km/h. Repare no mut (de mutável): no Rust, os valores não podem ser alterados a menos que você diga. É mais um pequeno hábito de segurança embutido na linguagem.

O Rust é rápido?

Muito. O Rust compila direto para código de máquina, como o C, e não tem coletor de lixo rodando nos bastidores. Cronometramos a mesma tarefa simples, contar os números primos abaixo de 2 milhões, em seis linguagens:

O Rust ficou em primeiro, com 0,29 segundo, mas sendo honesto: num teste tão pequeno, Rust, Go, C e JavaScript praticamente empatam. Numa rodada anterior, com o notebook mais ocupado, C e Rust levaram exatamente o mesmo tempo. O que importa é que o Rust joga na mesma liga do C e, além disso, é seguro para a memória. O Python puro, para comparar, levou quase 16 segundos.

Onde o Rust brilha de verdade é em programas grandes, que ficam rodando por muito tempo. Como não há coletor de lixo, não há pausas surpresa. O app de conversas Discord ficou famoso por reescrever um dos seus serviços mais movimentados de Go para Rust, em 2020, para se livrar das pequenas lentidões regulares causadas pelo coletor de lixo do Go.

Onde o Rust é usado

• Firefox: em 2017, o Firefox passou a usar um novo motor de estilos escrito em Rust, levando código Rust a centenas de milhões de computadores.
• Sistemas operacionais: o Linux, o sistema por trás da maioria dos servidores e de todo celular Android, passou a aceitar código Rust no seu núcleo, o "kernel", em 2022, ao lado do C. A Microsoft reescreveu partes do Windows em Rust, e o Google o usa bastante no Android.
• A nuvem: a Amazon construiu em Rust o Firecracker, a tecnologia por trás do serviço AWS Lambda. A Cloudflare atende uma enorme parte do tráfego da web com software baseado em Rust.
• Apps e serviços: Discord, Dropbox (cujo motor de sincronização de arquivos é escrito em Rust) e Figma usam a linguagem.
• Ferramentas para programadores: quando você busca nos arquivos dentro do Visual Studio Code, quem faz o trabalho é um programa em Rust chamado ripgrep. Ferramentas populares do Python, como o uv e o Ruff, são escritas em Rust porque ficam muito mais rápidas.

Em 2024, até o Escritório do Diretor Nacional de Cibersegurança da Casa Branca publicou um relatório pedindo que os fabricantes de software migrem para linguagens seguras para a memória, um grupo que inclui o Rust.

As desvantagens

• Curva de aprendizado íngreme. Posse e empréstimo são ideias novas para a maioria dos programadores. Os iniciantes costumam passar as primeiras semanas "brigando com o borrow checker", a parte do compilador que impõe as regras de empréstimo, até a ficha cair.
• Compilação lenta. Todas essas verificações levam tempo. Projetos grandes em Rust podem levar minutos para compilar, bem mais que em Go.
• Não é a primeira linguagem mais fácil. Para aprender a programar, Python ou JavaScript são começos mais suaves. O Rust recompensa quem já sabe um pouco de programação.
• Ecossistema mais novo. O Rust tem menos bibliotecas prontas que C++, Java ou Python em algumas áreas, como jogos, pesquisa em IA ou apps com janelas e botões.
• Segurança não é mágica. O Rust impede erros de segurança de memória, mas não impede erros de lógica, como uma calculadora que soma quando deveria subtrair. E o código dentro de blocos unsafe ainda depende do cuidado do programador.

Uma breve história

Os programadores claramente gostam dele: na enorme pesquisa anual de desenvolvedores do Stack Overflow, o Rust foi eleito a linguagem mais amada (depois chamada de "mais admirada") por nove anos seguidos, de 2016 a 2024. Em 2021, Amazon, Google, Huawei, Microsoft e Mozilla fundaram a Rust Foundation, uma organização sem fins lucrativos que hoje cuida da linguagem.

Vale a pena aprender Rust?

• Ótimos motivos: você quer escrever software em que velocidade e confiabilidade importam de verdade: ferramentas de sistema, motores de jogos, navegadores, dispositivos embarcados, infraestrutura de nuvem ou bibliotecas de alto desempenho. Mesmo que você nunca o use no trabalho, aprender Rust ensina como a memória funciona de verdade, o que faz de você um programador melhor em qualquer linguagem.
• Bom saber: o Rust é gratuito e roda no Windows, no Mac e no Linux. O site oficial, rust-lang.org, oferece um livro on-line gratuito, The Rust Programming Language (apelidado de "o livro"), e um playground on-line onde você pode experimentar o Rust no navegador.

Se você tem curiosidade sobre as linguagens com que o Rust costuma ser comparado, veja O Que É a Linguagem de Programação C?, O Que É a Linguagem de Programação C++? e O Que É a Linguagem de Programação Go?

Um pequeno glossário

• Rust: uma linguagem de programação focada em velocidade e segurança de memória, lançada em 2015.
• Memória: onde um programa em execução guarda os seus dados.
• Erro de segurança de memória: um erro como usar memória que não é sua ou depois de devolvê-la. Uma das principais causas de travamentos e brechas de segurança.
• Coletor de lixo: um ajudante que limpa automaticamente a memória não usada enquanto o programa roda.
• Compilador: a ferramenta que traduz o código num programa e, no caso do Rust, confere as regras de posse.
• Posse (ownership): a regra do Rust de que todo valor tem exatamente um dono e é limpo quando o dono termina.
• Empréstimo (borrowing): emprestar um valor temporariamente para outra parte do programa, escrito com &.
• Borrow checker: a parte do compilador do Rust que impõe as regras de empréstimo.
• Panic: o Rust parando um programa de propósito quando algo está errado, em vez de continuar com dados ruins.
• unsafe: uma palavra-chave que marca o código em que o programador, e não o compilador, garante a segurança.
• Cargo e crates: a ferramenta de compilação do Rust e os seus pacotes prontos.

Conclusão

O Rust começou com um elevador quebrado e uma pergunta simples: por que tanto software trava? A resposta dele é a posse, um conjunto de regras parecidas com as de uma biblioteca, que o compilador confere antes de o programa sequer ser criado. O resultado é uma linguagem tão rápida quanto o C que impede famílias inteiras de erros de memória, o tipo por trás da maioria das brechas graves de segurança.

Ele exige mais de você no começo, e o compilador pode parecer rigoroso. Mas esse rigor é justamente o objetivo: cada erro que ele pega no seu computador é um erro que nunca chega ao computador de ninguém. É por isso que navegadores, sistemas operacionais e servidores na nuvem estão sendo reconstruídos aos poucos, com uma ajudinha de um simpático caranguejo laranja.