Rust（プログラミング言語）

Rust は、2006 年にMozilla の従業員である Graydon Hoareによる個人的なプロジェクトとして始まりました。MIT Technology Reviewによると、彼はアパートのエレベーターのソフトウェアがクラッシュして故障したことに不満を感じてこのプロジェクトを開始し、^{[ 20 ]}「生存のために過剰に設計された」同名の菌類のグループにちなんでこの言語に名前を付けました。 ^{[ 20 ]} 2006 年から 2009 年の間、Rust は Mozilla の他の人には公表されず、Hoare の自由時間に書かれていました。^{[ 21 ] : 7:50} Hoare は、Mozilla の少数のグループがこのプロジェクトに興味を持った後、2009 年頃からこの言語について語り始めました。^{[ 22 ]} Hoare は、1970 年代、1980 年代、1990 年代の言語を影響源として挙げ、CLU、BETA、Mesa、NIL、^{[注 4 ]} Erlang、Newsqueak、Napier、Hermes、Sather、Alef、Limboなどを挙げた。^{[ 22 ]}彼はこの言語を「未来を自らから救うためにやってきた過去の技術」と表現した。^{[ 21 ] : 8:17 [ 22 ]} Rust の初期開発者 Manish Goregaokar も同様に、Rust は「ほとんど数十年前の研究」に基づいていると表現した。^{[ 20 ]}

初期の頃、Rustコンパイラは約38,000行のOCamlで書かれていました。^{[ 21 ] : 15:34 [ 23 ]}初期のRustには、キーワードによる明示的なオブジェクト指向プログラミング^{[ 21 ] : 10:08}や、未初期化から初期化済みへの遷移など、変数の状態変化のための型状態システムなど、現在では存在しないいくつかの機能が含まれていました。^{[ 21 ] : 13:12}obj

Mozilla は 2009 年に Rust プロジェクトを正式に後援しました。^{[ 20 ]}ブレンダン アイヒや他の幹部は、安全なウェブ ブラウザエンジンに Rust を使用する可能性に興味を持ち、パトリック ウォルトン、ニコ マツァキス、フェリックス クロック、マニッシュ ゴレガオカーなどのエンジニアをプロジェクトに配置しました。^{[ 20 ]}プロジェクト開発者が使用した会議室は「オタクの洞窟」と呼ばれ、ドアの外に看板が立てられました。^{[ 20 ]}

この期間中、作業は当初の OCaml コンパイラからLLVM をターゲットとする自己ホスト型コンパイラ(つまりRust で書かれたもの)に移行した。^{[ 24 ] [注 5 ]}所有権システムは 2010 年までに確立された。^{[ 20 ]} Rust のロゴは自転車のチェーンリングを基に 2011 年に開発された。^{[ 26 ]}

Rust 0.1 は、2012 年 1 月 20 日にWindows、Linux、および MacOS 向けに最初の公開リリースとなりました^{[ 27 ] 。 [ 28 ]} 2010 年代初頭には、Mozilla のフルタイムのエンジニアと Mozilla 以外のオープンソースのボランティアの関与が増加しました。^{[ 20 ]}

2012年から2015年にかけては、Rustの型システムに大きな変更が加えられました。^{[ 21 ] : 18:36 [ 20 ]}所有権システムによるメモリ管理が徐々に統合され、拡張されました。2013年までに、ガベージコレクタはほとんど使用されなくなり、所有権システムに置き換えられました。^{[ 20 ]}pure型状態、キーワード、^{[ 29 ]}さまざまな特殊化されたポインタ型、チャネルの構文サポートなど、言語を簡素化するために他の機能も削除されました。^{[ 21 ] : 22:32}

Steve Klabnik氏によると、この時期のRustは、C++（例えば、機能の低レベルなパフォーマンス）、スクリプト言語（例えば、Cargoやパッケージ管理）、関数型プログラミング（例えば、型システム開発）出身の開発者から影響を受けていたという。^{[ 21 ] : 30:50}

