Rust vs C++, Go et Python

« Est-ce que je dois apprendre Rust, ou Go, ou rester sur Python ? » C’est l’une des questions les plus fréquentes quand on découvre Rust. La réponse honnête : tout dépend de ce que vous voulez construire. Tous les langages de cette page sont de bons langages, utilisés par des millions de personnes. Chacun a simplement fait des compromis différents.

Pensez aux langages comme à des véhicules. Une voiture de sport, une camionnette de livraison et un vélo sont tous « bons ». Simplement, vous ne prendriez pas un vélo pour déménager des meubles. Cette page explique ces compromis avec des mots simples, pour que vous choisissiez le bon outil pour votre projet. Nous allons faire de notre mieux pour rester justes, y compris sur les points faibles de Rust.

Les points forts de Rust

La grande promesse de Rust, c’est la vitesse et la sécurité en même temps :

Rapide, comme C et C++. Rust compile en code machine natif et n’a pas de ramasse-miettes (garbage collector, ou GC), donc pas de pauses pendant le nettoyage de la mémoire.
Sûr en mémoire sans ramasse-miettes. Les règles d’ownership (possession) et de borrowing (emprunt) sont vérifiées à la compilation. Des familles entières de bugs (utiliser de la mémoire libérée, data races entre threads) sont rejetées avant même que le programme ne s’exécute.
D’excellents outils fournis d’office. Un seul outil, Cargo, compile votre code, télécharge les bibliothèques, lance les tests et génère la documentation. Le formateur (rustfmt) et le linter (clippy) sont officiels.
Des erreurs de compilation utiles. Le compilateur vous dit souvent exactement comment corriger le problème.

Et les développeurs ont l’air d’apprécier : dans l’enquête Stack Overflow 2025 auprès des développeurs (en anglais), Rust est encore une fois le langage le plus « admiré », c’est-à-dire que la plupart des gens qui l’utilisent veulent continuer à l’utiliser.

La même tâche dans quatre langages

Commençons par quelque chose de simple : additionner les nombres pairs d’une liste. Voici la version Rust :

fn main() {
    let numbers = vec![1, 2, 3, 4, 5, 6];
    let sum: i32 = numbers.iter().filter(|n| *n % 2 == 0).sum();
    println!("Somme des nombres pairs : {sum}");
}

Sortie :

Somme des nombres pairs : 12

▶ Essayez par vous-même

Le même programme en 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 << "Somme des nombres pairs : " << sum << "\n";
}

En 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("Somme des nombres pairs :", sum)
}

Et en Python :

numbers = [1, 2, 3, 4, 5, 6]
total = sum(n for n in numbers if n % 2 == 0)
print("Somme des nombres pairs :", total)

Les quatre affichent la même ligne. Python est le plus court, Go et C++ utilisent une simple boucle, et Rust enchaîne des itérateurs avec une closure (fonction anonyme). Vous pourriez aussi écrire une boucle for en Rust. Sur de petits programmes comme celui-ci, les différences sont surtout une question de style. Les vraies différences apparaissent sur de plus gros programmes.

Rust vs C++

C++ et Rust visent le même terrain : des programmes rapides avec un contrôle total de la mémoire, comme les navigateurs, les moteurs de jeu, les bases de données et les systèmes d’exploitation. La grande différence, c’est qui vérifie que la mémoire est utilisée correctement.

En C++, c’est vous. Voici un bug classique. Un compilateur C++ accepte ce code sans broncher, mais push_back peut déplacer le vecteur vers une nouvelle zone mémoire, et first peut alors pointer vers de la mémoire déjà libérée :

std::vector<int> v = {1, 2, 3};
int& first = v[0];
v.push_back(4);              // peut déplacer la mémoire du vecteur...
std::cout << first << "\n";  // ...donc ceci peut lire de la mémoire libérée

La même erreur en Rust ne compile pas :

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

Le compilateur explique (en anglais) qu’on ne peut pas emprunter v de façon mutable, pour y ajouter un élément, tant qu’il est déjà emprunté de façon immuable par first, qui est encore utilisé à la ligne 5.

Cela compte énormément en pratique. L’équipe de Chromium indique qu’environ 70 % de leurs bugs de sécurité graves sont des problèmes de sécurité mémoire (en anglais). L’équipe Android de Google écrit son nouveau code en Rust depuis plusieurs années. Elle a annoncé zéro vulnérabilité de sécurité mémoire trouvée dans le code Rust d’Android en 2022, puis en 2025 une densité de vulnérabilités mémoire plus de 1000 fois inférieure à celle de leur code C et C++ (articles en anglais). Le noyau Linux (en anglais) accepte lui aussi du code écrit en Rust.

Outils : C++ a de nombreux systèmes de build et gestionnaires de paquets, et les équipes passent souvent beaucoup de temps sur la configuration. Rust a un seul outil standard, Cargo, donc tous les projets Rust se compilent de la même façon.

Courbe d’apprentissage : les deux sont difficiles. C++ est immense, et beaucoup de ses règles s’apprennent en faisant des erreurs à l’exécution. Les règles de Rust sont strictes, mais le compilateur les fait respecter et les explique : vous les apprenez donc à la compilation.

