다음에 올 것을 만들어가는 기술에 대한 심층 기사.

Jiff vs Chrono: Rust 날짜 라이브러리 비교

Rust 날짜·시간 처리에서 Jiff와 chrono를 비교합니다. 서머타임 엣지 케이스, API 사용성, 각 라이브러리가 유리한 상황을 정리했습니다.

서로 겹쳐진 두 개의 양식화된 시계, 하나는 기계식이고 하나는 유기적인 모양으로 시간대 전환을 떠올리게 한다.
날짜·시간 버그는 보통 아무것도 크래시시키지 않습니다. 그냥 조용히 잘못된 시각을 건네줄 뿐이죠.

몇 년에 한 번씩, 어떤 불쌍한 엔지니어가 뉴욕의 2026-11-01 01:30이 두 번 나타난다는 사실을 발견하고, 자신의 스케줄러가 청구 작업을 한 시간 일찍 실행해 버렸다는 걸 알게 됩니다. 날짜·시간 버그는 프로그램을 죽이지 않습니다. 대신 조용히 데이터를 망가뜨리죠. 그래서 ripgrep으로 유명한 Andrew Gallant가 만든 새 Rust 날짜·시간 라이브러리 Jiff 1.0의 출시는 단순한 크레이트 릴리스 이상의 의미가 있습니다. 다음 Rust 프로젝트에서 Jiff vs chrono 중 무엇을 써야 할지 진지하게 묻게 만들거든요.

Rust 날짜·시간 처리의 아픈 역사

Rust에는 이미 이런 일이 있었고, 그 역사는 교훈적입니다. Chrono는 언어 1.0 이전 시기에 표준 라이브러리에서 time과 함께 분리되어 나온 크레이트로, ‘표준 라이브러리 적정 크기 맞추기’ 대정리 작업의 일환이었습니다. 거의 10년 동안 사실상 기본 선택지였죠. 대체로 잘 작동했습니다. 다만 API에 층이 계속 쌓였습니다. NaiveDateTime, DateTime<Utc>, DateTime<Local>, DateTime<FixedOffset>, 그리고 대부분의 사람이 구현체 두 개를 통해서만 접하는 TimeZone 트레이트까지. 타입 시스템은 의미가 전혀 맞지 않는 일도 허용했습니다. 예를 들어 naive 날짜·시간에 시간대가 있는 값을 더하면 자신만만하지만 틀린 답이 나오는 식이죠.

유지보수 이야기도 중요합니다. Chrono는 사실상 방치되는 시기를 겪었고, 이후 관리자들조차 개선하려 할 때마다 사용자들이 신성시하는 API 안정성과 부딪혔다고 설명합니다. 한 전직 메인테이너는 이렇게 말했습니다. 개선을 위한 작은 걸음마다 저항이 있었는데, chrono의 주된 장점이 설계가 아니라 안정성이 되어버렸기 때문이라고요. 오래 살아남은 라이브러리라면 누구나 빠질 수 있는 함정입니다. 설치된 사용자 기반이 곧 제품이 되어버리는 거죠. time 크레이트는 더 깔끔한 코어로 다른 방향을 택했지만, 오랫동안 완전한 시간대 처리를 미뤘습니다. 그사이 생태계에서는 ‘다음 3월 베를린은 몇 시지?’라는 질문이 핵심인 애플리케이션이 계속 출시되고 있었습니다.

Jiff가 기대는 이 오래된 아이디어는, 이름을 밝히든 아니든 2000년대 중반 Rico Mariani가 API 설계에 대해 말했던 ‘성공의 구덩이(pit of success)’ 철학입니다. 쉬운 길이 곧 올바른 길이 되도록 만드는 것이죠. Gallant의 관점은, 날짜·시간의 어려움은 빈약한 도메인 모델링에서 온다는 것, 그리고 ‘여기 naive 날짜·시간이 있으니 알아서 하세요’처럼 모호함을 사용자에게 떠넘기는 라이브러리는 가장 어려운 문제를 외주로 넘기고 있다는 것입니다. Rust의 소유권 모델에 담긴 철학과도 같습니다. 복잡성은 기계가 흡수해서, 사람이 신경 쓰지 않아도 되게 하자는 것이죠.

Jiff가 시간을 모델링하는 방식: 양파

Jiff의 핵심 설계는 Gallant가 ‘날짜·시간 양파’라고 부르는 구조입니다. 안쪽에서 바깥쪽으로 층을 보면 다음과 같습니다:

  • civil::Date — 위치 정보가 없는 그레고리력 날짜. 여러분의 생일이 바로 이것입니다.
  • civil::Time — 나노초 정밀도의 벽시계 시간, 위치 정보 없음.
  • civil::DateTime — 날짜와 시간을 합친 것, 여전히 위치 정보 없음. chrono에서 naive라고 부르는 것입니다.
  • Timestamp — 모호함이 없는 순간, 유닉스 에포크 이후의 나노초 단위 값.
  • TimeZone — 특정 지역에서 순간과 시민 시간(civil time) 사이를 매핑하는 규칙.
  • ZonedDateTime — 이 모든 것을 합친 것: 순간, 시민 시간, 시간대.