グレイドン・ホアは2013年にRustを退任した。^{[ 20 ]}ホアの退任後、Rustは連邦制のガバナンス構造の下で有機的に進化し、当初は6人の「コアチーム」^{[ 21 ] : 21:45}と、その他さまざまなチームに合計30～40人の開発者がいた。^{[ 21 ] : 22:22}新しい言語機能に関するRequest for Comments（RFC）プロセスは2014年3月に追加された。^{[ 21 ] : 33:47}コアチームは2016年までに9人に増え、 1600を超えるRFCが作成された。^{[ 21 ] : 21:45 [ 21 ] : 34:08}

2014年1月のDr. Dobb's JournalのAndrew Binstock氏によると、Rustは「非常に洗練された言語として広く認識されていた」ものの、バージョンごとに大きく変化したため、普及が遅れたという。^{[ 30 ]}この時期のRust開発は、後方互換性を約束できるように、バージョン1.0の機能を最終決定することに重点を置いていた。^{[ 21 ] : 41:26}

Mozillaのスポンサーシップから6年後、Rust 1.0が公開され、 2015年5月15日に最初の安定版リリースとなった。 ^{[ 20 ]} 1年後、Rustコンパイラには1,400人以上の貢献者が集まり、Rustパッケージ管理ウェブサイトCrates.ioには5,000以上のサードパーティライブラリが公開された。^{[ 21 ] : 43:15}

Servo ブラウザ エンジンの開発は、Mozilla とSamsungの共同出資により Rust と並行して続けられました。^{[ 31 ]} 2 つのプロジェクトのチームは緊密に連携して作業を進め、Rust の新機能は Servo チームによってテストされ、Servo の新機能は Rust チームへのフィードバックに使用されました。^{[ 21 ] : 5:41} Servo の最初のバージョンは 2016 年にリリースされました。 ^{[ 20 ]} Firefoxウェブ ブラウザは 2016 年 (バージョン 45) の時点で Rust コードを搭載して出荷されましたが、[ ^{21 ] : 53:30 [ 32 ] Servo}のコンポーネントは、 GeckoおよびQuantumプロジェクトの一部として 2017 年 9 月 (バージョン 57) まで Firefox には登場しませんでした。^{[ 33 ]}

Rustツールチェーンのエコシステムは、1.0以降数年間で改善され、Rustfmt、統合開発環境の統合^{[ 21 ] : 44:56}、定期的なコンパイラのテストとリリースサイクル^{[ 21 ] : 46:48など}が含まれるようになった。Rustコミュニティは行動規範と議論のためのIRCチャットを獲得した^{[ 21 ] : 50 :36}

Mozilla以外で最初に採用されたことが知られているのは、Samsung、Facebook（現在はMeta Platforms）、Dropbox、およびember.jsの開発元であるTilde, Inc.の個々のプロジェクトである。^{[ 21 ] : 55:44 [ 20 ]} Amazon Web Servicesは2020年にこれに続いた。^{[ 20 ]}エンジニアは、パフォーマンス、ガベージコレクタの欠如、安全性、および言語での作業の快適さを採用理由として挙げた。Amazonの開発者は、ポルトガルの研究者による、RustコードはJavaで書かれた同様のコードと比較してエネルギー消費が少ないという発見を引用した。^{[ 20 ] [ 34 ]}

2020年8月、MozillaはCOVID-19パンデミックによる企業再編の一環として、世界中の従業員1,000人のうち250人を解雇した。^{[ 35 ] [ 36 ]} Servoの開発チームは解散した。この出来事はRustの将来に対する懸念を引き起こした。^{[ 37 ]}翌週、Rustコアチームは解雇の深刻な影響を認め、Rust財団の計画が進行中であることを発表した。財団の最初の目標は、すべての商標とドメイン名の所有権を取得し、それらの費用に対する財政的責任を負うことだった。^{[ 38 ]}

2021年2月8日、Amazon Web Services、Google、Huawei、Microsoft、Mozillaの5社が設立を発表し、Rust Foundationの設立が発表されました。^{[ 39 ] [ 40 ]}この財団は、助成金やサーバー資金の形でRust開発者に財政支援を提供する予定です。^{[ 20 ]} 2021年4月6日に公開されたブログ記事で、GoogleはAndroid Open Source Project内でC/C++の代替としてRustをサポートすることを発表しました。^{[ 41 ]}

