Cpp2Rust : traduire du C++ en Rust sûr automatiquement, sans y croire trop vite

Le 14 juillet 2026, le dépôt Cpp2Rust affiche 273 étoiles et 10 forks sur GitHub. Des chiffres modestes, mais le projet mérite l'attention : il s'attaque frontalement à un problème que la plupart des équipes C++ redoutent depuis des années, celui de migrer une base de code existante vers un langage memory-safe sans tout réécrire à la main. Cpp2Rust est un traducteur automatique de C++ vers du Rust entièrement sûr, et son algorithme a été décrit dans un papier accepté à la conférence PLDI 2026, l'un des rendez-vous académiques de référence en langages de programmation.

Pour ceux qui découvrent le sujet : la promesse de « traduire automatiquement du C++ en Rust » revient régulièrement depuis que Rust s'est imposé comme alternative sérieuse au C++ pour les logiciels système, grâce à son modèle de propriété qui élimine à la compilation toute une classe de bugs mémoire (use-after-free, débordements de tampon, accès concurrents non protégés). Le problème, c'est que personne ne réécrit à la main des millions de lignes de C++ existant. D'où l'intérêt de tout outil capable d'automatiser tout ou partie de cette traduction.

Comment fonctionne la traduction, concrètement

Cpp2Rust ne devine rien : c'est un traducteur syntaxique piloté par l'AST de clang. Le pipeline se déroule en trois temps. D'abord, clang analyse votre ou vos fichiers .cpp et produit un arbre de syntaxe abstraite. Ensuite, Cpp2Rust parcourt cet arbre et génère du code Rust sous forme de chaînes de caractères, en insérant au passage des appels vers sa bibliothèque runtime libcc2rs, notamment pour tout ce qui touche à la sémantique des pointeurs bruts. Enfin, le résultat est mis en forme avec rustfmt et écrit dans un seul fichier .rs.

Sur l'exemple minimal fourni par le projet, un simple hello world en C++ :

#include <cstdio>

int main() {
    printf("hello world");
    return 0;
}

devient, une fois traduit :

pub fn main() {
    std::process::exit(main_0());
}

fn main_0() -> i32 {
    println!("hello world");
    return 0;
}

Le vrai prix de la sûreté automatique

Le point le plus intéressant, et le plus honnête, de ce projet se trouve dans sa bibliothèque runtime libcc2rs. Par défaut, chaque pointeur C est converti en un type Ptr<T> qui modélise la sémantique des pointeurs C, y compris le null, l'arithmétique de pointeur et l'aliasing, tout en satisfaisant le borrow checker de Rust grâce à des opérations vérifiées à l'exécution. Autrement dit : le Rust produit est sûr, mais cette sûreté n'est pas gratuite. Ce n'est pas un compilateur qui restructure votre code en emprunts et durées de vie idiomatiques comme le ferait un développeur Rust expérimenté, c'est une couche de compatibilité qui simule les pointeurs C avec des vérifications au runtime, sur le modèle du comptage de références.

La preuve la plus parlante de ce compromis : le projet propose lui-même un second mode, --model=unsafe, explicitement décrit comme destiné au débogage et à la comparaison de performances. Traduction : les auteurs savent que leur mode sûr par défaut coûte en performance, et fournissent un mode alternatif pour objectiver l'écart. C'est une posture rare et plutôt saine dans un domaine où l'on vend parfois la sûreté automatique comme gratuite.

Traduire un fichier, ou un programme entier

Sur un seul fichier, la commande est directe :

./build/cpp2rust/cpp2rust --file=hello.cpp -o=hello.rs

Pour un programme entier, Cpp2Rust a besoin d'un compile_commands.json, donc d'un projet déjà compilable avec CMake (ajoutez -DCMAKE_EXPORT_COMPILE_COMMANDS=ON à votre configuration), puis :

./build/cpp2rust/cpp2rust --dir=<dir> -o <output>.rs

Côté installation, comptez sur une toolchain récente : sur Ubuntu, il faut libclang-22-dev, clang++-22, ninja-build, cmake et l'outil Python ruff. Ce n'est pas un détail : exiger une version aussi récente de clang veut dire que la plupart des équipes devront mettre à jour leur chaîne d'outils avant même de tester l'outil sur un vrai projet.

Ce que ça implique si vous envisagez une migration

Trois enseignements concrets si vous pilotez, ou envisagez, une migration C++ vers Rust dans votre équipe :

• Ne comptez pas sur du Rust idiomatique en sortie. L'exemple hello world du projet le montre bien : le main() en C++ devient une fonction main_0() enveloppée, appelée depuis un point d'entrée Rust généré. C'est fonctionnellement correct, mais ce n'est pas nécessairement ce qu'un développeur Rust natif écrirait à la main. Prévoyez une relecture humaine après la traduction, surtout sur les modules critiques.
• Utilisez-le comme filet de sécurité mémoire, pas comme raccourci de livraison. Faire tourner une traduction automatique avec le modèle par défaut permet de vérifier, via le borrow checker, qu'aucun accès mémoire douteux ne subsiste dans un module hérité, avant même de retoucher le style du code. C'est une valeur réelle pour dérisquer une base ancienne, indépendamment de la question esthétique.
• Mesurez le delta de performance avant de trancher. Puisque le mode sûr par défaut ajoute des vérifications à l'exécution, comparez systématiquement contre le mode --model=unsafe sur vos chemins les plus sollicités avant de décider si le résultat est acceptable en production.

Notre lecture chez CZSyn

Chez CZSyn, nous croisons régulièrement des PME et éditeurs français avec un noyau C++ vieillissant, hérité, que plus personne n'ose vraiment retoucher. Cpp2Rust ne résout pas ce problème d'un coup de baguette magique, mais il pose une brique utile : un premier passage automatique, fondé sur des travaux publiés et évalués par les pairs à PLDI 2026, qui donne une base Rust sûre et testable sans réécriture manuelle intégrale.

Notre lecture reste mesurée : le projet est jeune (273 étoiles, 265 commits d'historique), dépend d'une version très récente de clang, et son modèle sûr par défaut a un coût de performance assumé par ses propres auteurs. Ce n'est clairement pas encore un outil à brancher sur une chaîne de production critique sans supervision humaine. Mais pour dégrossir une migration, isoler les modules les plus sensibles d'un point de vue mémoire, ou simplement objectiver un risque avant de lancer un chantier de réécriture, c'est le genre d'outil qui mérite un test sur un module non critique avant d'aller plus loin.

Sources primaires

• Dépôt officiel GitHub, Cpp2Rust/cpp2rust, consulté le 14 juillet 2026.
• Documentation officielle du projet Clang, clang.llvm.org/docs, le compilateur dont Cpp2Rust exploite l'AST pour piloter la traduction.
• Site officiel du langage Rust, rust-lang.org.