10 DST traps, 10 passes: I ran Jiff 1.0 against chrono

Jiff 1.0 shipped today, and I ran 10 daylight-saving traps through it and chrono. Jiff passed all 10; chrono got every answer right too — but only after I handled LocalResult by hand, and its Duration::days(1) silently means the wrong thing for "tomorrow at noon."

The battery

America/New_York, 2026. Ground truth timestamps computed independently with Python's zoneinfo — neither library under test. DST 2026: spring forward 8 March 02:00 → 03:00, fall back 1 November 02:00 → 01:00.

== jiff 1.0 == [PASS] fold default = first (EDT): got 1793511000 want 1793511000 [PASS] fold later = second (EST): got 1793514600 want 1793514600 [PASS] gap 02:30 rejected: error converting datetime to instant in time zone America/New_York: datetime is ambiguous since it falls into a gap between offsets -05 and -04 [PASS] spring +24h absolute -> 13:00 EDT: got 1772989200 want 1772989200 [PASS] spring +1 day calendar -> 12:00 EDT: got 1772985600 want 1772985600 [PASS] fall +24h absolute -> 11:00 EST: got 1793548800 want 1793548800 [PASS] fall +1 day calendar -> 12:00 EST: got 1793552400 want 1793552400 [PASS] Jan31 + 1 month -> 2026-02-28 [PASS] parse 01:30-05:00[NY]: got 1793514600 want 1793514600 [PASS] ts 1793514600 -> 2026-11-01T01:30:00-05:00[America/New_York] == chrono 0.4 + chrono-tz == [PASS] fold ambiguous first: got 1793511000 want 1793511000 [PASS] fold ambiguous second: got 1793514600 want 1793514600 [PASS] gap 02:30 -> LocalResult::None [PASS] spring +24h absolute -> 13:00 EDT: got 1772989200 want 1772989200 [PASS-as-absolute] chrono Duration::days(1) == +24h absolute (1772989200), NOT calendar 12:00 EDT (1772985600) [PASS] spring +1 cal day via NaiveDate: got 1772985600 want 1772985600 [PASS] fall +24h absolute -> 11:00 EST: got 1793548800 want 1793548800 [PASS] chrono Jan31 + 1 month -> 2026-02-28 [PASS] parse RFC3339 -05:00 (no zone name): got 1793514600 want 1793514600 [PASS] ts 1793514600 round-trips: got 1793514600 want 1793514600 

jiff 1.0.0, chrono 0.4.45, chrono-tz 0.10.4, rustc 1.99.1. Every case asserts against a hardcoded expected timestamp; the core snippets are shown inline in the sections below.

The one real footgun: Duration::days(1) is not a day

This is the case that justifies the whole exercise. "Tomorrow at noon" and "24 hours from now" are different questions twice a year, and the two libraries answer them differently by default:

// jiff: a Span knows the difference let start = civil::date(2026, 3, 7).at(12, 0, 0, 0) .to_zoned_datetime(tz)?; start.checked_add(Span::new().hours(24))?; // 2026-03-08T13:00:00-04:00 start.checked_add(Span::new().days(1))?; // 2026-03-08T12:00:00-04:00 // chrono: Duration only knows absolute time let cstart = New_York.from_local_datetime(&naive).unwrap(); cstart + Duration::hours(24); // 2026-03-08 13:00:00 EDT (correct, absolute) cstart + Duration::days(1); // 2026-03-08 13:00:00 EDT (also absolute!) 

Duration::days(1) is 86,400 seconds, always. If you meant "same wall-clock time tomorrow," chrono gives you 13:00 instead of 12:00 on the spring-forward Sunday — silently, with no error, in a type that looks like it means "a day." The correct chrono path is a manual round-trip through NaiveDate (add a day to the date, re-attach the time, re-resolve the zone), which is what my battery did to get the right answer. It works. It's also three steps where jiff needs one, and the one-step version compiles fine and returns the wrong wall-clock time.

The fall-back direction is the mirror image: +24h from 31 October noon lands at 11:00 on 1 November; +1 calendar day lands at 12:00. Both libraries get the absolute arithmetic right. Only jiff gets the calendar arithmetic right without help.

The fold: both correct, one of them by force

