Rust vs C++, Go e Python

“Devo aprender Rust, Go ou continuar no Python?” é uma das perguntas mais comuns de quem acaba de descobrir o Rust. A resposta sincera é: depende do que você quer construir. Todas as linguagens desta página são boas e usadas por milhões de pessoas. Cada uma fez escolhas diferentes.

Pense nas linguagens como veículos. Um carro esportivo, uma van de entregas e uma bicicleta são todos “bons”. Só que você não usaria uma bicicleta para fazer uma mudança. Esta página explica essas escolhas em palavras simples, para você escolher a ferramenta certa para o seu trabalho. Vamos nos esforçar para ser justos, inclusive sobre os pontos fracos do Rust.

No que o Rust é bom

A principal promessa do Rust é velocidade e segurança ao mesmo tempo:

• Rápido, como C e C++. O Rust compila para código de máquina nativo e não tem garbage collector (coletor de lixo), então não há pausas enquanto a memória é limpa.
• Seguro em relação à memória, sem garbage collector. As regras de ownership (posse) e borrowing (empréstimo) são verificadas na compilação. Grupos inteiros de bugs (usar memória já liberada, data races entre threads) são barrados antes de o programa sequer rodar.
• Ótimas ferramentas desde o início. Uma única ferramenta, o Cargo, compila seu código, baixa bibliotecas, roda testes e gera documentação. O formatador (rustfmt) e o linter (clippy) são oficiais.
• Mensagens de erro que ajudam. Muitas vezes o compilador diz exatamente como corrigir o problema.

E quem programa parece gostar: na Stack Overflow Developer Survey 2025 (em inglês), o Rust foi de novo a linguagem “mais admirada”, ou seja, a maioria das pessoas que usam Rust quer continuar usando.

A mesma tarefa em quatro linguagens

Vamos começar com algo pequeno: somar os números pares de uma lista. Em Rust fica assim:

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let sum: i32 = numbers.iter().filter(|n| *n % 2 == 0).sum();
    println!("Soma dos números pares: {sum}");
}

Saída:

Soma dos números pares: 12

▶ Experimente você mesmo

O mesmo programa em C++:

#include <iostream>
#include <vector>

int main() {
    std::vector<int> numbers = {1, 2, 3, 4, 5, 6};
    int sum = 0;
    for (int n : numbers) {
        if (n % 2 == 0) {
            sum += n;
        }
    }
    std::cout << "Soma dos números pares: " << sum << "\n";
}

Em Go:

package main

import "fmt"

func main() {
  numbers := []int{1, 2, 3, 4, 5, 6}
  sum := 0
  for _, n := range numbers {
    if n%2 == 0 {
      sum += n
    }
  }
  fmt.Println("Soma dos números pares:", sum)
}

E em Python:

numbers = [1, 2, 3, 4, 5, 6]
total = sum(n for n in numbers if n % 2 == 0)
print("Soma dos números pares:", total)

Os quatro imprimem a mesma linha. O Python é o mais curto, Go e C++ usam um laço simples, e o Rust usa uma cadeia de iteradores com uma closure (você também poderia escrever um laço for em Rust). Em programas pequenos como este, as diferenças são mais questão de estilo. As diferenças de verdade aparecem em programas maiores.

Rust vs C++

C++ e Rust miram o mesmo espaço: programas rápidos com controle total da memória, como navegadores, engines de jogos, bancos de dados e sistemas operacionais. A grande diferença é quem verifica se a memória está sendo usada corretamente.

Em C++, é você. Veja um bug clássico. Um compilador de C++ aceita este código sem reclamar, mas o push_back pode mover o vetor para outra região da memória, e aí first pode apontar para uma memória que já foi liberada:

std::vector<int> v = {1, 2, 3};
int& first = v[0];
v.push_back(4);              // pode mover a memória do vetor...
std::cout << first << "\n";  // ...então isto pode ler memória liberada

O mesmo erro em Rust nem compila:

fn main() {
    let mut v = vec![1, 2, 3];
    let first = &v[0];
    v.push(4);
    println!("{first}");
}

error[E0502]: cannot borrow `v` as mutable because it is also borrowed as immutable
 --> src/main.rs:4:5
  |
3 |     let first = &v[0];
  |                  - immutable borrow occurs here
4 |     v.push(4);
  |     ^^^^^^^^^ mutable borrow occurs here