이 설계의 보상은 타입 이름이 여러분이 이미 가진 멘탈 모델과 맞아떨어진다는 점입니다. Timestamp는 데이터베이스나 시스템 호출에서 받아오는 값이고, civil::DateTime은 사람이 달력 초대장에 적는 값입니다. 둘 사이를 시간대 없이 변환하는 건 불가능하고, Jiff는 그 변환을 명시적이고, 실패할 수 있으며, 시간대가 드러나는 연산으로 만듭니다. chrono에도 같은 구분이 존재하지만 흐리기 쉽습니다. NaiveDateTime::and_utc()는 그 벽시계 시간이 실제로 존재했었는지 묻지도 않고 시간대를 덥석 붙여 버리니까요.

사용성도 의도적으로 부드럽게 설계되었습니다. 시민 시간과 시간대를 조합하든, 타임스탬프와 시간대를 조합하든 양쪽 방향에서 zoned 날짜·시간을 만들 수 있고, 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(())
}

서머타임: Jiff가 빛을 발하는 지점

날짜·시간 라이브러리 설계에서 어른과 아이를 가르는 시나리오가 있습니다. 2026년 11월 1일, 뉴욕의 시계는 새벽 2시에 한 시간 뒤로 돌아갑니다. 그래서 1시 대 시간이 두 번 나타납니다. 사용자가 ‘11월 1일 오전 1시 30분’이라고 입력하면 어떻게 해야 할까요? Chrono의 답은 역사적으로 LocalResult였습니다. Single, Ambiguous, None 중 하나가 될 수 있는 열거형인데, 놀라울 정도로 많은 실서비스 코드가 이를 무시하거나, 그냥 unwrap하거나, 잘못 패턴 매칭합니다. 모호함은 노출되지만, 그걸 처리하는 부담도 매번 그대로 개발자에게 남습니다.

Jiff의 답은 합리적인 기본값을 고르고, 나머지 선택지는 메서드 한 번 호출로 닿을 수 있게 만드는 것입니다. 기본 ‘호환(compatible)’ 전략은 중복된 시각을 이전 발생 시점으로 해석합니다. 대부분의 달력 소프트웨어와 주요 운영체제가 따르는 방식이죠. 더 세밀한 제어가 필요하다면 전체 결정 트리가 바로 거기 있습니다:

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

간격(gap)도 같은 방식으로 다룹니다. 시계가 앞으로 넘어가서 오전 2시 30분이 아예 존재하지 않을 때, Jiff는 기본적으로 앞으로 밀어 주고, 역시 원하면 재정의할 수 있습니다. 여기서의 설계 판단은 의견이 뚜렷하고, 제 생각에는 옳습니다. 모호한 시각을 처리하는 대부분의 코드에는 정책이 없고, 대신 11월을 기다리는 버그가 있습니다. 사용자가 이미 휴대폰에서 기대하는 동작을 기본값으로 삼고, 탈출구는 눈에 보이고 타입으로 드러나게 두는 것, 이것이 실제로 ‘성공의 구덩이’가 뜻하는 바입니다. 이는 좋은 기본값을 설계한 직접 구현한 날짜 계산의 철학과도 비슷합니다. 규칙은 배울 수 있지만, 호출 지점마다 매번 다시 유도할 필요는 없어야 합니다.

폴드에서는 되돌아가고 갭에서는 끊기는 추상적인 리본 형태의 타임라인.
폴드(fold)와 갭(gap): 시민 시간이 순간에 깔끔하게 대응하지 않는 두 지점.

기간, 스팬, 그리고 ‘한 달’ 문제

Chrono에 ‘한 달’짜리 기간을 물어보면 실망하게 될 겁니다. Duration은 고정된 초 수이기 때문입니다. 한 달은 고정된 어떤 것의 수도 아니니까요. 이는 충분히 정당한 설계지만, 달력 연산(‘1월 31일에 3개월 더하기’)은 여러분의 몫이 된다는 뜻입니다. Jiff의 Span 타입은 다른 길을 택합니다. 연 단위부터 나노초까지 섞인 단위를 담고, 연산은 달력을 인식하는 방식으로 해결됩니다. 1월 31일에 한 달을 더하면 3월 3일이 아니라 2월 28일(또는 29일)이 됩니다. 서머타임 전환 전날 밤에 zoned 날짜·시간에 하루를 더하면 달력상 하루가 더해지며, 그 길이는 23시간이나 25시간일 수 있습니다. 이것이 사람이 ‘내일 같은 시간’이라고 말할 때 의미하는 바입니다.