Là où C++ garde l’avantage : des décennies de code existant, de bibliothèques et de développeurs expérimentés. Si votre entreprise ou votre moteur de jeu repose sur C++, C++ est souvent le choix le plus pragmatique. Rust peut appeler du code C, et du C++ via des interfaces de style C, mais mélanger les deux demande des efforts.

Rust vs Go

On compare souvent Go et Rust, car tous deux sont modernes, compilés et populaires pour les serveurs et les outils en ligne de commande. Mais ils ont été conçus avec des objectifs différents.

Ramasse-miettes contre ownership. Go utilise un ramasse-miettes (en anglais) qui trouve et libère la mémoire inutilisée pendant que votre programme tourne. Le code Go est donc plus simple à écrire : vous ne vous demandez jamais à qui appartient une valeur. Le prix à payer : un peu plus de mémoire et de CPU, et de courtes pauses. Rust n’a pas de ramasse-miettes. La mémoire est libérée à un moment connu, quand le propriétaire sort de sa portée (scope). Les performances sont plus prévisibles, mais il faut apprendre l’ownership et le borrowing.

Concurrence. Les goroutines et les canaux (channels) de Go sont réputés pour leur simplicité. Voici un petit exemple qui calcule le carré de trois nombres en parallèle et les additionne :

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)

La version Rust utilise des threads et un canal. Elle est un peu plus verbeuse : il faut cloner l’émetteur pour chaque thread et utiliser 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); // ferme notre copie pour que la boucle ci-dessous puisse se terminer

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

Sortie :

total : 14

▶ Essayez par vous-même

Ce que vous gagnez en échange de ces quelques lignes en plus : Rust refuse de compiler du code où deux threads pourraient modifier les mêmes données en même temps (une data race). En Go, les data races sont possibles ; Go fournit un détecteur de data races (en anglais) qui les repère pendant l’exécution du programme. Consultez La concurrence en Rust pour en savoir plus.

Temps de compilation. Go a été conçu pour compiler vite. Sa FAQ indique qu’il ne devrait falloir que quelques secondes au plus pour compiler un gros exécutable (en anglais). Rust compile plus lentement, car le compilateur vérifie et optimise beaucoup plus de choses. Vous le remarquerez sur les gros projets.

Simplicité. Go est volontairement un petit langage, avec peu de fonctionnalités à apprendre, et beaucoup de gens trouvent qu’on lit vite du code Go. Rust a plus de fonctionnalités (traits, génériques, lifetimes, macros), qui donnent plus de puissance mais demandent plus de temps d’apprentissage.

Rust vs Python

Python et Rust sont très différents, et on les utilise souvent ensemble plutôt que l’un à la place de l’autre.

Vitesse. Python est interprété : du code Python pur qui fait beaucoup de calculs est donc bien plus lent que du code compilé. C’est pour cela que les bibliothèques Python populaires font souvent le gros du travail en C, en C++ ou en Rust, en coulisses.

Typage. En Python, les types sont vérifiés pendant l’exécution. Cette fonction marche avec un nombre et échoue avec une chaîne de caractères, mais vous ne le découvrez qu’au moment où la ligne s’exécute :

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'

Python propose des annotations de type facultatives, mais l’interpréteur Python ne les fait pas respecter. En Rust, chaque type est vérifié avant l’exécution du programme :

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

Le compilateur signale des types incompatibles : la fonction attend un f64 (un nombre à virgule), mais reçoit un &str (du texte).

Là où Python reste le meilleur outil : les petits scripts, l’analyse de données, le machine learning, les notebooks, l’automatisation et l’apprentissage de la programmation. L’écosystème Python pour la data science est énorme, et vous pouvez tester une idée en quelques minutes. Si votre programme passe le plus clair de son temps à attendre le réseau ou une base de données, la vitesse de Python n’a souvent pas d’importance.

Utiliser les deux : le projet PyO3 (en anglais) permet d’écrire des modules Python en Rust. Vous gardez votre code Python et ne déplacez vers Rust que la partie lente. Certains outils Python populaires sont eux-mêmes écrits en Rust ; par exemple, l’enquête Stack Overflow note que le gestionnaire de paquets Python uv est écrit en Rust (en anglais).

Comparaison côte à côte

Ce sont des tendances générales, pas des règles strictes. Un programme bien écrit dans n’importe lequel de ces langages peut être « assez rapide ».

	Rust	C++	Go	Python
Vitesse	Très rapide, code natif, sans GC	Très rapide, code natif, sans GC	Rapide, code natif avec un GC	Plus lent pour les calculs lourds en Python pur
Sécurité mémoire	Vérifiée à la compilation (hors `unsafe`)	Responsabilité du programmeur	GC ; data races encore possibles	GC ; sûr, mais les erreurs de type apparaissent à l’exécution
Courbe d’apprentissage	Raide au début	Raide, et un langage très vaste	Douce	La plus douce
Temps de compilation	Plutôt lent	Plutôt lent (selon le projet)	Très rapide	Pas d’étape de compilation
Écosystème	Plus jeune, en croissance ; Cargo intégré	Immense et mature ; nombreux outils de build	Bibliothèque standard solide, idéale pour les serveurs	Gigantesque, surtout pour la data et le ML
Usages typiques	Outils CLI, serveurs, code système, WebAssembly, embarqué	Jeux, navigateurs, systèmes haute performance et existants	Services web, outils cloud et DevOps	Scripts, data science, ML, automatisation