5 |     println!("{first}");
  |                ----- immutable borrow later used here

O compilador explica (em inglês) que não dá para pegar v emprestado como mutável enquanto ainda existe um empréstimo imutável (first) que será usado depois.

Isso faz muita diferença na prática. O time do Chromium relata que cerca de 70% dos seus bugs de segurança graves são problemas de segurança de memória (em inglês). O time do Android, no Google, escreve código novo em Rust há vários anos. Eles relataram zero vulnerabilidades de segurança de memória encontradas no código Rust do Android (em inglês) em 2022 e, em 2025, uma densidade de vulnerabilidades de memória mais de 1000 vezes menor do que no código C e C++ (em inglês). O kernel do Linux (em inglês) também aceita código escrito em Rust.

Ferramentas: o C++ tem muitos sistemas de build e gerenciadores de pacotes, e as equipes costumam gastar um bom tempo com configuração. O Rust tem uma ferramenta padrão, o Cargo, então todo projeto Rust compila do mesmo jeito.

Curva de aprendizado: as duas são difíceis. O C++ é enorme, e muitas das suas regras são aprendidas errando em tempo de execução. As regras do Rust são rígidas, mas o compilador as aplica e as explica, então você aprende tudo em tempo de compilação.

Onde o C++ ainda ganha: décadas de código existente, bibliotecas e desenvolvedores experientes. Se a sua empresa ou a sua engine de jogo é baseada em C++, muitas vezes C++ é a escolha prática. O Rust consegue chamar código C, e C++ por meio de interfaces no estilo C, mas misturar as duas dá trabalho.

Rust vs Go

Go e Rust são comparados com frequência porque os dois são modernos, compilados e populares para servidores e ferramentas de linha de comando. Mas foram projetados com objetivos diferentes.

Garbage collector vs ownership. O Go usa um garbage collector (em inglês) que encontra e libera a memória não usada enquanto o programa roda. Isso deixa o código Go mais simples de escrever: você nunca pensa em quem é o dono de um valor. O custo é um pouco mais de memória e CPU, além de pausas curtas. O Rust não tem garbage collector. A memória é liberada num ponto conhecido, quando o dono sai do escopo. Isso dá um desempenho mais previsível, mas você precisa aprender ownership e borrowing.

Concorrência. As goroutines e os channels do Go são famosos por serem fáceis. Aqui vai um pequeno exemplo que eleva três números ao quadrado em paralelo e soma os resultados:

results := make(chan int)

for n := 1; n <= 3; n++ {
  go func() {
    results <- n * n
  }()
}

total := 0
for i := 0; i < 3; i++ {
  total += <-results
}
fmt.Println("total:", total)

A versão em Rust usa threads e um channel (canal). Ela é um pouco mais verbosa: você clona o remetente para cada thread e usa move:

use std::sync::mpsc;
use std::thread;

fn main() {
    let (tx, rx) = mpsc::channel();

    for n in 1..=3 {
        let tx = tx.clone();
        thread::spawn(move || {
            tx.send(n * n).unwrap();
        });
    }
    drop(tx); // fecha a nossa cópia para que o laço abaixo possa terminar

    let total: i32 = rx.iter().sum();
    println!("total: {total}");
}

Saída:

total: 14

▶ Experimente você mesmo

O que você ganha com essa digitação extra: o Rust se recusa a compilar código em que duas threads poderiam alterar os mesmos dados ao mesmo tempo (uma data race, ou condição de corrida). Em Go, data races são possíveis; o Go oferece um race detector (em inglês) que as encontra enquanto o programa roda. Veja Concorrência para saber mais.

Tempo de compilação. O Go foi feito para compilar rápido. O FAQ dele diz que compilar um executável grande deveria levar no máximo alguns segundos (em inglês). O Rust compila mais devagar, porque o compilador faz muito mais verificações e otimizações. Você vai notar isso em projetos grandes.

Simplicidade. O Go é uma linguagem pequena de propósito, com poucos recursos para aprender, e por isso muita gente consegue ler código Go rapidamente. O Rust tem mais recursos (traits, genéricos, lifetimes, macros), que dão mais poder, mas levam mais tempo para aprender.

Rust vs Python

Python e Rust são muito diferentes, e muitas vezes são usados juntos, e não um no lugar do outro.

