Des articles approfondis sur les technologies qui façonnent l'avenir.

Jiff vs Chrono : quelle bibliothèque datetime Rust gagne

Jiff vs chrono en Rust : heure d'été, ergonomie de l'API et quand choisir chaque bibliothèque datetime, par un développeur brûlé par les deux camps.

Deux horloges stylisées qui se chevauchent, l'une mécanique et l'autre organique, évoquant les transitions de fuseaux horaires.
Les bugs de dates ne font presque jamais planter quoi que ce soit : ils vous donnent simplement la mauvaise heure, discrètement.

Tous les quelques années, un développeur découvre que 2026-11-01 01:30 à New York se produit deux fois, et que son planificateur a lancé le job de facturation une heure trop tôt. Les bugs de dates ne font pas planter vos programmes : ils corrompent vos données en silence. C'est pourquoi l'arrivée de Jiff 1.0, une nouvelle bibliothèque datetime pour Rust signée Andrew Gallant (celui de ripgrep), compte plus qu'une simple sortie de crate. Elle pose une vraie question : Jiff vs chrono, lequel devriez-vous utiliser pour votre prochain projet Rust ?

Brève histoire des galères de dates en Rust

Rust a déjà connu ce problème, et son histoire est instructive. Chrono remonte à l'époque pré-1.0 du langage, quand il a été extrait de la bibliothèque standard avec time, dans le cadre du grand nettoyage de std. Pendant presque une décennie, c'était la réponse par défaut. Ça marchait, globalement. Mais son API s'est couverte de couches : NaiveDateTime, DateTime<Utc>, DateTime<Local>, DateTime<FixedOffset>, un trait TimeZone que la plupart des gens n'utilisent qu'à travers deux implémentations. Le système de types laissait faire pas mal de choses dépourvues de sens sémantique, comme additionner un datetime naïf à un datetime zoné et obtenir un résultat faux, mais avec assurance.

L'histoire de la maintenance compte aussi. Chrono a traversé une période d'abandon de fait, et même ses mainteneurs les plus récents ont décrit une situation où chaque petite amélioration se heurtait à une résistance, car la principale qualité de chrono était devenue sa stabilité, pas sa conception. C'est un piège dans lequel peut tomber toute bibliothèque ancienne : la base installée finit par devenir le produit. La crate time a tenté une autre approche, avec un cœur plus propre, mais a repoussé pendant des années la gestion complète des fuseaux horaires. Pendant ce temps, l'écosystème continuait de livrer des applications pour lesquelles « quelle heure sera-t-il à Berlin en mars prochain » est une question centrale.

C'est l'ancienne idée sur laquelle s'appuie Jiff, qu'il la nomme ou non : la philosophie « pit of success » que Rico Mariani a décrite pour la conception d'API au milieu des années 2000. Faites en sorte que le chemin facile soit aussi le chemin correct. Gallant part du principe que les difficultés liées aux dates viennent d'une mauvaise modélisation du domaine, et que les bibliothèques qui reportent l'ambiguïté sur l'utilisateur, du genre « voici un datetime naïf, bonne chance », externalisent leur problème le plus difficile. C'est le même réflexe que le modèle d'ownership de Rust : la machine doit absorber la complexité pour que l'humain n'ait pas à le faire.

Comment Jiff modélise le temps : l'oignon

Le choix de conception central de Jiff est ce que Gallant appelle l'oignon des dates. Les couches, de l'intérieur vers l'extérieur :

  • civil::Date : une date grégorienne, sans lieu associé. Votre date de naissance est de ce type.
  • civil::Time : une heure murale avec une précision à la nanoseconde, sans lieu.
  • civil::DateTime : date et heure, toujours sans lieu. C'est ce que chrono appelle naïf.
  • Timestamp : un instant non ambigu, en nanosecondes depuis l'epoch Unix.
  • TimeZone : les règles qui font correspondre instants et heure civile dans une région.
  • ZonedDateTime : le tout réuni : instant, heure civile et fuseau.

L'intérêt, c'est que les noms de types collent au modèle mental que vous avez déjà. Un Timestamp est ce que vous obtenez d'une base de données ou d'un appel système. Un civil::DateTime est ce qu'un humain écrit dans une invitation de calendrier. Convertir l'un en l'autre est impossible sans fuseau horaire, et Jiff fait de cette conversion une opération explicite, faillible et annotée par la zone. Comparez avec chrono, où la distinction équivalente existe mais se brouille plus facilement : NaiveDateTime::and_utc() attribuera volontiers une zone à une heure murale sans se demander si cette heure a jamais existé.

L'ergonomie est volontairement douce. Vous pouvez construire un datetime zoné dans les deux sens, à partir d'une heure civile plus un fuseau, ou d'un timestamp plus un fuseau, et l'API vous accompagne dans les deux cas :

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(())
}

Heure d'été : là où Jiff se rend utile

