Fundierte Artikel über Technologien, die das Kommende formen.

Jiff vs Chrono: Welche Rust-Datetime-Bibliothek gewinnt

Jiff vs Chrono für Rust: DST-Sonderfälle, API-Ergonomie und wann welche Bibliothek gewinnt. Praxisnah aus Sicht erfahrener Entwickler.

Zwei stilisierte, überlappende Uhren, eine mechanisch und eine organisch, die Zeitzonenübergänge andeuten.
Datetime-Bugs lassen selten etwas abstürzen – sie liefern dir einfach still die falsche Uhrzeit.

Alle paar Jahre entdeckt irgendein armer Entwickler, dass 2026-11-01 01:30 in New York zweimal vorkommt und sein Scheduler den Abrechnungsjob eine Stunde zu früh ausgelöst hat. Datetime-Bugs bringen dein Programm nicht zum Absturz – sie korrumpieren still deine Daten. Deshalb ist das Erscheinen von Jiff 1.0, einer neuen Rust-Datetime-Bibliothek von Andrew Gallant (bekannt durch ripgrep), mehr als nur ein weiteres Crate-Release. Es zwingt zu einer echten Frage: Jiff vs Chrono – welche sollte dein nächstes Rust-Projekt verwenden?

Eine kurze Geschichte des Rust-Datetime-Schmerzes

Rust hatte dieses Problem schon einmal, und die Geschichte ist lehrreich. Chrono stammt aus der Zeit vor Rust 1.0, als die Bibliothek im Zuge der großen „Right-size std“-Bereinigung zusammen mit time aus der Standardbibliothek ausgelagert wurde. Fast ein Jahrzehnt war sie die Standardantwort. Sie funktionierte, meistens. Doch ihre API wuchs in Schichten: NaiveDateTime, DateTime<Utc>, DateTime<Local>, DateTime<FixedOffset>, ein TimeZone-Trait, über den die meisten nur zwei Implementierungen ansprechen. Das Typsystem erlaubte vieles, was semantisch keinen Sinn ergab, etwa ein naives Datetime zu einem zonierten zu addieren und ein selbstbewusst falsches Ergebnis zu erhalten.

Auch die Wartungsgeschichte ist wichtig. Chrono durchlief eine Phase faktischer Verwaisung, und selbst spätere Maintainer beschreiben die Arbeit als ständiges Anstoßen an einer API-Stabilität, die Nutzer als heilig betrachteten. Ein früherer Maintainer formulierte es unverblümt: Jeder kleine Schritt zur Verbesserung stieß auf Widerstand, weil das wichtigste Verkaufsargument von chrono inzwischen seine Stabilität war, nicht sein Design. Das ist eine Falle, in die jede langlebige Bibliothek tappen kann – die installierte Basis wird zum Produkt. Das time-Crate versuchte es mit einem saubereren Kern, verschob aber die vollständige Zeitzonenbehandlung über Jahre. Derweil lieferte das Ökosystem weiter Anwendungen aus, bei denen „Wie spät ist es im März in Berlin?“ eine tragende Frage ist.

Das ist die alte Idee, auf der Jiff aufbaut, ob es sie nun so nennt oder nicht: die „Pit of Success“-Philosophie, die Rico Mariani Mitte der 2000er für API-Design beschrieb. Mach den einfachen Weg zum richtigen Weg. Gallants Sichtweise ist, dass die Schwierigkeit bei Datetimes aus schlechter Domänenmodellierung entsteht, und dass Bibliotheken, die Mehrdeutigkeit auf die Nutzer abwälzen – „Hier ist ein naives Datetime, viel Erfolg“ –, ihr schwierigstes Problem outsourcen. Es ist derselbe Gedanke hinter Rusts Ownership-Modell: Die Maschine soll die Komplexität übernehmen, damit der Mensch sie nicht tragen muss.

Wie Jiff Zeit modelliert: Die Zwiebel

Jiffs zentraler Designgriff ist das, was Gallant die Datetime-Zwiebel nennt. Die Schichten, von innen nach außen:

  • civil::Date – ein gregorianisches Datum ohne Ortsbezug. Dein Geburtstag ist so einer.
  • civil::Time – eine Wanduhrzeit mit Nanosekunden-Genauigkeit, ohne Ort.
  • civil::DateTime – Datum plus Uhrzeit, weiterhin ohne Ort. Das ist, was chrono naiv nennt.
  • Timestamp – ein eindeutiger Zeitpunkt, Nanosekunden seit der Unix-Epoche.
  • TimeZone – die Regeln, die Zeitpunkte und Zivilzeit in einer Region aufeinander abbilden.
  • ZonedDateTime – alles zusammen: Zeitpunkt, Zivilzeit und Zone.

