Artigos aprofundados sobre a tecnologia que molda o que vem a seguir.

Jiff vs Chrono: Qual Biblioteca de Datetime em Rust Vence

Jiff vs chrono em Rust: casos extremos de horário de verão, ergonomia da API e quando cada biblioteca vence, por quem já se queimou com as duas.

Dois relógios sobrepostos e estilizados, um mecânico e outro orgânico, evocando transições de fuso horário.
Bugs de datetime raramente derrubam alguma coisa — eles só te entregam a hora errada discretamente.

A cada poucos anos, algum engenheiro azarado descobre que 2026-11-01 01:30 em Nova York acontece duas vezes, e que o scheduler dele acabou de disparar o job de cobrança uma hora antes. Bugs de datetime não derrubam seu programa — eles corrompem seus dados silenciosamente. Por isso a chegada do Jiff 1.0, uma nova biblioteca de datetime para Rust criada por Andrew Gallant (do ripgrep), importa além de mais um lançamento de crate. Ela força uma pergunta real: Jiff vs chrono — qual deles seu próximo projeto em Rust deveria usar?

Uma Breve História da Dor com Datetime em Rust

O Rust já passou por isso, e a história é instrutiva. O chrono remonta à era pré-1.0 da linguagem, quando foi separado da biblioteca padrão junto com o time como parte da grande limpeza do 'right-size std'. Por quase uma década foi a resposta padrão. Funcionava, na maior parte do tempo. Mas sua API foi acumulando camadas: NaiveDateTime, DateTime<Utc>, DateTime<Local>, DateTime<FixedOffset>, um trait TimeZone que a maioria das pessoas só usa através de duas implementações. O sistema de tipos deixava você fazer muita coisa sem sentido semântico, como somar um datetime naive a um datetime com fuso e obter uma resposta confiante e errada.

A questão da manutenção também importa. O chrono passou por um período de abandono efetivo, e até seus mantenedores posteriores descreveram a experiência como lutar contra uma estabilidade de API que os usuários tratavam como sagrada. Um ex-mantenedor colocou sem rodeios: cada pequeno passo rumo a melhorias encontrava resistência, porque o principal argumento de venda do chrono tinha virado a estabilidade, não o design. Essa é uma armadilha em que qualquer biblioteca longeva pode cair — a base instalada vira o produto. O crate time tentou outra abordagem, com um núcleo mais limpo, mas por anos deixou de lado o tratamento completo de fusos horários. Enquanto isso, o ecossistema seguia entregando aplicações em que 'que horas são em Berlim em março que vem' é uma pergunta de carga estrutural.

Esta é a velha ideia em que o Jiff se apoia, nomeie-a ou não: a filosofia do 'pit of success' que Rico Mariani descreveu para design de API em meados dos anos 2000. Faça do caminho fácil o caminho correto. A tese de Gallant é que a dificuldade com datetime vem de modelagem de domínio ruim, e que bibliotecas que empurram a ambiguidade para o usuário — 'aqui está um datetime naive, boa sorte' — estão terceirizando o problema mais difícil delas. É o mesmo instinto por trás do modelo de ownership do Rust: a máquina deve absorver a complexidade para que o humano não precise.

Como o Jiff Modela o Tempo: A Cebola

A principal decisão de design do Jiff é o que Gallant chama de cebola do datetime. As camadas, de dentro para fora:

  • civil::Date — uma data gregoriana, sem local associado. Seu aniversário é um desses.
  • civil::Time — um horário de relógio com precisão de nanossegundos, sem local.
  • civil::DateTime — data mais horário, ainda sem local. É o que o chrono chama de naive.
  • Timestamp — um instante inequívoco, nanossegundos desde o Unix epoch.
  • TimeZone — as regras que mapeiam instantes e horário civil em uma região.
  • ZonedDateTime — tudo junto: instante, horário civil e fuso.

O ganho é que os nomes dos tipos batem com o modelo mental que você já tem. Um Timestamp é o que você obtém de um banco de dados ou de uma chamada de sistema. Um civil::DateTime é o que um humano escreve num convite de calendário. Converter entre eles é impossível sem um fuso horário, e o Jiff torna essa conversão uma operação explícita, falível e anotada com o fuso. Compare com o chrono, onde a mesma distinção existe, mas é mais fácil de borrar — NaiveDateTime::and_utc() atribui sem cerimônia um fuso a um horário de relógio sem perguntar se esse horário jamais existiu.

A ergonomia é deliberadamente suave. Você pode construir um datetime com fuso a partir de qualquer direção — horário civil mais fuso, ou timestamp mais fuso — e a API te encontra no meio do caminho:

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

Horário de Verão: Onde o Jiff Se Justifica

