Jiff vs Chrono: cuál librería de fechas de Rust gana
Jiff vs chrono para manejo de fechas en Rust: casos límite del horario de verano, ergonomía de la API y cuándo gana cada librería.

Cada pocos años, algún ingeniero desafortunado descubre que 2026-11-01 01:30 en Nueva York ocurre dos veces, y que su planificador acaba de ejecutar el job de facturación una hora antes. Los errores de fecha no hacen caer tu programa: corrompen tus datos en silencio. Por eso la llegada de Jiff 1.0, una nueva librería de fechas para Rust de Andrew Gallant (el de ripgrep), importa más que otra versión de un crate. Plantea una pregunta real: Jiff vs chrono, ¿cuál deberías usar en tu próximo proyecto en Rust?
Breve historia del dolor con las fechas en Rust
Rust ya ha pasado por esto, y la historia es instructiva. Chrono nació en la era previa a la 1.0 del lenguaje, cuando se separó de la biblioteca estándar junto con time como parte de la gran limpieza de 'right-size std'. Durante casi una década fue la respuesta por defecto. Funcionaba, más o menos. Pero su API fue acumulando capas: NaiveDateTime, DateTime<Utc>, DateTime<Local>, DateTime<FixedOffset>, un trait TimeZone que la mayoría de la gente solo usa a través de dos implementaciones. El sistema de tipos te permitía hacer muchas cosas sin sentido semántico, como sumar un datetime sin zona a uno con zona y obtener un resultado seguro de sí mismo pero incorrecto.
La historia de mantenimiento también importa. Chrono atravesó un periodo de abandono efectivo, y hasta sus mantenedores posteriores describen la experiencia como empujar contra una estabilidad de API que los usuarios tratan como sagrada. Un antiguo mantenedor lo resumió sin rodeos: cada pequeño paso hacia la mejora encontraba resistencia, porque el principal atractivo de chrono se había vuelto su estabilidad, no su diseño. Es una trampa en la que puede caer cualquier librería longeva: la base instalada acaba convirtiéndose en el producto. La crate time probó otro enfoque con un núcleo más limpio, pero durante años dejó de lado el manejo completo de zonas horarias. Mientras tanto, el ecosistema seguía publicando aplicaciones donde '¿qué hora será en Berlín el próximo marzo?' es una pregunta crítica.
Esta es la vieja idea en la que se apoya Jiff, lo nombre o no: la filosofía del 'pit of success' que Rico Mariani describió para el diseño de APIs a mediados de los 2000. Haz que el camino fácil sea el camino correcto. El planteamiento de Gallant es que la dificultad con las fechas viene de un modelado de dominio pobre, y que las librerías que trasladan la ambigüedad al usuario ('aquí tienes un datetime sin zona, suerte') están delegando su problema más difícil. Es el mismo instinto que hay detrás del modelo de propiedad de Rust: que la máquina absorba la complejidad para que la persona no tenga que hacerlo.
Cómo Jiff modela el tiempo: la cebolla
El movimiento de diseño central de Jiff es lo que Gallant llama la cebolla de datetime. Las capas, de dentro hacia fuera:
civil::Date: una fecha gregoriana, sin ubicación asociada. Tu cumpleaños es uno de estos.civil::Time: una hora de reloj con precisión de nanosegundos, sin ubicación.civil::DateTime: fecha y hora, todavía sin ubicación. Esto es lo que chrono llama naive.Timestamp: un instante inequívoco, nanosegundos desde la época Unix.TimeZone: las reglas que mapean instantes y hora civil en una región.ZonedDateTime: todo junto: instante, hora civil y zona.
La recompensa es que los nombres de los tipos coinciden con el modelo mental que ya tienes. Un Timestamp es lo que obtienes de una base de datos o de una llamada al sistema. Un civil::DateTime es lo que una persona escribe en una invitación de calendario. Convertir entre ambos es imposible sin una zona horaria, y Jiff hace de esa conversión una operación explícita, falible y anotada con la zona. Compara con chrono, donde existe la misma distinción pero es más fácil de difuminar: NaiveDateTime::and_utc() asignará alegremente una zona a una hora de reloj sin preguntar si esa hora de reloj llegó a existir.
La ergonomía es deliberadamente amable. Puedes construir un datetime con zona desde cualquiera de las dos direcciones (hora civil más zona, o timestamp más zona), y la API te recibe en ambos casos:
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(())
}
Horario de verano: donde Jiff se gana su sitio
Este es el escenario que separa a los adultos de los niños en el diseño de librerías de fechas. El 1 de noviembre de 2026, los relojes de Nueva York retroceden a las 2 AM. La hora de la 1 AM ocurre dos veces. Entonces, cuando un usuario escribe '1:30 AM del 1 de noviembre', ¿qué haces? La respuesta histórica de chrono ha sido LocalResult: un enum que puede ser Single, Ambiguous o None, y una cantidad sorprendente de código en producción lo desenvuelve, lo descarta o lo compara mal con pattern matching. La ambigüedad queda expuesta, pero también la carga de manejarla, cada vez.
La respuesta de Jiff es elegir un valor por defecto sensato y dejar las alternativas a una llamada de distancia. La estrategia por defecto, 'compatible', resuelve un fold a la ocurrencia anterior, igual que hace la mayoría del software de calendario y todos los sistemas operativos principales. Pero si te importa, el árbol completo de decisiones está ahí:
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(())
}
Los huecos reciben el mismo tratamiento: cuando los relojes saltan hacia adelante y las 2:30 AM nunca llegan, Jiff ajusta hacia adelante por defecto, y de nuevo puedes sobrescribirlo. La decisión de diseño es opinable y, creo, acertada. La mayoría del código que maneja horas ambiguas no tiene una política: tiene un bug esperando a noviembre. Adoptar el comportamiento que los usuarios ya esperan de sus teléfonos, mientras las salidas de emergencia siguen visibles y tipadas, es exactamente lo que significa 'pit of success' en la práctica. Es una filosofía parecida a la de los buenos valores por defecto en la aritmética de fechas hecha a mano: las reglas se pueden aprender, pero no deberías tener que deducirlas en cada punto de llamada.