경과 시간과 달력 시간의 구분은 날짜·시간 프로그래밍에서 가장 많이 혼동되는 개념이고, 어디서나 혼동되고 있습니다. Java의 원래 java.util.Date는 이 둘을 뒤섞었고, Java 8의 java.time 패키지(Joda-Time을 바탕으로 설계됨)는 Duration과 Period를 분리했으며 그 덕에 훨씬 나아졌습니다. JavaScript의 Temporal 제안도 같은 분리를 따릅니다. Jiff는 이 계보에 자연스럽게 놓입니다. 날짜·시간 설계의 좋은 아이디어들은 20년 동안 수렴해 왔고, Jiff는 본질적으로 그 합의를 Rust로 표현한 것입니다. 오래 숙성된 Rust 언어 기능들이 10년치 논쟁을 정제한 결과물로 결국 도착하는 것과 같은 맥락입니다.

‘친근한’ 기간 형식도 있습니다. 2h 30m이나 P1DT2H 같은 문자열을 자연스럽게 파싱하고 출력합니다. 여기에 strptime/strftime 스타일의 포맷팅과, 로케일에 민감한 출력을 위한 선택적 ICU4X 통합도 있습니다. 기본 기능처럼 들리지만, 로그 파이프라인을 위해 chrono 포맷 문자열을 직접 짜 본 사람이라면 이 기능이 얼마나 많은 마찰을 없애는지 알 겁니다.

Jiff vs Chrono: 각각이 이기는 경우

투어는 이 정도면 충분합니다. 이제 관점을 담은 솔직한 비교를 해보겠습니다.

Chrono가 여전히 이기는 경우

관성도 하나의 기능입니다. Chrono는 Rust 생태계의 엄청나게 많은 부분의 의존성 트리에 들어 있고, 수많은 공개 API에 등장하며, 믿을 만한 손길이 유지보수하고 있습니다. 코드베이스가 이미 chrono를 능숙하게 쓰고, 타임스탬프가 UTC 전용 순간이며(메트릭 파이프라인, 로그 엔벨로프, 내부 RPC 등을 떠올려 보세요), 팀이 그 날카로운 모서리를 잘 안다면 마이그레이션은 얻는 게 거의 없습니다. Chrono의 std 선택적, no_std 친화적인 방향도 임베디드 영역에서 여전히 중요합니다. 그리고 메가년 단위의 궤도 역학이나 TAI, UT1 같은 특이한 시간 척도를 다룬다면, 둘 중 어느 쪽도 정답이 아닙니다. 문자열 파싱을 위해 어느 한쪽을 감싸고 자체 표현을 유지하게 될 텐데, 그 가장자리에서는 chrono의 단순함이 충분합니다.

실무자들에게서 들은 정당한 반론도 있습니다. 어떤 사람들은 chrono의 명시성을 실제로 선호합니다. LocalResult::Ambiguous는 생각하도록 강제하니까요. 서머타임 중복 구간에서 잘못 추측하는 것이 법적·금전적 결과를 낳는 도메인, 예를 들어 급여 계산, 에너지 정산, 트레이딩이라면, 라이브러리가 항상 추측을 거부하기를 원할 수도 있습니다. Jiff도 unambiguous()로 그 방식을 지원하지만, chrono는 그것을 가장 저항이 적은 길로 만듭니다. 충분히 공정한 이야기입니다.

Jiff가 이기는 경우

그 외 거의 모든 곳입니다. 시민 시간을 다루는 모든 애플리케이션, 즉 스케줄링, 캘린더, 사용자 대면 날짜, 시간대를 넘나드는 모든 것은 Jiff에서 확실히 더 나은 조건을 얻습니다. 타입 이름이 도메인을 가르쳐 줍니다. 서머타임 모호함에는 합리적인 기본값과 타입이 있는 탈출구가 주어지고, 새벽 2시에 잘못 처리하게 될 열거형은 없습니다. Span은 달력 연산을 기본으로 올바르게 처리합니다. 파싱과 포맷팅은 사람들이 실제로 쓰는 친근한 형식을 다룹니다. 그리고 1.0 약속이 중요합니다. Gallant는 Jiff가 다른 라이브러리의 공개 API에 등장할 수 있도록 API를 무기한 안정적으로 유지할 의도를 밝혔습니다. 바로 chrono의 실수를 영구적으로 만든 그 속성을 반대로 활용하는 것이죠. 채택 목록도 이 야망을 뒷받침합니다. uv, Cargo, Starship, fd, Nushell, Jujutsu, uutils가 모두 사용하고, AWS의 LLRT는 Temporal 구현을 그 위에 만들었습니다.