Aqui está o cenário que separa os adultos das crianças no design de bibliotecas de datetime. Em 1º de novembro de 2026, os relógios em Nova York voltam às 2h. A hora da 1h acontece duas vezes. Então, quando um usuário digita '1:30 da manhã de 1º de novembro', o que você faz? A resposta histórica do chrono é o LocalResult: um enum que pode ser Single, Ambiguous ou None, e que uma quantidade surpreendente de código de produção desempacota, descarta ou faz pattern matching de forma incorreta. A ambiguidade fica exposta — mas também o fardo de tratá-la, toda vez.

A resposta do Jiff é escolher um padrão sensato e deixar as alternativas a uma chamada de método de distância. A estratégia padrão 'compatible' resolve o fold para a ocorrência anterior — o que bate com a maioria dos softwares de calendário e com todos os principais sistemas operacionais. Mas se você se importa, a árvore completa de decisão está ali:

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

Os gaps recebem o mesmo tratamento: quando os relógios avançam e as 2h30 nunca acontecem, o Jiff empurra para frente por padrão, e mais uma vez você pode sobrescrever. A decisão de design aqui é opinativa e, acho, correta. A maior parte do código que trata horários ambíguos não tem uma política — tem um bug esperando novembro. Adotar o comportamento que os usuários já esperam do celular, mantendo as saídas de emergência visíveis e tipadas, é exatamente o que 'pit of success' significa na prática. É uma filosofia parecida com a dos bons padrões em aritmética de datas feita à mão: as regras são aprendíveis, mas você não deveria precisar re-derivá-las em cada ponto de chamada.

Uma linha do tempo abstrata em forma de fita mostrando um fold, onde ela volta sobre si mesma, e um gap, onde ela se quebra.
Folds e gaps: os dois lugares onde o horário civil deixa de mapear limpamente para instantes.

Spans, Durations e o Problema do 'Um Mês'

Peça ao chrono uma duração de 'um mês' e você vai se decepcionar — o Duration dele é uma contagem fixa de segundos, porque um mês não é uma contagem fixa de nada. É um design defensável, mas significa que a aritmética de calendário ('some três meses a 31 de janeiro') vira problema seu. O tipo Span do Jiff segue o outro caminho: ele guarda unidades mistas, de anos até nanossegundos, e a aritmética se resolve de forma ciente do calendário. Somar um mês a 31 de janeiro dá 28 de fevereiro (ou 29), não 3 de março. Somar um dia a um datetime com fuso na véspera de uma transição de horário de verão adiciona um dia de calendário, que pode ter 23 ou 25 horas — que é exatamente o que um humano quer dizer quando fala 'mesmo horário amanhã'.

Essa distinção entre tempo decorrido e tempo de calendário é o conceito mais confuso da programação com datas, e é confundido em todo lugar. O java.util.Date original do Java misturava os dois; o java.time do Java 8 (ele mesmo inspirado no Joda-Time) separou Duration de Period e saiu ganhando com isso. A proposta Temporal do JavaScript faz a mesma divisão. O Jiff se encaixa confortavelmente nessa linhagem: as boas ideias em design de datetime vêm convergindo há vinte anos, e o Jiff é essencialmente a expressão em Rust desse consenso, assim como funcionalidades de linguagem do Rust que demoraram a amadurecer chegam como a versão destilada de uma década de debate.

Há também um formato de duração 'amigável' — strings como 2h 30m ou P1DT2H fazem parse e impressão de forma natural — além de formatação estilo strptime/strftime e integração opcional com ICU4X para saída sensível a locale. Parecem o mínimo, mas quem já escreveu uma string de formato personalizada no chrono para um pipeline de logs sabe o quanto isso tira de atrito.

Jiff vs Chrono: Quando Cada Um Vence

Chega de tour. Aqui vai a comparação honesta, com um ponto de vista.

Onde o chrono ainda vence

Inércia também é uma funcionalidade. O chrono está no grafo de dependências de uma parcela enorme do ecossistema Rust, aparece em inúmeras APIs públicas e é mantido por mãos confiáveis. Se sua base de código já fala chrono fluentemente, seus timestamps são instantes apenas em UTC (pense em pipelines de métricas, envelopes de logs, RPC interno) e seu time conhece as arestas, a migração traz pouco ganho. A postura do chrono, opcional de std e amigável a no_std, também importa em cantos de embarcados. E se você faz algo exótico — mecânica orbital em escalas de megaanos, escalas de tempo alternativas como TAI ou UT1 — nenhuma das duas bibliotecas é realmente a resposta; você vai envolver uma delas para parsing de strings e manter sua própria representação, e a simplicidade do chrono nas bordas serve para isso.