Der Gewinn liegt darin, dass die Typnamen zu dem mentalen Modell passen, das du ohnehin schon hast. Ein Timestamp bekommst du aus einer Datenbank oder einem Systemaufruf. Ein civil::DateTime ist das, was ein Mensch in eine Kalendereinladung schreibt. Die Umwandlung zwischen beiden ist ohne Zeitzone unmöglich, und Jiff macht sie zu einer expliziten, fehlbaren und zonenbehafteten Operation. Vergleiche mit chrono: Dort gibt es die gleiche Unterscheidung, sie verschwimmt aber leichter – NaiveDateTime::and_utc() weist einer Wanduhrzeit bereitwillig eine Zone zu, ohne zu fragen, ob diese Wanduhrzeit überhaupt existiert hat.

Die Ergonomie ist bewusst freundlich gehalten. Du kannst ein zonier. Datetime aus beiden Richtungen bauen – Zivilzeit plus Zone oder Zeitpunkt plus Zone – und die API kommt dir in beiden Fällen entgegen:

use jiff::civil;
fn main() -> anyhow::Result<()> {
// Start from what a human would write on a calendar.
let dt = civil::date(2026, 11, 1).at(17, 30, 0, 0);
let zdt = dt.in_tz("America/New_York")?;
assert_eq!(zdt.offset().seconds(), -(5 * 60 * 60));
// Arithmetic on the civil parts stays civil:
let tomorrow = zdt.date().tomorrow()?;
assert_eq!(tomorrow, civil::date(2026, 11, 2));
Ok(())
}

Sommerzeit: Wo Jiff sich bewährt

Hier trennt sich bei Datetime-Bibliotheken die Spreu vom Weizen. Am 1. November 2026 werden in New York die Uhren um 2 Uhr morgens zurückgestellt. Die Stunde von 1 bis 2 Uhr kommt also zweimal vor. Was machst du, wenn ein Nutzer „1:30 Uhr am 1. November“ eingibt? Chrono antwortete historisch mit LocalResult: einem Enum, das Single, Ambiguous oder None sein kann. Erstaunlich viel Produktionscode unwrappt, verwirft oder falsch pattern-matcht es. Die Mehrdeutigkeit wird offengelegt – aber auch die Last, sie jedes Mal selbst zu behandeln.

Jiffs Antwort: ein vernünftiger Standard, und die Alternativen liegen nur einen Methodenaufruf entfernt. Die Standardstrategie „compatible“ löst einen Fold auf das frühere Vorkommen auf – so wie es die meisten Kalenderprogramme und alle gängigen Betriebssysteme tun. Wenn dir die Entscheidung wichtig ist, ist der vollständige Entscheidungsbaum aber direkt verfügbar:

use jiff::{civil::date, tz::TimeZone};
fn main() -> anyhow::Result<()> {
let tz = TimeZone::get("America/New_York")?;
let dt = date(2026, 11, 1).at(1, 30, 0, 0);
let amb = tz.to_ambiguous_zoned_datetime(dt);
let earlier = amb.earlier()?;  // offset -04 (EDT), first 1:30
let later = amb.later()?;      // offset -05 (EST), second 1:30
// Or refuse to guess entirely:
assert!(tz.to_ambiguous_zoned_datetime(dt).unambiguous().is_err());
Ok(())
}

Lücken werden genauso behandelt: Wenn die Uhren vorgestellt werden und 2:30 Uhr nie vorkommt, springt Jiff standardmäßig nach vorn, und auch das lässt sich überschreiben. Die Designentscheidung ist meinungsstark und, wie ich finde, richtig. Die meisten Codepfade, die mehrdeutige Zeiten behandeln, haben keine Richtlinie – sie haben einen Bug, der auf den November wartet. Ein Standardverhalten, das Nutzer schon von ihren Handys kennen, und gleichzeitig sichtbare, typisierte Ausstiegsmöglichkeiten: Das ist in der Praxis genau, was „Pit of Success“ bedeutet. Es ist eine ähnliche Philosophie wie hinter guten Standards bei selbstgebauter Datumsarithmetik: Die Regeln sind lernbar, aber man sollte sie nicht an jeder Aufrufstelle neu herleiten müssen.

Eine abstrakte Bandzeitleiste, die einen Fold zeigt, wo sie sich zurückfaltet, und eine Lücke, wo sie bricht.
Folds und Lücken: die beiden Stellen, an denen Zivilzeit nicht mehr sauber auf Zeitpunkte abgebildet wird.

Spans, Dauern und das Problem mit dem „einen Monat“

