Rust 1.100: Der Never Type nach zehn Jahren Entwicklung
Rust 1.100 stabilisiert endlich den Never Type, Custom Allocators und Cargo-Dependency-Cooldowns. Was 100 Releases über Sprachdesign lehren.

Hier ist ein Szenario, das eigentlich bemerkenswert sein sollte, es aber nicht ist: Du führst an einem Donnerstagmorgen rustup update stable aus, baust einen Workspace mit ein paar hundert Crates und einer halben Million Zeilen Code neu, und alles kompiliert. Keine Deprecation-Warnungen, die du dir nicht verdient hast, kein überraschender Bruch in einer transitiven Abhängigkeit, kein hektisches Pinnen von Versionen. Mit Rust 1.100 — einem wirklich großen Release, das nach einem Jahrzehnt voller Versuche endlich den Never Type bringt — ist das Interessanteste daran, wie unspektakulär das Upgrade für fast alle werden wird. Das ist kein Zufall. Es ist das Ergebnis von hundert Releases voller institutioneller Disziplin, und es lohnt sich, diesen Release so zu lesen, wie man ein Design-Dokument liest.
Der Never Type, ein Jahrzehnt in der Entstehung
Das Hauptfeature von 1.100 ist ein Typ, der per Definition keine Werte hat. Der Never Type, geschrieben !, ist der klassische unbewohnte Typ: Er beschreibt Berechnungen, die nie zu einem Wert auswerten — eine Endlosschleife, ein return, ein panic!(), ein Aufruf von std::process::exit. Typtheoretiker kennen dieses Konstrukt seit sehr langer Zeit; es ist der Bottom-Typ, das ⊥ des Lambda-Kalküls, die leere Menge in der Ecke deines Typverbands. Haskell-Nutzer kennen es als Void. Rust umkreist es schon seit vor 1.0, und es hat zehn Jahre und fünf gescheiterte Stabilisierungsversuche gebraucht, bis es endlich gelandet ist.
Warum so schwierig? Weil ! in jeden anderen Typ umgewandelt werden kann — und genau darin liegt seine Stärke — und jede dieser Coercion-Stellen ist ein Ort, an dem Typinferenz, Trait-Auflösung und Exhaustivitätsprüfung übereinstimmen müssen. Weil ein Match-Arm, der divergiert, den Typ ! hat, kompiliert das hier:
fn infallible_unwrap<T>(res: Result<T, !>) -> T {
// ^^ naming `!` in a type position like this
// was not allowed on stable before 1.100
let Ok(v) = res;
v
}
Die Zeile let Ok(v) = res; ist die Belohnung: Da Err(!) niemals existieren kann, akzeptiert der Compiler das unwiderlegbare Muster, und eine ganze Kategorie defensiver unreachable!()-Aufrufe verschwindet. Außerdem wird das alte Enum std::convert::Infallible zu einem Typalias für !, sodass jede API, die in den letzten Jahren gegen Infallible geschrieben wurde, automatisch mit dem echten Never Type kompatibel ist. Diese Vereinheitlichung war von Anfang an der Plan — und sie war auch der Grund, warum sich die Stabilisierung immer wieder verzögerte, denn den Alias zu ändern erforderte eine Änderung des Never-Type-Fallbacks in den Editionen vor 2024, was technisch ein Breaking Change ist.
Schau dir an, wie das Team diesen Bruch gehandhabt hat, denn darin steckt die ganze Philosophie im Kleinen. Sie haben Future-Compatibility-Warnungen weit im Voraus ausgeliefert, das Ökosystem mit Crater getestet und proaktiv Fixes an öffentliche Crates geschickt, die betroffen gewesen wären. Ein Breaking Change, über mehrere Release-Zyklen umgesetzt, mit gemessenem und gepatchtem Wirkungsradius, bevor die meisten Nutzer überhaupt etwas bemerkt haben. Im Gegensatz dazu steht der übliche Industriereflex, eine Major-Version hochzuzählen und die Schultern zu zucken. Ich habe schon einmal geschrieben, wozu sich Rust mit Soundness eigentlich verpflichtet — die Never-Type-Geschichte ist die Prozessebene derselben Verpflichtung. Wenn deine Garantie lautet „sicherer Code kann kein undefiniertes Verhalten haben“, dann muss sich selbst ein Typ ohne jeden Wert seinen Platz verdienen.
Custom Allocators bekommen endlich ein stabiles Fundament
Fast genauso lange erwartet: Der Kern der allocator_api-Arbeit ist stabil. Der Trait Allocator, Global, System und die *_in-Konstruktoren — Vec::new_in, Vec::with_capacity_in, Box::new_in, Box::from_raw_in — sind jetzt auf Stable verfügbar. Library-Autoren können einen Allocator definieren und ihn an Standard-Collections übergeben:
use std::alloc::{Allocator, Global};
// A Vec that allocates from your arena/pool/slab instead of the heap
let mut v: Vec<u64, _> = Vec::new_in(MyArena::new());
v.push(42);
Wenn du bisher nur Anwendungscode geschrieben hast, wirkt das vielleicht wie Verdrahtungsarbeit. Das ist es auch — und genau dort entscheidet sich, ob Systemsprachen funktionieren. Bisher bedeutete das Austauschen von Allokatoren das stumpfe Werkzeug #[global_allocator]: ein Allokator für den gesamten Prozess. Das ist in Ordnung, wenn du überall jemalloc oder mimalloc willst (und es gibt echte Performance zu holen — jemalloc hat sich seinen Ruf im großen Maßstab verdient), aber nutzlos, wenn du einen einzelnen Vec auf einer Arena betreiben willst, die am Ende eines Requests in einem Schwung freigegeben wird, während alles andere den Standard-Heap nutzt. Game-Engines, Datenbanken, Embedded-Targets mit mehreren RAM-Bereichen, kernelnaher Code — all diese Bereiche wollen Kontrolle pro Collection, und sie wollen sie seit Jahren.
Beachte die Einordnung im Release selbst: Das hier ist ausdrücklich das Fundament des Projektziels „Allocators 1.0“, mit weiteren Collections und Pointer-Typen, die folgen sollen. Das Rust-Projekt hat sich daran gewöhnt zu sagen: „Hier ist der stabile Kern; der Rest bleibt bewusst noch Nightly.“ Diese Reihenfolge — den Trait und das Design stabilisieren, das Ökosystem darauf aufbauen lassen, die Oberfläche später erweitern — ist genau der Weg, um sich nicht mit einer API in eine Sackgasse zu manövrieren, die man für immer unterstützen muss. C++ ist mit std::allocator in den Neunzigern den umgekehrten Weg gegangen, hat es halbfertig ausgeliefert und Jahrzehnte damit verbracht, die Trümmer zu umgehen. Geduld ist billiger.
DropGuard: Gos defer, auf die Rust-Art
Der heimliche Hit des Releases ist std::mem::DropGuard. Rusts Trait Drop garantiert bereits, dass Cleanup-Code läuft, wenn ein Wert den Gültigkeitsbereich verlässt — ob durch return, ?, Panic, egal. Aber einen ganzen neuen Typ nur zu schreiben, um beim Verlassen eine Closure auszuführen, ist Boilerplate, über den die meisten von uns schon gemurrt haben. DropGuard umschließt einen Wert und eine Closure, dereferenziert auf den Wert, sodass du ihn normal verwenden kannst, und führt die Closure aus, sobald der Guard stirbt. Eine Methode dismiss() entschärft ihn. Der klassische Anwendungsfall ist ein transaktionales Rollback:
use std::mem::DropGuard;
use std::num::ParseIntError;
/// Push every parsed string into `nums`, or leave `nums` untouched.
fn parse_all(nums: &mut Vec<u32>, strings: &[&str]) -> Result<(), ParseIntError> {
let len = nums.len();
let mut nums = DropGuard::new(nums, move |nums| {
nums.truncate(len); // rollback on failure
});
for s in strings {
nums.push(s.parse()?); // `?` exits early; the guard truncates
}
DropGuard::dismiss(nums); // success: keep the values
Ok(())
}
Wenn das nach Gos defer riecht, dann stimmt das — aber mit einem entscheidenden Unterschied, wo die Garantie lebt. Gos defer ist eine funktionsbezogene Anweisung: Sie läuft, wenn die Funktion zurückkehrt, und ist für das Typsystem unsichtbar. DropGuard ist ein Wert. Du kannst ihn verschieben, speichern, an einen anderen Scope übergeben, bedingt entschärfen. Die Linie führt zurück zu C++-RAII und Alexandrescus altem ScopeGuard-Trick aus den Anfangstagen des modernen C++, der dasselbe mit Destruktoren und einem Dismiss()-Aufruf gemacht hat. Rust hat die Idee nicht erfunden; es hat ein zwanzig Jahre altes C++-Idiom übernommen, mit Ownership-Semantik versehen und in core untergebracht. So funktioniert gute Sprachentwicklung tatsächlich — nicht durch Neuheit, sondern durch die Übernahme bewährter Muster in das Standardvokabular.