Quand choisir Rust ?

Posez-vous ces questions :

Avez-vous besoin d’une vitesse maximale ou d’une faible consommation mémoire, par exemple pour un moteur de jeu, une base de données ou du code sur un petit appareil ? Rust (ou C++) est un excellent choix.
Les bugs coûteront-ils cher ? Le code sensible pour la sécurité, les serveurs qui tournent longtemps et le code dont beaucoup de gens dépendent profitent le plus des vérifications de Rust à la compilation.
Construisez-vous un outil en ligne de commande à partager ? Rust produit un seul binaire rapide, sans environnement d’exécution à installer. Go est aussi très bien pour ça.
Vous faut-il un service web rapidement, avec une équipe qui ne connaît aucun de ces langages ? Go vous y amènera sans doute plus vite. Rust fonctionne bien aussi (voir Projet : API web avec Axum), mais le temps d’apprentissage est plus long.
C’est un petit script, de l’analyse de données ou une expérience de ML ? Utilisez Python. Passez à Rust plus tard, via PyO3, si une partie devient trop lente.
Existe-t-il une grosse base de code C++ ? Restez sur C++ pour l’instant, ou introduisez Rust dans de nouvelles parties séparées, comme l’a fait Android.

Et si vous voulez simplement devenir meilleur en programmation : apprendre Rust vous montre comment la mémoire fonctionne vraiment, et ces connaissances vous servent dans tous les autres langages.

Les vrais défauts de Rust

Rust n’est pas parfait. Voici ce qui pose le plus de difficultés :

La courbe d’apprentissage est bien réelle. Les premières semaines avec le borrow checker peuvent être frustrantes. Attendez-vous à « vous battre avec le compilateur » pendant un moment. Tout devient beaucoup plus facile une fois que l’ownership fait tilt.
Les temps de compilation sont plus longs qu’en Go, surtout pour les gros projets et les builds de release.
Certaines choses sont plus difficiles à exprimer. Les données en forme de graphe, avec de nombreux liens entre objets, ou le code qui partage beaucoup d’état mutable, demandent des outils comme les pointeurs intelligents (smart pointers) et plus de réflexion en amont.
L’écosystème est plus jeune. Dans certains domaines (applications graphiques, certaines bibliothèques scientifiques), il y a moins d’options matures qu’en C++ ou en Python.
Moins de gens l’utilisent (pour l’instant). Dans l’enquête Stack Overflow 2025 (en anglais), bien plus de répondants disaient utiliser Python (environ 58 %) ou C++ (environ 24 %) que Rust (environ 15 %). Il y a donc moins de développeurs Rust expérimentés à recruter, à qui poser des questions ou auprès de qui apprendre au travail.
Plus de code pour des choses simples. Comme l’a montré l’exemple des canaux, Rust vous demande souvent d’être explicite là où d’autres langages sont plus détendus.

Récapitulatif

Rust offre la vitesse de C++ avec une sécurité mémoire vérifiée à la compilation, et d’excellents outils intégrés.
Par rapport à C++, Rust empêche des familles entières de bugs mémoire avant l’exécution ; C++ dispose de beaucoup plus de code et de bibliothèques existants.
Par rapport à Go, Rust n’a pas de ramasse-miettes et bloque les data races à la compilation ; Go est plus simple et compile beaucoup plus vite.
Par rapport à Python, Rust est bien plus rapide et vérifie les types avant l’exécution ; Python s’écrit plus vite et domine la data science. PyO3 permet de combiner les deux.
Les principaux coûts de Rust : une courbe d’apprentissage raide, des compilations plus lentes et un écosystème plus jeune.

Petit quiz

1. Comment Rust gère-t-il la mémoire sans ramasse-miettes ?

2. Lequel de ces points est un vrai avantage de Go sur Rust ?

3. Dans votre programme Python, une fonction est beaucoup trop lente. Quelle est l’approche courante ?

4. Dans l’exemple C++ vs Rust, que se passe-t-il pour le code qui garde &v[0] puis ajoute un élément à v ?

Score : 0 / 4

Pour aller plus loin

The Rust Programming Language — Introduction (en anglais) : à qui s’adresse Rust, selon les mots du livre officiel.
Rust in Android: move fast and fix things — Google Security Blog (en anglais) : des données réelles d’une grande équipe qui utilise Rust aux côtés de C et C++.
Stack Overflow Developer Survey 2025 — Admired and Desired (en anglais) : ce que les développeurs pensent de Rust, Go, Python, C++ et d’autres langages.
Go FAQ — Why did you create a new language? (en anglais) : les objectifs de conception de Go, utiles pour comprendre où il brille.
Guide utilisateur de PyO3 (en anglais) : comment écrire des extensions Python en Rust.