Voici le scénario qui sépare les adultes des enfants dans la conception d'une bibliothèque datetime. Le 1er novembre 2026, les horloges de New York reculent à 2 h du matin. L'heure de 1 h se produit donc deux fois. Alors, quand un utilisateur saisit « 1 h 30 le 1er novembre », que faites-vous ? La réponse de chrono, historiquement, c'est LocalResult : une énumération pouvant valoir Single, Ambiguous ou None, que beaucoup de code en production déballe, ignore ou traite mal à coups de pattern matching. L'ambiguïté est exposée, mais le fardeau de la gérer aussi, à chaque fois.

La réponse de Jiff consiste à choisir une valeur par défaut raisonnable et à rendre les alternatives accessibles en un seul appel de méthode. La stratégie par défaut, « compatible », résout un fold vers la première occurrence, ce qui correspond à ce que font la plupart des logiciels de calendrier et tous les grands systèmes d'exploitation. Mais si vous y tenez, l'arbre de décision complet est là :

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(())
}

Les gaps sont traités de la même façon : quand les horloges avancent et que 2 h 30 n'existe jamais, Jiff décale vers l'avant par défaut, et là encore vous pouvez changer ce comportement. Le choix de conception est tranché et, à mon avis, juste. La plupart du code qui gère les heures ambiguës n'a pas de politique : il a un bug qui attend novembre. Adopter le comportement que les utilisateurs attendent déjà de leur téléphone, tout en gardant des échappatoires visibles et typées, c'est exactement ce que signifie « pit of success » en pratique. C'est une philosophie proche de celle des bons défauts dans le calcul de dates fait main : les règles s'apprennent, mais vous ne devriez pas avoir à les redériver à chaque appel.

Une frise abstraite en ruban montrant un fold où la ligne revient en arrière et un gap où elle se brise.
Folds et gaps : les deux endroits où l'heure civile cesse de correspondre proprement aux instants.

Spans, durées et le problème du « un mois »

Demandez à chrono une durée d'« un mois » et vous serez déçu : son Duration est un nombre fixe de secondes, parce qu'un mois ne correspond à aucune quantité fixe. C'est un choix défendable, mais il fait de l'arithmétique calendaire (« ajouter trois mois au 31 janvier ») votre problème. Le type Span de Jiff prend l'autre voie : il contient des unités mélangées, des années jusqu'aux nanosecondes, et l'arithmétique se résout de façon consciente du calendrier. Ajouter un mois au 31 janvier donne le 28 février (ou le 29), et non le 3 mars. Ajouter un jour à un datetime zoné la veille d'une transition d'heure d'été ajoute un jour calendaire, qui peut faire 23 ou 25 heures, ce qu'un humain entend quand il dit « même heure demain ».

Cette distinction entre temps écoulé et temps calendaire est le concept le plus confus de la programmation de dates, et il l'est partout. L'ancien java.util.Date de Java les mélangeait ; le package java.time de Java 8 (lui-même inspiré de Joda-Time) a séparé Duration et Period, et y a gagné. La proposition Temporal de JavaScript fait la même séparation. Jiff s'inscrit confortablement dans cette lignée : les bonnes idées de conception datetime convergent depuis vingt ans, et Jiff est essentiellement l'expression en Rust de ce consensus, un peu comme les fonctionnalités de Rust longtemps en gestation finissent par arriver sous forme de version distillée de dix ans de débats.

Il existe aussi un format de durée « convivial » : des chaînes comme 2h 30m ou P1DT2H se parsent et s'affichent naturellement, avec en plus un formatage de style strptime/strftime et une intégration optionnelle d'ICU4X pour les sorties sensibles à la locale. Ça semble être le minimum, mais quiconque a écrit une chaîne de format chrono sur mesure pour un pipeline de logs sait à quel point cela retire de frictions.

Jiff vs Chrono : quand chacun gagne

Assez de visite guidée. Voici la comparaison honnête, avec un point de vue assumé.

Là où chrono gagne encore

L'inertie est une fonctionnalité. Chrono se trouve dans l'arbre de dépendances d'une part énorme de l'écosystème Rust, apparaît dans d'innombrables APIs publiques et est maintenu par une main fiable. Si votre base de code parle déjà couramment chrono, si vos timestamps sont des instants UTC uniquement (pensez aux pipelines de métriques, aux enveloppes de logs, aux RPC internes) et si votre équipe connaît ses aspérités, migrer vous rapporte peu. La posture de chrono, optionnelle sur std et compatible no_std, compte toujours dans les recoins embarqués. Et si vous faites quelque chose d'exotique, comme de la mécanique orbitale à l'échelle des mégaannées ou des échelles de temps alternatives comme TAI ou UT1, aucune des deux bibliothèques n'est vraiment votre réponse : vous en envelopperez une pour le parsing de chaînes et garderez votre propre représentation, et la simplicité de chrono aux bords suffit pour cela.

Il existe aussi un contre-argument légitime, que j'ai vu défendu par des praticiens : certains préfèrent réellement l'explicitude de chrono. LocalResult::Ambiguous vous oblige à réfléchir. Si votre domaine est tel qu'une erreur sur un fold d'heure d'été a des conséquences juridiques ou financières (paie, règlement d'énergie, trading), vous voulez peut-être que la bibliothèque refuse de deviner, toujours. Jiff le permet via unambiguous(), mais chrono en fait le chemin de moindre résistance. C'est un choix qui se défend.