누군가는 늘 묻는 성능 질문도 답하겠습니다. 두 라이브러리 모두 충분히 빨라서, 날짜·시간 처리가 병목이 되는 일은 거의 없습니다. Jiff는 압축된 IANA tz 데이터베이스 사본을 번들로 포함하고(rearguard tzdata 사용에 대해 문서화된 신중한 입장과 함께), 시스템의 시간대 데이터베이스를 사용할 수도 있습니다. 이 영역에서는 정확성이 마이크로벤치마크를 압도할 만큼 중요해서, 속도만 보고 고르는 것은 직무 태만에 가깝습니다. 50나노초 만에 나온 틀린 답도 여전히 틀린 답입니다.

모든 곳에서 모호함을 직접 처리하게 만드는 날짜·시간 라이브러리는 더 정직한 것이 아닙니다. 가장 어려운 문제를, 그것을 풀 준비가 가장 덜 된 사람, 즉 급하게 호출 지점에 서 있는 여러분에게 떠넘기는 것일 뿐입니다.

API 설계에 대한 더 큰 교훈

날짜를 걷어내고 보면 Jiff는 더 넓은 주장의 사례 연구입니다. 라이브러리는 도메인 복잡성을 충실히 그대로 노출하기보다 캡슐화해야 한다는 것입니다. 비판자들이 지적하듯, IANA 시간대 데이터베이스는 프로그래머 지향의 산물입니다. 위치 기반이고, 역사적으로 빠짐없이 포괄적이며, 어떤 사용자도 입력하지 않을 식별자로 가득 차 있죠. 게으른 라이브러리는 그것을 날 것 그대로 노출하고 이를 유연성이라 부릅니다. 좋은 라이브러리는 그것을 흡수합니다. 기본 모호성 해결 전략, 친근한 파싱, 사람의 개념에 대응하는 타입 이름이 그렇습니다. 같은 긴장은 다른 영역에서도 보입니다. 명세와 쓸 만한 구현 사이의 간극은 대부분의 버그가 사는 곳이고, 날짜·시간 처리는 그 간극의 자연스러운 서식지입니다.

생태계의 인내에 관한 이야기이기도 합니다. Rust는 ‘결정판’ 날짜·시간 라이브러리를 기다리는 데 10년을 보냈습니다. async가 자리 잡기를, never 타입이 안정화되기를 기다렸던 것과 같습니다. 그 기다림은 첫 번째 동작하는 초안에 묶이는 대신 모델을 제대로 잡는 데 드는 비용입니다. Chrono는 실패작이 아니었습니다. 당시 생태계에 필요했던 초안이었습니다. 하지만 초안은 수정되기 마련입니다.

추천 사항

새 Rust 프로젝트라면? Jiff를 쓰세요. 너무 고민하지 마세요. API가 더 낫고, 서머타임 처리가 기본적으로 더 안전하며, 1.0 안정성 약속이 명시적이고, 생태계의 추진력도 있습니다. Cargo와 uv는 크레이트를 아무렇게나 채택하지 않으니, 어차피 점점 더 자주 마주치게 될 겁니다. 사용자에게 보이는 것에는 ZonedDateTime을, 저장과 와이어 포맷에는 Timestamp를, 위치가 정말 적용되지 않는 경우에는 civil 타입을 쓰세요.

잘 돌아가는 기존 chrono 코드베이스라면? chrono의 함정이 실제로 비용을 치르게 하는 시민 시간 중심 기능을 건드리는 경우가 아니라면 그대로 두세요. 두 라이브러리는 타임스탬프와 ISO 문자열을 통해 잘 상호 운용되므로, 스케줄링 모듈에는 Jiff를, 나머지에는 chrono를 쓰는 부분 도입 전략은 타협이 아니라 정당한 전략입니다.

무엇을 선택하든 가장 깊은 교훈은 이것입니다. 날짜·시간 처리가 어려운 이유는 도메인 자체가 근본적으로 이상하기 때문입니다. 윤초, 폴드, 갭, 길이가 가변적인 달, 법령으로 바뀌는 정치적 시간대까지. 라이브러리가 할 수 있는 최선은 올바른 기본값을 고르고, 이름을 정직하게 붙이고, 탈출구를 가까이 두는 것입니다. Jiff는 이 세 가지를 모두 합니다. Joda-Time에서 java.time, Temporal에 이르기까지 20년 동안 날짜·시간 라이브러리가 진화하며 같은 모델로 수렴한 데는 이유가 있습니다. Rust도 마침내 그 버전을 갖게 된 것을 보니 반갑습니다.