Jiff vs Chrono: Rust में कौन सी datetime लाइब्रेरी जीतती है
Rust में datetime के लिए Jiff vs chrono: DST के edge cases, API की ergonomics, और कब कौन सी लाइब्रेरी चुनें, दोनों से जले हुए एक डेवलपर की नज़र से।

हर few साल में कोई बेचारा engineer खोज लेता है कि New York में 2026-11-01 01:30 दो बार आता है, और उसका scheduler billing job को एक घंटा पहले चला चुका होता है। Datetime bugs आपका प्रोग्राम crash नहीं करते — वे चुपचाप आपका data खराब कर देते हैं। इसलिए Andrew Gallant (ripgrep वाले) की नई Rust datetime library Jiff 1.0 का आना सिर्फ एक और crate release नहीं है। यह एक असली सवाल खड़ा करता है: Jiff vs chrono — आपके अगले Rust project में कौन सी लाइब्रेरी इस्तेमाल होनी चाहिए?
Rust में Datetime की पुरानी परेशानी का इतिहास
Rust इससे पहले भी यहाँ से गुज़र चुका है, और उस इतिहास से सीख मिलती है। Chrono की जड़ें भाषा के 1.0 से पहले के दौर तक जाती हैं, जब उसे time के साथ standard library से अलग किया गया था, 'right-size std' नाम की बड़ी सफ़ाई मुहिम के हिस्से के रूप में। लगभग एक दशक तक यही डिफ़ॉल्ट जवाब रहा। काम करता था, ज़्यादातर। लेकिन इसकी API में परतें जमती गईं: NaiveDateTime, DateTime<Utc>, DateTime<Local>, DateTime<FixedOffset>, और एक TimeZone trait जिसके दो implementations के अलावा ज़्यादातर लोग कुछ छूते ही नहीं। Type system आपको ऐसी कई चीज़ें करने देता था जिनका कोई semantic मतलब नहीं बनता था, जैसे naive datetime को zoned datetime में जोड़ना और एक आत्मविश्वास भरा, मगर गलत जवाब पा लेना।
Maintenance की कहानी भी मायने रखती है। Chrono एक ऐसे दौर से गुज़रा जब उसे लगभग छोड़ दिया गया था, और बाद के maintainers ने भी बताया है कि उन्हें ऐसी API stability से जूझना पड़ा जिसे users पवित्र मानते थे। एक पूर्व maintainer ने साफ़ कहा: सुधार की हर छोटी कोशिश का विरोध हुआ, क्योंकि chrono की मुख्य खूबी उसका design नहीं, बल्कि उसकी stability बन गई थी। यह हर लंबे समय तक चलने वाली library के लिए एक जाल है — installed base ही product बन जाता है। time crate ने एक साफ़ core के साथ अलग रास्ता अपनाया, पर सालों तक full time zone handling को टालता रहा। इस बीच ecosystem ऐसे applications बनाता रहा जहाँ 'अगले मार्च में बर्लिन में कितने बजे होंगे' एक अहम सवाल है।
यह वही पुराना विचार है जिस पर Jiff टिका है, चाहे वह इसका नाम ले या न ले: 'pit of success' दर्शन, जिसे Rico Mariani ने 2000 के दशक के मध्य में API design के संदर्भ में समझाया था। आसान रास्ते को ही सही रास्ता बनाओ। Gallant का कहना है कि datetime की कठिनाई खराब domain modeling से आती है, और जो libraries ambiguity को users पर डाल देती हैं — 'यह naive datetime है, शुभकामनाएँ' — वे अपनी सबसे कठिन समस्या आउटसोर्स कर रही हैं। यही प्रवृत्ति Rust के ownership model के पीछे भी है: मशीन को जटिलता संभालनी चाहिए ताकि इंसान को न संभालनी पड़े।
Jiff समय को कैसे model करता है: प्याज़ की परतें
Jiff का मुख्य design कदम वही है जिसे Gallant 'datetime onion' कहते हैं। परतें अंदर से बाहर की ओर:
civil::Date— एक Gregorian date, जिसके साथ कोई location नहीं जुड़ी होती। आपका जन्मदिन इसी तरह का होता है।civil::Time— nanosecond precision तक का wall-clock time, बिना location के।civil::DateTime— date और time, फिर भी location-free। इसे chrono naive कहता है।Timestamp— एक unambiguous instant, Unix epoch से nanoseconds में।TimeZone— किसी क्षेत्र में instants और civil time के बीच मैपिंग के नियम।ZonedDateTime— यह सब एक साथ: instant, civil time और zone।
इसका फ़ायदा यह है कि type के नाम वही मानसिक मॉडल दोहराते हैं जो आपके दिमाग में पहले से है। Timestamp वह है जो database या system call से मिलता है। civil::DateTime वह है जो कोई इंसान calendar invite पर लिखता है। Time zone के बिना इन दोनों के बीच बदलाव संभव नहीं, और Jiff इस बदलाव को एक स्पष्ट, fallible और zone-annotated operation बनाता है। Chrono से तुलना करें, जहाँ यही फ़र्क मौजूद है पर धुंधला करना आसान है — NaiveDateTime::and_utc() बिना यह पूछे कि वह wall-clock time कभी अस्तित्व में था भी या नहीं, उस पर zone थोप देता है।
Ergonomics जानबूझकर सरल रखी गई हैं। आप zoned datetime दोनों दिशाओं से बना सकते हैं — civil time plus zone, या timestamp plus zone — और 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(())
}
Daylight Saving Time: जहाँ Jiff अपनी जगह बनाता है
यहाँ वह परिदृश्य है जो datetime library design में बड़ों और बच्चों को अलग करता है। 1 नवंबर 2026 को New York की घड़ियाँ रात 2 बजे पीछे की जाती हैं। 1 बजे वाला घंटा दो बार आता है। तो जब कोई user '1 नवंबर को सुबह 1:30 बजे' टाइप करता है, तो आप क्या करेंगे? Chrono का पारंपरिक जवाब LocalResult रहा है: एक enum जो Single, Ambiguous या None हो सकता है, और जिसे production code का एक चौंकाने वाला हिस्सा unwrap कर देता है, नज़रअंदाज़ कर देता है, या गलत तरीके से pattern-match करता है। Ambiguity सामने रखी गई है — पर उसे संभालने का बोझ भी हर बार आपके ऊपर है।
Jiff एक समझदार डिफ़ॉल्ट चुनता है और विकल्पों को एक method call की दूरी पर रखता है। डिफ़ॉल्ट 'compatible' रणनीति fold को पहली घटना पर हल करती है — ठीक वैसा ही जैसा ज़्यादातर calendar software और हर बड़ा operating system करता है। पर अगर आपको फ़र्क पड़ता है, तो पूरा decision tree सामने है:
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 डिफ़ॉल्ट रूप से आगे खिसका देता है, और फिर से आप इसे बदल सकते हैं। यहाँ का design निर्णय राय वाला है और मेरे हिसाब से सही है। ambiguous times को संभालने वाला ज़्यादातर code कोई policy नहीं रखता — उसके पास नवंबर का इंतज़ार करता एक bug होता है। उसी व्यवहार को डिफ़ॉल्ट बनाना जिसकी users अपने phones से पहले से अपेक्षा रखते हैं, और escape hatches को स्पष्ट और typed रूप में दिखाई देते रखना ही व्यवहार में 'pit of success' का मतलब है। यह उसी दर्शन जैसा है जो हाथ से लिखी date arithmetic के पीछे अच्छे डिफ़ॉल्ट के लिए काम करता है: नियम सीखे जा सकते हैं, पर आपको उन्हें हर call site पर दोबारा निकालना नहीं चाहिए।