Là où Jiff gagne

Presque partout ailleurs. Toute application qui touche à l'heure civile (planification, calendriers, dates affichées aux utilisateurs, tout ce qui traverse des fuseaux) a tout intérêt à passer à Jiff. Les noms de types enseignent le domaine. L'ambiguïté de l'heure d'été reçoit une valeur par défaut saine, avec des échappatoires typées, au lieu d'une énumération que vous traiterez mal à 2 h du matin. Span fait correctement l'arithmétique calendaire dès la sortie de boîte. Le parsing et le formatage couvrent les formats conviviaux que les humains écrivent réellement. Et l'engagement 1.0 compte : Gallant a affirmé vouloir garder l'API stable indéfiniment, précisément pour que Jiff puisse apparaître dans les APIs publiques d'autres bibliothèques, la propriété même qui a rendu les erreurs de chrono permanentes. La liste d'adoption soutient déjà cette ambition : uv, Cargo, Starship, fd, Nushell, Jujutsu et uutils l'utilisent, et LLRT d'AWS a construit son implémentation de Temporal par-dessus.

La question des performances, puisque quelqu'un la pose toujours : les deux bibliothèques sont assez rapides pour que la gestion des dates ne soit jamais votre goulot d'étranglement. Jiff embarque une copie compactée de la base de fuseaux IANA (avec une position documentée et réfléchie sur l'usage des tzdata en rearguard) ou peut utiliser la base de fuseaux du système. C'est un domaine où l'exactitude l'emporte de si loin sur les microbenchmarks qu'un choix fondé sur la vitesse serait une faute professionnelle. Une mauvaise réponse en 50 nanosecondes reste une mauvaise réponse.

Une bibliothèque datetime qui vous oblige à gérer l'ambiguïté partout n'est pas plus honnête : elle refile simplement son problème le plus difficile à la personne la moins équipée pour le résoudre, c'est-à-dire vous, sur un call site, pressé.

La leçon plus large pour la conception d'API

Une fois les dates mises de côté, Jiff est une étude de cas d'un argument plus large : une bibliothèque doit encapsuler la complexité du domaine plutôt que de la réexporter fidèlement. La base de fuseaux horaires IANA est, comme le soulignent à juste titre les critiques, un artefact orienté programmeurs : basé sur des lieux, historiquement exhaustif, plein d'identifiants qu'aucun utilisateur ne taperait jamais. Une bibliothèque paresseuse expose tout cela brut et appelle ça de la flexibilité. Une bonne bibliothèque l'absorbe : stratégies de désambiguïsation par défaut, parsing convivial, noms de types qui correspondent à des concepts humains. On retrouve la même tension dans d'autres domaines : l'écart entre une spécification et une implémentation utilisable est là où vivent la plupart des bugs, et la gestion des dates en est l'habitat naturel.

C'est aussi une histoire de patience de l'écosystème. Rust a attendu une décennie sa bibliothèque datetime « définitive », comme il a attendu des années que l'async se stabilise ou que le never type soit stabilisé. Cette attente est le prix de la bonne modélisation, plutôt que de figer le premier brouillon fonctionnel. Chrono n'a pas été un échec : c'était le brouillon dont l'écosystème avait besoin à l'époque. Mais les brouillons se révisent.

La recommandation

Nouveau projet Rust ? Prenez Jiff. Ne réfléchissez pas trop. L'API est meilleure, la gestion de l'heure d'été est plus sûre par défaut, l'engagement de stabilité 1.0 est explicite, et la dynamique de l'écosystème (Cargo et uv n'adoptent pas les crates à la légère) fait que vous le croiserez de plus en plus de toute façon. Utilisez ZonedDateTime pour tout ce qui concerne l'utilisateur, Timestamp pour le stockage et les formats de transport, et les types civil lorsque le lieu ne s'applique vraiment pas.

Base de code chrono existante qui fonctionne ? Restez-y, sauf si vous touchez à des fonctionnalités très orientées heure civile où les pièges de chrono vous coûtent activement. Les deux bibliothèques interopèrent sans problème via les timestamps et les chaînes ISO, donc une adoption partielle (Jiff pour le module de planification, chrono partout ailleurs) est une stratégie légitime plutôt qu'un compromis.

La conclusion de fond, quel que soit votre choix : la gestion des dates est difficile parce que le domaine est irréductiblement bizarre. Secondes intercalaires, folds, gaps, mois de longueur variable, zones politiques qui changent par décret. Le mieux qu'une bibliothèque puisse faire est de choisir les bons défauts, de nommer les choses honnêtement et de garder les échappatoires à portée de main. Jiff fait les trois. Vingt ans d'évolution des bibliothèques datetime, de Joda-Time à java.time en passant par Temporal, ont convergé vers le même modèle pour une bonne raison. C'est agréable de voir enfin Rust obtenir sa version.