Spans, duraciones y el problema del 'un mes'
Pídele a chrono una duración de 'un mes' y te decepcionará: su Duration es una cantidad fija de segundos, porque un mes no es una cantidad fija de nada. Es un diseño defendible, pero significa que la aritmética de calendario ('sumar tres meses al 31 de enero') se convierte en tu problema. El tipo Span de Jiff toma el otro camino: almacena unidades mezcladas desde años hasta nanosegundos, y la aritmética se resuelve de forma consciente del calendario. Sumar un mes al 31 de enero da 28 de febrero (o 29), no 3 de marzo. Sumar un día a un datetime con zona la noche anterior a una transición de horario de verano suma un día de calendario, que puede durar 23 o 25 horas, que es lo que una persona quiere decir cuando dice 'a la misma hora mañana'.
Esta distinción entre tiempo transcurrido y tiempo de calendario es el concepto más confuso de la programación con fechas, y se confunde en todas partes. El java.util.Date original de Java los mezclaba; el paquete java.time de Java 8 (inspirado en Joda-Time) separó Duration de Period y salió ganando. La propuesta Temporal de JavaScript hace la misma división. Jiff encaja cómodamente en esa línea: las buenas ideas en el diseño de fechas llevan veinte años converger, y Jiff es esencialmente la expresión en Rust de ese consenso, igual que las funcionalidades del lenguaje Rust que tardan mucho en gestarse acaban llegando como la versión destilada de una década de debate.
También existe un formato de duración 'amigable': cadenas como 2h 30m o P1DT2H se parsean e imprimen de forma natural, además de formateo estilo strptime/strftime e integración opcional con ICU4X para salida sensible al idioma. Suena a lo mínimo indispensable, pero cualquiera que haya escrito una cadena de formato de chrono a medida para un pipeline de logs sabe cuánta fricción eliminan.
Jiff vs Chrono: cuándo gana cada uno
Basta de recorrido. Aquí tienes la comparación honesta, con un punto de vista incluido.
Dónde sigue ganando chrono
La inercia también es una característica. Chrono está en el árbol de dependencias de una enorme parte del ecosistema de Rust, aparece en innumerables APIs públicas y lo mantiene una mano fiable. Si tu base de código ya habla chrono con fluidez, tus timestamps son instantes solo en UTC (piensa en pipelines de métricas, envoltorios de logs, RPC internas) y tu equipo conoce sus aristas, migrar te aporta poco. La postura de chrono, opcional con std y amigable con no_std, también importa en rincones embebidos. Y si estás haciendo algo exótico, como mecánica orbital a escala de megaaños o escalas de tiempo alternativas como TAI o UT1, ninguna de las dos librerías es realmente tu respuesta: envolverás una de ellas para parsear cadenas y mantendrás tu propia representación, y la simplicidad de chrono en los bordes basta para eso.
También hay un contrapunto legítimo que he visto de otros profesionales: a algunos les gusta de verdad la explicitud de chrono. LocalResult::Ambiguous te obliga a pensar. Si tu dominio es uno en el que adivinar mal un fold de horario de verano tiene consecuencias legales o financieras (nóminas, liquidación energética, trading), quizá quieras que la librería se niegue a adivinar, siempre. Jiff lo permite mediante unambiguous(), pero chrono lo convierte en el camino de menor resistencia. Justo.
Dónde gana Jiff
Casi en todo lo demás. Cualquier aplicación que toque la hora civil (programación, calendarios, fechas de cara al usuario, cualquier cosa que cruce zonas horarias) sale mejor parada con Jiff. Los nombres de los tipos enseñan el dominio. La ambigüedad del horario de verano tiene un valor por defecto sensato con salidas de emergencia tipadas, en lugar de un enum que manejarás mal a las 2 AM. Span hace bien la aritmética de calendario desde el primer momento. El parseo y el formateo cubren los formatos amigables que las personas escriben de verdad. Y el compromiso de la 1.0 importa: Gallant ha declarado la intención de mantener la API estable indefinidamente precisamente para que Jiff pueda aparecer en las APIs públicas de otras librerías, la propiedad exacta que volvió permanentes los errores de chrono. La lista de adopción ya respalda esa ambición: uv, Cargo, Starship, fd, Nushell, Jujutsu y uutils lo usan, y LLRT de AWS construyó su implementación de Temporal sobre él.
La pregunta de rendimiento, porque alguien siempre la hace: ambas librerías son lo bastante rápidas como para que el manejo de fechas nunca sea tu cuello de botella. Jiff incluye una copia compacta de la base de datos de zonas horarias de IANA (con una postura documentada y reflexiva sobre el uso de tzdata rearguard) o puede usar la base de datos de zonas del sistema. Este es un dominio donde la corrección supera a los microbenchmarks por tanto margen que elegir según la velocidad sería una negligencia profesional. Una respuesta incorrecta en 50 nanosegundos sigue siendo incorrecta.
Una librería de fechas que te obliga a manejar la ambigüedad en todas partes no es más honesta: simplemente delega su problema más difícil en la persona menos preparada para resolverlo, tú, en un punto de llamada, con prisa.
La lección mayor para el diseño de APIs
Quitando las fechas, Jiff es un caso de estudio de un argumento más amplio: las librerías deberían encapsular la complejidad del dominio en lugar de reexportarla fielmente. La base de datos de zonas horarias de IANA es, como señalan con razón los críticos, un artefacto orientado al programador: basado en ubicaciones, históricamente exhaustivo, lleno de identificadores que ningún usuario escribiría jamás. Una librería perezosa lo expone tal cual y lo llama flexibilidad. Una buena lo absorbe: estrategias de desambiguación por defecto, parseo amigable, nombres de tipos que corresponden a conceptos humanos. Verás la misma tensión en otros dominios: la brecha entre una especificación y una implementación utilizable es donde vive la mayoría de los bugs, y el manejo de fechas es el hábitat natural de esa brecha.
También es una historia sobre la paciencia del ecosistema. Rust esperó una década por su biblioteca 'definitiva' de fechas, igual que esperó años a que async se asentara o a que el never type se estabilizara. La espera es el precio de acertar con el modelo en lugar de fijar el primer borrador que funcionaba. Chrono no fue un fracaso: fue el borrador que el ecosistema necesitaba en su momento. Pero los borradores se revisan.
La recomendación
¿Proyecto nuevo en Rust? Usa Jiff. No le des demasiadas vueltas. La API es mejor, el manejo de horario de verano es más seguro por defecto, el compromiso de estabilidad de la 1.0 es explícito, y el impulso del ecosistema (Cargo y uv no adoptan crates a la ligera) significa que te lo encontrarás cada vez más de todos modos. Usa ZonedDateTime para todo lo que vea el usuario, Timestamp para almacenamiento y formatos de transmisión, y los tipos civil cuando la ubicación realmente no aplique.
¿Base de código con chrono que funciona? Quédate donde estás, a menos que estés tocando funcionalidades muy cargadas de hora civil donde las trampas de chrono te estén costando de verdad. Las dos librerías interoperan bien a través de timestamps y cadenas ISO, así que la adopción parcial (Jiff para el módulo de programación, chrono en el resto) es una estrategia legítima y no un compromiso.
La conclusión más profunda, elijas lo que elijas: manejar fechas es difícil porque el dominio es irreduciblemente extraño: segundos intercalares, folds, gaps, meses de duración variable, zonas políticas que cambian por decreto. Lo mejor que puede hacer una librería es elegir los valores por defecto correctos, nombrar las cosas con honestidad y mantener cerca las salidas de emergencia. Jiff hace las tres cosas. Veinte años de evolución de librerías de fechas, desde Joda-Time pasando por java.time hasta Temporal, convergieron en el mismo modelo por una razón. Es bonito ver que Rust por fin tiene su versión.


