„Rust (Programmiersprache)“ – Bearbeiten

{{Infobox Programmiersprache
| Name                         = 
| Logo                         = [[Datei:Rust programming language black logo.svg|120px]]
| Beschreibung                 = 
| Paradigma                    = [[Programmierparadigma|multiparadigmatisch]] ([[Generische Programmierung|generisch]], [[Nebenläufigkeit|nebenläufig]], [[Funktionale Programmierung|funktional]], [[Imperative Programmierung|imperativ]], [[Strukturierte Programmierung|strukturiert]])
| Erscheinungsjahr             = 2010; erste stabile Version 2015
| Designer                     = <!-- Wikidata (Q575650) -->
| Entwickler                   = <!-- Wikidata (Q575650) -->
| AktuelleVersion              = <!-- Wikidata (Q575650) -->
| AktuelleVersionFreigabeDatum = <!-- Wikidata (Q575650) -->
| AktuelleVorabVersion         = 
| AktuelleVorabVersionFreigabeDatum = 
| Typisierung                  = [[Starke Typisierung|stark]], [[Statische Typisierung|statisch]], [[Substrukturelles Typsystem|affin]],<ref>Alexis Beingessner: [https://gankra.github.io/blah/linear-rust/ The Pain Of Real Linear Types in Rust]. In Beingessners Blog, 8. Mai 2017, abgerufen am 10. Oktober 2019.</ref> [[Typinferenz]]
| Implementierung              = 
| Dialekte                     = 
| Standardisierungen           = 
| Beeinflusst_von              = 
| Beeinflusste                 = 
| Betriebssystem               = [[Linux]], [[macOS]], [[Microsoft Windows|Windows]], [[FreeBSD]], [[Android (Betriebssystem)|Android]], [[iOS (Betriebssystem)|iOS]]<ref>{{cite web|url=https://github.com/rust-lang/rust/wiki/Doc-building-for-ios |title=Doc building for ios |website=GitHub |accessdate=2015-01-04}}</ref> und weitere<ref name="RustPlatforms">{{cite web |url=https://forge.rust-lang.org/platform-support.html |title=Rust Platform Support |author=<!--Unstated--> |date=<!--Undated--> |website=Rust Forge |accessdate=2019-06-03 |language=englisch}}</ref><ref name="EmbeddedFAQ">{{cite web |url=https://docs.rust-embedded.org/faq.html |title=Frequently Asked Questions |author=<!--Unstated--> |date=<!--Undated--> |website=Rust Embedded |accessdate=2019-06-03 |language=englisch}}</ref>
| Lizenz                       = <!-- Wikidata (Q575650) -->
| Website                      = [https://www.rust-lang.org/ www.rust-lang.org]
}}

'''Rust''' ist eine [[Programmierparadigma|Multiparadigmen]]-[[Systemprogrammiersprache]], die von der Open-Source-Community entwickelt wird. Sie wird mit dem Ziel entwickelt, sicher, [[Nebenläufigkeit|nebenläufig]] und praxisnah zu sein.<ref name="rust-lang">{{cite web|url=https://www.rust-lang.org/|title=The Rust Programming Language|accessdate=2012-10-21}}</ref> Sicherheit bezieht sich dabei insbesondere auf die Vermeidung von [[Programmfehler]]n, die zu [[Zugriffsverletzung|Speicherzugriffsfehlern]] oder [[Pufferüberlauf|Pufferüberläufen]] und damit unter Umständen auch zu [[Sicherheitslücke]]n führen, vor allem auch in nebenläufigen Prozessen. Der Wertebereich von Variablen wird dabei mittels eines [[Typsystem]]s eingeschränkt und die angestrebte [[Typsicherheit]] wurde formal bewiesen.<ref>{{Internetquelle |autor=Ralf Jung |url=https://people.mpi-sws.org/~jung/thesis.html |titel=Understanding and Evolving the Rust Programming Language |abruf=2021-07-15 |sprache=de }}</ref>

Rust vereint Ansätze aus verschiedenen [[Programmierparadigma|Programmierparadigmen]], unter anderem aus der [[Funktionale Programmierung|funktionalen]], der [[Objektorientierte Programmierung|objektorientierten]] und der [[Nebenläufige Programmierung|nebenläufigen]] Programmierung und erlaubt so ein hohes [[Abstraktion (Informatik)|Abstraktionsniveau]]. Beispielsweise gibt es in Rust [[Algebraischer Datentyp|algebraische Datentypen]], [[Pattern Matching]], [[Trait (Programmierung)|Traits]] (ähnlich den Typklassen in [[Haskell (Programmiersprache)|Haskell]]), [[Closure (Funktion)|Closures]] sowie Unterstützung für [[Ressourcenbelegung ist Initialisierung|RAII]]. Die Sprache wurde so entworfen, dass die Kosten der Abstraktionen zur [[Laufzeit (Informatik)|Laufzeit]] so gering wie möglich bleiben können (''zero-cost abstractions''), um eine mit [[C++]] vergleichbare Performanz zu erreichen.<ref>{{Internetquelle |autor=The Rust Project Developers |url=https://prev.rust-lang.org/en-US/faq.html#how-fast-is-rust |titel=The Rust Language FAQ: How fast is Rust? |abruf=2021-06-27 |sprache=en }}</ref>

Rust wurde ursprünglich bei [[Mozilla]] entwickelt. Seit 2021 besteht allerdings die ''Rust Foundation''<ref>{{Internetquelle |url=https://rustfoundation.org/ |titel=The Rust Foundation - Official |sprache=en-US |abruf=2025-10-29}}</ref>, eine gemeinnützige Stiftung, die die Weiterentwicklung der Sprache betreut und das Eigentum an den Marken und Logos von Rust hat. Zu den Sponsoren der Stiftung und der Entwickler gehören große Konzerne wie [[Google]], [[Amazon]] [[Amazon Web Services|AWS]], [[Meta Platforms|Meta]] und [[Microsoft]].<ref>{{Internetquelle |url=https://rustfoundation.org/members/ |titel=Rust Foundation Members {{!}} Join Us |werk=https://rustfoundation.org/ |sprache=en-US |abruf=2025-10-29}}</ref>

== Geschichte ==
Die Sprache entstand aus einem persönlichen Projekt des Mozilla-Mitarbeiters Graydon Hoare. Sein Fokus lag darauf, eine Programmiersprache mit sicherer Speicherverwaltung zu entwerfen, die schnellen und kompakten Code generiert.<ref>{{Internetquelle |url=https://www.technologyreview.com/2023/02/14/1067869/rust-worlds-fastest-growing-programming-language/ |autor=Clive Thompson |titel=How Rust went from a side project to the world’s most-loved programming language |hrsg=MIT Technology Review |datum=2023-02-14 |sprache=en |abruf=2025-10-30}}</ref> Frühe Versionen von Rust unterschieden sich selbst von der Version 1.0 wesentlich, so gab es automatisch verwaltete Zeiger mittels <code>~T</code> ähnlich wie in [[Swift (Programmiersprache)|Swift]], ein [[Effektprogrammierung|Effektsystem]], [[Green Thread]]s, prototypen-ähnliche Objektorientierung,<ref>{{Internetquelle |autor=Graydon Hoare |url=https://graydon2.dreamwidth.org/307291.html |titel=The Rust I Wanted Had No Future |datum=2023-06-04 |sprache=en |abruf=2025-10-30}}</ref> und heutige Features wie <code>async</code>, <code>const</code> und der Fehlerbehandlungsoperator <code>?</code> fehlten.

Mozilla begann das Sponsoring des Projekts im Jahr 2009.<ref name="proj-faq">{{cite web|url=https://github.com/mozilla/rust/wiki/Doc-project-FAQ|title=Project FAQ|date=2010-09-14|language=en|access-date=2012-01-11}}</ref> Es wurde 2010 zum ersten Mal angekündigt.<ref name="future-tense">{{cite web|url=https://www.slideshare.net/BrendanEich/future-tense-7782010|title=Future Tense|date=2011-04-29|language=en|access-date=2012-02-06|quote=At Mozilla Summit 2010, we launched Rust, a new programming language motivated by safety and concurrency for parallel hardware, the “manycore” future which is upon us.}}</ref> Im selben Jahr begann der Wechsel von einem (noch in [[OCaml]] geschriebenen) ersten [[Compiler]] zu einem neuen Compiler, der selbst in Rust geschrieben ist.<ref name="rust-in-rust">{{Internetquelle |url=http://blog.mozilla.com/graydon/2010/10/02/rust-progress/ |titel=Rust Progress |sprache=en |autor=Graydon Hoare |werk=Graydon’s work on Mozilla |datum=2010-10-02 |archiv-url=https://web.archive.org/web/20120319230524/http://blog.mozilla.com/graydon/2010/10/02/rust-progress/ |archiv-datum=2012-03-19 |abruf=2016-04-03}}</ref> Dieser ''rustc'' genannte Compiler verwendet [[LLVM]] als [[Front-End und Back-End|Back-End]] und kann sich seit 2011 erfolgreich selbst übersetzen.<ref name="rust-compiles-rust">{{cite web|url=https://mail.mozilla.org/pipermail/rust-dev/2011-April/000330.html|title=[rust-dev&#93; stage1/rustc builds|last=Hoare|first=Graydon|date=2011-04-20|language=en|access-date=2011-04-20|quote=After that last change fixing the logging scope context bug, looks like stage1/rustc builds. Just shy of midnight :)|archiveurl=https://web.archive.org/web/20110720122600/https://mail.mozilla.org/pipermail/rust-dev/2011-April/000330.html|archivedate=2011-07-20|url-status=live|archivebot=2024-04-30 16:13:07 InternetArchiveBot}}</ref> Eine erste stabile Version von Compiler und [[Standardbibliothek]], Rust 1.0, wurde am 15.&nbsp;Mai 2015 veröffentlicht.<ref name="rust-1.0">[https://blog.rust-lang.org/2015/05/15/Rust-1.0.html Announcing Rust 1.0]</ref>

Im August 2020 entließ Mozilla im Rahmen einer Unternehmensumstrukturierung unter anderem große Teile des Rust-Teams.<ref>{{Internetquelle |url=https://www.heise.de/news/Mozilla-streicht-Stellen-und-Projekte-4876909.html |titel=Mozilla streicht Stellen und Projekte |hrsg=heise online |datum=2020-08-29 |abruf=2021-02-09}}</ref> Das [[Servo (Software)|Servo-Team]] wurde komplett aufgelöst. Nach Angaben der Vorstandsvorsitzenden [[Mitchell Baker]] wurde dies durch die Folgen der [[COVID-19-Pandemie]] notwendig.<ref>{{Internetquelle |autor=@tschneidereit |url=https://twitter.com/tschneidereit/status/1293868141953667074 |titel="Much of the team I used to manage was part of the Mozilla layoffs on Tuesday. That team was Mozilla's Rust team, and Mozilla's Wasmtime team. I thought I'd know how to talk about it by now, but I don't. It's heartbreaking, incomprehensible, and staggering in its impact" |werk=Twitter |datum=2020-08-12 |abruf=2021-02-09 |sprache=en}}</ref><ref>{{Internetquelle |autor=@asajeffrey |url=https://twitter.com/asajeffrey/status/1293220656339988483 |titel="Mozilla is closing down the team I'm on, so I am one of the many folks now wondering what the next gig will be. It's been a wild ride!" |werk=Twitter |datum=2020-08-11 |abruf=2021-02-09 |sprache=en}}</ref> Das Ereignis führte zu Bedenken über die Zukunft von Rust.<ref>{{Internetquelle |url=https://insights.dice.com/2020/08/27/rust-in-trouble-after-big-mozilla-layoffs/ |autor=Nick Kolakowski |titel=Is Rust in Trouble After Big Mozilla Layoffs? |werk=Dice |datum=2020-08-27 |sprache=en |abruf=2021-02-09}}</ref>

Daher gründete das Rust-Kernteam eine Stiftung, um das Eigentum an allen Markenzeichen und Domainnamen zu übernehmen wie auch die finanzielle Verantwortung für deren Kosten.<ref>{{Internetquelle |url=https://blog.rust-lang.org/2020/08/18/laying-the-foundation-for-rusts-future.html |titel=Laying the foundation for Rust's future |werk=Rust Blog |datum=2020-08-18 |sprache=en |abruf=2021-02-09}}</ref> Am 8. Februar 2021 gaben die Unternehmen [[Amazon Web Services|AWS]], [[Huawei]], [[Google LLC|Google]], [[Microsoft]] und [[Mozilla]] sowie fünf Mitglieder aus dem Rust-Team die Gründung der ''Rust Foundation'' bekannt.<ref>{{Internetquelle |url=https://foundation.rust-lang.org/posts/2021-02-08-hello-world/ |autor=Ashley Williams |titel=Hello World! |werk=Rust Blog |hrsg=Rust Foundation |datum=2021-02-08 |sprache=en |abruf=2021-02-09 |offline=1 |archiv-url=https://web.archive.org/web/20210209095655/https://foundation.rust-lang.org/posts/2021-02-08-hello-world/}}</ref><ref>{{Internetquelle |url=https://www.heise.de/news/Willkommen-Rust-Foundation-Die-Programmiersprache-hat-eine-neue-Heimat-5047312.html |autor=Silke Hahn |titel=Willkommen, Rust Foundation! Die Programmiersprache hat eine neue Heimat |werk=heise online |datum=2021-02-08 |sprache=de |abruf=2021-02-09}}</ref>
<!-- Kontroverse rund um JeanHeyd Meneides (inzwischen C-Editor) RustConf 2023 Vortrag über Reflection, welcher vom serde-Autor über Hintertüren in der Organisation „abgeschossen“ wurde und von Rassismusvorwürfen begleitet war; siehe u.a. https://thephd.dev/i-am-no-longer-speaking-at-rustconf-2023 -->

== Sprachdesign ==
=== Syntax, Sprachkonstrukte ===
Syntaktisch ist die Sprache an [[C (Programmiersprache)|C]] angelehnt. Sie besitzt auch Einflüsse aus der [[ML (Programmiersprache)|ML-Sprachfamilie]]. Mehrere aufeinanderfolgende Anweisungen werden durch ein [[Semikolon]] getrennt, Blöcke stehen in geschweiften Klammern. In vielen Details weicht die [[Syntax]] allerdings davon ab. So werden beispielsweise keine Klammern um die Bedingungen von <code>if</code>- und <code>while</code>-Statements benötigt, stattdessen aber geschweifte Klammern um den dahinterstehenden Block erzwungen, auch wenn dort nur eine Anweisung steht. Das Schlüsselwort <code>for</code> leitet in Rust immer eine [[Foreach-Schleife]] ein, die das Iterieren über beliebige (auch benutzerdefinierte) Container und Objekte ermöglicht. Anstelle des <code>switch</code>-Statements gibt es die wesentlich mächtigeren <code>match</code>-Ausdrücke, die nicht nur mit Zahlen und Zeichenketten umgehen können, sondern [[Pattern Matching]] auf beliebig verschachtelten Strukturen durchführen können.

Die Styleguides empfehlen die Namenskonventionen <code>snake_case</code> für Variablen, <code>SCREAMING_SNAKE_CASE</code> für Konstanten und <code>PascalCase</code> für Datentypen, mit Ausnahme der Primitiven.<ref>{{Internetquelle| url=https://rust-lang.github.io/rfcs/0430-finalizing-naming-conventions.html| titel=0430-finalizing-naming-conventions - The Rust RFC Book| abruf=2024-09-08| datum=2014-11-02}}</ref>
Typparameter von generischen Typen und Funktionen stehen in spitzen Klammern. Zwei Doppelpunkte drücken wie in [[C++]] aus, dass der Bezeichner auf der rechten Seite aus dem Namensraum des Bezeichners auf der linken Seite entstammen soll. Die Bindung eines Bezeichners <code>x</code> an einen Wert wird

<syntaxhighlight lang="Rust">let x: Typ = Wert;</syntaxhighlight>

geschrieben, wobei die Angabe des Typs auch entfallen darf, wenn der Typ [[Typinferenz|abgeleitet]] werden kann. Diese Syntax entstammt der ML-Familie an Programmiersprachen. Eine Variablen-Deklaration für die Variable <code>v</code> hat die Form:

<syntaxhighlight lang="Rust">let mut v: Typ = Initialwert;</syntaxhighlight>

oder allgemeiner:

<syntaxhighlight lang="Rust">
let mut v: Typ;
v = Wert;
</syntaxhighlight>

Der Compiler überprüft mittels [[Datenflussanalyse]], ob alle Bindungen und Variablen vor dem Auslesen initialisiert wurden. Verwendung von uninitialisiertem Speicher ist nur über einen speziellen Befehl möglich, welcher zwingend mit <code>unsafe</code> markiert werden muss.

=== Typsystem ===
Benutzerdefinierte Datentypen können entweder als <code>struct</code> ([[Struktur (Datentyp)|Struktur]] wie in C, [[Algebraischer Datentyp#Produkttyp|Produkttypen]]) oder als <code>enum</code> (tagged-Union, [[Algebraischer Datentyp#Summentyp|Summentypen]]) definiert werden. Dabei ist <code>enum</code> vielseitiger als das gleichnamige Schlüsselwort in C und C++: In Rust können die Varianten des <code>enum</code> auch innere Werte (wie Strukturen oder Tupel) enthalten.

<syntaxhighlight lang="rust">
struct Person {
    age: u8,
    first_name: String,
    last_name: String,
}

impl Person {
    // Erzeuge ein neues Person-Objekt.
    // Diese Funktion hat keine besonderen Eigenschaften.
    // "new" ist nur eine Konvention.
    fn new(first_name: String, last_name: String) -> Self {
        Self {
            first_name: first_name,
            last_name: last_name,
            age: 0,
        }
    }
}

// Einfaches Enum ohne Werte in den Varianten.
// In dieser Form identisch zu C/C++.
enum Weekday {
    Monday,
    Tuesday,
    Wednesday,
    Thursday,
    Friday,
    Saturday,
    Sunday,
}

// Vereinfachter mathematischer Ausdruck.
enum Expression {
    Add {
        left: u64,
        right: u64,
    },
    Multiply {
        left: u64,
        right: u64,
    },
    Negate(u64),
    Literal(u64),
    Invalid,
}
</syntaxhighlight>Für beide Arten von Datentypen kann man mittels des <code>impl</code>-Schlüsselwortes [[Methode (Programmierung)|Methoden]] definieren. Die sonst für [[objektorientierte Programmierung]] übliche [[Vererbung (Programmierung)|Vererbung]] gibt es in Rust allerdings nicht; [[Polymorphie (Programmierung)|Polymorphie]] wird stattdessen durch [[Trait (Programmierung)|Traits]] und [[generische Programmierung]] ermöglicht. Ein Trait definiert eine Menge von Funktionen und Methoden, die dann jeweils zusammen von Datentypen implementiert werden und bei [[Generischer Typ|Typparametern]] als Einschränkung für die erlaubten Typen dienen können. Dies wird auch für Operatoren verwendet, sodass beispielsweise der Operator <code>+</code> mit jedem Datentyp verwendet werden kann, der den Trait <code>Add</code> implementiert.<ref>[https://static.rust-lang.org/doc/stable/std/ops/trait.Add.html Dokumentation des „Add“-Traits]</ref> Alle Funktions-, Methoden- und Operatoraufrufe werden dabei statisch gebunden, wodurch dem Compiler einige [[Programmoptimierung|Optimierungen]] ermöglicht werden. Allerdings kann über sogenannte ''Trait-Objects'' auch mittels [[Dynamische Bindung|dynamischer Bindung]] auf Trait-Methoden zugegriffen werden. Es ist erlaubt, sowohl existierende Traits aus fremdem Code für benutzerdefinierte Typen, als auch neue, benutzerdefinierte Traits für existierende Typen zu implementieren.

=== Zeiger, Speicherverwaltung ===
Rust kennt neben den sogenannten Raw-[[Zeiger (Informatik)|Pointern]], die Zeigern in C entsprechen und nur in explizit als <code>unsafe</code> markiertem Code dereferenziert werden dürfen, auch noch [[Referenz (Programmierung)|Referenzen]]. Diese zeigen immer auf gültigen Speicher und dürfen niemals den Wert [[Zeiger (Informatik)#Nullzeiger|null]] annehmen. Es werden zwei verschiedene Arten von Referenzen unterschieden: gemeinsame Referenzen (''shared references''), eingeleitet durch <code>&amp;</code>, und veränderbare Referenzen (''mutable references''), eingeleitet durch <code>&amp;mut</code>. Der Rust-Compiler garantiert [[Statische Code-Analyse|statisch]], dass keine Referenz das von ihr referenzierte Objekt [[Variable (Programmierung)#Lebensdauer von Variablen|„überlebt“]], dass das referenzierte Objekt nicht verändert wird, während eine Referenz (egal ob gemeinsam oder veränderbar) existiert, und dass eine veränderbare Referenz – wenn eine solche existiert – stets die einzige Referenz auf ein Objekt ist, sodass Veränderungen am Objekt vorgenommen werden können, ohne dabei Referenzen zum selben Objekt an anderen Stellen im Code oder sogar in anderen [[Thread (Informatik)|Threads]] ungültig zu machen. Um ein eigentlich unveränderliches Objekt innen veränderlich zu machen, gibt es den Hilfstyp <code>Cell</code>.

Das Erstellen von Referenzen wird auch als ''Borrowing'' (Ausleihen) bezeichnet und bildet zusammen mit dem Konzept der ''Ownership'' (Besitz) die Grundlage für die sichere Speicherverwaltung ohne Garbage Collection. ''Ownership'' bedeutet hier, dass jedes Objekt im Speicher im Besitz derjenigen Variable ist, der es bei der Erstellung zugewiesen wird. Am Ende der [[Variable (Programmierung)#Lebensdauer von Variablen|Lebensdauer]] dieser Variable wird der Speicher automatisch freigegeben. Für die meisten komplexeren Datentypen verwendet Rust die sogenannte ''Move''-Semantik, sodass bei Zuweisung eines Objektes zu einer anderen Variablen das Objekt „verschoben“ wird, und ein Zugriff auf die alte Variable daraufhin nicht mehr möglich ist. Auch beim Übergeben von Objekten als [[Wertparameter]] an Funktionen (''call by value'') werden solche Objekte in die Funktion „hineingeschoben“ und sind von außen nicht mehr zugreifbar, wenn sie nicht wieder von der Funktion zurückgegeben werden. [[Datentyp#Elementare Datentypen|Primitive Datentypen]] im engeren Sinne verwenden keine ''Move''-Semantik, sondern die sonst übliche ''Copy''-Semantik (Zuweisungen erstellen eine Kopie). Dies gilt nicht für folgende Datentypen, die in Rust als primitiv gelten: veränderbare Referenzen (''mutable references'')<ref>{{Internetquelle |url=https://doc.rust-lang.org/std/primitive.reference.html#trait-implementations-1 |titel=Trait-Implementierungen für Referenzen |werk=Dokumentation der Rust-Standardbibliothek |sprache=en |abruf=2023-08-07}}</ref>, manche [[Closure (Funktion)|Closures]]<ref>{{Internetquelle |url=https://doc.rust-lang.org/std/marker/trait.Copy.html#additional-implementors |titel=Der „Copy“-Trait |werk=Dokumentation der Rust-Standardbibliothek |sprache=en |abruf=2023-08-07}}</ref>, str<ref>{{Internetquelle |url=https://doc.rust-lang.org/std/primitive.str.html |titel=Der „str“-Datentyp |werk=Dokumentation der Rust-Standardbibliothek |abruf=2023-08-07}}</ref> und manche Arrays<ref>{{Internetquelle |url=https://doc.rust-lang.org/std/primitive.array.html |titel=Der „array“-Datentyp |werk=Dokumentation der Rust-Standardbibliothek |sprache=en |abruf=2023-08-07}}</ref> und manche Tupel<ref>{{Internetquelle |url=https://doc.rust-lang.org/std/primitive.tuple.html |titel=Der „tuple“-Datentyp |werk=Dokumentation der Rust-Standardbibliothek |sprache=en |abruf=2023-08-07}}</ref>. Bei benutzerdefinierten Datentypen kann mittels des <code>Copy</code>-Traits selbst entschieden werden, ob ''Move''- oder ''Copy''-Semantik verwendet werden soll.

Zur dynamischen Speicherverwaltung stehen die [[Intelligenter Zeiger|Smart-Pointer-Typen]] <code>Box</code>, <code>Rc</code> und der Hilfstyp <code>RefCell</code> zur Verfügung, welche einerseits dem System Ownership-Borrowing-Lifetime-Move unterworfen sind, dieses System andererseits auf die Laufzeitdynamik übertragen. Der Typ <code>Box&lt;T&gt;</code> beschreibt einen besitzenden Zeiger auf einen Wert vom Typ <code>T</code> im dynamisch allozierten Speicher. Der Typ <code>Rc&lt;T&gt;</code> beschreibt über [[Referenzzählung]] einen gemeinschaftlichen Besitz auf einen unveränderlichen Wert. Ein unveränderlicher Wert kann jedoch veränderliche innere Daten vom Typ <code>RefCell&lt;T&gt;</code> besitzen, wobei jeweils ein Referenzzähler für einen Zugriff analog zu <code>&amp;</code> und <code>&amp;mut</code> das sichere dynamische Borrowing durch Prüfung zur Laufzeit ermöglicht.

Mit <code>Rc</code> allein ist keine Dynamik zyklischer Datenstrukturen möglich. Hierzu kann wieder <code>RefCell</code> herangezogen werden, wobei die Zyklen manuell aufgebrochen werden müssen, damit es nicht zu einem [[Speicherleck]] kommt. Als alternatives Konzept ist der Zeigertyp <code>Weak&lt;T&gt;</code> vorhanden, bei dem die Zeiger analog zu <code>Rc</code> sind, jedoch keinen Besitz am Wert haben. Zur Umsetzung von <code>Weak</code> ist in <code>Rc</code> ein zweiter Referenzzähler implementiert. Ein Zeiger vom Typ <code>Weak</code> verhindert zwar nicht den Destruktor-Aufruf beim Verschwinden aller Zeiger vom Typ <code>Rc</code>, die Deallokation des brach liegenden Knotens geschieht dann allerdings erst beim Verschwinden des letzten Zeigers vom Typ <code>Weak</code>. Die Destruktor-Aufrufe sorgen dabei für ein automatisches Aufbrechen der Zyklen.

Für die nebenläufige Programmierung ist ein Austausch von <code>Rc</code> gegen <code>Arc</code>, und <code>RefCell</code> sowie <code>Cell</code> gegen die analogen Konzepte <code>Mutex</code> oder <code>RwLock</code> notwendig.

[[Zeiger (Informatik)#Nullzeiger|Nullzeiger]] kommen in Rust nicht vor. Abwesenheit eines Werts wird stattdessen durch den Typ <code>Option&lt;T&gt;</code> modelliert, welcher es als <code>enum</code> ermöglicht, zwischen <code>Some(T)</code> (Vorhandensein) und <code>None</code> (Abwesenheit) zu unterscheiden. Die Verwendung von Optionen ist nicht auf Zeiger beschränkt. Möchte man z.&nbsp;B. einen großen Teil einer <code>struct</code> zunächst uninitialisiert lassen, dann kann man diesen als innere <code>struct</code> hinter einer Option verbergen und mit <code>None</code> initialisieren.

=== Fehlerbehandlung ===
Rust unterscheidet zwischen nicht behebbaren (''unrecoverable'') und behebbaren (''recoverable'') Fehlern. Tritt ein nicht behebbarer Fehler auf, der in der Regel mit <code>panic!()</code> ausgelöst wird, wird eine Meldung ausgegeben, der Stack aufgeräumt (''unwinding'') und der betroffene Thread beendet. Wenn dies nicht der Haupt-Thread ist, läuft das Programm weiter. Ein sofortiger Programmabbruch via <code>abort</code> ist auch konfigurierbar und auf eingebetteten Systemen üblich.

Für behebbare Fehler gibt es in Rust die in vielen Sprachen vorhandene Ausnahmebehandlung mit automatischem Stack-Unwinding nicht. Stattdessen werden behebbare Fehler als gewöhnliche Rückgabewerte von Funktionen modelliert. Zur strengen Typisierung dienen dabei die Typen <code>Result&lt;T,E&gt;</code> und <code>Option&lt;T></code>. Beide Typen sind als <code>enum</code> formuliert, <code>Result</code> unterscheidet hierbei zwischen <code>Ok(T)</code> (normale Werte) und <code>Err(E)</code> (Fehlerwerte), <code>Option</code> definiert hingegen <code>Some(T)</code> (normale Werte) und <code>None</code> (kein Wert).<ref>{{Internetquelle |url=https://doc.rust-lang.org/book/ch09-02-recoverable-errors-with-result.html |titel=Recoverable Errors with Result – The Rust Programming Language |abruf=2019-04-23}}</ref> Wird eine Funktion aufgerufen, die einen Fehler erzeugen kann, so kann mit dem <code>?</code>-Operator dieser Fehler direkt an die nächsthöhere Funktion weitergegeben werden, ohne ihn zu behandeln.<syntaxhighlight lang="rust">
// Entspricht etwa `array.first()` aus der Standardbibliothek
fn get_first_element(array: &[u32]) -> Option<u32> {
    if array.is_empty() {
        None
    } else {
        Some(array[0])
    }
}

// Kann None zurückgeben, wenn es kein erstes Element zum Verdoppeln gibt.
fn double_first_element(array: &[u32]) -> Option<u32> {
    // Gebe direkt None zurück, falls das Array leer ist.
    let first_element = get_first_element(array)?;
    Some(first_element * 2)
}

fn main() {
    let array = [1,2,3]; // Benutzereingabe
    let result = double_first_element(&array);
    match result {
        Some(doubled) => println!("{doubled}"),
        None => eprintln!("Fehler: leeres Array"),
    }
}

</syntaxhighlight>Ein Laufzeitnachteil entsteht bei der Rückgabe von <code>enum</code> bzw. <code>struct</code> innerhalb von <code>Option</code> oder <code>Result</code> in vielen Fällen nicht, da der Compiler mit sogenannten „Nischenoptimierungen“ in der Lage ist, unbenutzten Platz im Typ zu finden und diesen für die Markierung des Zustands (also <code>Ok</code> vs. <code>Err</code>, oder <code>Some</code> vs. <code>None</code>) zu verwenden. Beispielsweise ist <code>Option<&u64></code> genauso groß wie <code>&u64</code> bzw. jeder andere Zeiger, da <code>&u64</code> niemals Null sein kann und somit der Wert 0 stattdessen zur Repräsentation von <code>None</code> benutzt werden kann.<ref>{{Internetquelle |autor=0xAtticus |url=https://www.0xatticus.com/posts/understanding_rust_niche/ |titel=Niche optimizations in Rust |datum=2024-07-14 |sprache=en-us |abruf=2025-10-29}}</ref>

=== Übersetzungszeitberechnungen ===
Mittels <code>const</code> lassen sich viele Berechnungen zur Übersetzungszeit ausführen, die dann nicht zur Laufzeit ausgeführt werden müssen. Dies ähnelt C++ <code>constexpr</code>. Eine mit <code>const</code> markierte Funktion darf zur Laufzeit oder zur Übersetzungszeit ausgeführt werden. Eine Konstante mit <code>const</code> berechnet ihren Wert zur Übersetzungszeit und lässt sich zur Laufzeit nicht ändern. Sie wird (wie auch z.&nbsp;B. Ganzzahlliterale) in der Regel an jedem Verwendungsort eingefügt, um die größtmögliche Performance zu erreichen. Genauso müssen statische Variablen mit <code>static</code> durch einen <code>const</code>-kompatiblen Wert initialisiert werden (der Compiler schreibt diesen Wert ins Datensegment der Objektdatei), können aber als globale Variablen zur Laufzeit verändert werden.<syntaxhighlight lang="rust">
// Fakultätsfunktion von unten - kann auch zur Übersetzungszeit verwendet werden.
const fn fakultaet(i: u64) -> u64 {
    let mut acc = 1;
    for num in 2..=i {
        acc *= num;
    }
    acc
}

// Berechnet 15! = 1307674368000 zur Übersetzungszeit.
const FAKULTAET_15: u64 = fakultaet(15);

// Hier können zur Laufzeit neue Werte gespeichert werden, Startwert ist 1!
static AKTUELLE_FAKULTAET: Mutex<u64> = Mutex::new(fakultaet(1));
</syntaxhighlight>

=== Nebenläufigkeit ===
Rust unterstützt in der Standardbibliothek [[Thread (Informatik)|Threads]] des Betriebssystems zur [[Nebenläufigkeit|nebenläufigen]] Programmierung. Außerdem werden Synchronisierungsprimitive wie <code>Mutex</code>, <code>Atomic</code> und <code>RwLock</code> bereitgestellt.

Bei der nebenläufigen Programmierung bestehen zusätzliche Gefahren, die durch nicht synchronisierten Zugriff auf gemeinsame Daten, insbesondere statische Variablen geschehen. Diese Fehler vermeidet Rust, indem durch das Typsystem und die besonderen Traits <code>Send</code> und <code>Sync</code> sichergestellt wird, dass nur solche Daten zwischen mehreren Ausführungssträngen geteilt werden können, die dafür auch geeignet sind. Daten, die <code>Sync</code> implementieren, erlauben den gemeinsamen Zugriff durch zwei oder mehr Ausführungsstränge, daher erfordern statische Variablen auch <code>Sync</code> von ihren Typen. <code>Cell</code> ist beispielsweise nicht <code>Sync</code>, da es keine Mechanismen zum gegenseitigen Ausschluss hat, <code>Mutex</code> wiederum ist <code>Sync</code>. Daten, die <code>Send</code> implementieren, dürfen zwischen Threads hin- und hergeschickt werden. Dies trifft ebenso wie <code>Sync</code> für viele Typen standardmäßig zu, nicht aber beispielsweise für betriebssystemabhängige threadspezifische Daten wie <code>MutexGuard</code> (da [[POSIX]] erfordert, dass Mutexe auf demselben Thread entsperrt werden, auf dem sie gesperrt wurden).

Neben der Benutzung von Kernel-Threads können in Rust auch [[Koroutine]]n mittels <code>async</code> eingesetzt werden, ähnlich zu [[JavaScript]] (Promises) und [[Python (Programmiersprache)|Python]]. Aus einer mit <code>async</code> markierten Funktion erzeugt der Compiler einen [[Automat (Informatik)|Automaten]], sodass die Funktion bis zu einem <code>await</code>-Punkt ausgeführt wird, dann unterbrochen werden kann, und ein anderer <code>async</code>-Task ausgeführt wird. <code>async</code> ist also für [[kooperatives Multitasking]] geeignet und ähnelt [[User-Thread|User-Threads]], da die Anzahl der Tasks deutlich höher als die Anzahl der Betriebssystem-Threads sein kann. <code>await</code> wird genutzt, um auf I/O-Operationen oder zeitgebundene Ereignisse zu warten, häufig Lesen oder Schreiben einer Datei und Netzwerkkommunikation. Die Standardbibliothek enthält nur Grundfunktionalität für async, wie den <code>Future</code>-Trait (Zustandsmaschine einer <code>async</code>-Funktion). Für die Verwendung einer Laufzeitumgebung, die <code>async</code>-Tasks tatsächlich ausführt, und die I/O-Operationen implementiert, stehen verschiedene Bibliotheken zur Verfügung, wie tokio<ref>{{Internetquelle |url=https://tokio.rs/ |titel=Tokio - An asynchronous Rust runtime |abruf=2025-10-30}}</ref> und async-std<ref>{{Internetquelle |url=http://async.rs/ |titel=async-std |abruf=2025-10-30}}</ref>.

Obwohl <code>async</code> primär für hochgradig parallele [[Rechnernetz|Netzwerkanwendungen]] wie [[Cloud Computing]] und [[Webserver]] entwickelt wurde,<ref>{{Internetquelle |autor=withoutboats |url=https://github.com/rust-lang/rfcs/blob/master/text/2394-async_await.md |titel=RFC&nbsp;2394: async/await notation for ergonomic asynchronous IO |datum=2018-05-18 |sprache=en |abruf=2025-10-30 |zitat=High performance network services frequently use asynchronous IO, rather than blocking IO, because it can be easier to get optimal performance when handling many concurrent connections. Rust has seen some adoption in the network services space, and we wish to continue to enable those users - and to enable adoption by other users - by making it more ergonomic to write asynchronous network services in Rust.}}</ref> eignet sich das <code>async</code>-Modell ebenfalls für [[Eingebettetes System|eingebettete]] Anwendungen, einschließlich kleiner [[Mikrocontroller]]. Zu den Vorteilen im eingebetteten Bereich gehören die Möglichkeit zur Taskverwaltung ohne jegliche Speicherallozierung, das kooperative Multitasking zum Erreichen von Echtzeitgarantien, die Unterstützung einer Vielzahl von unabhängigen Tasks auf einem einzigen physischen Prozessor, und die Kompatibilität des Polling- und Waker-basierten <code>async</code>-I/O-Modells mit [[Interrupt]]s. Die Laufzeitumgebung embassy<ref>{{Internetquelle |autor=Embassy |url=https://embassy.dev/ |titel=Embassy |sprache=en |abruf=2025-10-30}}</ref> weist in einem direkten Vergleich zum C-basierten [[FreeRTOS]] einen kleineren Speicherverbrauch (RAM und Flash), geringere Task-Laufzeiten und kleinere Interrupt-Verarbeitungslatenzen auf.<ref>{{Internetquelle |autor=Dion |url=https://tweedegolf.nl/en/blog/65/async-rust-vs-rtos-showdown |titel=Async Rust vs RTOS showdown! |werk=tweede golf |datum=2022-01-31 |sprache=en |abruf=2025-10-30}}</ref> Embassy verfügt über optionale Komponenten, die es um <code>async</code>-basierte [[Echtzeitbetriebssystem|RTOS]]-Funktionalität wie mehrere Task-Prioritäten erweitert.

== Beispiele ==

=== Hello-World-Funktion ===
<syntaxhighlight lang="rust">
fn main() {
    println!("Hello, world!");
}
</syntaxhighlight>

Das obige Beispiel gibt den Text <code>Hello, world!</code> am Ausgabemedium aus. <code>println!()</code> ist hierbei keine gewöhnliche [[Funktion (Programmierung)|Funktion]], sondern ein [[Makro]]. Die Funktionsdeklaration erfolgt in Rust mit dem [[Schlüsselwort (Programmierung)|Schlüsselwort]] <code>fn</code>.

=== Fakultäts-Funktion ===
Für die Berechnung der [[Fakultät (Mathematik)|Fakultät]] einer Zahl <math>n</math>, also <math>n! = 1\cdot 2 \cdot 3 \dotsm n = \prod_{k=1}^n k</math>, existieren verschiedene Lösungswege, insbesondere ein rekursiver und ein iterativer. Beide sind in Rust umsetzbar.

==== Iterativ ====
<syntaxhighlight lang="rust">fn fakultaet(i: u64) -> u64 {
    let mut acc = 1;
    for num in 2..=i {
        acc *= num;
    }
    acc
}</syntaxhighlight>
Da die Fakultät für alle [[Natürliche Zahl|natürlichen Zahlen]] definiert ist, kann als Datentyp auf <code>u64</code>, eine vorzeichenlose 64-Bit-Ganzzahl,<ref>{{Internetquelle|url=https://doc.rust-lang.org/std/primitive.u64.html|titel=u64 – Rust|abruf=2019-04-21}}</ref> zurückgegriffen werden. In dieser Variante wird die Fakultät nach obiger Definition umgesetzt. Auffällig ist das Schlüsselwort <code>mut</code> in Zeile 2, das in der Deklaration der Variable ''acc'' vorkommt, um diese als veränderlich (''mut''able) zu kennzeichnen, da im Schleifenkörper in Zeile 4 eine erneute [[Wertzuweisung]] vorgenommen wird. Eine explizite <code>return</code>-Anweisung wird in Rust nicht benötigt, weil der letzte Ausdruck (der aufgrund des fehlenden Semikolons keine Anweisung ist) als Rückgabewert gilt.<ref>{{Internetquelle|url=https://doc.rust-lang.org/rust-by-example/fn.html|titel=Functions – Rust By Example|abruf=2019-04-21}}</ref> Dieser Ausdruck muss dem Rückgabetypen aus dem Funktionskopf entsprechen.

Alternativ erlaubt es Rust, das Problem im Sinne der funktionalen Programmierung anzugehen. Sogenannte ''Iterators'' bieten eine Möglichkeit, iterierbare Objekte zu verarbeiten. So lässt sich die Fakultät mit Hilfe des Iterators <code>(1..=i)</code> und dessen Methode <code>product()</code><ref>{{Internetquelle|url=https://doc.rust-lang.org/std/iter/trait.Product.html#tymethod.product|titel=std::iter::Product – Rust Documentation|abruf=2019-04-21}}</ref> wie folgt darstellen:<syntaxhighlight lang="rust">
fn fakultaet(i: u64) -> u64 {
    (1..=i).product()
}
</syntaxhighlight>

==== Rekursiv ====
<syntaxhighlight lang="rust">
fn fakultaet(i: u64) -> u64 {
    match i {
        0 => 1,
        n => n * fakultaet(n - 1)
    }
}
</syntaxhighlight>

Bei dieser Variante liegt der Kern in einer [[Bedingte Anweisung und Verzweigung|Fallunterscheidung]], mit der die Fakultät ebenfalls definiert werden kann:

:<math>n! =\begin{cases} 1, &n=0 \\ n\cdot (n-1)!, &n>0\end{cases}</math>

Dieser Ausdruck lässt sich in Rust mittels Pattern Matching und rekursivem Funktionsaufruf implementieren.

==== Behandlung von Überlauf ====

Mit dem hier benutzten 64-Bit-Integer-Datentyp lässt sich die Fakultät nur bis 20 berechnen, bis ein [[Integer (Datentyp)#Arithmetischer Überlauf|Überlauf]] passiert, welcher nur noch falsche Ergebnisse liefert. Dies geschieht häufig unbemerkt. Je nach Kompiliermethode würde dieser Überlauf in den obigen Beispielen als nicht behebbarer Fehler bemerkt, sodass das Programm sich beendet, oder es würde mit dem Überlauf weitergerechnet.

Stattdessen kann dieser Fehlerfall wie folgt mit Hilfe des Typsystems behandelt werden:

<syntaxhighlight lang="rust">
fn fakultaet(i: u64) -> Option<u64> {
    match i {
        0 => Some(1),
        n => match fakultaet(n - 1) {
            Some(m) => n.checked_mul(m),
            None => None
        }
    }
}
</syntaxhighlight>

=== Stapelspeicher ===

Die kombinierte Nutzung von Enumerationen, Strukturen und Zeigern erlaubt die Konstruktion komplexer Datenstrukturen. Das folgende Beispiel zeigt die Implementierung eines unbeschränkten [[Stapelspeicher]]s als [[Liste (Datenstruktur)|einfach verkettete Liste]], der durch Verhüllung in ein Modul zu einem abstrakten Datentyp gemacht wird. Die öffentliche Schnittstelle ist durch das Schlüsselwort <code>pub</code> gekennzeichnet.

Die Formulierung des abstrakten Datentyps <code>Stack&lt;T&gt;</code> ist generisch über seinem Elementtyp <code>T</code> gestaltet. Man sagt auch, <code>Stack&lt;T&gt;</code> ist ''parametrisch polymorph'' oder ist ''allquantifiziert'' über die Typvariable <code>T</code>. Bei der Erzeugung von Maschinencode wird die Funktion für jeden tatsächlich im Programm verwendeten Elementtyp separat generiert, ein ''Monomorphisierung'' genannter Prozess.

<syntaxhighlight lang="rust">
mod stack {
    struct Node<T> {
        data: T,
        next: Option<Box<Node<T>>>
    }
    pub struct Stack<T> {
        top: Option<Box<Node<T>>>
    }
    impl<T> Stack<T> {
        pub fn new() -> Self {
            Self{top: None}
        }
        pub fn push(&mut self, element: T) {
            let node = self.top.take();
            self.top = Some(Box::new(Node{data: element, next: node}));
        }
        pub fn pop(&mut self) -> Option<T> {
            if let Some(node) = self.top.take() {
                self.top = node.next;
                Some(node.data)
            } else {
                None
            }
        }
    }
}

use stack::Stack;

fn main() {
    let mut a: Stack<i32> = Stack::new();
    a.push(1);
    a.push(2);
    println!("{:?}", a.pop());
    println!("{:?}", a.pop());
    println!("{:?}", a.pop());
}
</syntaxhighlight>
Die Notation <code>&amp;mut self</code> ist eine Kurzschreibweise für <code>self: &amp;mut Self</code>.

Bei der Entnahme des Knotens in <code>pop</code> gibt es ein Problem: Weil es hier zur Besitzübertragung an <code>node</code> kommt, würde die Speicherzelle ungültig werden. Zur Umgehung dieser gefährlichen Situation wurde die Methode <code>Option::take</code> genutzt, die die ungültige Speicherzelle sogleich mit dem Wert <code>None</code> überschreibt.

Die Standardbibliothek enthält viele Hilfsfunktionen, die manchmal lediglich zur moderaten Verknappung von Quelltext herangezogen werden können. Die Benutzung der [[Monade (Informatik)|monadischen]] Methode <code>Option::map</code> gestattet bspw. eine kürzere Formulierung der Methode <code>pop</code>:
<syntaxhighlight lang="rust">
pub fn pop(&mut self) -> Option<T> {
    self.top.take().map(|node| {
        self.top = node.next;
        node.data
    })
}
</syntaxhighlight>
Es ist im Allgemeinen nicht empfehlenswert, grundlegende Datenstrukturen neu zu erfinden, da dies eine vermeidbare Fehlerquelle ist und den Datenaustausch verkomplizieren kann. Anstelle des hier beispielhaft gezeigten Stack sollte ''Vec'' verwendet werden.<ref>{{Internetquelle |url=https://doc.rust-lang.org/std/collections/ |titel=std::collections |werk=Rust documentation |abruf=2020-10-13 }}</ref>

== Verwendung ==
Der Rust-Compiler wird standardmäßig mit [[Cargo (Software)|Cargo]], einer [[Paketverwaltung]] für Rust-Software, ausgeliefert, die verwendete [[Programmbibliothek|Bibliotheken]] automatisch herunterlädt und Abhängigkeiten auflöst. Jedes Paket beinhaltet eine Konfigurationsdatei im [[TOML]]-Format, die als Cargo.toml im Paketverzeichnis abgelegt wird. In dieser werden neben allgemeinen Informationen zum Paket (u.&nbsp;a. Name, Version, Autoren und Kompiliereinstellungen) auch die benötigten Abhängigkeiten angegeben.<ref>{{Internetquelle |url=https://doc.rust-lang.org/cargo/reference/manifest.html#the-manifest-format |titel=The Manifest Format – The Cargo Book |abruf=2019-04-19}}</ref>

Eine Vielzahl wiederverwendbarer [[Open Source|Open-Source]]-Komponenten stehen im offiziellen Paket-[[Repository]] ''crates.io''<ref>{{Internetquelle |url=https://crates.io/ |titel=The Rust community’s crate host |sprache=en |abruf=2017-04-03}}</ref> zur Verfügung. Ab der Version 1.34.0 ist es zudem möglich, andere Paket-Repositories zu nutzen. Dies ermöglicht beispielsweise, dass Unternehmen eigene, interne Paket-Repositories erstellen und für [[Proprietäre Software|Closed-Source]]-Komponenten nutzen.

Rust ist mit C direkt interoperabel (sogenanntes ''Foreign Function Interface'' bzw. ''FFI''). C-Funktionen können in Rust als <code>extern</code> deklariert werden, genauso können Rust-Funktionen und manche Datentypen die <code>extern "C"</code>-[[Binärschnittstelle|ABI]] benutzen und somit aus C verwendet werden. Mithilfe von Werkzeugen wie cbindgen<ref>{{Internetquelle |url=https://github.com/mozilla/cbindgen |titel=mozilla/cbindgen |hrsg=Mozilla |datum=2025-10-29 |abruf=2025-10-29}}</ref>, welches C-Header für Rust-Funktionen und Datentypen erzeugt, und bindgen<ref>{{Internetquelle |url=https://github.com/rust-lang/rust-bindgen |titel=rust-lang/rust-bindgen |hrsg=The Rust Programming Language |datum=2025-10-28 |abruf=2025-10-29}}</ref>, welches Rust-Module aus C-Headern erzeugt, ist es möglich, in einem Programm C und Rust gemischt zu verwenden. Die Interoperabilität von Rust und C++ ist mit komplexeren Werkzeugen wie CXX<ref>{{Internetquelle |url=https://cxx.rs/ |titel=CXX — safe interop between Rust and C++ |sprache=en |abruf=2025-10-29}}</ref> beschränkt möglich, soll aber in Zukunft in der Sprache selbst besser unterstützt werden.<ref>{{Internetquelle |autor=Jon Bauman, Oliver Scherer, Tyler Mandry, David Tolnay |url=https://rust-lang.github.io/rust-project-goals/2025h2/interop-problem-map.html |titel=C++/Rust Interop Problem Space Mapping - Rust Project Goals |abruf=2025-10-29}}</ref> Dank der Interoperabilität setzen bereits viele C- und C++-Projekte Rust in kleinem Umfang ein.

Rust findet unter anderem in folgenden Projekten Verwendung:<!-- Bitte nur Einträge hinzufügen, die einen Wikipedia-Artikel besitzen. -->

* [[Mozilla Firefox]]<ref>{{Internetquelle |url=https://hacks.mozilla.org/2016/07/shipping-rust-in-firefox/ |titel=Shipping Rust in Firefox |sprache=en |autor=Dave Herman |werk=Mozilla Hacks |datum=2016-07-12 |abruf=2017-04-02}}</ref><ref>{{Internetquelle |url=https://wiki.mozilla.org/Quantum |titel=Quantum |sprache=en |werk=Mozilla Wiki |abruf=2017-04-03}}</ref>
* [[Mozilla Thunderbird]] – ab Version 128, für mehr Performance und Sicherheit, aber auch um zukünftig Code zwischen Desktop und Mobile gleichermaßen entwickeln und teilen zu können.<ref>{{Internetquelle |autor=Jason Evangelho |url=https://blog.thunderbird.net/2024/07/welcome-to-thunderbird-128-nebula/ |titel=Welcome to Thunderbird 128 "Nebula" |datum=2024-07-12 |sprache=en-US |abruf=2024-07-22}}</ref>
* [[Servo (Software)|Servo]] – eine neue [[Layout-Engine]] für [[Webbrowser]], ehemals von [[Mozilla]].<ref>{{Internetquelle |url=https://www.heise.de/newsticker/meldung/Mozilla-veroeffentlicht-erste-Preview-der-neuen-Browser-Engine-Servo-3253464.html |werk=[[Heise Newsticker]] |abruf=2016-07-04 |datum=2016-07-04 |titel=Mozilla veröffentlicht erste Preview der neuen Browser-Engine Servo |autor=Rainald Menge-Sonnentag}}</ref> Servo war das erste Projekt, welches ausschließlich und im großen Stil Rust einsetzte.
* [[OpenDNS]] – verwendet Rust in zwei Softwarekomponenten.<ref>{{cite web|last1=Frank|first1=Denis|title=Using HyperLogLog to Detect Malware Faster Than Ever|url=https://labs.opendns.com/2013/12/05/hyperloglog-and-malware-detection/|website=OpenDNS Security Labs|accessdate=2016-03-19|archiveurl=https://web.archive.org/web/20160603035129/https://labs.opendns.com/2013/12/05/hyperloglog-and-malware-detection/|archivedate=2016-06-03|offline=yes}}</ref><ref>{{cite web|last1=Denis|first1=Frank|title=ZeroMQ: Helping us Block Malicious Domains in Real Time|url=https://labs.opendns.com/2013/10/04/zeromq-helping-us-block-malicious-domains/|website=OpenDNS Security Labs|accessdate=2016-03-19|archiveurl=https://web.archive.org/web/20160630043417/https://labs.opendns.com/2013/10/04/zeromq-helping-us-block-malicious-domains/|archivedate=2016-06-30|offline=yes}}</ref>
* [[librsvg]] – freie [[Scalable Vector Graphics|SVG]]-Bibliothek, Teil des [[Gnome]]-Projektes.
* [[Google Fuchsia]] – ein Betriebssystem, das von Google entwickelt wird.<ref>{{Internetquelle |url=https://fuchsia.googlesource.com/fuchsia/+/HEAD/docs/development/languages/rust/README.md |titel=Fuchsia – Rust |werk=fuchsia.googlesource.com |abruf=2019-03-05}}</ref>
* [[Deno (Software)|Deno]] – eine Laufzeitumgebung für [[JavaScript]] und [[TypeScript]] als Alternative zu Node.js
* [[RustDesk]] – eine Remote-Desktop-Anwendung
* [[Signal (Messenger)|Signal Messenger]] – Kernfunktionalitäten wie Signal-Protokoll oder Kryptographie für alle Apps (Android, iOS, Desktop).<ref>{{Internetquelle |url=https://github.com/signalapp/libsignal |titel=Overview |hrsg=Signal |datum=2023-03-26 |sprache=en |abruf=2023-03-27}}</ref>
* [[Matrix (Kommunikationsprotokoll)|Matrix]] – Offizielle Bibliothek für Matrix-Protokoll-Clients<ref>{{Internetquelle |url=https://github.com/matrix-org/matrix-rust-sdk |titel=matrix-org/matrix-rust-sdk |hrsg=The Matrix.org Foundation |datum=2025-10-29 |abruf=2025-10-29}}</ref>, Serverimplementierung conduit<ref>{{Internetquelle |url=https://conduit.rs/ |titel=Conduit - Your own chat server |abruf=2025-10-29}}</ref> und seine Abspaltungen (u.&nbsp;a. continuwuity<ref>{{Internetquelle |url=https://continuwuity.org/ |titel=Introduction - continuwuity |abruf=2025-10-29}}</ref> und tuwunel<ref>{{Internetquelle |url=https://github.com/matrix-construct/tuwunel |titel=matrix-construct/tuwunel |hrsg=Matrix Construct |datum=2025-10-29 |abruf=2025-10-29}}</ref>)
* [[Tor (Netzwerk)|Tor]] – „Arti“<ref>{{Internetquelle |url=https://tpo.pages.torproject.net/core/arti/ |titel=Getting started with Arti {{!}} Arti |datum=2025-08-28 |sprache=en |abruf=2025-10-29}}</ref>, experimentelle Reimplementierung der gesamten C-Tor-Codebase
* [[Fish (Shell)|Fish]] – eine [[Shell (Betriebssystem)|Shell]] für [[unixoides System|unixoide Systeme]], seit Version 4.0
* [[Zed (Texteditor)|Zed]] – ein Texteditor

=== Betriebssysteme ===
Rust findet in vielen Betriebssystemen zunehmend Anwendung, da vor allem [[Zugriffsverletzung|Speicherzugriffsfehler]] oder [[Pufferüberlauf|Pufferüberläufe]] immer wieder zu Sicherheitslücken führen, welche mit Rust von Haus aus vermieden werden können. Dabei wird zumeist [[C (Programmiersprache)|C]] oder [[C++]] ersetzt.

==== Microsoft Windows ====
[[Microsoft]] ist Gründungsmitglied der Rust Foundation und bezahlt als Platinum-Sponsor 300.000 US-Dollar im Jahr an die Organisation.<ref name=":1">{{Internetquelle |url=https://foundation.rust-lang.org/ |titel=Rust Foundation |werk=foundation.rust-lang.org |sprache=en |abruf=2023-11-07}}</ref>

2020 hatte Microsoft angekündigt, Teile von [[Microsoft Windows|Windows]] in Rust neu zu schreiben. DWriteCore, eine [[Engine]] zur Textanalyse, Layout und Rendering, besteht mittlerweile aus rund 150.000 Zeilen Rust.<ref>{{Internetquelle |autor=Thomas Claburn |url=https://www.theregister.com/2023/04/27/microsoft_windows_rust/ |titel=Microsoft is rewriting core Windows libraries in Rust |werk=The Register |datum=2023-04-27 |sprache=en |abruf=2023-06-07}}</ref> „''Auch wenn es sich um einen kleinen Test handelt, werden wir die Nutzung von Rust im Kernel weiter steigern“,'' heißt es in einem Windows Blog Post vom Juli 2023, zur Implementierung der GDI-Region in win32kbase_rs.sys in sicherem Rust.<ref>{{Internetquelle |autor=Amanda Langowski, Brandon LeBlanc |url=https://blogs.windows.com/windows-insider/2023/07/12/announcing-windows-11-insider-preview-build-25905/ |titel=Announcing Windows 11 Insider Preview Build 25905 |werk=blogs.windows.com |datum=2023-07-12 |sprache=en-US |abruf=2023-11-05}}</ref> Bereits im Oktober 2023 war Rust im Kernel von Windows 11, als ein [[Systemaufruf|SysCall]], angekommen.<ref>{{Internetquelle |url=https://windowsreport.com/windows-11-kernel-rust/ |titel=Rust is now up and running in Windows 11 kernel |werk=windowsreport.com |datum=2023-05-11 |sprache=en-US |abruf=2023-11-04}}</ref>

Im November 2023 hat der bei Microsoft für Betriebssystemsicherheit zuständige David Weston angegeben, dass Rust von Microsofts hauseigenen Entwicklungswerkzeugen künftig ''„erstklassig“'' unterstützt werden und damit auf einer Stufe wie C oder C++ stehen soll. Dies bedeutet vor allem Arbeiten an sowie Investitionen in interne Systeme. Dafür sind 10 Millionen US-Dollar veranschlagt. Als Ziel möchte man vor allem die Speichersicherheit der eigenen Anwendungen erhöhen. Zusätzlich zu der Ankündigung hat man neben dem Mitgliedsbeitrag eine Million an die Rust Foundation gespendet.<ref>{{Internetquelle |url=https://www.golem.de/sonstiges/zustimmung/auswahl.html?from=https%3A%2F%2Fwww.golem.de%2Fnews%2Fwindows-microsoft-will-rust-als-volle-systemsprache-unterstuetzen-2311-179137.html |titel=Golem.de: IT-News für Profis |werk=golem.de |sprache=de |abruf=2023-11-07}}</ref>

==== Google Android ====
[[Google LLC|Google]] ist Gründungsmitglied der Rust Foundation und zahlt als Platinum-Sponsor 300.000 US-Dollar im Jahr an die Organisation.<ref name=":1" />

Bereits seit 2019 wird Rust von Google in [[Android (Betriebssystem)|Android]] verwendet, was laut Aussage von Android-Sicherheits-Ingenieur Jeffrey Vander Stoep von 2019 bis 2022 bereits die Anzahl der Speichersicherheitsfehler von 223 auf 85 pro Jahr reduzieren konnte. Bisher wurden auch keine Speicherfehler im hinzugefügten Rust-Code gefunden.<ref name=":0">{{Internetquelle |url=https://security.googleblog.com/2022/12/memory-safe-languages-in-android-13.html |titel=Memory Safe Languages in Android 13 |werk=Google Online Security Blog |sprache=en |abruf=2023-11-04}}</ref>

In Android 12 wurde Rust-Support erstmals angekündigt. In Android 13 war bereits ein größerer Teil des neu hinzugefügten Code in Rust geschrieben.<ref name=":0" />

Für Android 14 wurde bereits eine [[Bare Metal|Bare-Metal]]-Rust-Umsetzung veröffentlicht. Die Protected-Virtual-Machine-[[Firmware]] ersetzt den in C geschriebenen Open-Source-[[Bootloader]] U-Boot. Grund dafür sind Speicherfehler wie [[Pufferüberlauf]] oder Out-of-Bounds-Fehler im Bootloader, die aufgrund der Angreifbarkeit eines Bootloaders zumeist als kritisch eingestuft werden und zukünftig damit vermieden werden könnten.<ref>{{Internetquelle |autor=heise online |url=https://www.heise.de/news/Noch-mehr-Rust-in-Android-Speichersicherheit-jetzt-auch-auf-Bare-Metal-Ebene-9330945.html |titel=Weniger Speicherfehler: Google setzt für Android nun auch auf Bare-Metal Rust |datum=2023-10-11 |sprache=de |abruf=2023-11-04}}</ref>

Im November 2023 wurde der erste komplette [[Linux]]-Treiber für Android namens Binder erstellt. Dabei handelt es sich um eine komplett neue Umsetzung der [[Interprozesskommunikation]] (IPC), zuvor in C umgesetzt, und im Zuge dessen wurden auch weitere Pläne und Funktionen umgesetzt.<ref>{{Internetquelle |url=https://www.golem.de/news/android-google-zeigt-ersten-linux-treiber-in-rust-2311-179075.html |titel=Android: Google zeigt ersten Linux-Treiber in Rust |abruf=2023-11-04}}</ref>

==== Linux ====
Der Linuxkernel enthält {{FormatNum|25000|de}} Zeilen Rustcode bei {{FormatNum|34000000|de}} Zeilen C-Code, Rust macht somit 0,07 % aus (Stand: 2025).<ref name=":2">{{Internetquelle |autor=[[Greg Kroah-Hartman]] |url=https://git.sr.ht/~gregkh/presentation-rust/tree/ea733ca3a1255c35bffdd86b18dcbd931506b984/item/rust.pdf |titel=Rust and Linux |datum=2025-04-01 |abruf=2025-04-09}}</ref>

Für Kernelentwickler bietet Rust als Sprache, Bibliothek und Tooling viele moderne Verbesserungen im Vergleich zu C.<ref name=":3">{{Internetquelle |autor=heise online |url=https://www.heise.de/hintergrund/Drei-Fragen-und-Antworten-Was-die-Rust-Zukunft-fuer-Linux-bringt-7531986.html |titel=Drei Fragen und Antworten: Was die Rust-Zukunft für Linux bringt |datum=2023-03-06 |sprache=de |abruf=2023-11-04}}</ref>

Die zahlenmäßig meisten gefundenen Fehler im Kernelcode betreffen Spezialfälle in C, die in Rust nicht vorkommen können, wie beispielsweise überschriebener Speicher, Aufräumarbeiten im Fehlerfall, vergessene Fehlerüberprüfung und Speichernutzung nach Rückgabe.<ref name=":2" /><ref>{{Internetquelle |autor=[[Greg Kroah-Hartman]] |url=https://lore.kernel.org/rust-for-linux/2025021954-flaccid-pucker-f7d9@gregkh/ |titel=Rust kernel policy |abruf=2025-04-09}}</ref> Dies betrifft rund 70 % der Sicherheitslücken.<ref name=":3" /> Rust erzwingt bereits beim Kompilieren die Validierung nicht vertrauenswürdiger Daten, die Regeln für Speicherverwaltung, Sperrregeln, Fehlerbehandlung und Typsicherheit, das vereinfacht Codereviews und reduziert Programmierfehler im Linuxkernel.<ref name=":2" />

Mit dem [[Linux (Kernel)|Linux-Kernel]] 6.1 wurde erstmals die Möglichkeit geschaffen, neben der Programmiersprache C auch Rust als zweite Programmiersprache im Kernel zu verwenden. Dies war aber noch nicht als produktiv zu bezeichnen, da noch entsprechende Rust-Module im Kernel fehlten.<ref>{{Internetquelle |autor=heise online |url=https://www.heise.de/news/Linux-6-1-als-naechster-Langzeit-Kernel-erschienen-7393140.html |titel=Linux 6.1 als nächster Langzeit-Kernel erschienen |datum=2022-12-13 |sprache=de |abruf=2023-11-04}}</ref><ref>{{Internetquelle |autor=Ferdinand Thommes |url=https://linuxnews.de/linux-6-1-mit-initialem-rust-code-freigegeben/ |titel=Linux 6.1 mit initialem Rust-Code freigegeben |hrsg= |datum=2022-12-12 |sprache=de |abruf=2023-05-10}}</ref>

Erst mit den folgenden Kerneln wurden Module und mehrere Updates der [[Toolchain]] gemacht, um dem produktiven Einsatz näher zu kommen und zukünftig näher an der aktuellen Entwicklung von Rust zu sein.<ref>{{Internetquelle |url=https://www.phoronix.com/news/Rust-For-Linux-6.5 |titel=Linux 6.5 Upgrading The Rust Toolchain, New Modules Added |sprache=en |abruf=2023-11-04}}</ref><ref>{{Internetquelle |url=https://www.phoronix.com/news/Linux-6.7-Rust |titel=Rust WQ Abstractions, Rust Toolchain Upgrade & Android Kernel Builds For Linux 6.7 |sprache=en |abruf=2023-11-04}}</ref>

Die Umstellung auf Rust warf aber auch diverse Diskussionen auf, in deren Folge im Jahr 2025 langjährige Kernel-Maintainer das Projekt verlassen haben.<ref>{{Internetquelle |url=https://www.heise.de/news/Der-Rust-DMA-Streit-beim-Linux-Kernel-ein-Analyseversuch-10291076.html |titel=Der Rust-DMA-Streit beim Linux-Kernel |autor=Thorsten Leemhuis |werk=heise.de |datum=2025-02-21 |sprache=de |abruf=2025-02-21}}</ref>

== Literatur ==
* {{Literatur |Autor=Georg Nold |Titel=Neuling im Programmiersprachenwald. Was Rust hat, das andere nicht haben |Sammelwerk=[[iX – Magazin für professionelle Informationstechnik]] |Nummer=5 |Datum=2021-05 |ISSN=0935-9680 |Seiten=42–44}}

== Weblinks ==
* [https://www.rust-lang.org/ Offizielle Website]
* [https://doc.rust-lang.org/book/ Offizielles Lehrbuch] (englisch) / [https://rust-lang-de.github.io/rustbook-de/ Deutsche Übersetzung]
* [https://doc.rust-lang.org/reference/ Offizielle Referenz] und [https://rust-lang.github.io/fls/ FLS-Spezifikation]
* {{Internetquelle |url=https://doc.rust-lang.org/stable/rust-by-example/ |titel=Introduction – Rust By Example |werk=rustbyexample.com |sprache=en |abruf=2018-02-09 |abruf-verborgen=1}}

== Einzelnachweise ==
<references responsive />

{{Normdaten|TYP=s|GND=1078438080}}

[[Kategorie:Programmiersprache]]
[[Kategorie:Mozilla]]
[[Kategorie:Rust (Programmiersprache)| ]]
[[Kategorie:Imperative Programmiersprache]]
[[Kategorie:Freies Programmierwerkzeug]]