Rust et l'industrie automobile

L’automobile moderne est devenue un produit logiciel. Les véhicules dits Software Defined Vehicles (SDV – véhicules définis par logiciel) reposent sur des millions de lignes de code pour gérer la motorisation, la sécurité, l’info-divertissement et la connectivité.

Dans ce contexte, le choix du langage de programmation est stratégique : il doit garantir performance, sécurité et fiabilité. Historiquement, le C et le C++ dominent ce secteur.  

Mais depuis quelques années, Rust commence à s’imposer comme une alternative crédible, notamment grâce à son système de gestion mémoire sans garbage collector (ramasse-miettes) et son approche stricte de l’ownership (propriété des données) et du borrowing (emprunt des données). Ces caractéristiques en font un candidat idéal pour les logiciels embarqués critiques.¹

‍

Pourquoi Rust attire l'automobile ?

‍

Sécurité mémoire : Rust empêche les erreurs classiques de C++ comme les buffer overflows ou les danglaings pointers. Dans un système embarqué automobile, une telle erreur peut provoquer une panne critique.

‍

Concrètement, voici ce qui peut se passer :

‍

• C++

‍

#include <iostream> 

 

int* createPointer() { 

    int x = 42; 

    return &x; // retourne l'adresse d'une variable locale -> dangereux 

} 

 

int main() { 

    int* p = createPointer(); 

    std::cout << *p << std::endl; // comportement indéfini 

} 

‍

À la compilation, on a bien un warning indiquant qu'on retourne l'adresse d'une variable locale et le binaire est utilisable. Il en résulte qu'un crash apparaît lors de l'exécution.

• Rust

‍

fn create_pointer<'a>() -> &'a i32 { 

    let x = 42; 

    &x // Erreur de compilation : x ne vit pas assez longtemps 

} 

 

fn main() { 

    let p = create_pointer(); 

    println!("{}", p); 

} 

‍

‍

Quand on compile ce programme, on a un warning similaire à C++ mais le binaire n'est pas créé : on ne peut pas avoir de mauvais surprise à l'éxcution du code !

• Performance : Rust offre des performances comparables à C++ à l’exécution du programme, sans surcoût lié à un garbage collector. Cette particularité lui permet d’être déployé sur des systèmes « temps réel ». Néanmoins, notons que le temps de compilation est généralement plus long pour Rust que C++.²
• Fiabilité : Le compilateur Rust impose des règles strictes qui réduisent les bugs dès la phase de développement. Là où C++ laisse plus de liberté (et donc de risques), Rust force une discipline bénéfique dans un contexte industriel.

‍

Une approche basique d’un calcul utilisant un multi-threading pourrait se définir de la façon suivante :

• On déclare une variable commune aux threads ;

• On l’incrémente de 1 ;

• On observe le résultat.

‍

Lorsque l'on n'est pas familier avec les threads ou avec les nouveaux concepts C++ comme « std::atomic », protéger ses données contre la modification concurrentielle n’est pas automatique et on peut se retrouver avec un code naïf comme ceci :

• C++

‍

#include <thread> 

#include <iostream> 

 

int main() { 

    int x = 0; 

    auto t1 = std::thread([&]() { x++; }); 

    auto t2 = std::thread([&]() { x++; }); 

    t1.join(); 

    t2.join(); 

    std::cout << x << std::endl; // résultat indéfini 

} 

‍

On pourrait s'attendre à ce que le résultat soit toujours 2, mais dans les faits, ce n'est pas garanti.

‍

Un équivalent en Rust se ferait comme ceci :

• Rust

‍

use std::thread; 

 

fn main() { 

    let mut x = 0; 

    let handle1 = thread::spawn(|| { 

        x += 1; 

    }); 

    handle1.join().unwrap(); 

    println!(“{}”, x); 

} 

‍

Ce code ne compile pas, car le compilateur Rust refuse que la variable x soit modifiée depuis un thread.
Le problème vient du fait que la closure passée à thread::spawn capture x par référence implicite, ce qui suppose que la variable reste valide pendant toute l’exécution du thread. Or, dans cet exemple, x est une variable locale de la fonction main, et Rust ne peut pas garantir sa durée de vie au regard du thread nouvellement créé.

Même si on attend la fin du thread avec join(), le compilateur ne prend aucune hypothèse implicite sur l’ordre d’exécution : il exige que les règles d’emprunt et de propriété soient respectées de manière stricte. C’est pourquoi il refuse ce code et signale que le comportement autour de x est indéfini ou non sécurisé.

‍

Rust et les standards automobiles

• AUTOSAR (AUTomotive Open System ARchitecture) : standard mondial définissant les architectures logicielles pour l’automobile. Vector, acteur incontournable dans le domaine, explore l’intégration de Rust dans AUTOSAR Classic et Adaptive.

• Qualification logicielle : HighTec et Solid Sands travaillent à qualifier les bibliothèques Rust pour répondre aux normes de sûreté (ISO 26262 – sécurité fonctionnelle automobile).

• Comparatif C++ : C++ est déjà largement intégré dans AUTOSAR et bénéficie d’un écosystème mature. Rust doit encore franchir l’étape de la certification, mais son approche mémoire sûre lui donne un avantage potentiel à long terme.

‍

Cas d'usages concrets

• Systèmes embarqués critiques : contrôle moteur, gestion de la batterie, ADAS (Advanced Driver Assistance Systems – systèmes avancés d’aide à la conduite). Rust est testé pour réduire les risques de bugs dans ces modules.

• Cloud et connectivité : Rust est utilisé par des acteurs comme Amazon Web Services (AWS) et Cloudflare pour des services réseau. Ces briques peuvent être intégrées aux véhicules connectés pour les mises à jour OTA (Over-The-Air).

• Outils open source : des projets Rust comme a2lfile ou asammdf permettent de manipuler des fichiers de calibration et de mesure, très utilisés dans l’ingénierie automobile.

• Comparatif C++ : C++ reste dominant dans les calculateurs embarqués, mais Rust commence à apparaître dans les couches logicielles liées à la connectivité et aux outils d’ingénierie.
  

‍

Défis et perspectives

• Obstacle actuel : l’écosystème automobile est historiquement centré sur C et C++. Les ingénieurs sont formés à ces langages, et les outils sont optimisés pour eux.

• Perspectives : avec l’intégration progressive de Rust dans AUTOSAR et les efforts de qualification ISO 26262, Rust pourrait devenir un langage clé pour les SDV et les véhicules autonomes.

• Vision : Rust n’est pas encore un standard, mais il est en train de se positionner comme un langage de confiance pour les environnements critiques. On le voit percer dans d’autres domaines comme le Web par exemple.

‍

Conclusion

Rust n’est pas seulement un langage performant : il pourrait devenir un pilier de la sûreté logicielle automobile. Là où C++ offre puissance et flexibilité mais laisse la porte ouverte aux erreurs mémoire, Rust impose une rigueur qui séduit les acteurs du secteur. Si son adoption dans les chaînes de montage reste marginale, son rôle dans les véhicules eux-mêmes est appelé à croître, notamment dans les domaines critiques comme l’ADAS, la gestion énergétique et la connectivité.

‍

‍

Sources :

¹ TIOBE Index - TIOBE‍Rust in Industry: Case Studies and Success Stories in 2025 | Andrew Odendaal‍Why Rust is Replacing C++ in AAA Game Engines (2025 Case Studies) | Markaicode

² Rust vs C++ g++ - Which programs are fastest? (Benchmarks Game)

‍