Frag chrono nach einer Dauer von „einem Monat“, und du wirst enttäuscht – seine Duration ist eine feste Anzahl von Sekunden, weil ein Monat keine feste Anzahl von irgendetwas ist. Das ist eine vertretbare Entscheidung, bedeutet aber, dass Kalenderarithmetik („drei Monate zum 31. Januar addieren“) dein Problem wird. Jiffs Typ Span geht den anderen Weg: Er hält gemischte Einheiten von Jahren bis Nanosekunden, und die Arithmetik löst sich kalenderbewusst auf. Ein Monat zum 31. Januar addiert ergibt den 28. Februar (oder 29.), nicht den 3. März. Einen Tag zu einem zonierten Datetime in der Nacht vor einem Sommerzeitwechsel zu addieren, ergibt einen Kalendertag, der 23 oder 25 Stunden haben kann – was ein Mensch meint, wenn er „morgen zur gleichen Uhrzeit“ sagt.

Diese Unterscheidung – verstrichene Zeit versus Kalenderzeit – ist das am meisten verwechselte Konzept der Datetime-Programmierung, und es wird überall verwechselt. Javas ursprüngliches java.util.Date vermischte beides; das java.time-Paket aus Java 8 (selbst von Joda-Time inspiriert) trennte Duration von Period und war dadurch besser. Auch der JavaScript-Vorschlag Temporal trifft diese Trennung. Jiff steht in dieser Linie ganz selbstverständlich: Die guten Ideen im Datetime-Design konvergieren seit zwanzig Jahren, und Jiff ist im Grunde die Rust-Umsetzung dieses Konsenses – ähnlich wie lange gereifte Sprachfeatures in Rust schließlich als destillierte Fassung eines Jahrzehnts Debatte ankommen.

Dazu kommt ein „freundliches“ Dauerformat – Zeichenketten wie 2h 30m oder P1DT2H lassen sich natürlich parsen und ausgeben – sowie Formatierung im Stil von strptime/strftime und optionale ICU4X-Integration für lokalisierte Ausgaben. Das klingt nach Grundausstattung, aber wer schon einmal einen eigenen chrono-Formatstring für eine Log-Pipeline geschrieben hat, weiß, wie viel Reibung das entfernt.

Jiff vs Chrono: Wann welche Bibliothek gewinnt

Genug Rundgang. Hier ist der ehrliche Vergleich, mit einer klaren Meinung dazu.

Wo chrono weiterhin gewinnt

Trägheit ist ein Feature. Chrono steckt im Abhängigkeitsbaum eines enormen Teils des Rust-Ökosystems, taucht in unzähligen öffentlichen APIs auf und wird verlässlich gepflegt. Wenn deine Codebasis bereits fließend chrono spricht, deine Zeitstempel reine UTC-Zeitpunkte sind (denk an Metrik-Pipelines, Log-Envelopes, interne RPCs) und dein Team die scharfen Kanten kennt, bringt eine Migration wenig. Chronos optionales std und seine no_std-Freundlichkeit sind zudem in Embedded-Nischen weiterhin wichtig. Und wenn du etwas Exotisches machst – Orbitalmechanik über Megajahre oder alternative Zeitskalen wie TAI oder UT1 –, ist keine der beiden Bibliotheken wirklich deine Antwort; du wirst eine davon fürs Parsen von Strings umhüllen und deine eigene Repräsentation behalten, und chrono ist an den Rändern einfach gut genug dafür.

Es gibt außerdem ein berechtigtes Gegenargument, das ich von Praktikern gehört habe: Manche schätzen chronos Explizitheit. LocalResult::Ambiguous zwingt dich nachzudenken. Wenn in deiner Domäne ein falsch geratener DST-Fold rechtliche oder finanzielle Folgen hat – Lohnabrechnung, Energieabrechnung, Handel –, willst du vielleicht, dass die Bibliothek grundsätzlich nicht rät. Jiff unterstützt das über unambiguous(), aber chrono macht es zum Weg des geringsten Widerstands. Fair genug.

Wo Jiff gewinnt

Fast überall sonst. Jede Anwendung, die mit Zivilzeit zu tun hat – Terminplanung, Kalender, nutzerseitige Datumsangaben, alles, was Zeitzonen überschreitet –, profitiert deutlich von Jiff. Die Typnamen vermitteln die Domäne. DST-Mehrdeutigkeit bekommt einen vernünftigen Standard mit typisierten Ausstiegsmöglichkeiten, statt eines Enums, das du um 2 Uhr nachts falsch behandelst. Span rechnet Kalenderarithmetik von Haus aus korrekt. Parsen und Formatieren decken die freundlichen Formate ab, die Menschen tatsächlich schreiben. Und die 1.0-Zusage zählt: Gallant hat erklärt, die API dauerhaft stabil halten zu wollen, damit Jiff in den öffentlichen APIs anderer Bibliotheken auftauchen kann – genau die Eigenschaft, die chrono-Fehler dauerhaft machte. Die Adoptionsliste untermauert diesen Anspruch bereits: uv, Cargo, Starship, fd, Nushell, Jujutsu und uutils nutzen sie, und AWS' LLRT hat seine Temporal-Implementierung darauf aufgebaut.