2021年11月22日、コミュニティ行動規範の執行を担当していたモデレーションチームは、「コアチームが自分たち以外には誰にも責任を負わないという姿勢に抗議して」辞任を発表した。^{[ 42 ]} 2022年5月、Rustのリーダーシップ評議会のメンバーは、この事件に対する公式声明を発表した。^{[ 43 ]}

Rust Foundation は 2023 年 4 月 6 日に新しい商標ポリシーの草案を公開したが、Rust のユーザーや貢献者から広範な否定的な反応が寄せられた。^{[ 44 ]}商標ポリシーには、Rust のロゴと名前の使用方法に関するルールが含まれていた。^{[ 44 ]}

以下はRust の「Hello, World!」プログラムです。キーワードは関数fnを表し、マクロ( §マクロを参照) はメッセージを標準出力に出力します。^{[ 48 ]} Rust のステートメントはセミコロンで区切られます。println! 

fn main () { println! ( "Hello, World!" ); }

Rust の変数letはキーワードで定義されます。^{[ 49 ]}foo以下の例では、type という名前の変数に値を代入しi32、その値を出力します。型注釈は省略できます。:i32

fn main () { let foo : i32 = 10 ; println! ( "fooの値は{foo}です" ); }

変数は、キーワードが追加されない限り、デフォルトでは変更できませんmut。^{[ 50 ]}次の例では、コメント//の開始を示す を使用しています。^{[ 51 ]}