Nichts herbeizaubern: Zero-Sized Types richtig gemacht
Weiter unten in den Notizen steht eine Funktion, deren Name ich wirklich liebe: std::mem::conjure_zst. Zero-Sized Types — Unit-Structs, Marker-Token wie PyO3s Python<'py — sind im typebasierten Programmieren in Rust allgegenwärtig. Wenn ein inhabiter Typ keine Größe hat, gibt es genau einen Wert, den er halten kann, und seine Erzeugung ist in gewissem Sinne immer „sicher“. Aber APIs verlassen sich regelmäßig darauf, dass diese Token nicht fälschbar sind: Ein Python<'py aus dem Nichts zu beschwören würde sicheren Code vorgaukeln lassen, er halte den GIL. Bisher hat man ZSTs mit Transmutes von () oder MaybeUninit-Beschwörungen erzeugt, jede mit leicht unterschiedlichen Konsequenzen für die noch offenen Unsafe-Code-Richtlinien. Jetzt gibt es eine offiziell freigegebene, deutlich mit unsafe markierte Schreibweise. Es ist eine winzige Funktion, die existiert, damit eine große Spezifikationsfrage eine einzige, prüfbare Antwort hat. Unspektakulär, sorgfältig, korrekt — das ganze Release in einer API.
Cargos Dependency-Cooldowns: Lieferkettenschutz mit Timer
Die folgenreichste Änderung in 1.100 steckt vielleicht gar nicht in der Sprache. Cargo unterstützt jetzt min-publish-age-bewusste Dependency-Auflösung — Dependency-Cooldowns. Die Idee dahinter ist empirisch: Bösartige Paketversionen werden meist innerhalb von Stunden oder Tagen nach Veröffentlichung entdeckt, durch Scanner oder Menschen. Also wird einfach die Auflösung auf Versionen verweigert, die jünger als ein konfiguriertes Zeitfenster sind:
# .cargo/config.toml
[registry]
global-min-publish-age = "3 days"
Ab dann überspringt cargo update frische Releases still und sagt dir, was es zurückgehalten hat — clap 4.6.7 (available: 4.6.9, published 2 days ago). Wenn du wirklich einen Hotfix brauchst, erlaubt eine einmalige Umgebungsvariable, ihn bewusst zu ziehen, und diese Entscheidung wird in Cargo.lock festgehalten, statt sich stillschweigend auszubreiten. Das ist eine seltene Sicherheitsmaßnahme, die dich fast nichts kostet: Du tauschst ein paar Tage Aktualität gegen eine dauerhafte Quarantäne für jeden Zero-Day-Paketangriff, der schnell entdeckt wird. Angesichts dessen, was wir bei anderen Registries beobachtet haben — der LiteLLM-Kompromittierung auf PyPI als jüngstes Lehrstück dafür, wie schnell sich ein vergiftetes Release verbreitet — ist ein Cooldown die günstigste Versicherung im Ökosystem. Die Release-Notes sind erfreulich ehrlich, dass dies keine vollständige Verteidigung ist, und cargo install umgeht sie komplett. Quarantäne-Unterstützung und automatische Erkennung verdächtiger Releases stehen weiterhin auf der crates.io-Roadmap. Defense in Depth, Schicht für Schicht ausgeliefert.
Build-Hygiene: Ungenutzte Abhängigkeiten und Cache-Kollisionen
Zwei Verbesserungen im Alltag verdienen Erwähnung, weil sie die beiden häufigsten Klagen in jedem Rust-Thread angehen: Kompilierzeiten und Speicherverbrauch. Erstens meldet Cargo jetzt ungenutzte Abhängigkeiten direkt, mit einer Warnung, die auf die genaue Zeile in deiner Cargo.toml zeigt. Rustc hat schon lange einen Lint namens unused_crate_dependencies, der aber mit Cargo Fehlalarme produzierte, weil Abhängigkeiten über Build-Targets hinweg geteilt werden — eine Dependency, die von einem bin im Paket genutzt wird, sieht für ein anderes wie ungenutzt aus. Cargo hat die globale Sicht, die rustc fehlt, also lebt die Warnung nun dort, wo die Wahrheit lebt. Sie greift nur, wenn alle relevanten Targets gebaut werden, und ist der erste Vertreter eines brandneuen Lint-Systems [lints.cargo] für das Manifest selbst.
Zweitens wurde das Build-Verzeichnis neu organisiert. Unterschiedliche Build-Konfigurationen — Feature-Sets, Profile — erzeugen unterschiedliche Artefakte, und ein Konfigurations-Hash hält sie auseinander. Dieser Hash wurde aufgrund von Plattformbeschränkungen nicht konsistent angewendet, was zu zusätzlichen Neubauten, verpassten Neubauten und allgemeiner Verwirrung führte — alles schlimmer, wenn du ein Build-Verzeichnis über Git-Worktrees hinweg teilst. Der Fix verschiebt den Hash aus den Dateinamen in eine nach Build-Schritten organisierte Verzeichnisstruktur. Unsichtbar, wenn es funktioniert, und genau das ist der Punkt — und es macht die Cache-Garbage-Collection und die workspace-übergreifende Deduplizierung später möglich. Wenn dein target/-Verzeichnis jemals 90 Gigabyte gefressen und ein tägliches cargo clean erzwungen hat, ist gerade das Fundament für deine Erlösung gelegt worden. Die vollständige Lösung ist noch nicht da, aber das tragende Refactoring schon.

