77 ns vs 31 ns: jiff 1.0 is not the fastest datetime lib
jiff 1.0 parses an RFC3339 timestamp in 77 nanoseconds on my machine. time does it in 31. chrono does it in 42. I benchmarked all three this morning, and the new 1.0 release — the one BurntSushi has been building toward for two years — is not the fastest datetime library in Rust. That's the headline, and it's also the wrong reason to judge it. The interesting numbers are the ones around the edges: formatting, where jiff beats chrono by 1.4x, and error messages, where it isn't close at all.
What 1.0 actually is
jiff 1.0.0 shipped November 15, 2026. The changelog is refreshingly boring for a 1.0: the big breaking change is a rename, Zoned → ZonedDateTime (which broke my first build this morning — more on that below). The MSRV went to Rust 1.85, Timestamp subtraction now returns a SignedDuration, and conversions to SystemTime became fallible. The message is stability: "this release marks an indefinite commitment to 1.x.y. Consumers should feel confident about putting Jiff types into their public API."
Then 1.0.1 followed two days later, November 17, with two fixes. One was cosmetic (%Z in strftime should format as UTC). The other is the kind of thing that makes you blink: "Parsing a timestamp could produce an out of bounds value." A datetime library shipped a parse out-of-bounds bug in its 1.0.0 and fixed it in 48 hours. Nobody's perfect; the fix time is the part worth noting.
The benchmark
Same machine for all three libraries (AMD EPYC 9D25, rustc 1.99.1, --release, 1,000,000 iterations per case, best of 5 runs). The input is a real timestamp with nanoseconds and a Z suffix; the offset variant uses +05:30.
let ts = "2026-11-18T07:00:00.123456789Z"; let ts_off = "2026-11-18T07:00:00+05:30"; // parse: jiff Timestamp::from_str // chrono DateTime::parse_from_rfc3339 // time OffsetDateTime::parse(.., Rfc3339) // format: jiff Timestamp Display / chrono to_rfc3339() / time format(Rfc3339) parse RFC3339 (Z) jiff 77.1 ns chrono 42.5 ns time 31.3 ns parse RFC3339 (+05:30) jiff 60.8 ns chrono 37.7 ns time — * format RFC3339 jiff 81.9 ns chrono 116.7 ns time 43.7 ns * time's offset parse is the same code path; I only ran it for the Z input.
Ratios, because ratios are the story:
parse (Z): jiff is 1.8x slower than chrono, 2.5x slower than time format: jiff is 1.4x FASTER than chrono, 1.9x slower than time So jiff loses parsing and wins one formatting matchup. Before you conclude anything, the sanity check: all three agree on the instant. Epoch 1794985200, nanoseconds 123456789, identical output strings. And jiff's zoned form does the thing the other two make you work for:
jiff: 2026-11-18T07:00:00.123456789Z chrono: 2026-11-18T07:00:00.123456789Z time: 2026-11-18T07:00:00.123456789Z jiff zoned: 2026-11-17T23:00:00.123456789-08:00[America/Los_Angeles] The part the benchmark doesn't measure
Feed all three a date that doesn't exist — February 30 — and compare what comes back:
jiff: parsed date is not valid: parameter 'day' for `2026-02` is invalid, must be in range `1..=28` chrono: ParseError(OutOfRange) time: TryFromParsed(ComponentRange(ComponentRange { name: "day", is_conditional: true })) jiff tells you which parameter, which month, and the valid range, in one sentence. chrono gives you an enum variant. time gives you a Debug dump of an internal struct. This is jiff's actual product: every error is a sentence a human can act on, every API refuses to silently do the wrong thing (hence fallible SystemTime conversions in 1.0), and the DST arithmetic doesn't have the footguns that made people write their own wrappers around chrono in the first place.
That costs nanoseconds. jiff validates more on the parse path — the range checks, the offset handling, the civil-date validation — and validation is work. time is a thinner layer over the same bytes. If your hot loop parses a million timestamps a second, take the 31 ns. If your program parses user input, config files, or API responses, the 46 extra nanoseconds buys you an error message your on-call engineer can paste into a search box.
The rename that broke my build
One honest footnote: my first compile failed.
error[E0433]: cannot find `Zoned` in `jiff` The 1.0 changelog lists it plainly — Zoned is now ZonedDateTime, to_zoned is now to_zoned_datetime — and I still wrote the old name from muscle memory. That's the entire cost of the biggest breaking change in the release: one rename, one compiler error, one sed command. For a library whose pre-1.0 API moved constantly, that's the point of the 1.0 line in the changelog. The API is done moving now.
So should you switch?
The scoreboard, without romance:
- Parsing throughput:
time>chrono>jiff. jiff pays ~2.5x vstimefor validation. - Formatting:
time>jiff>chrono. jiff beats chrono by 1.4x. - Error messages: jiff, by a distance.
- API stability: 1.0 is a commitment;
ZonedDateTimeis the name now.
jiff 1.0 is not a speed release. It's a "you can put this in your public API and stop thinking about it" release, and the benchmark says the tax for that is measured in tens of nanoseconds per parse. If you're choosing a datetime library on parse throughput alone, you already know which one to pick — and it's not this one. If you're choosing on the strength of what happens when the input is wrong, the numbers point the other way.
Sources: jiff CHANGELOG, 1.0.0 (2026-11-15) and 1.0.1 (2026-11-17); jiff on crates.io, 1.0.1. Benchmarks are my own measurements (rustc 1.99.1, --release, AMD EPYC 9D25, 1M iterations, best of 5; jiff 1.0.1, chrono 0.4.45, time 0.3.55). I dropped one comparison from the results: a date-arithmetic microbenchmark where the jiff number came out at an implausible 0.5 ns/op — the compiler had hoisted the loop-invariant computation out of the timed loop, so the number measured nothing. I removed it rather than publish a benchmark artifact as a result.