fn main () { // このコードは「mut」を追加しないとコンパイルされません。let mut foo = 10 ; println! ( "foo の値は {foo} です" ); foo = 20 ; println! ( "foo の値は {foo} です" ); }

複数のlet式で同じ名前の複数の変数を定義できます。これは変数シャドウイングと呼ばれます。変数シャドウイングを使用すると、変数に異なる名前を付けることなく変数を変換できます。^{[ 52 ]}以下の例では、元の値の2倍の同じ名前の新しい変数を宣言しています。

fn main () { let foo = 10 ; // これは "The value of foo is 10" と出力しますprintln! ( "The value of foo is {foo}" ); let foo = foo * 2 ; // これは "The value of foo is 20" と出力しますprintln! ( "The value of foo is {foo}" ); }

異なる型の値に対しても変数シャドウイングが可能です。例えば、文字列からその長さを取得する場合などです。

fn main () { let letters = "abc" ; let letters = letters.len ( ) ; }

ブロック式は中括弧で囲まれます。ブロック内の最後の式がセミコロンで終わらない場合、ブロックはその末尾の式の値に評価されます。^{[ 53 ]}

fn main () { let x = { println! ( "これはブロック内です" ); 1 + 2 }; println! ( "1 + 2 = {x}" ); }

関数本体の末尾の式は戻り値として使用されます: ^{[ 54 ]}

fn add_two ( x : i32 ) -> i32 { x + 2 }

fn main () { let x = 10 ; if x > 5 { println! ( "値は5より大きい" ); }if x % 7 == 0 { println! ( "値は7で割り切れます" ); } else if x % 5 == 0 { println! ( "値は5で割り切れます" ); } else { println! ( "値は7でも5でも割り切れません" ); } }

fn main () { let x = 10 ; let new_x = if x % 2 == 0 { x / 2 } else { 3 * x + 1 }; println! ( "{new_x}" ); }

fn main () { // 4から10までのすべての整数を反復処理するlet mut value = 4 ; while value <= 10 { println! ( "value = {value}" ); value += 1 ; } }

fn main () { // 上記と同じ機能を実現するために、範囲構文を使用した`for`を使用します。// 構文4..=10は、4から10までの範囲（10を含む）を意味します。for value in 4 ..= 10 { println! ( "value = {value}" ); } }

( 1 ..= 100 ). filter ( | x | x % 3 == 0 ). sum ()

fn main () { let value = 456 ; let mut x = 1 ; let y = loop { x *= 10 ; if x > value { break x / 10 ; } }; println! ( "value より小さいか等しい最大の 10 のべき乗: {y}" );let mut up = 1 ; ' outer : loop { let mut down = 120 ; loop { if up > 100 { break 'outer ; }ダウンが4未満の場合、処理を中断します。down /= 2 ; up += 1 ; println! ( "up: {up}, down: {down}" ); } up *= 2 ; } }

および式はパターンマッチングに使用できます。たとえば、 は、オプションの整数値が存在する場合はそれmatchを2倍にし、それ以外の場合はゼロを返すために使用できます。^{[ 59 ]}ifletmatch

fn double ( x : Option < u64 > ) -> u64 { match x { Some ( y ) => y * 2 , None => 0 , } }

同様に、これは と を使って次のように書くこともできます。ifletelse

fn double ( x : Option < u64 > ) -> u64 { if let Some ( y ) = x { y * 2 } else { 0 } }

Rustは強力な型付けと静的型付けを採用しており、コンパイル時にすべての変数の型が既知である必要があります。特定の型の値を異なる型の変数に代入すると、コンパイルエラーが発生します。型が指定されていない場合は、型推論を使用して変数の型を決定します。^{[ 60 ]}

Rust の「ユニット型」と呼ばれる型は()、正確に 1 つの値を持つ具体的な型です。メモリを占有しません (値の不在を表すため)。戻り値の型が指定されていないすべての関数は、暗黙的に を返します()。これは他の C スタイルの言語の に似ていますvoidが、 はvoid型の不在を表し、値を持つことはできません。

デフォルトの整数型はi32、デフォルトの浮動小数点型はです。リテラルf64数値の型が明示的に指定されていない場合は、コンテキストから推論されるか、デフォルトの型が使用されます。^{[ 61 ]}

let tuple : ( u32 , bool ) = ( 3 , true ); let array : [ i8 ; 5 ] = [ 1 , 2 , 3 , 4 , 5 ]; let value = tuple.1 ; // true let value = array [ 2 ] ; // 3

let array2 : [ char ; 10 ] = [ ' ' ; 10 ];

Rust の所有権システムは、ガベージ コレクタを使用せずにメモリの安全性を保証するルールで構成されています。コンパイル時に、各値はその値の所有者と呼ばれる変数に添付されなければならず、すべての値は正確に 1 つの所有者を持たなければなりません。^{[ 71 ]}値は、代入または関数パラメータとして値を渡すことによって、異なる所有者間で移動されます。値は借用することもできます。つまり、所有者に返される前に、一時的に別の関数に渡されます。^{[ 72 ]}これらのルールにより、Rust はダングリング ポインタの作成と使用を防ぐことができます。^{[ 72 ] [ 73 ]}

fn print_string ( s : String ) { println! ( "{}" , s ); }fn main () { let s = String :: from ( "Hello, World" ); print_string ( s ); // s は print_string によって消費されます// s は移動されたため、これ以上使用できません// 別の print_string(s); を実行するとコンパイルエラーになります}

この関数は渡された値のprint_string所有権を取得します。あるいは、参照型 ( )を示すために使用したり、参照 ( ) を作成するために使用したりすることもできます。^{[ 74 ]}String&&String&s

fn print_string ( s : & String ) { println! ( "{}" , s ); }fn main () { let s = String :: from ( "Hello, World" ); print_string ( & s ); // s は print_string によって借用されますprint_string ( & s ); // s はまだ消費されていません。この関数を何度でも呼び出すことができます}

これらの所有権ルールにより、Rust の型はアフィン型として知られており、各値は最大で 1 回しか使用できません。これにより、値の所有者がその正確性と解放に単独で責任を負うため、ソフトウェア障害の分離の一形態が強制されます。 ^{[ 75 ]}

値がスコープ外になると、デストラクタを実行して破棄されます。デストラクタは、トレイトを実装することでプログラム的に定義できます。オブジェクトが破棄されると、それに関連付けられたリソースが自動的に閉じられるか解放されるため、ファイルハンドル、ネットワークソケット、ロックなどのリソースの管理に役立ちます。 ^{[ 76 ]}Drop

fn main () { let mut x = 5 ; // ------------------+- ライフタイム 'a // | let r = & x ; // -+-- ライフタイム 'b | // | | println! ( "r: {}" , r ); // -+ | // r はもう使われていないので、 | // そのライフタイムは終了します | let r2 = & mut x ; // -+-- ライフタイム 'c | } // ------------------+

fn main () { let r ; // ------------------+- ライフタイム 'a // | { // | let x = 5 ; // -+-- ライフタイム 'b | r = & x ; // エラー: x は | | } // 十分に長く生きません -| | // | println! ( "r: {}" , r ); // | } // ------------------+

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

ユーザー定義型は、structまたはenumキーワードを使用して作成されます。キーワードは、複数の関連する値をグループ化するレコード型structを示すために使用されます。 ^{[ 86 ]}は実行時にさまざまなバリアントを取ることができ、その機能は関数型プログラミング言語にある代数的データ型に似ています。 ^{[ 87 ]}レコードと列挙型の両方のバリアントには、異なる型のフィールドを含めることができます。^{[ 88 ]}同じ型の別名、つまりエイリアスは、キーワードを使用して定義できます。^{[ 89 ]}enumtype

キーワードimplは、ユーザー定義型のメソッドを定義できます。データと関数は別々に定義されます。実装は、他の言語におけるクラスと同様の役割を果たします。^{[ 90 ]}

標準ライブラリ

Rust標準ライブラリはVec、Option、 、などのコアデータ構造やスマートポインタHashMap型など、広く使用されている多くのカスタムデータ型を定義および実装しています。Rust は、組み込みデバイスなどのアプリケーション向けに、属性 を使用して標準ライブラリの大部分を除外する方法を提供しています。内部的には、標準ライブラリは 、 、、 の3 つの部分に分割されており、と はによって除外されます。^{[ 91 ]}#![no_std]coreallocstdstdalloc#![no_std]

Rust はオプション型Option<T>を使用してオプション値を定義し、それを使用して一致させif let、match内部値にアクセスできます: ^{[ 92 ]}

fn main () { let name1 : Option <& str > = None ; // この場合、何も出力されませんif let Some ( name ) = name1 { println! ( "{name}" ); }let name2 : Option <& str > = Some ( "Matthew" ); // この場合、単語 "Matthew" が出力されます。if let Some ( name ) = name2 { println! ( "{name}" ); } }

同様に、Rust の結果型はResult<T, E>、正常に計算された値 (Okバリアント) またはエラー (Errバリアント) を保持します。^{[ 93 ]}と同様にOption、 の使用は、Result内部の値を直接使用できないことを意味します。プログラマは、式、 (「try」演算子)matchなどの構文糖衣、または明示的なアサーションを使用して、それにアクセスする必要があります。 と は両方とも標準ライブラリ全体で使用されており、エラーと欠落データの処理に対する Rust の明示的なアプローチの基本的な部分です。?unwrapOptionResult

および参照型は&、null ではなく有効なメモリを指すことが保証されています。^{[ 94 ]}生ポインタ型およびは安全性の保証を除外するため、null または無効な場合があります。ただし、ブロックを使用してコードが明示的に安全でないと宣言されない限り、それらを逆参照することはできません。^{[ 95 ]}逆参照とは異なり、生ポインタの作成は安全な Rust コード内で許可されています。^{[ 96 ]}&mut*const*mutunsafe

Rust は、トレイト、ジェネリック関数、およびトレイト オブジェクトを通じてポリモーフィズムをサポートしています。^{[ 98 ]}

trait Zero : Sized { fn zero () -> Self ; fn is_zero ( & self ) -> bool where Self : PartialEq , { self == & Zero :: zero () } }impl Zero for u32 { fn zero () -> u32 { 0 } }impl Zero for f32 { fn zero () -> Self { 0.0 } }

// zero は型パラメータ Num を 1 つ持つ汎用関数です。fn zero < Num : Zero > () -> Num { Num :: zero () }fn main ( ) { let a : u32 = zero (); let b : f32 = zero (); assert! ( a.is_zero ( ) && b.is_zero ( ) ); }

use std :: fmt :: Display ;let v : Vec < Box < dyn Display >> = vec! [ Box :: new ( 3 ), Box :: new ( 5.0 ), Box :: new ( "hi" ), ];for x in v { println! ( "{x}" ); }

Rust はガベージ コレクションを使用しません。メモリやその他のリソースは、代わりに「リソースの取得は初期化である」という規約^{[ 107 ]}とオプションの参照カウントによって管理されます。Rust は、非常に低いオーバーヘッドで決定論的なリソース管理を提供します。^{[ 108 ]}値はデフォルトでスタック上に割り当てられ、すべての動的割り当ては明示的に行う必要があります。^{[ 109 ]}

シンボルを使用する組み込みの参照型は、&実行時の参照カウントを伴いません。基となるポインタの安全性と有効性はコンパイル時に検証され、ダングリングポインタやその他の未定義の動作を防ぎます。^{[ 110 ]} Rust の型システムは、形式の共有された不変の&T参照と、形式の一意の可変の参照を分離します&mut T。可変の参照は不変の参照に強制できますが、その逆はできません。^{[ 111 ]}

Rust のメモリ安全性チェック ( #Safetyunsafeを参照)は、ブロックを使用することで回避できます。これにより、プログラマは任意の生ポインタを逆参照したり、外部コードを呼び出したり、安全な Rust では許可されていないその他の低レベル機能を実行したりできます。 ^{[ 112 ]}この方法で有効になる低レベル機能には、 volatile メモリへのアクセス、アーキテクチャ固有の組み込み関数、型パンニング、インラインアセンブリなどがあります。^{[ 113 ]}

例えば、データ構造の実装では、安全でないコードが必要になります。^{[ 114 ]}よく引用される例として、安全なRustで二重リンクリストを実装するのは困難または不可能です。 ^{[ 115 ] [ 116 ] [ 117 ] [ 118 ]}

安全でない Rust を使用するプログラマは、例えば同じ場所を指す可変参照が 2 つ存在しないなど、Rust のメモリと型の安全性の要件を遵守する責任があるとみなされます。^{[ 119 ]}プログラマがこれらの要件に違反するコードを書いた場合、未定義の動作が発生します。^{[ 119 ]} Rust のドキュメントには、ダングリング ポインタやアラインメントがずれたポインタへのアクセス、参照のエイリアス ルールの違反など、未定義とみなされる動作のリストが含まれています。^{[ 120 ]}

マクロを使用すると、Rust コードの生成と変換によって繰り返しを減らすことができます。マクロには 2 つの形式があり、を介して定義される宣言型マクロmacro_rules!と、別のクレートで定義される手続き型マクロがあります。^{[ 121 ] [ 122 ]}

macro_rules! sum { ( $initial : expr $(, $expr : expr ) * $(, ) ? ) => { $initial $( + $expr ) * } }fn main () { let x = sum ! ( 1 , 2 , 3 ); println! ( "{x}" ); // 6 と表示される}

Rust はキーワードを使用して外部関数インターフェース(FFI)の作成をサポートしていますextern。C呼び出し規約を使用する関数はを使用して記述できます。シンボルは属性を使用して Rust から他の言語にエクスポートでき、シンボルはブロックを使用して Rust にインポートできます。^{[注 6 ] [ 128 ]}extern"C"fn#[unsafe(no_mangle)]extern

#[unsafe(no_mangle)] pub extern "C" fn exported_from_rust ( x : i32 ) -> i32 { x + 1 } unsafe extern "C" { fn imported_into_rust ( x : i32 ) -> i32 ; }

この属性により、FFI境界を越えて使用できるsとs#[repr(C)]の決定論的なメモリレイアウトが可能になります。 ^{[ 128 ]}やなどの外部ライブラリは、C/C++用のRustバインディングを生成できます。^{[ 128 ] [ 129 ]}structenumbindgencxx

Rustコンパイラはrustc、Rustコードをバイナリにコンパイルします。まず、コンパイラはソースコードをASTに解析します。次に、このASTはIRにダウングレードされます。その後、コンパイラのバックエンドがサブコンポーネントとして呼び出され、最適化を適用して、結果として得られたIRをオブジェクトコードに変換します。最後に、リンカを使用してオブジェクトを単一の実行可能イメージに結合します。^{[ 137 ]}

rustc はデフォルトでLLVM をコンパイラ バックエンドとして使用しますが、GCCやCraneliftなどの代替バックエンドの使用もサポートしています。^{[ 138 ]}これらの代替バックエンドの目的は、Rust のプラットフォーム カバレッジを拡大するか、コンパイル時間を短縮することです。^{[ 139 ] [ 140 ]}

CargoはRustのビルドシステムおよびパッケージマネージャーです。公式レジストリで管理されているパッケージ（クレートと呼ばれる）をダウンロード、コンパイル、配布、アップロードします。また、Clippyやその他のRustコンポーネントのフロントエンドとしても機能します。^{[ 141 ]}

デフォルトでは、Cargo はユーザーが提供したレジストリcrates.ioから依存関係を取得しますが、Gitリポジトリ、ローカル ファイルシステム内のクレート、その他の外部ソースも依存関係として指定できます。^{[ 142 ]}

Cargo は、Cargo.toml と Cargo.lock という 2 つのメタデータ ファイルを通じて再現可能なビルドをサポートします。^{[ 143 ]} Cargo.toml は、使用される各パッケージとそのバージョン要件を宣言します。Cargo.lock は依存関係の解決中に自動的に生成され、推移的依存関係を含むすべての依存関係の正確なバージョンを記録します。^{[ 144 ]}

Rustfmt はRust 用のコード フォーマッタです。特に指定がない限り、一般的なスタイルに従ってコードを生成するように空白とインデントをフォーマットします。スタンドアロン プログラムとして、または Cargo を介して Rust プロジェクトから呼び出すことができます。^{[ 145 ]}

Clippyは、Rustコードの正確性、パフォーマンス、可読性を向上させるためのRustに組み込まれたリンティングツールです。 2026年現在800以上のルールがあります。^{[ 146 ] [ 147 ]}

Rust 1.0以降、新機能は毎日リリースされるナイトリーバージョンで開発されています。6週間ごとのリリースサイクルでは、ナイトリーバージョンの変更がベータ版にリリースされ、前のベータ版の変更が新しい安定版にリリースされます。^{[ 148 ]}

2～3年ごとに新しい「エディション」がリリースされます。エディションは、 async/await機能をサポートするためにキーワードを昇格させるなど、限定的な破壊的変更を可能にするためにリリースされます。異なるエディションを対象とするクレートは相互運用できるため、呼び出し元や依存関係が古いエディションを対象としていても、クレートは新しいエディションにアップグレードできます。新しいエディションへの移行は、自動化されたツールによって支援できます。^{[ 149 ]}await

rust-analyzer は、言語サーバープロトコルを介して統合開発環境(IDE) やテキストエディタに Rust プロジェクトに関する情報を提供するユーティリティ群です。これにより、コード編集時にオートコンプリートやコンパイルエラー表示などの機能が利用可能になります。^{[ 150 ]}

Rust Foundationは、米国で設立された非営利の会員制組織であり、Rustの商標、インフラストラクチャ、および資産を管理しています。^{[ 202 ] [ 46 ]}

2021年2月8日に設立され、5社の創設企業メンバー（Amazon Web Services、Huawei、Google、Microsoft、Mozilla）が参加した。^{[ 203 ]}財団の理事会はシェーン・ミラーが議長を務め、^{[ 204 ]}アシュリー・ウィリアムズが暫定事務局長を務めた。^{[ 46 ]} 2021年後半には、レベッカ・ランブルが事務局長兼CEOに就任した。^{[ 205 ]}

Rustプロジェクトは、2025年11月現在、 8つのトップレベルのチームによって維持管理されている。: リーダーシップ評議会、コンパイラチーム、開発ツールチーム、インフラストラクチャチーム、言語チーム、ローンチパッド、ライブラリチーム、モデレーションチーム。^{[ 206 ]}リーダーシップ評議会はプロジェクトを監督し、他のチームからの代表者によって構成されます。^{[ 207 ]}