Jiff vs Chrono: какая библиотека datetime в Rust лучше
Jiff vs chrono для работы с датами в Rust: DST, эргономика API и когда выбрать каждую библиотеку. Пишем от тех, кто обжёгся на обеих.

Каждые пару лет какой-нибудь бедолага обнаруживает, что 2026-11-01 01:30 в Нью-Йорке случается дважды, и его планировщик запустил биллинг-задачу на час раньше. Ошибки с датами не роняют программу, они тихо портят данные. Поэтому выход Jiff 1.0, новой библиотеки для работы с датами и временем в Rust от Эндрю Галланта (известного по ripgrep), интересен не просто очередным релизом крейта. Он ставит реальный вопрос: Jiff vs chrono, что выбрать для следующего проекта на Rust?
Краткая история болей с датами в Rust
Rust уже проходил через это, и история поучительна. Chrono появился в эпоху до 1.0, когда его вынесли из стандартной библиотеки вместе с time в рамках большой чистки «right-size std». Почти десятилетие он был ответом по умолчанию. В целом работал. Но его API обрастал слоями: NaiveDateTime, DateTime<Utc>, DateTime<Local>, DateTime<FixedOffset>, трейт TimeZone, с которым большинство людей работает только через две реализации. Система типов позволяла делать много бессмысленных вещей, например прибавить наивную дату к дате с зоной и уверенно получить неверный ответ.
История поддержки тоже важна. Chrono пережил период фактической заброшенности, а позже его сопровождающие описывали, как трудно было двигаться вперёд, когда пользователи относились к стабильности API как к святыне. Один из бывших мейнтейнеров сказал прямо: каждый маленький шаг к улучшению встречал сопротивление, потому что главным достоинством chrono стала стабильность, а не дизайн. Это ловушка, в которую может попасть любая долгоживущая библиотека: установленная база пользователей становится продуктом. Крейт time пошёл другим путём с более чистым ядром, но годами откладывал полноценную работу с часовыми поясами. Тем временем экосистема продолжала выпускать приложения, где вопрос «который сейчас час в Берлине в следующем марте» критически важен.
Это старая идея, на которую опирается Jiff, называет он её или нет: философия «pit of success», которую Рико Мариани описывал для дизайна API ещё в середине 2000-х. Сделайте правильный путь самым простым. Галлант считает, что сложность работы с датами возникает из-за плохого моделирования предметной области, а библиотеки, которые перекладывают неоднозначность на пользователя («вот наивная дата, удачи»), отдают самую трудную задачу на аутсорсинг. Та же логика лежит в основе модели владения в Rust: машина должна брать сложность на себя, чтобы человеку не приходилось.
Как Jiff моделирует время: луковица
Ключевой дизайнерский ход Jiff — то, что Галлант называет луковицей дат. Слои от центра наружу:
civil::Date— григорианская дата без привязки к месту. Ваш день рождения — как раз такая.civil::Time— время по настенным часам с наносекундной точностью, без места.civil::DateTime— дата плюс время, всё ещё без места. Это то, что в chrono называется naive.Timestamp— однозначный момент времени, наносекунды от Unix-эпохи.TimeZone— правила, которые связывают моменты времени и гражданское время в регионе.ZonedDateTime— всё вместе: момент, гражданское время и зона.
Выигрыш в том, что названия типов совпадают с моделью, которая уже есть в голове. Timestamp — то, что вы получаете из базы данных или системного вызова. civil::DateTime — то, что человек пишет в приглашении на встречу. Перевести одно в другое без часового пояса нельзя, и Jiff делает это преобразование явным, потенциально неудачным и с указанием зоны. Сравните с chrono: там то же различие существует, но его легко размыть. NaiveDateTime::and_utc() спокойно приписывает зону настенному времени, не спрашивая, существовало ли оно вообще.
Эргономика намеренно мягкая. Зонированную дату можно построить с любой стороны, из гражданского времени плюс зона или из timestamp плюс зона, и API пойдёт навстречу:
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(())
}
Переход на летнее время: где Jiff доказывает свою ценность
Вот сценарий, который отделяет взрослых от детей в дизайне библиотек для дат. 1 ноября 2026 года в Нью-Йорке часы переводятся назад в 2 ночи. Час с 1 до 2 наступает дважды. Так что делать, когда пользователь вводит «1:30 ночи 1 ноября»? Ответ chrono исторически таков: LocalResult, перечисление, которое может быть Single, Ambiguous или None. Поразительно много боевого кода его либо распаковывает, либо отбрасывает, либо неправильно обрабатывает через сопоставление с образцом. Неоднозначность видна, но и бремя её обработки лежит на вас каждый раз.
Ответ Jiff: выбрать разумное поведение по умолчанию и сделать альтернативы одним вызовом метода. Стратегия по умолчанию, «compatible», разрешает fold в более раннее вхождение, так же как большинство календарных программ и все основные операционные системы. Но если вам важно, полное дерево решений доступно:
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(())
}
С пропусками (gaps) та же история: когда часы переводятся вперёд и 2:30 ночи не наступает, Jiff по умолчанию сдвигает время вперёд, и это тоже можно переопределить. Дизайнерское решение здесь принципиальное и, по-моему, верное. Большинство кода, который обрабатывает неоднозначные времена, не имеет политики: у него есть баг, который ждёт ноября. Поведение по умолчанию, которое пользователи уже ожидают от телефонов, плюс видимые и типизированные лазейки и есть «pit of success» на практике. Похожая философия лежит в основе хороших значений по умолчанию в самописной арифметике дат: правила выучиваются, но не стоит выводить их заново в каждом месте вызова.

