Rust (langage de programmation)

(ou éventuellement un pointeur nul s'il est enveloppé dans une option)

Rust n'utilise pas de pointeurs nuls pour indiquer un manque de données, car cela peut conduire à un déréférencement nul . En conséquence, les références basic &et sont garanties de ne pas être nulles. Rust utilise plutôt à cette fin : indique qu'une valeur est présente, et est analogue au pointeur nul. implémente une « optimisation de pointeur nul », évitant toute surcharge spatiale pour les types qui ne peuvent pas avoir de valeur nulle (les références ou les types, par exemple). &mutOptionSome(T)None OptionNonZero

Contrairement aux références, les types de pointeurs bruts *constet *mutpeuvent être nuls ; cependant, il est impossible de les déréférencer à moins que le code ne soit explicitement déclaré non sécurisé via l'utilisation d'un unsafebloc. Contrairement au déréférencement, la création de pointeurs bruts est autorisée à l'intérieur du code Rust sécurisé.

laissez x = 1000 ; println! ( "1000 comme u16 est : {}" , x comme u16 );

Le système de propriété de Rust se compose de règles qui assurent la sécurité de la mémoire sans utiliser de ramasse-miettes. Au moment de la compilation, chaque valeur doit être attachée à une variable appelée le propriétaire de cette valeur, et chaque valeur doit avoir exactement un propriétaire. Les valeurs sont déplacées entre différents propriétaires par affectation ou en passant une valeur en tant que paramètre de fonction. Les valeurs peuvent également être empruntées, ce qui signifie qu'elles sont temporairement transmises à une fonction différente avant d'être renvoyées au propriétaire. Avec ces règles, Rust peut empêcher la création et l'utilisation de pointeurs suspendus :

fn 
print_string ( s : Chaîne ) { println! ( "{}" , s ); }
fn 
main () { let s = String :: from ( "Hello, World" ); print_string ( s ); // s consommé par print_string // s a ​​été déplacé, il ne peut donc plus être utilisé // un autre print_string(s); entraînerait une erreur de compilation }

En raison de ces règles de propriété, les types Rust sont appelés types linéaires ou affines , ce qui signifie que chaque valeur peut être utilisée exactement une fois. Cela impose une forme d' isolement des pannes logicielles puisque le propriétaire d'une valeur est seul responsable de son exactitude et de sa désallocation.

Lorsqu'une valeur sort de la portée, elle est supprimée en exécutant son destructeur . Le destructeur peut être défini par programmation en implémentant le Droptrait. Cela permet de gérer les ressources telles que les handles de fichiers, les sockets réseau et les verrous , car lorsque des objets sont supprimés, les ressources qui leur sont associées sont fermées ou libérées automatiquement.

La durée de vie d'un objet fait référence à la période de temps pendant laquelle une référence est valide, c'est-à-dire le temps entre la création et la destruction de l'objet. Ces durées de vie sont implicitement associées à tous les types de référence Rust. Bien que souvent déduites, elles peuvent également être indiquées explicitement avec des paramètres de durée de vie nommés (souvent notés 'a, 'b, etc.).

Les durées de vie dans Rust peuvent être considérées comme ayant une portée lexicale , ce qui signifie que la durée de vie d'un objet est déduite de l'ensemble des emplacements dans le code source (c'est-à-dire les numéros de fonction, de ligne et de colonne) pour lesquels une variable est valide. Par exemple, une référence à une variable locale a une durée de vie correspondant au bloc dans lequel elle est définie :

fn 
main () { let x = 5 ; // ------------------+- Durée de vie 'a // | let r = & x ; // -+-- Durée de vie 'b | // | | println! ( "r: {}" , r ); // | | // | | // -+ | } // ------------------+

Le vérificateur d'emprunt du compilateur Rust veille ensuite à ce que les références ne soient utilisées que dans les emplacements du code source où la durée de vie associée est valide. Dans l'exemple ci-dessus, le stockage d'une référence à une variable xdans rest valide, car la variable xa une durée de vie plus longue ( 'a) que la variable r( 'b). Cependant, lorsque xla durée de vie est plus courte, le vérificateur d'emprunt rejetterait le programme :

fn 
main () { let r ; // ------------------+- Durée de vie 'a // | { // | let x = 5 ; // -+-- Durée de vie 'b | r = & x ; // | | // ERREUR ici : x ne vit pas assez longtemps } // -| | // | println! ( "r: {}" , r ); // | } // ------------------+

Étant donné que la durée de vie de la variable référencée ( 'b) est plus courte que la durée de vie de la variable contenant la référence ( 'a), le vérificateur d'emprunt génère des erreurs, empêchant xtoute utilisation en dehors de sa portée.

Les durées de vie peuvent être indiquées à l'aide de paramètres de durée de vie explicites sur les arguments de fonction. Par exemple, le code suivant spécifie que la référence renvoyée par la fonction a la même durée de vie que original(et pas nécessairement la même durée de vie que prefix) :

fn 
remove_prefix <' a > ( mut original : & ' a str , prefix : & str ) -> & ' a str { si original . starts_with ( prefix ) { original = original [ prefix . len () .. ]; } original }

Lorsque les types définis par l'utilisateur contiennent des références à des données, ils doivent également utiliser des paramètres de durée de vie. L'exemple ci-dessous analyse certaines options de configuration à partir d'une chaîne et crée une structure contenant les options. La fonction parse_configprésente également l'élision de durée de vie, ce qui réduit la nécessité de définir explicitement les paramètres de durée de vie.

utiliser std :: collections :: HashMap ;
// Cette structure a un paramètre de durée de vie, 'src. Le nom n'est utilisé que dans la définition de la structure. 
#[derive(Debug)] 
struct 
Config <' src > { hostname : & ' src str , username : & ' src str , }
// Le paramètre '_ lifetime, dans ce cas, fait référence à la durée de vie anonyme attachée au type 
// de l'argument `config`. 
fn 
parse_config ( config : & str ) -> Config <' _ > { let key_values ​​: HashMap < _ , _ > = config . lines () . filter ( | line | ! line . starts_with ( '#' )) . filter_map ( | line | line . split_once ( '=' )) . map ( | ( key , value ) | ( key . trim (), value . trim ())) . collect (); Config { hostname : key_values ​​[ "hostname" ], username : key_values ​​[ "username" ], } }
fn 
main () { let config = parse_config ( r#"hostname = foobar username=barfoo"# , ); println! ( "Configuration analysée : {:#?}" , config ); }

Dans le compilateur, la propriété et les durées de vie fonctionnent ensemble pour éviter les problèmes de sécurité de la mémoire tels que les pointeurs suspendus.

Les fonctionnalités les plus avancées de Rust incluent l'utilisation de fonctions génériques . Une fonction générique reçoit des paramètres génériques , qui permettent d'appliquer la même fonction à différents types de variables. Cette capacité réduit le code dupliqué et est connue sous le nom de polymorphisme paramétrique .

Le programme suivant calcule la somme de deux choses, pour lesquelles l'addition est implémentée à l'aide d'une fonction générique :

utiliser std :: ops :: Add ;
// sum est une fonction générique avec un paramètre de type, T 
fn 
sum < T > ( num1 : T , num2 : T ) -> T où T : Add < Output = T > , // T doit implémenter le trait Add où l'addition renvoie un autre T { num1 + num2 // num1 + num2 est le sucre syntaxique pour num1.add(num2) fourni par le trait Add }
fn 
main () { let result1 = sum ( 10,20 ) ; println! ( " La somme est : {}" , result1 ); // La somme est : 30
laissez resultat2 = somme ( 10,23 , 20,45 ); println! ( "La somme est : {}" , resultat2 ); // La somme est : 30,68 }

Au moment de la compilation, les fonctions polymorphes comme sumsont instanciées avec les types spécifiques requis par le code ; dans ce cas, la somme des entiers et la somme des flottants.

Les génériques peuvent être utilisés dans des fonctions pour permettre l'implémentation d'un comportement pour différents types sans répéter le même code. Les fonctions génériques peuvent être écrites en relation avec d'autres génériques, sans connaître le type réel.

Le système de types de Rust prend en charge un mécanisme appelé traits, inspiré des classes de types du langage Haskell , pour définir un comportement partagé entre différents types. Par exemple, le Addtrait peut être implémenté pour les nombres flottants et les entiers, qui peuvent être ajoutés ; et les traits Displayor Debugpeuvent être implémentés pour tout type pouvant être converti en chaîne. Les traits peuvent être utilisés pour fournir un ensemble de comportements communs à différents types sans connaître le type réel. Cette fonctionnalité est connue sous le nom de polymorphisme ad hoc .

Les fonctions génériques peuvent contraindre le type générique à implémenter un ou plusieurs traits particuliers ; par exemple, une add_onefonction peut exiger que le type implémente Add. Cela signifie qu'une fonction générique peut être vérifiée dès qu'elle est définie. L'implémentation des génériques est similaire à l'implémentation typique des modèles C++ : une copie distincte du code est générée pour chaque instanciation. Cela s'appelle la monomorphisation et contraste avec le schéma d'effacement de type généralement utilisé dans Java et Haskell. L'effacement de type est également disponible via le mot-clé dyn(abréviation de dynamic). Étant donné que la monomorphisation duplique le code pour chaque type utilisé, elle peut donner lieu à un code plus optimisé pour des cas d'utilisation spécifiques, mais le temps de compilation et la taille du binaire de sortie sont également augmentés.

En plus de définir des méthodes pour un type défini par l'utilisateur, le implmot-clé peut être utilisé pour implémenter un trait pour un type. Les traits peuvent fournir des méthodes dérivées supplémentaires lorsqu'ils sont implémentés. Par exemple, le trait Iteratorexige que la nextméthode soit définie pour le type. Une fois la nextméthode définie, le trait peut fournir des méthodes d'assistance fonctionnelles communes sur l'itérateur, telles que mapou filter.

Les traits de Rust sont implémentés à l'aide de la répartition statique , ce qui signifie que le type de toutes les valeurs est connu au moment de la compilation ; cependant, Rust utilise également une fonctionnalité connue sous le nom d' objets de trait pour réaliser une répartition dynamique (également connue sous le nom de typage de canard ). Les objets de trait répartis dynamiquement sont déclarés à l'aide de la syntaxe dyn Troù Trest un trait. Les objets de trait sont dimensionnés dynamiquement, ils doivent donc être placés derrière un pointeur, tel que Box. L'exemple suivant crée une liste d'objets où chaque objet peut être imprimé à l'aide du Displaytrait :

utiliser std :: fmt :: Display ;
laissez v : Vec < Box < dyn Display >> = vec! [ Box :: new ( 3 ), Box :: new ( 5.0 ), Box :: new ( "hi" ), ];
pour x dans v { println! ( "{x}" ); }

Si un élément de la liste n'implémente pas le Displaytrait, cela provoquera une erreur de compilation.

Rust est conçu pour être sûr en termes de mémoire . Il n'autorise pas les pointeurs nuls, les pointeurs suspendus ou les courses de données . Les valeurs de données ne peuvent être initialisées que via un ensemble fixe de formulaires, qui nécessitent tous que leurs entrées soient déjà initialisées.

Un code non sécurisé peut contourner certaines de ces restrictions en utilisant le unsafemot-clé. Un code non sécurisé peut également être utilisé pour des fonctionnalités de bas niveau, telles que l'accès à la mémoire volatile , les intrinsèques spécifiques à l'architecture, le jeu de mots de type et l'assemblage en ligne.

Rust n'utilise pas de ramasse-miettes . La mémoire et les autres ressources sont gérées via la convention « l'acquisition des ressources est une initialisation », un comptage de références optionnel . Rust fournit une gestion déterministe des ressources, avec une charge très faible . Les valeurs sont allouées sur la pile par défaut, et toutes les allocations dynamiques doivent être explicites.

Les types de référence intégrés utilisant le &symbole n'impliquent pas de comptage de références au moment de l'exécution. La sécurité et la validité des pointeurs sous-jacents sont vérifiées au moment de la compilation, ce qui évite les pointeurs suspendus et d'autres formes de comportement indéfini . Le système de types de Rust sépare les références partagées et immuables du formulaire &Tdes références uniques et mutables du formulaire &mut T. Une référence mutable peut être forcée à devenir une référence immuable, mais pas l'inverse.

Il est possible d'étendre le langage Rust à l'aide de macros.

Une macro déclarative (également appelée « macro par exemple ») est une macro, définie à l'aide du macro_rules!mot-clé, qui utilise la correspondance de motifs pour déterminer son expansion. Un exemple est la println!()macro.

Les macros procédurales sont des fonctions Rust qui exécutent et modifient le flux de jetons d'entrée du compilateur , avant que d'autres composants ne soient compilés. Elles sont généralement plus flexibles que les macros déclaratives, mais sont plus difficiles à maintenir en raison de leur complexité.

Les macros procédurales sont disponibles en trois versions :

• Macros de type fonctioncustom!(...)
• Dériver des macros#[derive(CustomDerive)]
• Macros d'attributs#[custom_attribute]

La rsx!macro dans le framework front-end Dioxus est un exemple de macro de type fonction. La serde_derivemacro fournit une bibliothèque couramment utilisée pour générer du code pour la lecture et l'écriture de données dans de nombreux formats, tels que JSON . Les macros d'attributs sont couramment utilisées pour les liaisons de langage, telles que la extendrbibliothèque pour les liaisons Rust à R.

Le code suivant montre l'utilisation des macros procédurales dérivées de Serialize, Deserialize, et Debugpour implémenter la lecture et l'écriture JSON, ainsi que la possibilité de formater une structure pour le débogage.

utiliser serde :: { Sérialiser , Désérialiser };
#[derive(Sérialiser, Désérialiser, Déboguer)] 
struct 
Point { x : i32 , y : i32 , }
fn 
main () { laissez point = Point { x : 1 , y : 2 };
laissez sérialisé = serde_json :: to_string ( & point ). unwrap (); println! ( "sérialisé = {}" , sérialisé );
laissez désérialisé : Point = serde_json :: from_str ( & sérialisé ). unwrap (); println! ( "désérialisé = {:?}" , désérialisé ); }

macro_rules! calculate { // Le modèle pour un seul `eval` ( eval $e : expr ) => {{ { let val : usize = $e ; // Forcer les types à être des entiers println! ( "{} = {}" , stringify! { $e }, val ); } }};
// Décomposer plusieurs `eval` de manière récursive 
( eval $e : expr , $( eval $es : expr ), + ) => {{ calculer ! { eval $e } calculer ! { $( eval $es ), + } }}; }
fn 
main () { calculate ! { // Regardez ma! Variadic `calculate!`! eval 1 + 2 , eval 3 + 4 , eval ( 2 * 3 ) + 1 } }

Rust dispose d'une interface de fonction étrangère (FFI) qui peut être utilisée à la fois pour appeler du code écrit dans des langages tels que C à partir de Rust et pour appeler du code Rust à partir de ces langages. En 2024 , une bibliothèque externe appelée CXX existe pour appeler vers ou depuis C++. Rust et C diffèrent dans la façon dont ils disposent les structures en mémoire, de sorte que les structures Rust peuvent recevoir un #[repr(C)]attribut, forçant la même disposition que la structure C équivalente.

L'écosystème Rust comprend son compilateur, sa bibliothèque standard et des composants supplémentaires pour le développement de logiciels. L'installation des composants est généralement gérée par rustup, un installateur de chaîne d'outils Rust développé par le projet Rust.

Le compilateur Rust, , traduit le code Rust en IRrustc LLVM de bas niveau . LLVM est ensuite invoqué en tant que sous-composant pour appliquer des optimisations et traduire l'IR résultant en code objet . Un éditeur de liens est ensuite utilisé pour combiner les objets en une seule image exécutable ou un fichier binaire.

Outre LLVM, le compilateur prend également en charge l'utilisation de backends alternatifs tels que GCC et Cranelift pour la génération de code. L'objectif de ces backends alternatifs est d'augmenter la couverture de la plateforme Rust ou d'améliorer les temps de compilation.

La bibliothèque standard Rust définit et implémente de nombreux types de données personnalisés largement utilisés, notamment des structures de données de base telles que Vec, Option, et HashMap, ainsi que des types de pointeurs intelligents . Rust fournit également un moyen d'exclure la majeure partie de la bibliothèque standard à l'aide de l'attribut #![no_std]; cela permet aux applications, telles que les appareils intégrés, qui souhaitent supprimer le code de dépendance ou fournir leurs propres structures de données de base. En interne, la bibliothèque standard est divisée en trois parties, core, alloc, et std, où stdet allocsont exclus par #![no_std].

Cargo est le système de construction et le gestionnaire de paquets de Rust . Il télécharge, compile, distribue et charge des paquets, appelés crates , qui sont conservés dans un registre officiel. Il fait également office d'interface pour Clippy et d'autres composants Rust.

Par défaut, Cargo tire ses dépendances du registre crates.io fourni par l'utilisateur , mais les référentiels Git et les caisses du système de fichiers local, ainsi que d'autres sources externes peuvent également être spécifiés comme dépendances.

Rustfmt est un formateur de code pour Rust. Il formate les espaces et l'indentation pour produire du code conformément à un style commun , sauf indication contraire. Il peut être invoqué en tant que programme autonome ou à partir d'un projet Rust via Cargo.

Clippy est l'outil de linting intégré de Rust pour améliorer l'exactitude, les performances et la lisibilité du code Rust. En 2024 , il compte plus de 700 règles.

Après Rust 1.0, de nouvelles fonctionnalités sont développées dans des versions nocturnes qui sont publiées quotidiennement. Au cours de chaque cycle de publication de six semaines, les modifications apportées aux versions nocturnes sont publiées en version bêta, tandis que les modifications de la version bêta précédente sont publiées dans une nouvelle version stable.

Tous les deux ou trois ans, une nouvelle « édition » est produite. Les éditions sont publiées pour permettre d'effectuer des changements de rupture limités , comme la promotion awaitd'un mot-clé pour prendre en charge les fonctionnalités async/await . Les crates ciblant différentes éditions peuvent interagir entre elles, de sorte qu'une crate peut passer à une nouvelle édition même si ses appelants ou ses dépendances ciblent toujours des éditions plus anciennes. La migration vers une nouvelle édition peut être facilitée par des outils automatisés.

rust-analyzer est un ensemble d'utilitaires qui fournit aux environnements de développement intégrés (IDE) et aux éditeurs de texte des informations sur un projet Rust via le protocole Language Server Protocol . Cela permet d'activer des fonctionnalités telles que la saisie semi-automatique et l'affichage des erreurs de compilation lors de l'édition.

En général, les garanties de sécurité de la mémoire de Rust n'imposent pas de surcharge d'exécution. Une exception notable est l'indexation des tableaux qui est vérifiée au moment de l'exécution, bien que cela n'ait souvent pas d'impact sur les performances. Comme il n'effectue pas de nettoyage de mémoire, Rust est souvent plus rapide que d'autres langages sécurisés en mémoire.

Rust propose deux « modes » : safe et unsafe. Le mode safe est le mode « normal », dans lequel la plupart des programmes Rust sont écrits. En mode unsafe, le développeur est responsable de la sécurité de la mémoire du code, qui est utilisée par les développeurs dans les cas où le compilateur est trop restrictif.

De nombreuses fonctionnalités de Rust sont des abstractions dites à coût nul , ce qui signifie qu'elles sont optimisées au moment de la compilation et n'entraînent aucune pénalité d'exécution. Le système de propriété et d'emprunt permet des implémentations sans copie pour certaines tâches sensibles aux performances, telles que l'analyse . La répartition statique est utilisée par défaut pour éliminer les appels de méthode , à l'exception des méthodes appelées sur des objets de trait dynamiques. Le compilateur utilise également l'expansion en ligne pour éliminer les appels de fonction et les invocations de méthodes distribuées de manière statique.

Étant donné que Rust utilise LLVM , toutes les améliorations de performances de LLVM sont également transférées à Rust. Contrairement à C et C++, Rust permet de réorganiser les éléments struct et enum pour réduire la taille des structures en mémoire, pour un meilleur alignement de la mémoire et pour améliorer l'efficacité de l'accès au cache .

Rust est utilisé dans les logiciels de différents domaines. Des composants du moteur de navigateur Servo (financé par Mozilla et Samsung) ont été intégrés au moteur de navigateur Gecko sous-jacent à Firefox. En janvier 2023, Google ( Alphabet ) a annoncé la prise en charge de l'utilisation de bibliothèques Rust tierces dans Chromium .

Rust est utilisé dans plusieurs projets de logiciels back-end de grands services Web . OpenDNS , un service de résolution DNS appartenant à Cisco , utilise Rust en interne. Amazon Web Services utilise Rust dans les « composants sensibles aux performances » de ses différents services. En 2019, AWS a ouvert la source de Firecracker , une solution de virtualisation principalement écrite en Rust. Microsoft Azure IoT Edge, une plateforme utilisée pour exécuter des services Azure sur des appareils IoT , possède des composants implémentés en Rust. Microsoft utilise également Rust pour exécuter des modules conteneurisés avec WebAssembly et Kubernetes . Cloudflare , une société fournissant des services de réseau de diffusion de contenu , a utilisé Rust pour créer un nouveau proxy Web nommé Pingora pour des performances et une efficacité accrues. Le gestionnaire de paquets npm a utilisé Rust pour son service d'authentification de production en 2019.

Dans les systèmes d'exploitation, le projet Rust pour Linux , lancé en 2020, a fusionné le support initial dans la version 6.1 du noyau Linux fin 2022. Le projet est actif avec une équipe de 6 à 7 développeurs et a ajouté du code Rust supplémentaire avec les versions du noyau de 2022 à 2024, dans le but de démontrer la viabilité minimale du projet et de résoudre les principaux bloqueurs de compatibilité. Les premiers pilotes écrits en Rust ont été fusionnés dans le noyau de la version 6.8. Les développeurs Android ont utilisé Rust en 2021 pour réécrire les composants existants. Microsoft a réécrit des parties de Windows en Rust. Le projet r9 vise à réimplémenter Plan 9 de Bell Labs en Rust. Rust a été utilisé dans le développement de nouveaux systèmes d'exploitation tels que Redox , un système d'exploitation et un micro-noyau de type Unix , Theseus, un système d'exploitation expérimental avec gestion d'état modulaire, et la plupart des systèmes d'exploitation Fuchsia . Rust est également utilisé pour les outils de ligne de commande et les composants du système d'exploitation, notamment stratisd , un gestionnaire de système de fichiers et COSMIC, un environnement de bureau de System76 .

Dans le développement Web, Deno , un environnement d'exécution sécurisé pour JavaScript et TypeScript , est construit sur V8 en utilisant Rust et Tokio. D'autres adoptions notables dans cet espace incluent Ruffle , un émulateur SWF open source , et Polkadot , une plate-forme open source de blockchain et de crypto-monnaie .

Discord , une société de logiciels de messagerie instantanée , a réécrit certaines parties de son système en Rust pour améliorer ses performances en 2020. La même année, Dropbox a annoncé que sa synchronisation de fichiers avait été réécrite en Rust. Facebook ( Meta ) a utilisé Rust pour repenser son système qui gère le code source des projets internes.

Dans l'enquête 2024 de Stack Overflow auprès des développeurs, 12,6 % des répondants avaient récemment effectué un développement approfondi en Rust. L'enquête a désigné Rust comme le « langage de programmation le plus admiré » chaque année de 2016 à 2024 (inclus), en fonction du nombre de développeurs existants souhaitant continuer à travailler dans le même langage. En 2024, Rust était la 6e « technologie la plus recherchée », avec 28,7 % des développeurs ne travaillant pas actuellement en Rust exprimant leur intérêt à le faire.

Rust a été étudié dans le cadre de recherches universitaires, tant pour les propriétés du langage lui-même que pour l'utilité qu'il fournit pour l'écriture de logiciels utilisés pour la recherche. Ses caractéristiques en matière de sécurité et de performances ont été examinées.

Dans un article publié dans Proceedings of the International Astronomical Union , les astrophysiciens Blanco-Cuaresma et Bolmont ont réimplémenté des programmes responsables de la simulation de systèmes multi-planétaires dans Rust, et ont découvert qu'il s'agissait d'un langage de programmation compétitif pour sa « rapidité et sa précision ». De même, un article publié dans Nature a partagé plusieurs histoires de bioinformaticiens utilisant Rust pour ses performances et sa sécurité. Cependant, les deux articles ont cité les concepts uniques de Rust, y compris son système de propriété, qui sont difficiles à apprendre comme l'un des principaux inconvénients de l'adoption de Rust.

Rust a été reconnu comme une communauté inclusive, et a particulièrement accueilli les personnes de la communauté queer , en partie en raison de son code de conduite qui décrit un ensemble d'attentes que les membres de la communauté Rust doivent suivre. Un article du MIT Technology Review décrit la communauté Rust comme « inhabituellement amicale » envers les nouveaux arrivants.

La Rust Foundation est une organisation à but non lucratif constituée aux États-Unis , dont les principaux objectifs sont de soutenir le projet technique en tant qu'entité juridique et d'aider à gérer les actifs de marque et d'infrastructure.

Elle a été créée le 8 février 2021, avec cinq membres fondateurs (Amazon Web Services, Huawei, Google, Microsoft et Mozilla). Le conseil d'administration de la fondation est présidé par Shane Miller. À compter de fin 2021, sa directrice exécutive et PDG est Rebecca Rumbul. Avant cela, Ashley Williams était directrice exécutive par intérim.

Le projet Rust est composé d' équipes responsables de différents sous-domaines du développement. L'équipe du compilateur développe, gère et optimise les composants internes du compilateur ; et l'équipe du langage conçoit de nouvelles fonctionnalités du langage et aide à les implémenter. Le site Web du projet Rust répertorie 6 équipes de haut niveau en juillet 2024. [ Les représentants des équipes forment le conseil de direction, qui supervise le projet Rust dans son ensemble.