Die Frage nach der Performance kommt immer, also vorab: Beide Bibliotheken sind schnell genug, dass Datetime-Verarbeitung nie der Engpass ist. Jiff bündelt eine komprimierte Kopie der IANA-tz-Datenbank (mit einer dokumentierten, durchdachten Haltung zum Einsatz von rearguard-tzdata) oder kann die Zonendatenbank des Systems nutzen. Hier wiegt Korrektheit so viel schwerer als Mikrobenchmarks, dass eine Wahl nach Geschwindigkeit fahrlässig wäre. Eine falsche Antwort in 50 Nanosekunden bleibt falsch.

Eine Datetime-Bibliothek, die dich Mehrdeutigkeit überall selbst behandeln lässt, ist nicht ehrlicher – sie lagert ihr schwierigstes Problem an die Person aus, die am schlechtesten dafür gerüstet ist: dich, an einer Aufrufstelle, in Eile.

Die größere Lehre für API-Design

Lässt man die Datumsangaben beiseite, ist Jiff eine Fallstudie für ein breiteres Argument: Bibliotheken sollten Domänenkomplexität kapseln, statt sie treu weiterzureichen. Die IANA-Zeitzonendatenbank ist, wie Kritiker zu Recht anmerken, ein programmiererorientiertes Artefakt – ortsbasiert, historisch erschöpfend, voller Kennungen, die kein Nutzer jemals tippen würde. Eine bequeme Bibliothek legt das roh offen und nennt es Flexibilität. Eine gute nimmt es auf: Standard-Strategien für die Auflösung von Mehrdeutigkeiten, freundliches Parsen, Typnamen, die menschlichen Konzepten entsprechen. Dieselbe Spannung findest du in anderen Bereichen – die Lücke zwischen einer Spezifikation und einer brauchbaren Implementierung ist der Ort, an dem die meisten Bugs leben, und Datetime-Verarbeitung ist der natürliche Lebensraum dieser Lücke.

Es ist auch eine Geschichte von Geduld im Ökosystem. Rust wartete ein Jahrzehnt auf seine „endgültige“ Datetime-Bibliothek, so wie es auf die Stabilisierung von async oder des Never-Typs wartete. Das Warten ist der Preis dafür, das Modell richtig zu machen, statt den ersten funktionierenden Entwurf festzuschreiben. Chrono war kein Fehlschlag – es war der Entwurf, den das Ökosystem damals brauchte. Aber Entwürfe werden überarbeitet.

Die Empfehlung

Neues Rust-Projekt? Nimm Jiff. Denk nicht zu lange darüber nach. Die API ist besser, die DST-Behandlung standardmäßig sicherer, die 1.0-Stabilitätszusage ist explizit, und die Dynamik im Ökosystem – Cargo und uv übernehmen Crates nicht leichtfertig – bedeutet, dass du ihm ohnehin zunehmend begegnen wirst. Nutze ZonedDateTime für alles, was Nutzer sehen, Timestamp für Speicherung und Wire-Formate und die civil-Typen, wenn ein Ort wirklich keine Rolle spielt.

Bestehende chrono-Codebasis, die funktioniert? Bleib dabei, es sei denn, du arbeitest an Funktionen mit viel Zivilzeit, bei denen chronos Fallstricke dich aktiv Zeit kosten. Die beiden Bibliotheken arbeiten über Zeitstempel und ISO-Strings problemlos zusammen. Teilweise Migration – Jiff für das Scheduling-Modul, chrono überall sonst – ist deshalb eine legitime Strategie und kein Kompromiss.

Die tiefere Erkenntnis, egal wofür du dich entscheidest: Datetime-Verarbeitung ist schwer, weil die Domäne grundsätzlich eigentümlich ist – Schaltsekunden, Folds, Lücken, Monate mit variabler Länge, politische Zonen, die per Dekret wechseln. Das Beste, was eine Bibliothek tun kann, ist, die richtigen Standards zu wählen, Dinge ehrlich zu benennen und die Ausstiegsmöglichkeiten griffbereit zu halten. Jiff tut alle drei. Zwanzig Jahre Entwicklung von Datetime-Bibliotheken, von Joda-Time über java.time bis Temporal, sind aus gutem Grund auf dasselbe Modell gekommen. Schön, dass Rust endlich seine Version bekommt.