Интервалы, длительности и проблема «одного месяца»
Попросите chrono длительность «один месяц», и будете разочарованы: его Duration — это фиксированное количество секунд, потому что месяц не является фиксированным количеством чего бы то ни было. Это обоснованный дизайн, но тогда арифметика календаря («прибавить три месяца к 31 января») становится вашей проблемой. Тип Span в Jiff идёт другим путём: он хранит смешанные единицы от лет до наносекунд, и арифметика учитывает календарь. Прибавление одного месяца к 31 января даёт 28 (или 29) февраля, а не 3 марта. Прибавление одного дня к зонированной дате накануне перехода на летнее время добавляет календарный день, в котором может быть 23 или 25 часов. Именно это человек имеет в виду, когда говорит «то же время завтра».
Различие между прошедшим и календарным временем — самое путаное понятие в программировании с датами, и путают его повсеместно. Исходный java.util.Date в Java их смешивал; java.time из Java 8 (сам построенный по образцу Joda-Time) разделил Duration и Period и от этого только выиграл. Предложение Temporal для JavaScript делает то же разделение. Jiff уверенно вписывается в эту традицию: хорошие идеи в дизайне дат сходились двадцать лет, и Jiff по сути является выражением этого консенсуса на Rust, как давно вынашиваемые фичи языка Rust, которые в итоге появляются как выжимка из десятилетия споров.
Есть и «дружелюбный» формат длительностей: строки вроде 2h 30m или P1DT2H парсятся и печатаются естественно. Плюс форматирование в стиле strptime/strftime и опциональная интеграция с ICU4X для локализованного вывода. Это звучит как базовый минимум, но тот, кто писал самодельную строку формата chrono для логов, знает, сколько трения это убирает.
Jiff vs Chrono: когда побеждает каждый
Хватит экскурсий. Вот честное сравнение, с моей точкой зрения.
Где chrono всё ещё выигрывает
Инерция тоже свойство. Chrono есть в дереве зависимостей огромной части экосистемы Rust, фигурирует во множестве публичных API и поддерживается надёжными руками. Если ваша кодовая база уже свободно говорит на chrono, временные метки — это только UTC-моменты (метрики, конверты логов, внутренний RPC), а команда знает его острые углы, миграция принесёт мало пользы. Опциональный std и дружественность к no_std у chrono тоже важны во встраиваемых системах. А если вы делаете что-то экзотическое, например орбитальную механику на мегагодовых масштабах или работаете с альтернативными шкалами времени вроде TAI или UT1, ни одна из библиотек не станет решением: вы будете оборачивать одну из них для парсинга строк и держать собственное представление, а простота chrono на краях для этого подходит.
Есть и законный контраргумент, который я слышал от практиков: некоторые всерьёз предпочитают явность chrono. LocalResult::Ambiguous заставляет думать. Если ваш домен такой, что ошибка в догадке о переходе на летнее время грозит юридическими или финансовыми последствиями (расчёт зарплаты, энергетические расчёты, трейдинг), возможно, вы хотите, чтобы библиотека всегда отказывалась угадывать. Jiff поддерживает это через unambiguous(), но chrono делает этот путь самым лёгким. Справедливо.
Где выигрывает Jiff
Почти везде в остальных местах. Любое приложение, которое работает с гражданским временем (расписания, календари, даты для пользователя, всё, что пересекает часовые пояса), получает от Jiff заметно лучшие условия. Названия типов обучают предметной области. Неоднозначность DST получает разумное значение по умолчанию с типизированными лазейками вместо перечисления, которое вы обработаете неправильно в 2 ночи. Span правильно считает календарную арифметику из коробки. Парсинг и форматирование покрывают дружелюбные форматы, которые люди реально пишут. И обязательство версии 1.0 важно: Галлант заявил о намерении держать API стабильным бессрочно, именно чтобы Jiff мог появляться в публичных API других библиотек, то самое свойство, которое сделало ошибки chrono постоянными. Список внедрений уже подтверждает этот замысел: uv, Cargo, Starship, fd, Nushell, Jujutsu и uutils используют его, а LLRT от AWS построен на нём как реализация Temporal.
Вопрос о производительности, который всегда кто-нибудь задаёт: обе библиотеки достаточно быстры, чтобы работа с датами никогда не была узким местом. Jiff включает сжатую копию базы часовых поясов IANA (с документированной и продуманной позицией насчёт rearguard tzdata) или может использовать системную базу зон. Это та область, где корректность важнее микробенчмарков с таким большим отрывом, что выбирать по скорости было бы халатностью. Неверный ответ за 50 наносекунд всё равно неверен.
Библиотека дат, которая заставляет вас обрабатывать неоднозначность везде, не более честна. Она просто перекладывает самую трудную задачу на того, кто меньше всего к ней готов: на вас, в каком-нибудь месте вызова, в спешке.
Главный урок для дизайна API
Если убрать даты, Jiff становится примером более широкого аргумента: библиотеки должны инкапсулировать сложность предметной области, а не аккуратно её реэкспортировать. База часовых поясов IANA, как справедливо замечают критики, это артефакт для программистов: основанный на локациях, исторически исчерпывающий, полный идентификаторов, которые ни один пользователь никогда не напечатает. Ленивая библиотека выставляет это как есть и называет гибкостью. Хорошая поглощает сложность: разумные стратегии разрешения неоднозначности по умолчанию, дружелюбный парсинг, названия типов, которые соответствуют человеческим понятиям. Ту же напряжённость видно и в других областях: разрыв между спецификацией и пригодной реализацией это место, где живёт большинство багов, а работа с датами, естественная среда обитания этого разрыва.
Это также история о терпении экосистемы. Rust ждал десятилетие своей «окончательной» библиотеки для дат, так же как ждал годами, пока устаканится async или стабилизируется never type. Ожидание цена за правильную модель, а не закрепление первого рабочего черновика. Chrono не был провалом: он был тем черновиком, который экосистеме тогда был нужен. Но черновики пересматривают.
Рекомендация
Новый проект на Rust? Берите Jiff, не усложняйте. API лучше, обработка DST безопаснее по умолчанию, обязательство стабильности версии 1.0 явное, а импульс экосистемы (Cargo и uv не принимают крейты легкомысленно) означает, что вы всё равно будете всё чаще с ним сталкиваться. Используйте ZonedDateTime для всего, что видит пользователь, Timestamp для хранения и форматов передачи, а типы civil когда локация действительно не применима.
Есть рабочая кодовая база на chrono? Оставайтесь на месте, если только вы не трогаете функции, сильно завязанные на гражданское время, где ловушки chrono реально вам обходятся. Две библиотеки хорошо взаимодействуют через временные метки и строки ISO, так что частичный переход (Jiff для модуля расписаний, chrono везде остальные) это законная стратегия, а не компромисс.
Более глубокий вывод, что бы вы ни выбрали: работа с датами трудна, потому что предметная область неустранимо странная. Високосные секунды, fold и gap, месяцы переменной длины, политические зоны, которые меняются по указу. Лучшее, что может сделать библиотека, это выбрать правильные значения по умолчанию, честно называть вещи и держать лазейки рядом. Jiff делает все три. Двадцатилетняя эволюция библиотек дат, от Joda-Time через java.time до Temporal, сошлась к одной и той же модели не случайно. Приятно видеть, что Rust наконец получил свою версию.