Velocidade. O Python é interpretado, então código Python puro que faz muita computação é bem mais lento do que código compilado. É por isso que bibliotecas populares de Python costumam fazer o trabalho pesado em C, C++ ou Rust por baixo dos panos.

Tipagem. Em Python, os tipos são verificados enquanto o programa roda. Esta função funciona com um número e falha com uma string, mas você só descobre quando aquela linha é executada:

def add_tax(price):
    return price * 1.2

print(add_tax(10))    # 12.0
print(add_tax("10"))  # TypeError: can't multiply sequence by non-int of type 'float'

O Python tem type hints opcionais, mas o runtime do Python não os obriga a serem respeitados (em inglês). Em Rust, todo tipo é verificado antes de o programa rodar:

fn add_tax(price: f64) -> f64 {
    price * 1.2
}

fn main() {
    println!("{}", add_tax(10.0));
    println!("{}", add_tax("10"));
}

error[E0308]: mismatched types
 --> src/main.rs:7:28
  |
7 |     println!("{}", add_tax("10"));
  |                    ------- ^^^^ expected `f64`, found `&str`
  |                    |
  |                    arguments to this function are incorrect

O erro diz (em inglês) que os tipos não batem: a função esperava um f64 e recebeu um &str.

Quando o Python ainda é a melhor ferramenta: scripts rápidos, análise de dados, machine learning, notebooks, automação e ensino para iniciantes. O ecossistema do Python para ciência de dados é enorme, e você consegue testar uma ideia em minutos. Se o seu programa passa a maior parte do tempo esperando a rede ou um banco de dados, a velocidade do Python muitas vezes nem importa.

Usando os dois: o projeto PyO3 (em inglês) permite escrever módulos Python em Rust, então você pode manter seu código Python e mover só a parte lenta para Rust. Algumas ferramentas populares de Python são escritas em Rust; por exemplo, a pesquisa do Stack Overflow observa que o gerenciador de pacotes Python uv é feito em Rust (em inglês).

Comparação lado a lado

Estas são tendências gerais, não regras rígidas. Um programa bem escrito em qualquer uma dessas linguagens pode ser “rápido o suficiente”.

	Rust	C++	Go	Python
Velocidade	Muito rápido, código nativo, sem GC	Muito rápido, código nativo, sem GC	Rápido, código nativo com GC	Mais lento para computação pesada em Python puro
Segurança de memória	Verificada na compilação (fora de unsafe)	Responsabilidade de quem programa	GC; data races ainda são possíveis	GC; seguro, mas erros de tipo aparecem em tempo de execução
Curva de aprendizado	Íngreme no começo	Íngreme, e a linguagem é enorme	Suave	A mais suave
Tempo de compilação	Meio lento	Meio lento (depende do projeto)	Muito rápido	Sem etapa de compilação
Ecossistema	Mais jovem, em crescimento; Cargo incluso	Enorme e maduro; muitas ferramentas de build	Biblioteca padrão forte, ótima para servidores	Enorme, principalmente para dados e ML
Usos típicos	Ferramentas de linha de comando, servidores, código de sistemas, WebAssembly, embarcados	Jogos, navegadores, sistemas de alto desempenho e legados	Serviços web, ferramentas de nuvem e DevOps	Scripts, ciência de dados, ML, automação

Quando escolher Rust?

Faça a si mesmo estas perguntas:

• Você precisa de velocidade máxima ou de pouco uso de memória, por exemplo numa engine de jogo, num banco de dados ou em código para um dispositivo pequeno? Rust (ou C++) é uma ótima escolha.
• Bugs vão sair caro? Código sensível à segurança, servidores que ficam rodando por muito tempo e código do qual muita gente depende são os que mais se beneficiam das verificações do Rust em tempo de compilação.
• Você está criando uma ferramenta de linha de comando para compartilhar? O Rust gera um único binário rápido, sem runtime para instalar. O Go também é ótimo aqui.
• Você precisa de um serviço web rápido, com uma equipe que ainda não conhece nenhuma dessas linguagens? O Go provavelmente vai levar você lá mais rápido. O Rust também funciona bem (veja Projeto: API web), mas o tempo de aprendizado é maior.
• É um script rápido, uma análise de dados ou um experimento de ML? Use Python. Recorra ao Rust depois, via PyO3, se alguma parte ficar lenta demais.
• Existe uma grande base de código em C++? Fique com o C++ por enquanto, ou introduza o Rust em partes novas e separadas, como fez o Android.