Spans, Durations और 'एक महीना' वाली समस्या
Chrono से 'एक महीने' की duration माँगें, तो निराशा होगी — उसकी Duration सेकंडों की एक निश्चित गिनती है, क्योंकि महीना किसी भी चीज़ की निश्चित गिनती नहीं है। यह बचाव योग्य design है, पर इसका मतलब है कि calendar arithmetic ('जनवरी 31 में तीन महीने जोड़ो') आपकी समस्या बन जाती है। Jiff का Span type दूसरा रास्ता लेता है: उसमें years से लेकर nanoseconds तक की mixed units होती हैं, और arithmetic calendar-aware तरीके से हल होती है। 31 जनवरी में एक महीना जोड़ने पर 28 (या 29) फ़रवरी मिलती है, 3 मार्च नहीं। DST transition से एक रात पहले zoned datetime में एक दिन जोड़ने पर एक calendar day जुड़ता है, जो 23 या 25 घंटे का हो सकता है — और 'कल इसी समय' कहने से इंसान का यही मतलब होता है।
elapsed time और calendar time का यह फ़र्क datetime programming की सबसे उलझी हुई अवधारणा है, और यह हर जगह उलझी है। Java का पुराना java.util.Date इन दोनों को मिला देता था; Java 8 का java.time package (जो खुद Joda-Time पर आधारित है) Duration को Period से अलग करता है और उसके लिए बेहतर बना। JavaScript का Temporal proposal भी यही विभाजन करता है। Jiff इसी परंपरा में आराम से बैठता है: datetime design के अच्छे विचार बीस सालों से एक बिंदु की ओर बढ़ रहे हैं, और Jiff मूल रूप से उसी सहमति का Rust रूप है, जैसे लंबे समय से पक रहे Rust language features आखिरकार एक दशक की बहस का परिष्कृत रूप बनकर आते हैं।
एक 'friendly' duration format भी है — 2h 30m या P1DT2H जैसी strings स्वाभाविक रूप से parse और print होती हैं — साथ ही strptime/strftime शैली की formatting और locale-sensitive output के लिए वैकल्पिक ICU4X integration। ये बुनियादी ज़रूरतें लगती हैं, पर जिसने log pipeline के लिए chrono का format string खुद लिखा है, वह जानता है कि ये कितनी रुकावटें दूर करती हैं।
Jiff vs Chrono: कब कौन जीतता है
बहुत हो गया परिचय। यह रही ईमानदार तुलना, एक राय के साथ।
Chrono अब भी कहाँ जीतता है
जड़ता भी एक फ़ीचर है। Chrono Rust ecosystem के एक बड़े हिस्से के dependency tree में है, कई public APIs में दिखता है, और एक भरोसेमंद हाथ से maintained होता है। अगर आपका codebase पहले से chrono अच्छे से बोलता है, आपके timestamps सिर्फ UTC instants हैं (जैसे metrics pipelines, log envelopes, internal RPC), और आपकी टीम उसकी तीखी धार जानती है, तो migration से आपको कम ही फ़ायदा होगा। Chrono का std-optional और no_std-friendly रुख embedded क्षेत्रों में अब भी मायने रखता है। और अगर आप कुछ अनोखा कर रहे हैं — megayear पैमाने पर orbital mechanics, या TAI और UT1 जैसे वैकल्पिक time scales — तो दोनों में से कोई भी library आपका असली जवाब नहीं है; आप string parsing के लिए किसी एक को wrap करेंगे और अपनी representation खुद रखेंगे, और उसके लिए chrono की किनारों पर सादगी ठीक है।
व्यवहारियों से मैंने एक वैध विरोधी तर्क भी सुना है: कुछ लोग वाकई chrono की स्पष्टता पसंद करते हैं। LocalResult::Ambiguous आपको सोचने पर मजबूर करता है। अगर आपका domain ऐसा है जहाँ DST fold के बारे में गलत अनुमान लगाने के कानूनी या वित्तीय परिणाम हों — payroll, energy settlement, trading — तो शायद आप चाहेंगे कि library कभी अनुमान न लगाए। Jiff unambiguous() के ज़रिए यह सुविधा देता है, पर chrono इसे सबसे आसान रास्ता बना देता है। ठीक है, उचित बात है।
Jiff कहाँ जीतता है
लगभग हर दूसरी जगह। जो भी application civil time को छूता है — scheduling, calendars, user-facing dates, time zones के पार जाने वाली कोई भी चीज़ — उसे Jiff से कहीं बेहतर सौदा मिलता है। Type के नाम domain सिखाते हैं। DST ambiguity को एक समझदार डिफ़ॉल्ट मिलता है, typed escape hatches के साथ, न कि एक ऐसे enum के साथ जिसे आप 2 बजे रात में गलत संभालेंगे। Span calendar arithmetic को बिना किसी अतिरिक्त मेहनत के सही करता है। Parsing और formatting वे friendly formats कवर करते हैं जो इंसान सचमुच लिखते हैं। और 1.0 का वादा मायने रखता है: Gallant ने API को अनिश्चित काल तक स्थिर रखने का इरादा जताया है, ताकि Jiff दूसरी libraries की public APIs में भी आ सके — ठीक वही गुण जिसने chrono की गलतियों को स्थायी बना दिया। अपनाने वाली सूची इस महत्वाकांक्षा का समर्थन करती है: uv, Cargo, Starship, fd, Nushell, Jujutsu और uutils इसे इस्तेमाल करते हैं, और AWS के LLRT ने अपना Temporal implementation इसी के ऊपर बनाया है।
Performance का सवाल, क्योंकि कोई न कोई हमेशा पूछता है: दोनों libraries इतनी तेज़ हैं कि datetime handling कभी आपकी bottleneck नहीं होती। Jiff IANA tz database की एक compacted copy साथ लाता है (rearguard tzdata के इस्तेमाल पर दस्तावेज़ित और सोच-समझकर लिए गए रुख के साथ) या system zone database का उपयोग कर सकता है। यह ऐसा क्षेत्र है जहाँ correctness microbenchmarks को इतने बड़े अंतर से पीछे छोड़ देती है कि सिर्फ़ speed पर चुनना malpractice होगा। 50 nanoseconds में गलत जवाब फिर भी गलत है।
जो datetime library आपको हर जगह ambiguity संभालने देती है, वह ज़्यादा ईमानदार नहीं — वह अपनी सबसे कठिन समस्या उस व्यक्ति पर डाल देती है जो उसे हल करने के लिए सबसे कम तैयार है: आप, किसी call site पर, जल्दी में।
API Design के लिए बड़ा सबक
तारीखें हटा दें, तो Jiff एक व्यापक तर्क का case study है: libraries को domain complexity को समेटना चाहिए, न कि उसे वफ़ादारी से दोबारा export करना चाहिए। IANA time zone database, जैसा आलोचक ठीक ही कहते हैं, एक programmer-oriented artifact है — location-based, ऐतिहासिक रूप से exhaustive, और ऐसे identifiers से भरा जो कोई user कभी टाइप नहीं करेगा। एक आलस्य भरी library इसे कच्चा खोलकर रख देती है और उसे लचीलापन कहती है। एक अच्छी library इसे समेट लेती है: डिफ़ॉल्ट disambiguation strategies, friendly parsing, और ऐसे type नाम जो इंसानी अवधारणाओं से मेल खाते हैं। यही तनाव दूसरे क्षेत्रों में भी दिखता है — spec और उपयोगी implementation के बीच का अंतर वह जगह है जहाँ ज़्यादातर bugs रहते हैं, और datetime handling उस अंतर का स्वाभाविक घर है।
यह ecosystem के धैर्य की कहानी भी है। Rust ने अपनी 'निर्णायक' datetime library के लिए एक दशक इंतज़ार किया, जैसे async के स्थिर होने या never type के stabilize होने का इंतज़ार किया था। यह इंतज़ार मॉडल को सही बनाने की कीमत है, बजाय इसके कि पहले काम करने वाले draft पर ताला लगा दिया जाए। Chrono असफल नहीं था — उस समय ecosystem को वही draft चाहिए था। पर drafts में संशोधन होते हैं।
मेरी सिफ़ारिश
नया Rust project? Jiff इस्तेमाल करें। ज़्यादा सोचने की ज़रूरत नहीं। API बेहतर है, DST handling डिफ़ॉल्ट रूप से सुरक्षित है, 1.0 stability वादा स्पष्ट है, और ecosystem का momentum — Cargo और uv crates को हल्के में नहीं अपनाते — का मतलब है कि आप इसे वैसे भी तेज़ी से देखेंगे। User-facing चीज़ों के लिए ZonedDateTime, storage और wire formats के लिए Timestamp, और जहाँ location सचमुच लागू नहीं होती वहाँ civil types इस्तेमाल करें।
काम कर रहा मौजूदा chrono codebase? वहीं टिके रहें, जब तक आप civil-time-भारी features नहीं छू रहे जहाँ chrono की footguns सक्रिय रूप से नुकसान कर रही हों। दोनों libraries timestamps और ISO strings के ज़रिए ठीक से साथ काम करती हैं, इसलिए आंशिक अपनाना — scheduling module में Jiff, बाकी सब जगह chrono — एक वैध रणनीति है, कोई समझौता नहीं।
आप जो भी चुनें, गहरा सबक यही है: datetime handling कठिन है क्योंकि इसका domain मूल रूप से अजीब है — leap seconds, folds, gaps, बदलती लंबाई वाले महीने, राजनीतिक zones जो आदेश से बदल जाते हैं। एक library सबसे अच्छा यही कर सकती है कि सही डिफ़ॉल्ट चुने, चीज़ों को ईमानदारी से नाम दे, और escape hatches को पास रखे। Jiff तीनों करता है। Joda-Time से java.time होते हुए Temporal तक बीस सालों का datetime library विकास एक कारण से एक ही मॉडल पर पहुँचा। अच्छा लगता है कि Rust को आखिरकार अपना संस्करण मिल रहा है।