1:30 AM on 1 November 2026 happens twice in New York — once at offset −04:00 (timestamp 1793511000), once at −05:00 (1793514600). Jiff's default is to pick the first occurrence and lets you ask for the second explicitly:

let dt = civil::date(2026, 11, 1).at(1, 30, 0, 0); dt.to_zoned_datetime(tz)?; // first: 1793511000, offset -04 tz.to_ambiguous_zoned_datetime(dt).later()?; // second: 1793514600, offset -05 

Chrono makes the ambiguity impossible to ignore — which is a feature, until it's a footgun:

New_York.from_local_datetime(&naive_fold) // => Ambiguous(2026-11-01T01:30:00EDT, 2026-11-01T01:30:00EST) 

LocalResult::Ambiguous carries both instants, and .single() returns None on it. The dangerous line is the one every tutorial teaches: .unwrap(). On a fold it panics; on a gap it panics too. Chrono is honest about ambiguity in its return type and then lets you silence that honesty with one method call. Jiff inverts the default: the easy path picks a documented answer (first occurrence, "compatible" strategy), and you have to opt into strictness with .unambiguous() — which is what rejected the gap case in my battery with a clear error naming both offsets.

The gap itself, 02:30 on 8 March, doesn't exist. Both libraries refuse it. Jiff's compatible() fallback shifts it to 03:30 EDT (timestamp 1772955000) — the same wall-clock arithmetic Python's zoneinfo does, for what that's worth.

Parsing: the zone name is the whole point

// jiff parses RFC 9557, zone name included let parsed: ZonedDateTime = "2026-11-01T01:30:00-05:00[America/New_York]".parse()?; // timestamp 1793514600 — the second 01:30, unambiguous // chrono parses the offset, not the zone DateTime::parse_from_rfc3339("2026-11-01T01:30:00-05:00")?; // timestamp 1793514600 — correct instant, but the zone is gone 

An offset tells you what the clock said. A zone name tells you what the clock will say next March. Chrono's DateTime<Tz> can hold a zone, but its parsers can't read one out of a string — you parse a FixedOffset and re-attach the zone yourself, hoping the offset you parsed agrees with the zone at that instant. Jiff round-trips the whole thing in one parse().

So should you switch?

Honest scoreboard: on correctness, this battery is a draw with an asterisk. Chrono answered every case correctly once I used its API the way it demands — LocalResult matching, NaiveDate round-trips for calendar math, checked_add_months for month arithmetic (Jan 31 + 1 month → Feb 28 in both). The asterisk is that chrono's easiest path is the wrong one in exactly the case users write without thinking: datetime + Duration::days(1).

Jiff's win is ergonomic, not numerical. One type (ZonedDateTime) carries the instant, the civil time, and the zone together, so "add a day" and "add 24 hours" are different method calls on the same value instead of different types in different modules. That is the entire thesis of the 1.0 announcement: the library is designed so the pit of success is the default path. Burntsushi's 1.0 commitment is explicit — no semver-incompatible releases made lightly, because jiff is meant to be a public dependency in other libraries' APIs. It's already the datetime layer in uv, Cargo, Starship, fd, Nushell, mise, Jujutsu, uutils/coreutils, and AWS LLRT's Temporal implementation.

The scale of the bet is visible on crates.io: jiff has 285.5M total downloads (120.7M recent), against chrono's 989.2M (243.3M recent). Chrono is still the default. But jiff's download curve is the one to watch — a 1.0 with a stability promise is exactly the release that turns "used inside uv" into "used in your public API."

My rule after this battery: if the value represents a moment a human will see on a clock — a meeting, a deadline, a "tomorrow at noon" — use the type that keeps the zone attached and makes calendar arithmetic one call. If it's a pure instant — a log timestamp, a TTL — chrono's DateTime<Utc> is still the simplest correct tool in the ecosystem. The bug class isn't "chrono is wrong." It's "the code that looks like it adds a day adds 86,400 seconds instead," and it only fires twice a year, on the two Sundays your on-call rotation already dreads.

Sources: Jiff 1.0 announcement (16 Nov 2026); the battery program (jiff 1.0.0, chrono 0.4.45, chrono-tz 0.10.4, rustc 1.99.1) with its full output; ground truth via Python 3.12 zoneinfo; download counts via crates.io API, 17 Nov 2026.