Também há um contraponto legítimo que vi de profissionais da área: algumas pessoas preferem genuinamente a explicitude do chrono. O LocalResult::Ambiguous obriga você a pensar. Se o seu domínio é aquele em que chutar errado sobre um fold de horário de verão tem consequências legais ou financeiras — folha de pagamento, liquidação de energia, trading —, talvez você queira que a biblioteca se recuse a chutar, sempre. O Jiff suporta isso via unambiguous(), mas no chrono essa é o caminho de menor resistência. Justo.

Onde o Jiff vence

Em quase todo o resto. Qualquer aplicação que toque em horário civil — agendamento, calendários, datas voltadas ao usuário, tudo que cruza fusos — leva um acordo estritamente melhor com o Jiff. Os nomes dos tipos ensinam o domínio. A ambiguidade de horário de verão ganha um padrão sensato com saídas de emergência tipadas, em vez de um enum que você vai tratar errado às 2h da manhã. O Span faz aritmética de calendário corretamente logo de cara. O parsing e a formatação cobrem os formatos amigáveis que humanos realmente escrevem. E o compromisso do 1.0 importa: Gallant declarou a intenção de manter a API estável indefinidamente justamente para que o Jiff possa aparecer em APIs públicas de outras bibliotecas — exatamente a propriedade que tornou permanentes os erros do chrono. A lista de adoção já sustenta essa ambição: uv, Cargo, Starship, fd, Nushell, Jujutsu e uutils o usam, e a LLRT da AWS construiu sua implementação de Temporal sobre ele.

A pergunta de performance, já que alguém sempre faz: as duas bibliotecas são rápidas o suficiente para que o tratamento de datas nunca seja seu gargalo. O Jiff embute uma cópia compactada do banco de fusos horários IANA (com uma postura documentada e cuidadosa sobre o uso de tzdata rearguard) ou pode usar a base de fusos do sistema. Esse é um domínio em que correção vence microbenchmarks por uma margem tão grande que escolher com base em velocidade seria negligência profissional. Uma resposta errada em 50 nanossegundos continua errada.

Uma biblioteca de datetime que obriga você a tratar ambiguidade em todo lugar não é mais honesta — só terceiriza o problema mais difícil para a pessoa menos equipada para resolvê-lo: você, num ponto de chamada, com pressa.

A Grande Lição para Design de API

Tirando as datas, o Jiff é um estudo de caso de um argumento mais amplo: bibliotecas devem encapsular a complexidade do domínio em vez de reexportá-la fielmente. O banco de fusos horários IANA é, como críticos apontam com razão, um artefato voltado a programadores — baseado em localização, historicamente exaustivo, cheio de identificadores que nenhum usuário digitaria. Uma biblioteca preguiçosa expõe isso cru e chama de flexibilidade. Uma boa absorve: estratégias de desambiguação padrão, parsing amigável, nomes de tipos que mapeiam conceitos humanos. Você vê a mesma tensão em outros domínios — a lacuna entre uma especificação e uma implementação utilizável é onde mora a maioria dos bugs, e o tratamento de datas é o habitat natural dessa lacuna.

É também uma história sobre paciência do ecossistema. O Rust esperou uma década por sua biblioteca de datetime 'definitiva', do mesmo jeito que esperou anos para async se acomodar ou para o never type estabilizar. A espera é o custo de acertar o modelo em vez de travar o primeiro rascunho que funcionava. O chrono não foi um fracasso — foi o rascunho que o ecossistema precisava na época. Mas rascunhos são revisados.

A Recomendação

Novo projeto em Rust? Use Jiff. Não pense demais. A API é melhor, o tratamento de horário de verão é mais seguro por padrão, o compromisso de estabilidade do 1.0 é explícito, e o embalo do ecossistema — Cargo e uv não adotam crates casualmente — significa que você vai encontrá-lo cada vez mais de qualquer forma. Use ZonedDateTime para tudo que for voltado ao usuário, Timestamp para armazenamento e formatos de transmissão, e os tipos civil quando a localização realmente não se aplicar.

Já tem uma base de código com chrono que funciona? Fique onde está, a menos que esteja mexendo em funcionalidades pesadas em horário civil em que as armadilhas do chrono estão de fato te custando caro. As duas bibliotecas interoperam bem por meio de timestamps e strings ISO, então a adoção parcial — Jiff para o módulo de agendamento, chrono no resto — é uma estratégia legítima, e não um meio-termo.

A conclusão mais profunda, qualquer que seja a sua escolha: lidar com datas é difícil porque o domínio é irredutivelmente estranho — segundos intercalares, folds, gaps, meses de duração variável, zonas políticas que mudam por decreto. O melhor que uma biblioteca pode fazer é escolher os padrões certos, nomear as coisas honestamente e manter as saídas de emergência por perto. O Jiff faz as três coisas. Vinte anos de evolução de bibliotecas de datetime, do Joda-Time passando pelo java.time até o Temporal, convergiram para o mesmo modelo por um motivo. É bom ver o Rust finalmente ganhar a sua versão.