E se você só quer se tornar uma pessoa programadora melhor: aprender Rust ensina como a memória funciona de verdade, e esse conhecimento ajuda em qualquer outra linguagem.

Os pontos fracos do Rust, com sinceridade

O Rust não é perfeito. Estas são as coisas com que as pessoas mais sofrem:

• A curva de aprendizado existe mesmo. As primeiras semanas com o borrow checker podem ser frustrantes. Espere “brigar com o compilador” por um tempo. Fica bem mais fácil quando a ficha do ownership cai.
• O tempo de compilação é maior que o do Go, principalmente em projetos grandes e em builds de release.
• Algumas coisas são mais difíceis de expressar. Dados em forma de grafo, com muitas ligações entre objetos, ou código que compartilha muito estado mutável, exigem ferramentas como smart pointers (ponteiros inteligentes) e mais planejamento.
• O ecossistema é mais jovem. Em algumas áreas (aplicativos com interface gráfica, certas bibliotecas científicas) há menos opções maduras do que em C++ ou Python.
• Menos gente usa (por enquanto). Na Stack Overflow survey 2025 (em inglês), muito mais participantes disseram usar Python (cerca de 58%) ou C++ (cerca de 24%) do que Rust (cerca de 15%). Isso significa menos desenvolvedores Rust experientes para contratar, tirar dúvidas ou aprender junto no trabalho.
• Mais código para coisas simples. Como o exemplo do channel mostrou, o Rust muitas vezes pede que você seja explícito onde outras linguagens são mais relaxadas.

Para ir além

Vem de outra linguagem? Temos guias que mostram o equivalente em Rust do que você já conhece: Rust para desenvolvedores C#, Rust para desenvolvedores Python, Rust para desenvolvedores JavaScript e TypeScript, Rust para desenvolvedores Java e Rust para desenvolvedores Go.

Resumo

• O Rust oferece velocidade no nível do C++ com segurança de memória verificada na compilação, e tem ferramentas excelentes já incluídas.
• Comparado ao C++, o Rust evita classes inteiras de bugs de memória antes de o programa rodar; o C++ tem muito mais código e bibliotecas existentes.
• Comparado ao Go, o Rust não tem garbage collector e barra data races na compilação; o Go é mais simples e compila muito mais rápido.
• Comparado ao Python, o Rust é muito mais rápido e verifica os tipos antes de rodar; o Python é mais rápido de escrever e domina a ciência de dados. O PyO3 permite combinar os dois.
• Os principais custos do Rust são uma curva de aprendizado íngreme, compilação mais lenta e um ecossistema mais jovem.

Teste o que aprendeu

Teste o que aprendeu

1. Como o Rust gerencia a memória sem um garbage collector?

Ele nunca libera memória Por meio de regras de ownership e borrowing verificadas na compilação O sistema operacional faz uma limpeza a cada poucos segundos Você precisa chamar free() na mão

2. Qual destas é uma vantagem justa do Go sobre o Rust?

O Go evita todas as data races na compilação O Go não tem garbage collector O Go é uma linguagem menor e compila mais rápido O Go é sempre mais rápido em tempo de execução

3. Você tem um programa em Python em que uma função é lenta demais. Qual é uma abordagem comum?

Reescrever o programa inteiro em C++ Adicionar mais type hints Não tem como deixar Python mais rápido Reescrever só essa função em Rust e chamá-la do Python com PyO3

4. No exemplo de C++ vs Rust, o que acontece com o código que guarda &v[0] e depois faz push em v?

O Rust se recusa a compilá-lo O Rust compila e o programa trava em tempo de execução O Rust copia o vetor silenciosamente As duas linguagens o rejeitam

Pontuação: 0 / 4

Para saber mais

• The Rust Programming Language — Introduction (em inglês): para quem o Rust foi feito, nas palavras do próprio livro oficial.
• Rust in Android: move fast and fix things — Google Security Blog (em inglês): dados reais de uma equipe grande usando Rust ao lado de C e C++.
• Stack Overflow Developer Survey 2025 — Admired and Desired (em inglês): o que os desenvolvedores acham de Rust, Go, Python, C++ e outras linguagens.
• Go FAQ — Why did you create a new language? (em inglês): os objetivos de design do próprio Go, úteis para entender onde ele brilha.
• PyO3 user guide (em inglês): como escrever extensões Python em Rust.