Was hundert Releases über Sprachentwicklung lehren
Stabilität ist nicht die Abwesenheit von Veränderung. Sie ist die Disziplin, Veränderungen so zu takten, dass niemand mit seinem Code für deine Roadmap bezahlt.
Tritt einen Schritt zurück und betrachte die Form dieses Releases. Eine typtheoretische Verfeinerung, die ein Jahrzehnt brauchte. Ein Allocator-Trait, bewusst als Fundament statt als fertige Oberfläche ausgeliefert. Ein Scope-Guard-Idiom, älter als einige seiner Nutzer, endlich standardisiert. Ein Sicherheitsfeature, das auf Registry-Metadaten und ehrlichen Einschränkungen aufbaut. Build-System-Interna, die umgebaut wurden, um künftige Arbeit zu ermöglichen. Keine dieser Änderungen ist ein spektakulärer Paradigmenwechsel, und zusammen ergeben sie genau das: eine Sprache, die tiefer wird, ohne sich unter dir zu verändern. Es ist dasselbe stille Zinseszins-Prinzip, das man auch bei Javas unspektakulärem Vormarsch sieht, einem weiteren Ökosystem, das begriffen hat, dass Langweiligkeit ein Feature ist.
Die Maschinerie, die das möglich macht, verdient so viel Anerkennung wie jedes Feature. Das Sechs-Wochen-Zugmodell sorgt dafür, dass keine Stabilisierung je ein Notfall ist. Crater — das Tool, das praktisch das gesamte öffentliche Crate-Ökosystem gegen einen Kandidaten-Compiler baut — macht aus der Frage „Wird das jemanden kaputtmachen?“ eine Messung statt eines Gebets. Editionen bieten einen optionalen Migrationspfad, sodass die Sprache ihre Standardwerte ändern kann, ohne deinen Code zu ändern. Und die vergleichsweise neue Einrichtung benannter Projektziele (Allocators 1.0, das Build-Verzeichnis-Layout, die Härtung der crates.io-Lieferkette) gibt mehrjährigen Vorhaben ein öffentliches Rückgrat, sodass ein Feature wie der Never Type fünfmal scheitern kann und trotzdem einen festen Weg nach vorn hat, statt in einem Mailinglisten-Thread zu sterben.
Hier steckt eine Lehre für alle, die eine Plattform, ein Protokoll oder eine weit verbreitete Bibliothek pflegen. Nutzer erleben deine Roadmap nicht; sie erleben deine Diffs. Dass der Never Type in 1.100 landet statt in 1.35, ist keine Geschichte von Langsamkeit — sie erzählt davon, was passiert, wenn ein Projekt „wir erkennen es, wenn wir es sehen“ ein Jahrzehnt lang als akzeptable Antwort behandelt. Die meisten Software-Organisationen können sich diese Geduld nicht leisten, und ehrlich gesagt brauchen die meisten sie auch nicht. Wenn du aber etwas baust, auf dem andere aufbauen, dreht sich die Rechnung: Das Vertrauen deiner Nutzer wächst wie Zinsen, und der einzige Weg, es zu verdienen, sind hundert Releases, bei denen nichts kaputtgeht. Rust 1.100 ist ein großes Release. Die größere Geschichte ist, dass du es installieren kannst, ohne vorher die Notes zu lesen.


