diff --git a/gix-date/src/parse.rs b/gix-date/src/parse.rs
deleted file mode 100644
index 7f71c95180c..00000000000
--- a/gix-date/src/parse.rs
+++ /dev/null
@@ -1,439 +0,0 @@
-use std::str::FromStr;
-
-use smallvec::SmallVec;
-
-use crate::Time;
-
-#[derive(thiserror::Error, Debug, Clone)]
-#[allow(missing_docs)]
-pub enum Error {
-    #[error("Could not convert a duration into a date")]
-    RelativeTimeConversion,
-    #[error("Date string can not be parsed")]
-    InvalidDateString { input: String },
-    #[error("The heat-death of the universe happens before this date")]
-    InvalidDate(#[from] std::num::TryFromIntError),
-    #[error("Current time is missing but required to handle relative dates.")]
-    MissingCurrentTime,
-}
-
-/// A container for just enough bytes to hold the largest-possible [`time`](Time) instance.
-/// It's used in conjunction with
-#[derive(Default, Clone)]
-pub struct TimeBuf {
-    buf: SmallVec<[u8; Time::MAX.size()]>,
-}
-
-impl TimeBuf {
-    /// Represent this instance as standard string, serialized in a format compatible with
-    /// signature fields in Git commits, also known as anything parseable as [raw format](function::parse_header()).
-    pub fn as_str(&self) -> &str {
-        // SAFETY: We know that serialized times are pure ASCII, a subset of UTF-8.
-        //         `buf` and `len` are written only by time-serialization code.
-        let time_bytes = self.buf.as_slice();
-        #[allow(unsafe_code)]
-        unsafe {
-            std::str::from_utf8_unchecked(time_bytes)
-        }
-    }
-
-    /// Clear the previous content.
-    fn clear(&mut self) {
-        self.buf.clear();
-    }
-}
-
-impl std::io::Write for TimeBuf {
-    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
-        self.buf.write(buf)
-    }
-
-    fn flush(&mut self) -> std::io::Result<()> {
-        self.buf.flush()
-    }
-}
-
-impl Time {
-    /// Serialize this instance into `buf`, exactly as it would appear in the header of a Git commit,
-    /// and return `buf` as `&str` for easy consumption.
-    pub fn to_str<'a>(&self, buf: &'a mut TimeBuf) -> &'a str {
-        buf.clear();
-        self.write_to(buf)
-            .expect("write to memory of just the right size cannot fail");
-        buf.as_str()
-    }
-}
-
-impl FromStr for Time {
-    type Err = Error;
-
-    fn from_str(s: &str) -> Result<Self, Self::Err> {
-        crate::parse_header(s).ok_or_else(|| Error::InvalidDateString { input: s.into() })
-    }
-}
-
-pub(crate) mod function {
-    use std::{str::FromStr, time::SystemTime};
-
-    use jiff::{civil::Date, fmt::rfc2822, tz::TimeZone, Zoned};
-
-    use crate::{
-        parse::{relative, Error},
-        time::format::{DEFAULT, GITOXIDE, ISO8601, ISO8601_STRICT, SHORT},
-        OffsetInSeconds, SecondsSinceUnixEpoch, Time,
-    };
-
-    /// Parse `input` as any time that Git can parse when inputting a date.
-    ///
-    /// ## Examples
-    ///
-    /// ### 1. SHORT Format
-    ///
-    /// *   `2018-12-24`
-    /// *   `1970-01-01`
-    /// *   `1950-12-31`
-    /// *   `2024-12-31`
-    ///
-    /// ### 2. RFC2822 Format
-    ///
-    /// *   `Thu, 18 Aug 2022 12:45:06 +0800`
-    /// *   `Mon Oct 27 10:30:00 2023 -0800`
-    ///
-    /// ### 3. GIT_RFC2822 Format
-    ///
-    /// *   `Thu, 8 Aug 2022 12:45:06 +0800`
-    /// *   `Mon Oct 27 10:30:00 2023 -0800` (Note the single-digit day)
-    ///
-    /// ### 4. ISO8601 Format
-    ///
-    /// *   `2022-08-17 22:04:58 +0200`
-    /// *   `1970-01-01 00:00:00 -0500`
-    ///
-    /// ### 5. ISO8601_STRICT Format
-    ///
-    /// *   `2022-08-17T21:43:13+08:00`
-    ///
-    /// ### 6. UNIX Timestamp (Seconds Since Epoch)
-    ///
-    /// *   `123456789`
-    /// *   `0` (January 1, 1970 UTC)
-    /// *   `-1000`
-    /// *   `1700000000`
-    ///
-    /// ### 7. Commit Header Format
-    ///
-    /// *   `1745582210 +0200`
-    /// *   `1660874655 +0800`
-    /// *   `-1660874655 +0800`
-    ///
-    /// See also the [`parse_header()`].
-    ///
-    /// ### 8. GITOXIDE Format
-    ///
-    /// *   `Thu Sep 04 2022 10:45:06 -0400`
-    /// *   `Mon Oct 27 2023 10:30:00 +0000`
-    ///
-    /// ### 9. DEFAULT Format
-    ///
-    /// *   `Thu Sep 4 10:45:06 2022 -0400`
-    /// *   `Mon Oct 27 10:30:00 2023 +0000`
-    ///
-    /// ### 10. Relative Dates (e.g., "2 minutes ago", "1 hour from now")
-    ///
-    /// These dates are parsed *relative to a `now` timestamp*. The examples depend entirely on the value of `now`.
-    /// If `now` is October 27, 2023 at 10:00:00 UTC:
-    ///     *   `2 minutes ago` (October 27, 2023 at 09:58:00 UTC)
-    ///     *   `3 hours ago` (October 27, 2023 at 07:00:00 UTC)
-    pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
-        Ok(if let Ok(val) = Date::strptime(SHORT.0, input) {
-            let val = val
-                .to_zoned(TimeZone::UTC)
-                .map_err(|_| Error::InvalidDateString { input: input.into() })?;
-            Time::new(val.timestamp().as_second(), val.offset().seconds())
-        } else if let Ok(val) = rfc2822_relaxed(input) {
-            Time::new(val.timestamp().as_second(), val.offset().seconds())
-        } else if let Ok(val) = strptime_relaxed(ISO8601.0, input) {
-            Time::new(val.timestamp().as_second(), val.offset().seconds())
-        } else if let Ok(val) = strptime_relaxed(ISO8601_STRICT.0, input) {
-            Time::new(val.timestamp().as_second(), val.offset().seconds())
-        } else if let Ok(val) = strptime_relaxed(GITOXIDE.0, input) {
-            Time::new(val.timestamp().as_second(), val.offset().seconds())
-        } else if let Ok(val) = strptime_relaxed(DEFAULT.0, input) {
-            Time::new(val.timestamp().as_second(), val.offset().seconds())
-        } else if let Ok(val) = SecondsSinceUnixEpoch::from_str(input) {
-            // Format::Unix
-            Time::new(val, 0)
-        } else if let Some(val) = relative::parse(input, now).transpose()? {
-            Time::new(val.timestamp().as_second(), val.offset().seconds())
-        } else if let Some(val) = parse_raw(input) {
-            // Format::Raw
-            val
-        } else {
-            return Err(Error::InvalidDateString { input: input.into() });
-        })
-    }
-
-    /// Unlike [`parse()`] which handles all kinds of input, this function only parses the commit-header format
-    /// like `1745582210 +0200`.
-    ///
-    /// Note that failure to parse the time zone isn't fatal, instead it will default to `0`. To know if
-    /// the time is wonky, serialize the return value to see if it matches the `input.`
-    pub fn parse_header(input: &str) -> Option<Time> {
-        pub enum Sign {
-            Plus,
-            Minus,
-        }
-        fn parse_offset(offset: &str) -> Option<OffsetInSeconds> {
-            if (offset.len() != 5) && (offset.len() != 7) {
-                return None;
-            }
-            let sign = match offset.get(..1)? {
-                "-" => Some(Sign::Minus),
-                "+" => Some(Sign::Plus),
-                _ => None,
-            }?;
-            if offset.as_bytes().get(1).is_some_and(|b| !b.is_ascii_digit()) {
-                return None;
-            }
-            let hours: i32 = offset.get(1..3)?.parse().ok()?;
-            let minutes: i32 = offset.get(3..5)?.parse().ok()?;
-            let offset_seconds: i32 = if offset.len() == 7 {
-                offset.get(5..7)?.parse().ok()?
-            } else {
-                0
-            };
-            let mut offset_in_seconds = hours * 3600 + minutes * 60 + offset_seconds;
-            if matches!(sign, Sign::Minus) {
-                offset_in_seconds *= -1;
-            }
-            Some(offset_in_seconds)
-        }
-
-        if input.contains(':') {
-            return None;
-        }
-        let mut split = input.split_whitespace();
-        let seconds = split.next()?;
-        let seconds = match seconds.parse::<SecondsSinceUnixEpoch>() {
-            Ok(s) => s,
-            Err(_err) => {
-                // Inefficient, but it's not the common case.
-                let first_digits: String = seconds.chars().take_while(char::is_ascii_digit).collect();
-                first_digits.parse().ok()?
-            }
-        };
-        let offset = match split.next() {
-            None => 0,
-            Some(offset) => {
-                if split.next().is_some() {
-                    0
-                } else {
-                    parse_offset(offset).unwrap_or_default()
-                }
-            }
-        };
-        let time = Time { seconds, offset };
-        Some(time)
-    }
-
-    /// Strictly parse the raw commit header format like `1745582210 +0200`.
-    ///
-    /// Some strict rules include:
-    ///
-    /// - The timezone offset must be present.
-    /// - The timezone offset must have a sign; either `+` or `-`.
-    /// - The timezone offset hours must be less than or equal to 14.
-    /// - The timezone offset minutes must be exactly 0, 15, 30, or 45.
-    /// - The timezone offset seconds may be present, but 0 is the only valid value.
-    /// - Only whitespace may suffix the timezone offset.
-    ///
-    /// But this function isn't perfectly strict insofar as it allows arbitrary
-    /// whitespace before and after the seconds and offset components.
-    ///
-    /// The goal is to only accept inputs that _unambiguously_ look like
-    /// git's raw date format.
-    fn parse_raw(input: &str) -> Option<Time> {
-        let mut split = input.split_whitespace();
-        let seconds = split.next()?.parse::<SecondsSinceUnixEpoch>().ok()?;
-        let offset_str = split.next()?;
-        if split.next().is_some() {
-            return None;
-        }
-        let offset_len = offset_str.len();
-        if offset_len != 5 && offset_len != 7 {
-            return None;
-        }
-        let sign: i32 = match offset_str.get(..1)? {
-            "-" => Some(-1),
-            "+" => Some(1),
-            _ => None,
-        }?;
-        let hours: u8 = offset_str.get(1..3)?.parse().ok()?;
-        let minutes: u8 = offset_str.get(3..5)?.parse().ok()?;
-        let offset_seconds: u8 = if offset_len == 7 {
-            offset_str.get(5..7)?.parse().ok()?
-        } else {
-            0
-        };
-        if hours > 14 || (minutes != 0 && minutes != 15 && minutes != 30 && minutes != 45) || offset_seconds != 0 {
-            return None;
-        }
-        let offset: i32 = sign * ((hours as i32) * 3600 + (minutes as i32) * 60);
-        Time { seconds, offset }.into()
-    }
-
-    /// This is just like `Zoned::strptime`, but it allows parsing datetimes
-    /// whose weekdays are inconsistent with the date. While the day-of-week
-    /// still must be parsed, it is otherwise ignored. This seems to be
-    /// consistent with how `git` behaves.
-    fn strptime_relaxed(fmt: &str, input: &str) -> Result<Zoned, jiff::Error> {
-        let mut tm = jiff::fmt::strtime::parse(fmt, input)?;
-        tm.set_weekday(None);
-        tm.to_zoned()
-    }
-
-    /// This is just like strptime_relaxed, except for RFC 2822 parsing.
-    /// Namely, it permits the weekday to be inconsistent with the date.
-    fn rfc2822_relaxed(input: &str) -> Result<Zoned, jiff::Error> {
-        static P: rfc2822::DateTimeParser = rfc2822::DateTimeParser::new().relaxed_weekday(true);
-        P.parse_zoned(input)
-    }
-
-    #[cfg(test)]
-    mod tests {
-        use super::*;
-
-        #[test]
-        fn parse_raw_valid() {
-            // These examples show how it's more loose than it has to be,
-            // merely as a side effect of the implementation.
-            for (valid, expected_seconds, expected_offset) in [
-                ("12345 +0000", 12345, 0),
-                ("-1234567 +0000", -1234567, 0),
-                ("+1234567 -000000", 1234567, 0),
-                ("   +0    -000000    ", 0, 0),
-                ("\t-0\t-0000\t", 0, 0),
-                ("\n-0\r\n-0000\n", 0, 0),
-            ] {
-                assert_eq!(
-                    parse_raw(valid),
-                    Some(Time {
-                        seconds: expected_seconds,
-                        offset: expected_offset
-                    }),
-                    "should succeed: '{valid}'"
-                );
-            }
-        }
-
-        #[test]
-        fn parse_raw_invalid() {
-            for (bad_date_str, message) in [
-                ("123456 !0600", "invalid sign - must be + or -"),
-                ("123456 0600", "missing offset sign"),
-                ("123456 +060", "positive offset too short"),
-                ("123456 -060", "negative offset too short"),
-                ("123456 +06000", "not enough offset seconds"),
-                ("123456 --060", "duplicate offset sign with correct offset length"),
-                ("123456 -+060", "multiple offset signs with correct offset length"),
-                ("123456 --0600", "multiple offset signs, but incorrect offset length"),
-                ("123456 +-06000", "multiple offset signs with correct offset length"),
-                ("123456 +-0600", "multiple offset signs with incorrect offset length"),
-                ("123456 +-060", "multiple offset signs with correct offset length"),
-                ("123456 +10030", "invalid offset length with one 'second' field"),
-                ("123456 06000", "invalid offset length, missing sign"),
-                ("123456 +0600 extra", "extra field past offset"),
-                ("123456 +0600 2005", "extra field past offset that looks like year"),
-                ("123456+0600", "missing space between unix timestamp and offset"),
-                (
-                    "123456 + 600",
-                    "extra spaces between sign and offset (which also is too short)",
-                ),
-                ("123456 -1500", "negative offset hours out of bounds"),
-                ("123456 +1500", "positive offset hours out of bounds"),
-                ("123456 +6600", "positive offset hours out of bounds"),
-                ("123456 +0660", "invalid offset minutes"),
-                ("123456 +060010", "positive offset seconds is allowed but only if zero"),
-                ("123456 -060010", "negative offset seconds is allowed but only if zero"),
-                ("123456 +0075", "positive offset minutes invalid"),
-                ("++123456 +0000", "duplicate timestamp sign"),
-                ("--123456 +0000", "duplicate timestamp sign"),
-                ("1234567 -+1+1+0", "unsigned offset parsing rejects '+'"),
-            ] {
-                assert!(
-                    parse_raw(bad_date_str).is_none(),
-                    "should fail: '{bad_date_str}': {message}"
-                );
-            }
-        }
-    }
-}
-
-mod relative {
-    use std::{str::FromStr, time::SystemTime};
-
-    use jiff::{tz::TimeZone, Span, Timestamp, Zoned};
-
-    use crate::parse::Error;
-
-    fn parse_inner(input: &str) -> Option<Result<Span, Error>> {
-        let mut split = input.split_whitespace();
-        let units = i64::from_str(split.next()?).ok()?;
-        let period = split.next()?;
-        if split.next()? != "ago" {
-            return None;
-        }
-        span(period, units)
-    }
-
-    pub(crate) fn parse(input: &str, now: Option<SystemTime>) -> Option<Result<Zoned, Error>> {
-        parse_inner(input).map(|result| {
-            let span = result?;
-            // This was an error case in a previous version of this code, where
-            // it would fail when converting from a negative signed integer
-            // to an unsigned integer. This preserves that failure case even
-            // though the code below handles it okay.
-            if span.is_negative() {
-                return Err(Error::RelativeTimeConversion);
-            }
-            now.ok_or(Error::MissingCurrentTime).and_then(|now| {
-                let ts = Timestamp::try_from(now).map_err(|_| Error::RelativeTimeConversion)?;
-                // N.B. This matches the behavior of this code when it was
-                // written with `time`, but we might consider using the system
-                // time zone here. If we did, then it would implement "1 day
-                // ago" correctly, even when it crosses DST transitions. Since
-                // we're in the UTC time zone here, which has no DST, 1 day is
-                // in practice always 24 hours. ---AG
-                let zdt = ts.to_zoned(TimeZone::UTC);
-                zdt.checked_sub(span).map_err(|_| Error::RelativeTimeConversion)
-            })
-        })
-    }
-
-    fn span(period: &str, units: i64) -> Option<Result<Span, Error>> {
-        let period = period.strip_suffix('s').unwrap_or(period);
-        let result = match period {
-            "second" => Span::new().try_seconds(units),
-            "minute" => Span::new().try_minutes(units),
-            "hour" => Span::new().try_hours(units),
-            "day" => Span::new().try_days(units),
-            "week" => Span::new().try_weeks(units),
-            "month" => Span::new().try_months(units),
-            "year" => Span::new().try_years(units),
-            // Ignore values you don't know, assume seconds then (so does git)
-            _anything => Span::new().try_seconds(units),
-        };
-        Some(result.map_err(|_| Error::RelativeTimeConversion))
-    }
-
-    #[cfg(test)]
-    mod tests {
-        use super::*;
-
-        #[test]
-        fn two_weeks_ago() {
-            let actual = parse_inner("2 weeks ago").unwrap().unwrap();
-            assert_eq!(actual.fieldwise(), Span::new().weeks(2));
-        }
-    }
-}
diff --git a/gix-date/src/parse/function.rs b/gix-date/src/parse/function.rs
new file mode 100644
index 00000000000..00b000be4d2
--- /dev/null
+++ b/gix-date/src/parse/function.rs
@@ -0,0 +1,182 @@
+use std::{str::FromStr, time::SystemTime};
+
+use jiff::{civil::Date, fmt::rfc2822, tz::TimeZone, Zoned};
+
+use crate::parse::git::parse_git_date_format;
+use crate::parse::raw::parse_raw;
+use crate::{
+    parse::{relative, Error},
+    time::format::{DEFAULT, GITOXIDE, ISO8601, ISO8601_STRICT, SHORT},
+    OffsetInSeconds, SecondsSinceUnixEpoch, Time,
+};
+
+/// Parse `input` as any time that Git can parse when inputting a date.
+///
+/// ## Examples
+///
+/// ### 1. SHORT Format
+///
+/// *   `2018-12-24`
+/// *   `1970-01-01`
+/// *   `1950-12-31`
+/// *   `2024-12-31`
+///
+/// ### 2. RFC2822 Format
+///
+/// *   `Thu, 18 Aug 2022 12:45:06 +0800`
+/// *   `Mon Oct 27 10:30:00 2023 -0800`
+///
+/// ### 3. GIT_RFC2822 Format
+///
+/// *   `Thu, 8 Aug 2022 12:45:06 +0800`
+/// *   `Mon Oct 27 10:30:00 2023 -0800` (Note the single-digit day)
+///
+/// ### 4. ISO8601 Format
+///
+/// *   `2022-08-17 22:04:58 +0200`
+/// *   `1970-01-01 00:00:00 -0500`
+///
+/// ### 5. ISO8601_STRICT Format
+///
+/// *   `2022-08-17T21:43:13+08:00`
+///
+/// ### 6. UNIX Timestamp (Seconds Since Epoch)
+///
+/// *   `123456789`
+/// *   `0` (January 1, 1970 UTC)
+/// *   `-1000`
+/// *   `1700000000`
+///
+/// ### 7. Commit Header Format
+///
+/// *   `1745582210 +0200`
+/// *   `1660874655 +0800`
+/// *   `-1660874655 +0800`
+///
+/// See also the [`parse_header()`].
+///
+/// ### 8. GITOXIDE Format
+///
+/// *   `Thu Sep 04 2022 10:45:06 -0400`
+/// *   `Mon Oct 27 2023 10:30:00 +0000`
+///
+/// ### 9. DEFAULT Format
+///
+/// *   `Thu Sep 4 10:45:06 2022 -0400`
+/// *   `Mon Oct 27 10:30:00 2023 +0000`
+///
+/// ### 10. Relative Dates (e.g., "2 minutes ago", "1 hour from now")
+///
+/// These dates are parsed *relative to a `now` timestamp*. The examples depend entirely on the value of `now`.
+/// If `now` is October 27, 2023 at 10:00:00 UTC:
+///     *   `2 minutes ago` (October 27, 2023 at 09:58:00 UTC)
+///     *   `3 hours ago` (October 27, 2023 at 07:00:00 UTC)
+pub fn parse(input: &str, now: Option<SystemTime>) -> Result<Time, Error> {
+    Ok(if let Ok(val) = Date::strptime(SHORT.0, input) {
+        let val = val
+            .to_zoned(TimeZone::UTC)
+            .map_err(|_| Error::InvalidDateString { input: input.into() })?;
+        Time::new(val.timestamp().as_second(), val.offset().seconds())
+    } else if let Ok(val) = rfc2822_relaxed(input) {
+        Time::new(val.timestamp().as_second(), val.offset().seconds())
+    } else if let Ok(val) = strptime_relaxed(ISO8601.0, input) {
+        Time::new(val.timestamp().as_second(), val.offset().seconds())
+    } else if let Ok(val) = strptime_relaxed(ISO8601_STRICT.0, input) {
+        Time::new(val.timestamp().as_second(), val.offset().seconds())
+    } else if let Ok(val) = strptime_relaxed(GITOXIDE.0, input) {
+        Time::new(val.timestamp().as_second(), val.offset().seconds())
+    } else if let Ok(val) = strptime_relaxed(DEFAULT.0, input) {
+        Time::new(val.timestamp().as_second(), val.offset().seconds())
+    } else if let Ok(val) = SecondsSinceUnixEpoch::from_str(input) {
+        Time::new(val, 0)
+    } else if let Some(val) = parse_git_date_format(input) {
+        val
+    } else if let Some(val) = relative::parse(input, now).transpose()? {
+        Time::new(val.timestamp().as_second(), val.offset().seconds())
+    } else if let Some(val) = parse_raw(input) {
+        // Format::Raw
+        val
+    } else {
+        return Err(Error::InvalidDateString { input: input.into() });
+    })
+}
+
+/// Unlike [`parse()`] which handles all kinds of input, this function only parses the commit-header format
+/// like `1745582210 +0200`.
+///
+/// Note that failure to parse the time zone isn't fatal, instead it will default to `0`. To know if
+/// the time is wonky, serialize the return value to see if it matches the `input.`
+pub fn parse_header(input: &str) -> Option<Time> {
+    pub enum Sign {
+        Plus,
+        Minus,
+    }
+    fn parse_offset(offset: &str) -> Option<OffsetInSeconds> {
+        if (offset.len() != 5) && (offset.len() != 7) {
+            return None;
+        }
+        let sign = match offset.get(..1)? {
+            "-" => Some(Sign::Minus),
+            "+" => Some(Sign::Plus),
+            _ => None,
+        }?;
+        if offset.as_bytes().get(1).is_some_and(|b| !b.is_ascii_digit()) {
+            return None;
+        }
+        let hours: i32 = offset.get(1..3)?.parse().ok()?;
+        let minutes: i32 = offset.get(3..5)?.parse().ok()?;
+        let offset_seconds: i32 = if offset.len() == 7 {
+            offset.get(5..7)?.parse().ok()?
+        } else {
+            0
+        };
+        let mut offset_in_seconds = hours * 3600 + minutes * 60 + offset_seconds;
+        if matches!(sign, Sign::Minus) {
+            offset_in_seconds *= -1;
+        }
+        Some(offset_in_seconds)
+    }
+
+    if input.contains(':') {
+        return None;
+    }
+    let mut split = input.split_whitespace();
+    let seconds = split.next()?;
+    let seconds = match seconds.parse::<SecondsSinceUnixEpoch>() {
+        Ok(s) => s,
+        Err(_err) => {
+            // Inefficient, but it's not the common case.
+            let first_digits: String = seconds.chars().take_while(char::is_ascii_digit).collect();
+            first_digits.parse().ok()?
+        }
+    };
+    let offset = match split.next() {
+        None => 0,
+        Some(offset) => {
+            if split.next().is_some() {
+                0
+            } else {
+                parse_offset(offset).unwrap_or_default()
+            }
+        }
+    };
+    let time = Time { seconds, offset };
+    Some(time)
+}
+
+/// This is just like `Zoned::strptime`, but it allows parsing datetimes
+/// whose weekdays are inconsistent with the date. While the day-of-week
+/// still must be parsed, it is otherwise ignored. This seems to be
+/// consistent with how `git` behaves.
+fn strptime_relaxed(fmt: &str, input: &str) -> Result<Zoned, jiff::Error> {
+    let mut tm = jiff::fmt::strtime::parse(fmt, input)?;
+    tm.set_weekday(None);
+    tm.to_zoned()
+}
+
+/// This is just like strptime_relaxed, except for RFC 2822 parsing.
+/// Namely, it permits the weekday to be inconsistent with the date.
+fn rfc2822_relaxed(input: &str) -> Result<Zoned, jiff::Error> {
+    static P: rfc2822::DateTimeParser = rfc2822::DateTimeParser::new().relaxed_weekday(true);
+    P.parse_zoned(input)
+}
diff --git a/gix-date/src/parse/git.rs b/gix-date/src/parse/git.rs
new file mode 100644
index 00000000000..ff0625a3d8b
--- /dev/null
+++ b/gix-date/src/parse/git.rs
@@ -0,0 +1,292 @@
+use crate::Time;
+use jiff::Zoned;
+
+/// Parse Git-style flexible date formats that aren't covered by standard strptime:
+/// - ISO8601 with dots: `2008.02.14 20:30:45 -0500`
+/// - Compact ISO8601: `20080214T203045`, `20080214T20:30:45`, `20080214T2030`, `20080214T20`
+/// - Z suffix for UTC: `1970-01-01 00:00:00 Z`
+/// - 2-digit hour offset: `2008-02-14 20:30:45 -05`
+/// - Colon-separated offset: `2008-02-14 20:30:45 -05:00`
+/// - Subsecond precision (ignored): `20080214T203045.019-04:00`
+// TODO: this can probably be done more smartly, right now it's more of a brute force. Learn from Git here.
+//       After all, this is generated to have something quickly.
+pub fn parse_git_date_format(input: &str) -> Option<Time> {
+    parse_iso8601_dots(input)
+        .or_else(|| parse_compact_iso8601(input))
+        .or_else(|| parse_flexible_iso8601(input))
+}
+
+/// Parse ISO8601 with dots: `2008.02.14 20:30:45 -0500`
+fn parse_iso8601_dots(input: &str) -> Option<Time> {
+    // Format: YYYY.MM.DD HH:MM:SS offset
+    let input = input.trim();
+    let first_10 = input.get(..10)?;
+    if !first_10.is_ascii() || !first_10.contains('.') {
+        return None;
+    }
+
+    // Replace dots with dashes for date part only
+    let (date_part, rest) = input.split_once(' ')?;
+
+    // Validate date part has dot separators
+    if date_part.len() != 10 || date_part.chars().nth(4)? != '.' || date_part.chars().nth(7)? != '.' {
+        return None;
+    }
+
+    // Convert to standard ISO8601 format
+    let normalized = format!("{} {}", date_part.replace('.', "-"), rest);
+    parse_flexible_iso8601(&normalized)
+}
+
+/// Parse compact ISO8601 formats:
+/// - `20080214T203045` (compact time)
+/// - `20080214T20:30:45` (normal time)
+/// - `20080214T2030` (hours and minutes only)
+/// - `20080214T20` (hours only)
+/// - With optional subsecond precision (ignored)
+/// - With optional timezone
+fn parse_compact_iso8601(input: &str) -> Option<Time> {
+    let input = input.trim();
+
+    // Must have T separator and start with 8 digits for YYYYMMDD
+    let t_pos = input.find('T')?;
+    if t_pos != 8 {
+        return None;
+    }
+
+    let date_part = &input.get(..8)?;
+    // Verify date part is ASCII (valid date chars are all ASCII)
+    if !date_part.is_ascii() {
+        return None;
+    }
+    // Parse YYYYMMDD
+    let year: i32 = date_part[0..4].parse().ok()?;
+    let month: i32 = date_part[4..6].parse().ok()?;
+    let day: i32 = date_part[6..8].parse().ok()?;
+
+    // Parse time part - may have colons or not, may have subseconds, may have timezone
+    let rest = &input.get(9..)?; // after T
+    let (time_str, offset_str) = split_time_and_offset(rest);
+
+    // Strip subseconds (anything after a dot in the time part, before offset)
+    let time_str = if let Some(dot_pos) = time_str.find('.') {
+        &time_str[..dot_pos]
+    } else {
+        time_str
+    };
+
+    // Parse time - could be HH:MM:SS, HHMMSS, HH:MM, HHMM, or HH
+    let (hour, minute, second) = parse_time_component(time_str)?;
+
+    // Parse offset
+    let offset = parse_flexible_offset(offset_str)?;
+
+    // Construct the datetime
+    let zoned = new_zoned(year, month, day, hour, minute, second, offset)?;
+    Time::new(zoned.timestamp().as_second(), offset).into()
+}
+
+/// Parse ISO8601 with flexible timezone (Z suffix, 2-digit offset, colon-separated offset)
+/// and optional subsecond precision
+fn parse_flexible_iso8601(input: &str) -> Option<Time> {
+    let input = input.trim();
+
+    // Check if this looks like ISO8601 (YYYY-MM-DD format)
+    let date_part = &input.get(..10)?;
+    // Verify date part is ASCII (valid date chars are all ASCII)
+    if !date_part.is_ascii() {
+        return None;
+    }
+    if date_part.chars().nth(4)? != '-' || date_part.chars().nth(7)? != '-' {
+        return None;
+    }
+
+    // Parse the date
+    let year: i32 = date_part[0..4].parse().ok()?;
+    let month: i32 = date_part[5..7].parse().ok()?;
+    let day: i32 = date_part[8..10].parse().ok()?;
+
+    // Rest after date
+    let rest = &input.get(10..)?;
+    if rest.is_empty() {
+        return None;
+    }
+
+    // Skip T or space separator
+    let rest = if rest.starts_with('T') || rest.starts_with(' ') {
+        &rest[1..]
+    } else {
+        return None;
+    };
+
+    // Split into time and offset
+    let (time_str, offset_str) = split_time_and_offset(rest);
+
+    // Strip subseconds
+    let time_str = if let Some(dot_pos) = time_str.find('.') {
+        &time_str[..dot_pos]
+    } else {
+        time_str
+    };
+
+    // Parse time HH:MM:SS
+    let (hour, minute, second) = parse_time_component(time_str)?;
+
+    // Parse offset
+    let offset = parse_flexible_offset(offset_str)?;
+
+    // Construct the datetime
+    let zoned = new_zoned(year, month, day, hour, minute, second, offset)?;
+    Some(Time::new(zoned.timestamp().as_second(), offset))
+}
+
+fn new_zoned(year: i32, month: i32, day: i32, hour: u32, minute: u32, second: u32, offset: i32) -> Option<Zoned> {
+    if !(1..=12).contains(&month) || !(1..=31).contains(&day) {
+        return None;
+    }
+    let date = jiff::civil::Date::new(year as i16, month as i8, day as i8).ok()?;
+    let datetime = date.at(hour as i8, minute as i8, second as i8, 0);
+    let tz_offset = jiff::tz::Offset::from_seconds(offset).ok()?;
+    let zoned = datetime.to_zoned(tz_offset.to_time_zone()).ok()?;
+    zoned.into()
+}
+
+/// Split time string into time component and offset component
+fn split_time_and_offset(input: &str) -> (&str, &str) {
+    // Look for offset indicators: Z, +, - (but - after digits could be in time)
+    // The offset is at the end, after the time
+    let input = input.trim();
+
+    // Check for Z suffix
+    if let Some(stripped) = input.strip_suffix('Z') {
+        return (stripped, "Z");
+    }
+
+    // Look for + or - that indicates timezone (not part of time)
+    // Time format is HH:MM:SS or HHMMSS, so offset starts after that
+    // Find the last + or - that's after position 5 (minimum for HH:MM)
+    let mut offset_start = None;
+    for (i, c) in input.char_indices().rev() {
+        if (c == '+' || c == '-') && i >= 5 {
+            // Check if this looks like an offset (followed by digits)
+            let after = &input[i + 1..];
+            if after.chars().next().is_some_and(|c| c.is_ascii_digit()) {
+                offset_start = Some(i);
+                break;
+            }
+        }
+    }
+
+    // Also handle space-separated offset
+    if let Some(space_pos) = input.rfind(' ') {
+        if space_pos > 5 {
+            let potential_offset = input[space_pos + 1..].trim();
+            if potential_offset.starts_with('+') || potential_offset.starts_with('-') || potential_offset == "Z" {
+                return (&input[..space_pos], potential_offset);
+            }
+        }
+    }
+
+    if let Some(pos) = offset_start {
+        (&input[..pos], &input[pos..])
+    } else {
+        (input, "")
+    }
+}
+
+/// Parse time component: HH:MM:SS, HHMMSS, HH:MM, HHMM, or HH
+fn parse_time_component(time: &str) -> Option<(u32, u32, u32)> {
+    let time = time.trim();
+
+    // Time components must be ASCII
+    if !time.is_ascii() {
+        return None;
+    }
+
+    let (hour, minute, second) = if time.contains(':') {
+        // Colon-separated: HH:MM:SS or HH:MM
+        let parts: Vec<&str> = time.split(':').collect();
+        let hour: u32 = parts.first()?.parse().ok()?;
+        let minute: u32 = parts.get(1).unwrap_or(&"0").parse().ok()?;
+        let second: u32 = parts.get(2).unwrap_or(&"0").parse().ok()?;
+        Some((hour, minute, second))
+    } else {
+        // Compact: HHMMSS, HHMM, or HH
+        match time.len() {
+            2 => {
+                let hour: u32 = time.parse().ok()?;
+                Some((hour, 0, 0))
+            }
+            4 => {
+                let hour: u32 = time[0..2].parse().ok()?;
+                let minute: u32 = time[2..4].parse().ok()?;
+                Some((hour, minute, 0))
+            }
+            6 => {
+                let hour: u32 = time[0..2].parse().ok()?;
+                let minute: u32 = time[2..4].parse().ok()?;
+                let second: u32 = time[4..6].parse().ok()?;
+                Some((hour, minute, second))
+            }
+            _ => None,
+        }
+    }?;
+    if hour > 23 || minute > 59 || second > 59 {
+        return None;
+    }
+    (hour, minute, second).into()
+}
+
+/// Parse flexible timezone offset:
+/// - Empty or missing: +0000
+/// - Z: +0000
+/// - +/-HH: +/-HH00
+/// - +/-HHMM: +/-HHMM
+/// - +/-HH:MM: +/-HHMM
+fn parse_flexible_offset(offset: &str) -> Option<i32> {
+    let offset = offset.trim();
+
+    if offset.is_empty() {
+        return Some(0);
+    }
+
+    // Offset must be ASCII
+    if !offset.is_ascii() {
+        return None;
+    }
+
+    if offset == "Z" {
+        return Some(0);
+    }
+
+    let (sign, rest) = if let Some(stripped) = offset.strip_prefix('+') {
+        (1, stripped)
+    } else if let Some(stripped) = offset.strip_prefix('-') {
+        (-1, stripped)
+    } else {
+        return None;
+    };
+
+    // Remove colon if present
+    let rest = rest.replace(':', "");
+    let (hours, minutes) = match rest.len() {
+        2 => {
+            // HH format
+            let hours: i32 = rest.parse().ok()?;
+            (hours, 0)
+        }
+        4 => {
+            // HHMM format
+            let hours: i32 = rest[0..2].parse().ok()?;
+            let minutes: i32 = rest[2..4].parse().ok()?;
+            (hours, minutes)
+        }
+        _ => return None,
+    };
+
+    if hours > 23 || minutes > 59 {
+        return None;
+    }
+
+    Some(sign * (hours * 3600 + minutes * 60))
+}
diff --git a/gix-date/src/parse/mod.rs b/gix-date/src/parse/mod.rs
new file mode 100644
index 00000000000..943c82887f9
--- /dev/null
+++ b/gix-date/src/parse/mod.rs
@@ -0,0 +1,78 @@
+use std::str::FromStr;
+
+use smallvec::SmallVec;
+
+use crate::Time;
+
+#[derive(thiserror::Error, Debug, Clone)]
+#[allow(missing_docs)]
+pub enum Error {
+    #[error("Could not convert a duration into a date")]
+    RelativeTimeConversion,
+    #[error("Date string can not be parsed")]
+    InvalidDateString { input: String },
+    #[error("The heat-death of the universe happens before this date")]
+    InvalidDate(#[from] std::num::TryFromIntError),
+    #[error("Current time is missing but required to handle relative dates.")]
+    MissingCurrentTime,
+}
+
+/// A container for just enough bytes to hold the largest-possible [`time`](Time) instance.
+/// It's used in conjunction with
+#[derive(Default, Clone)]
+pub struct TimeBuf {
+    buf: SmallVec<[u8; Time::MAX.size()]>,
+}
+
+impl TimeBuf {
+    /// Represent this instance as standard string, serialized in a format compatible with
+    /// signature fields in Git commits, also known as anything parseable as [raw format](function::parse_header()).
+    pub fn as_str(&self) -> &str {
+        // SAFETY: We know that serialized times are pure ASCII, a subset of UTF-8.
+        //         `buf` and `len` are written only by time-serialization code.
+        let time_bytes = self.buf.as_slice();
+        #[allow(unsafe_code)]
+        unsafe {
+            std::str::from_utf8_unchecked(time_bytes)
+        }
+    }
+
+    /// Clear the previous content.
+    fn clear(&mut self) {
+        self.buf.clear();
+    }
+}
+
+impl std::io::Write for TimeBuf {
+    fn write(&mut self, buf: &[u8]) -> std::io::Result<usize> {
+        self.buf.write(buf)
+    }
+
+    fn flush(&mut self) -> std::io::Result<()> {
+        self.buf.flush()
+    }
+}
+
+impl Time {
+    /// Serialize this instance into `buf`, exactly as it would appear in the header of a Git commit,
+    /// and return `buf` as `&str` for easy consumption.
+    pub fn to_str<'a>(&self, buf: &'a mut TimeBuf) -> &'a str {
+        buf.clear();
+        self.write_to(buf)
+            .expect("write to memory of just the right size cannot fail");
+        buf.as_str()
+    }
+}
+
+impl FromStr for Time {
+    type Err = Error;
+
+    fn from_str(s: &str) -> Result<Self, Self::Err> {
+        crate::parse_header(s).ok_or_else(|| Error::InvalidDateString { input: s.into() })
+    }
+}
+
+pub(crate) mod function;
+mod git;
+mod raw;
+mod relative;
diff --git a/gix-date/src/parse/raw.rs b/gix-date/src/parse/raw.rs
new file mode 100644
index 00000000000..8cb165cfd58
--- /dev/null
+++ b/gix-date/src/parse/raw.rs
@@ -0,0 +1,116 @@
+use crate::{SecondsSinceUnixEpoch, Time};
+
+/// Strictly parse the raw commit header format like `1745582210 +0200`.
+///
+/// Some strict rules include:
+///
+/// - The timezone offset must be present.
+/// - The timezone offset must have a sign; either `+` or `-`.
+/// - The timezone offset hours must be less than or equal to 14.
+/// - The timezone offset minutes must be exactly 0, 15, 30, or 45.
+/// - The timezone offset seconds may be present, but 0 is the only valid value.
+/// - Only whitespace may suffix the timezone offset.
+///
+/// But this function isn't perfectly strict insofar as it allows arbitrary
+/// whitespace before and after the seconds and offset components.
+///
+/// The goal is to only accept inputs that _unambiguously_ look like
+/// git's raw date format.
+pub fn parse_raw(input: &str) -> Option<Time> {
+    let mut split = input.split_whitespace();
+    let seconds = split.next()?.parse::<SecondsSinceUnixEpoch>().ok()?;
+    let offset_str = split.next()?;
+    if split.next().is_some() {
+        return None;
+    }
+    let offset_len = offset_str.len();
+    if offset_len != 5 && offset_len != 7 {
+        return None;
+    }
+    let sign: i32 = match offset_str.get(..1)? {
+        "-" => Some(-1),
+        "+" => Some(1),
+        _ => None,
+    }?;
+    let hours: u8 = offset_str.get(1..3)?.parse().ok()?;
+    let minutes: u8 = offset_str.get(3..5)?.parse().ok()?;
+    let offset_seconds: u8 = if offset_len == 7 {
+        offset_str.get(5..7)?.parse().ok()?
+    } else {
+        0
+    };
+    if hours > 14 || (minutes != 0 && minutes != 15 && minutes != 30 && minutes != 45) || offset_seconds != 0 {
+        return None;
+    }
+    let offset: i32 = sign * ((hours as i32) * 3600 + (minutes as i32) * 60);
+    Time { seconds, offset }.into()
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn parse_raw_valid() {
+        // These examples show how it's more loose than it has to be,
+        // merely as a side effect of the implementation.
+        for (valid, expected_seconds, expected_offset) in [
+            ("12345 +0000", 12345, 0),
+            ("-1234567 +0000", -1234567, 0),
+            ("+1234567 -000000", 1234567, 0),
+            ("   +0    -000000    ", 0, 0),
+            ("\t-0\t-0000\t", 0, 0),
+            ("\n-0\r\n-0000\n", 0, 0),
+        ] {
+            assert_eq!(
+                parse_raw(valid),
+                Some(Time {
+                    seconds: expected_seconds,
+                    offset: expected_offset
+                }),
+                "should succeed: '{valid}'"
+            );
+        }
+    }
+
+    #[test]
+    fn parse_raw_invalid() {
+        for (bad_date_str, message) in [
+            ("123456 !0600", "invalid sign - must be + or -"),
+            ("123456 0600", "missing offset sign"),
+            ("123456 +060", "positive offset too short"),
+            ("123456 -060", "negative offset too short"),
+            ("123456 +06000", "not enough offset seconds"),
+            ("123456 --060", "duplicate offset sign with correct offset length"),
+            ("123456 -+060", "multiple offset signs with correct offset length"),
+            ("123456 --0600", "multiple offset signs, but incorrect offset length"),
+            ("123456 +-06000", "multiple offset signs with correct offset length"),
+            ("123456 +-0600", "multiple offset signs with incorrect offset length"),
+            ("123456 +-060", "multiple offset signs with correct offset length"),
+            ("123456 +10030", "invalid offset length with one 'second' field"),
+            ("123456 06000", "invalid offset length, missing sign"),
+            ("123456 +0600 extra", "extra field past offset"),
+            ("123456 +0600 2005", "extra field past offset that looks like year"),
+            ("123456+0600", "missing space between unix timestamp and offset"),
+            (
+                "123456 + 600",
+                "extra spaces between sign and offset (which also is too short)",
+            ),
+            ("123456 -1500", "negative offset hours out of bounds"),
+            ("123456 +1500", "positive offset hours out of bounds"),
+            ("123456 +6600", "positive offset hours out of bounds"),
+            ("123456 +0660", "invalid offset minutes"),
+            ("123456 +060010", "positive offset seconds is allowed but only if zero"),
+            ("123456 -060010", "negative offset seconds is allowed but only if zero"),
+            ("123456 +0075", "positive offset minutes invalid"),
+            ("++123456 +0000", "duplicate timestamp sign"),
+            ("--123456 +0000", "duplicate timestamp sign"),
+            ("1234567 -+1+1+0", "unsigned offset parsing rejects '+'"),
+        ] {
+            assert!(
+                parse_raw(bad_date_str).is_none(),
+                "should fail: '{bad_date_str}': {message}"
+            );
+        }
+    }
+}
diff --git a/gix-date/src/parse/relative.rs b/gix-date/src/parse/relative.rs
new file mode 100644
index 00000000000..2000707d984
--- /dev/null
+++ b/gix-date/src/parse/relative.rs
@@ -0,0 +1,66 @@
+use std::{str::FromStr, time::SystemTime};
+
+use jiff::{tz::TimeZone, Span, Timestamp, Zoned};
+
+use crate::parse::Error;
+
+fn parse_inner(input: &str) -> Option<Result<Span, Error>> {
+    let mut split = input.split_whitespace();
+    let units = i64::from_str(split.next()?).ok()?;
+    let period = split.next()?;
+    if split.next()? != "ago" {
+        return None;
+    }
+    span(period, units)
+}
+
+pub fn parse(input: &str, now: Option<SystemTime>) -> Option<Result<Zoned, Error>> {
+    parse_inner(input).map(|result| {
+        let span = result?;
+        // This was an error case in a previous version of this code, where
+        // it would fail when converting from a negative signed integer
+        // to an unsigned integer. This preserves that failure case even
+        // though the code below handles it okay.
+        if span.is_negative() {
+            return Err(Error::RelativeTimeConversion);
+        }
+        now.ok_or(Error::MissingCurrentTime).and_then(|now| {
+            let ts = Timestamp::try_from(now).map_err(|_| Error::RelativeTimeConversion)?;
+            // N.B. This matches the behavior of this code when it was
+            // written with `time`, but we might consider using the system
+            // time zone here. If we did, then it would implement "1 day
+            // ago" correctly, even when it crosses DST transitions. Since
+            // we're in the UTC time zone here, which has no DST, 1 day is
+            // in practice always 24 hours. ---AG
+            let zdt = ts.to_zoned(TimeZone::UTC);
+            zdt.checked_sub(span).map_err(|_| Error::RelativeTimeConversion)
+        })
+    })
+}
+
+fn span(period: &str, units: i64) -> Option<Result<Span, Error>> {
+    let period = period.strip_suffix('s').unwrap_or(period);
+    let result = match period {
+        "second" => Span::new().try_seconds(units),
+        "minute" => Span::new().try_minutes(units),
+        "hour" => Span::new().try_hours(units),
+        "day" => Span::new().try_days(units),
+        "week" => Span::new().try_weeks(units),
+        "month" => Span::new().try_months(units),
+        "year" => Span::new().try_years(units),
+        // Ignore values you don't know, assume seconds then (so does git)
+        _anything => Span::new().try_seconds(units),
+    };
+    Some(result.map_err(|_| Error::RelativeTimeConversion))
+}
+
+#[cfg(test)]
+mod tests {
+    use super::*;
+
+    #[test]
+    fn two_weeks_ago() {
+        let actual = parse_inner("2 weeks ago").unwrap().unwrap();
+        assert_eq!(actual.fieldwise(), Span::new().weeks(2));
+    }
+}
diff --git a/gix-date/tests/fixtures/generate_git_date_baseline.sh b/gix-date/tests/fixtures/generate_git_date_baseline.sh
index 1b241350b1d..062f2feaf0f 100755
--- a/gix-date/tests/fixtures/generate_git_date_baseline.sh
+++ b/gix-date/tests/fixtures/generate_git_date_baseline.sh
@@ -22,25 +22,172 @@ function baseline() {
     } >> baseline.git
 }
 
-# success
+# Relative dates use a fixed "now" timestamp for reproducibility
+# GIT_TEST_DATE_NOW sets Git's internal "now" to a specific Unix timestamp
+# We use 1000000000 (Sun Sep 9 01:46:40 UTC 2001) as our reference point
+function baseline_relative() {
+    local test_date="$1" # first argument is the relative date to test
+    local test_name="$2" # second argument is the format name (usually empty for relative dates)
 
-# date formats following to https://git-scm.com/docs/git-log#Documentation/git-log.txt---dateltformatgt
+    local status=0
+    GIT_TEST_DATE_NOW=1000000000 git -c section.key="$test_date" config --type=expiry-date section.key || status="$?"
+
+    {
+      echo "$test_date"
+      echo "$test_name"
+      echo "$status"
+      if [ "$status" = 0 ]; then
+        GIT_TEST_DATE_NOW=1000000000 git -c section.key="$test_date" config --type=expiry-date section.key
+      else
+        echo '-1'
+      fi
+    } >> baseline.git
+}
+
+# ============================================================================
+# FIXED DATE FORMATS
+# ============================================================================
+# Tests from https://github.com/git/git/blob/master/t/t0006-date.sh
+
+# Note: SHORT format (YYYY-MM-DD) is NOT included in baseline tests because
+# Git fills in current time-of-day, making it non-reproducible for baseline comparison.
+# SHORT format is tested separately in the unit tests.
 
-# short
-# ODO
-#baseline '2022-08-22'
-# rfc2822
+# RFC2822 format: "Day, DD Mon YYYY HH:MM:SS +/-ZZZZ"
 baseline 'Thu, 18 Aug 2022 12:45:06 +0800' 'RFC2822'
-# iso8601
+baseline 'Sat, 01 Jan 2000 00:00:00 +0000' 'RFC2822'
+baseline 'Fri, 13 Feb 2009 23:31:30 +0000' 'RFC2822'  # Unix timestamp 1234567890
+baseline 'Wed, 15 Jun 2016 16:13:20 +0200' 'RFC2822'  # from git t0006
+baseline 'Thu, 7 Apr 2005 15:14:13 -0700' ''  # from git t0006
+
+# GIT_RFC2822 format: like RFC2822 but with non-padded day
+baseline 'Thu, 1 Aug 2022 12:45:06 +0800' ''
+baseline 'Sat, 1 Jan 2000 00:00:00 +0000' ''
+
+# ISO8601 format: "YYYY-MM-DD HH:MM:SS +/-ZZZZ" from git t0006
 baseline '2022-08-17 22:04:58 +0200' 'ISO8601'
-# iso8601_strict
+baseline '2000-01-01 00:00:00 +0000' 'ISO8601'
+baseline '1970-01-01 00:00:00 +0000' 'ISO8601'
+baseline '2008-02-14 20:30:45 +0000' ''  # from git t0006
+baseline '2008-02-14 20:30:45 -0500' ''  # from git t0006
+baseline '2016-06-15 16:13:20 +0200' 'ISO8601'  # from git t0006
+
+# ISO8601 with dots: "YYYY.MM.DD HH:MM:SS +/-ZZZZ" from git t0006
+baseline '2008.02.14 20:30:45 -0500' ''
+
+# ISO8601_STRICT format: "YYYY-MM-DDTHH:MM:SS+ZZ:ZZ"
 baseline '2022-08-17T21:43:13+08:00' 'ISO8601_STRICT'
-# default
+baseline '2000-01-01T00:00:00+00:00' 'ISO8601_STRICT'
+baseline '2009-02-13T23:31:30+00:00' 'ISO8601_STRICT'  # Unix timestamp 1234567890
+baseline '2016-06-15T16:13:20+02:00' 'ISO8601_STRICT'  # from git t0006
+
+# Z suffix for UTC timezone from git t0006
+baseline '1970-01-01 00:00:00 Z' ''
+
+# Compact ISO8601 formats from git t0006 (YYYYMMDDTHHMMSS)
+# Note: Some compact formats like 20080214T2030 are not universally supported
+# across all Git versions and platforms, so we only test the most common ones.
+# baseline '20080214T20:30:45' '' # doesn't work on the macOS version yet. TODO: fix this - it worked on Linux
+# baseline '20080214T203045' ''
+baseline '20080214T203045-04:00' ''
+
+# Subsecond precision (Git ignores the subseconds)
+baseline '2008-02-14 20:30:45.019-04:00' ''
+
+# Various timezone formats from git t0006
+baseline '2008-02-14 20:30:45 -0015' ''  # 15-minute offset
+baseline '2008-02-14 20:30:45 -05' ''    # 2-digit hour offset
+baseline '2008-02-14 20:30:45 -05:00' '' # colon-separated offset
+baseline '2008-02-14 20:30:45 +00' ''    # 2-digit +00
+
+# Timezone edge cases from git t0006
+baseline '1970-01-01 00:00:00 +0000' ''
+baseline '1970-01-01 01:00:00 +0100' ''
+baseline '1970-01-02 00:00:00 +1100' ''
+
+# DEFAULT format (Git's default): "Day Mon D HH:MM:SS YYYY +/-ZZZZ"
 baseline 'Thu Sep 04 2022 10:45:06 -0400' '' # cannot round-trip, incorrect day-of-week
 baseline 'Sun Sep 04 2022 10:45:06 -0400' 'GITOXIDE'
-# unix
+baseline 'Thu Aug 18 12:45:06 2022 +0800' ''
+baseline 'Wed Jun 15 16:13:20 2016 +0200' ''  # from git t0006
+
+# UNIX timestamp format
+# Note: Git only treats numbers >= 100000000 as UNIX timestamps.
+# Smaller numbers are interpreted as date components.
 baseline '1234567890' 'UNIX'
-# raw
+baseline '100000000' 'UNIX'
+baseline '946684800' 'UNIX'  # 2000-01-01 00:00:00 UTC
+baseline '1466000000' 'UNIX'  # from git t0006
+
+# RAW format: "SECONDS +/-ZZZZ"
+# Note: Git only treats timestamps >= 100000000 as raw format.
+# Smaller numbers are interpreted as date components.
 baseline '1660874655 +0800' 'RAW'
+baseline '1660874655 -0800' 'RAW'
+baseline '100000000 +0000' 'RAW'
+baseline '1234567890 +0000' 'RAW'
+baseline '946684800 +0000' 'RAW'
+baseline '1466000000 +0200' 'RAW'  # from git t0006
+baseline '1466000000 -0200' 'RAW'  # from git t0006
+
+# Note: Git does not support negative timestamps through --type=expiry-date
+# gix-date does support them, but they can't be tested via the baseline.
+
+# ============================================================================
+# RELATIVE DATE FORMATS from git t0006
+# ============================================================================
+# These tests use GIT_TEST_DATE_NOW=1000000000 (Sun Sep 9 01:46:40 UTC 2001)
+
+# Seconds - from git t0006 check_relative
+baseline_relative '1 second ago' ''
+baseline_relative '2 seconds ago' ''
+baseline_relative '30 seconds ago' ''
+baseline_relative '5 seconds ago' ''  # from git t0006 check_relative 5
+baseline_relative '150 seconds ago' ''  # from git t0006 check_relative 5
+
+# Minutes - from git t0006 check_relative 300 = 5 minutes
+baseline_relative '1 minute ago' ''
+baseline_relative '2 minutes ago' ''
+baseline_relative '30 minutes ago' ''
+baseline_relative '5 minutes ago' ''
+baseline_relative '10 minutes ago' ''
+baseline_relative '90 minutes ago' ''
+
+# Hours - from git t0006 check_relative 18000 = 5 hours
+baseline_relative '1 hour ago' ''
+baseline_relative '2 hours ago' ''
+baseline_relative '12 hours ago' ''
+baseline_relative '5 hours ago' ''
+baseline_relative '72 hours ago' ''
+
+# Days - from git t0006 check_relative 432000 = 5 days
+baseline_relative '1 day ago' ''
+baseline_relative '2 days ago' ''
+baseline_relative '7 days ago' ''
+baseline_relative '5 days ago' ''
+baseline_relative '3 days ago' ''
+baseline_relative '100 days ago' ''
+
+# Weeks - from git t0006 check_relative 1728000 = 3 weeks (20 days)
+baseline_relative '1 week ago' ''
+baseline_relative '2 weeks ago' ''
+baseline_relative '4 weeks ago' ''
+baseline_relative '3 weeks ago' ''
+baseline_relative '8 weeks ago' ''
+
+# Months - from git t0006 check_relative 13000000 ≈ 5 months
+baseline_relative '1 month ago' ''
+baseline_relative '2 months ago' ''
+baseline_relative '6 months ago' ''
+baseline_relative '5 months ago' ''
+baseline_relative '3 months ago' ''
+baseline_relative '12 months ago' ''
+baseline_relative '24 months ago' ''
+
+# Years - from git t0006 check_relative 630000000 = 20 years
+baseline_relative '1 year ago' ''
+baseline_relative '2 years ago' ''
+baseline_relative '10 years ago' ''
+baseline_relative '20 years ago' ''
 
 # Note that we can't necessarily put 64bit dates here yet as `git` on the system might not yet support it.
diff --git a/gix-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar b/gix-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar
index 073cb0db8a3..cf9c7c93a6f 100644
Binary files a/gix-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar and b/gix-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar differ
diff --git a/gix-date/tests/time/baseline.rs b/gix-date/tests/time/baseline.rs
index 67b9e95f8cd..872deaff9ea 100644
--- a/gix-date/tests/time/baseline.rs
+++ b/gix-date/tests/time/baseline.rs
@@ -6,6 +6,7 @@ use gix_date::{
 };
 use gix_testtools::Result;
 use std::sync::LazyLock;
+use std::time::Duration;
 
 struct Sample {
     format_name: Option<String>,
@@ -13,6 +14,21 @@ struct Sample {
     seconds: SecondsSinceUnixEpoch,
 }
 
+/// Returns true if the pattern looks like a relative date of the form "N unit ago".
+/// Note: This only covers the relative dates tested in the baseline (e.g., "1 day ago").
+/// Other relative formats like "yesterday", "last week" etc. are not included in baseline
+/// testing because they would require additional handling in the baseline script.
+fn is_relative_date(pattern: &str) -> bool {
+    pattern.ends_with(" ago")
+}
+
+/// The fixed "now" timestamp used for testing relative dates.
+/// This matches GIT_TEST_DATE_NOW=1000000000 in the baseline script.
+/// This is Sun Sep 9 01:46:40 UTC 2001.
+fn fixed_now() -> SystemTime {
+    std::time::UNIX_EPOCH + Duration::from_secs(1_000_000_000)
+}
+
 static BASELINE: LazyLock<HashMap<String, Sample>> = LazyLock::new(|| {
     (|| -> Result<_> {
         let base = gix_testtools::scripted_fixture_read_only("generate_git_date_baseline.sh")?;
@@ -53,7 +69,8 @@ fn parse_compare_format() {
         },
     ) in BASELINE.iter()
     {
-        let res = gix_date::parse(pattern.as_str(), Some(SystemTime::now()));
+        let now = is_relative_date(pattern).then(fixed_now);
+        let res = gix_date::parse(pattern.as_str(), now);
         assert_eq!(
             res.is_ok(),
             *exit_code == 0,
@@ -68,6 +85,7 @@ fn parse_compare_format() {
             if let Some(format_name) = format_name {
                 let reformatted = t
                     .format(match format_name.as_str() {
+                        "SHORT" => Format::Custom(format::SHORT),
                         "RFC2822" => Format::Custom(format::RFC2822),
                         "ISO8601" => Format::Custom(format::ISO8601),
                         "ISO8601_STRICT" => Format::Custom(format::ISO8601_STRICT),
diff --git a/gix-date/tests/time/parse.rs b/gix-date/tests/time/parse.rs
deleted file mode 100644
index fd4ab2c5a78..00000000000
--- a/gix-date/tests/time/parse.rs
+++ /dev/null
@@ -1,357 +0,0 @@
-use std::time::SystemTime;
-
-use gix_date::Time;
-
-#[test]
-fn time_without_offset_is_not_parsed_yet() {
-    assert!(
-        gix_date::parse("1979-02-26 18:30:00", Some(SystemTime::now())).is_err(),
-        "This was a special time with special handling, but it is not  anymore"
-    );
-}
-
-#[test]
-fn parse_header_is_not_too_lenient() {
-    let now = SystemTime::now();
-    for not_a_header_str in ["2005-04-07T22:13:09", "2005-04-07 22:13:09"] {
-        assert!(
-            gix_date::parse_header(not_a_header_str).is_none(),
-            "It's not timestamp-like, despite some leniency"
-        );
-        assert!(
-            gix_date::parse(not_a_header_str, Some(now)).is_err(),
-            "it misses the timezone offset, so can't be parsed"
-        );
-    }
-}
-
-#[test]
-fn short() {
-    assert_eq!(
-        gix_date::parse("1979-02-26", Some(SystemTime::now())).unwrap(),
-        Time {
-            seconds: 288835200,
-            offset: 0,
-        },
-        "could not parse with SHORT format"
-    );
-}
-
-#[test]
-fn rfc2822() {
-    assert_eq!(
-        gix_date::parse("Thu, 18 Aug 2022 12:45:06 +0800", None).unwrap(),
-        Time {
-            seconds: 1660797906,
-            offset: 28800,
-        },
-    );
-}
-
-#[test]
-fn git_rfc2822() {
-    let expected = Time {
-        seconds: 1659329106,
-        offset: 28800,
-    };
-    assert_eq!(
-        gix_date::parse("Thu, 1 Aug 2022 12:45:06 +0800", None).unwrap(),
-        expected,
-    );
-    assert_eq!(
-        gix_date::parse("Thu,  1 Aug 2022 12:45:06 +0800", None).unwrap(),
-        expected,
-    );
-}
-
-#[test]
-fn raw() -> gix_testtools::Result {
-    assert_eq!(
-        gix_date::parse("1660874655 +0800", None)?,
-        Time {
-            seconds: 1660874655,
-            offset: 28800,
-        },
-    );
-
-    assert_eq!(
-        gix_date::parse("1112911993 +0100", None)?,
-        Time {
-            seconds: 1112911993,
-            offset: 3600,
-        },
-    );
-
-    assert_eq!(
-        gix_date::parse("1313584730 +051500", None)?,
-        Time {
-            seconds: 1313584730,
-            offset: 18900,
-        },
-        "seconds for time-offsets work as well"
-    );
-
-    assert_eq!(
-        gix_date::parse("1313584730 -0230", None)?,
-        Time {
-            seconds: 1313584730,
-            offset: -150 * 60,
-        },
-    );
-
-    assert!(gix_date::parse("1313584730 +1500", None).is_err());
-    assert!(gix_date::parse("1313584730 +000001", None).is_err());
-    assert!(gix_date::parse("1313584730 +0001", None).is_err());
-    assert!(gix_date::parse("1313584730 +000100", None).is_err());
-
-    let expected = Time {
-        seconds: 1660874655,
-        offset: -28800,
-    };
-    for date_str in [
-        "1660874655 -0800",
-        "1660874655 -0800  ",
-        "  1660874655 -0800",
-        "  1660874655 -0800  ",
-        "  1660874655  -0800  ",
-        "1660874655\t-0800",
-        "1660874655\t-080000",
-    ] {
-        assert_eq!(gix_date::parse_header(date_str), Some(expected));
-    }
-    Ok(())
-}
-
-#[test]
-fn bad_raw() {
-    for bad_date_str in [
-        "123456 !0600",
-        "123456 +060",
-        "123456 -060",
-        "123456 +06000",
-        "123456 +10030",
-        "123456 06000",
-        "123456  0600",
-        "123456 +0600 extra",
-        "123456+0600",
-        "123456 + 600",
-    ] {
-        assert_eq!(
-            gix_date::parse_header(bad_date_str),
-            Some(Time {
-                seconds: 123456,
-                offset: 0
-            }),
-            "{bad_date_str}: invalid offsets default to zero (like in git2), and Git ignores them mostly"
-        );
-    }
-}
-
-#[test]
-fn double_negation_in_offset() {
-    let actual = gix_date::parse_header("1288373970 --700").unwrap();
-    assert_eq!(
-        actual,
-        gix_date::Time {
-            seconds: 1288373970,
-            offset: 0,
-        },
-        "double-negation isn't special, it's considered malformed"
-    );
-
-    assert_eq!(
-        actual.to_string(),
-        "1288373970 +0000",
-        "serialization is lossy as offset couldn't be parsed"
-    );
-}
-
-#[test]
-fn git_default() {
-    assert_eq!(
-        gix_date::parse("Thu Aug 8 12:45:06 2022 +0800", None).unwrap(),
-        Time {
-            seconds: 1659933906,
-            offset: 28800,
-        },
-    );
-}
-
-#[test]
-fn invalid_dates_can_be_produced_without_current_time() {
-    assert!(matches!(
-        gix_date::parse("foobar", None).unwrap_err(),
-        gix_date::parse::Error::InvalidDateString { input } if input == "foobar"
-    ));
-}
-
-mod relative {
-    use std::time::SystemTime;
-
-    use jiff::{ToSpan, Zoned};
-    use pretty_assertions::assert_eq;
-
-    #[test]
-    fn large_offsets() {
-        gix_date::parse("999999999999999 weeks ago", Some(std::time::UNIX_EPOCH)).ok();
-    }
-
-    #[test]
-    fn large_offsets_do_not_panic() {
-        assert!(matches!(
-            gix_date::parse("9999999999 weeks ago", Some(std::time::UNIX_EPOCH)),
-            Err(gix_date::parse::Error::RelativeTimeConversion)
-        ));
-    }
-
-    #[test]
-    fn offset_leading_to_before_unix_epoch_can_be_represented() {
-        let date = gix_date::parse("1 second ago", Some(std::time::UNIX_EPOCH)).unwrap();
-        assert_eq!(date.seconds, -1);
-    }
-
-    #[test]
-    fn various() {
-        let now = SystemTime::now();
-        let cases = [
-            ("5 seconds ago", 5.seconds()),
-            ("12345 florx ago", 12_345.seconds()), // Anything parses as seconds
-            ("5 minutes ago", 5.minutes()),
-            ("5 hours ago", 5.hours()),
-            ("5 days ago", 5.days()),
-            ("3 weeks ago", 3.weeks()),
-            ("21 days ago", 21.days()),              // 3 weeks
-            ("504 hours ago", 504.hours()),          // 3 weeks
-            ("30240 minutes ago", 30_240.minutes()), // 3 weeks
-            ("2 months ago", 2.months()),
-            ("1460 hours ago", 1460.hours()),        // 2 months
-            ("87600 minutes ago", 87_600.minutes()), // 2 months
-            ("14 weeks ago", 14.weeks()),
-            ("98 days ago", 98.days()),                // 14 weeks
-            ("2352 hours ago", 2352.hours()),          // 14 weeks
-            ("141120 minutes ago", 141_120.minutes()), // 14 weeks
-            ("5 months ago", 5.months()),
-            ("3650 hours ago", 3650.hours()),          // 5 months
-            ("219000 minutes ago", 219_000.minutes()), // 5 months
-            ("26 weeks ago", 26.weeks()),
-            ("182 days ago", 182.days()),              // 26 weeks
-            ("4368 hours ago", 4368.hours()),          // 26 weeks
-            ("262080 minutes ago", 262_080.minutes()), // 26 weeks
-            ("8 months ago", 8.months()),
-            ("5840 hours ago", 5840.hours()),          // 8 months
-            ("350400 minutes ago", 350_400.minutes()), // 8 months
-            ("38 weeks ago", 38.weeks()),
-            ("266 days ago", 266.days()),              // 38 weeks
-            ("6384 hours ago", 6384.hours()),          // 38 weeks
-            ("383040 minutes ago", 383_040.minutes()), // 38 weeks
-            ("11 months ago", 11.months()),
-            ("8030 hours ago", 8030.hours()),          // 11 months
-            ("481800 minutes ago", 481_800.minutes()), // 11 months
-            ("14 months ago", 14.months()),            // "1 year, 2 months ago" not yet supported.
-            ("21 months ago", 21.months()),            // "1 year, 9 months ago" not yet supported.
-            ("2 years ago", 2.years()),
-            ("20 years ago", 20.years()),
-            ("630720000 seconds ago", 630_720_000.seconds()), // 20 years
-        ];
-
-        let cases_with_times = cases.map(|(input, _)| {
-            let time = gix_date::parse(input, Some(now)).expect("relative time string should parse to a Time");
-            (input, time)
-        });
-        assert_eq!(
-            cases_with_times.map(|(_, time)| time.offset),
-            cases_with_times.map(|_| 0),
-            "They don't pick up local time"
-        );
-
-        let expected = cases.map(|(input, span)| {
-            let expected = Zoned::new(
-                now.try_into().expect("system time is representable"),
-                // As relative dates are always UTC in Git, we do the same, and must
-                // compare to UTC as well or else time might be off due to daylight savings, etc.
-                jiff::tz::TimeZone::UTC,
-            )
-            // account for the loss of precision when creating `Time` with seconds
-            .round(
-                jiff::ZonedRound::new()
-                    .smallest(jiff::Unit::Second)
-                    .mode(jiff::RoundMode::Trunc),
-            )
-            .expect("test needs to truncate current timestamp to seconds")
-            .saturating_sub(span)
-            .timestamp();
-
-            (input, expected)
-        });
-        let actual = cases_with_times.map(|(input, time)| {
-            let actual = jiff::Timestamp::from_second(time.seconds)
-                .expect("seconds obtained from a Time should convert to Timestamp");
-            (input, actual)
-        });
-        assert_eq!(actual, expected);
-    }
-
-    #[test]
-    fn various_examples() {
-        #[rustfmt::skip]
-        let expected = [
-        // ### 1. SHORT Format
-            "2018-12-24",
-            "1950-01-01",
-            "1970-01-01",
-            "2024-12-31",
-
-        // ### 2. RFC2822 Format
-            "Thu, 18 Aug 2022 12:45:06 +0800",
-            "Mon Oct 27 10:30:00 2023 -0800",
-
-        // ### 3. GIT_RFC2822 Format
-            "Thu, 8 Aug 2022 12:45:06 +0800",
-            "Mon Oct 27 10:30:00 2023 -0800",
-
-        // ### 4. ISO8601 Format
-            "2022-08-17 22:04:58 +0200",
-            "1970-01-01 00:00:00 -0500",
-
-        // ### 5. ISO8601_STRICT Format
-            "2022-08-17T21:43:13+08:00",
-
-        // ### 6. UNIX Timestamp (Seconds Since Epoch)
-            "123456789",
-            "0",
-            "-100",
-            "1700000000",
-
-
-        // ### 7. RAW Format
-            "1745582210 +0200",
-            "1660874655 +0800",
-            "-1660874655 +0800",
-        // ### 8. GITOXIDE Format
-            "Thu Sep 04 2022 10:45:06 -0400",
-            "Mon Oct 27 2023 10:30:00 +0000",
-        // ### 9. DEFAULT Format
-            "Thu Sep 4 10:45:06 2022 -0400",
-            "Mon Oct 27 10:30:00 2023 +0000",
-        ];
-        for date in expected {
-            _ = gix_date::parse(date, None)
-                .unwrap_or_else(|err| unreachable!("{date}: all examples can be parsed: {err}"));
-        }
-    }
-}
-
-/// Various cases the fuzzer found
-mod fuzz {
-    #[test]
-    fn reproduce_1979() {
-        gix_date::parse("fRi ", None).ok();
-    }
-
-    #[test]
-    fn invalid_but_does_not_cause_panic() {
-        for input in ["-9999-1-1", "7	-𬞋", "5 ڜ-09", "-4 week ago Z", "8960609 day ago"] {
-            gix_date::parse(input, Some(std::time::UNIX_EPOCH)).ok();
-        }
-    }
-}
diff --git a/gix-date/tests/time/parse/compact_iso8601.rs b/gix-date/tests/time/parse/compact_iso8601.rs
new file mode 100644
index 00000000000..3514bf5d9db
--- /dev/null
+++ b/gix-date/tests/time/parse/compact_iso8601.rs
@@ -0,0 +1,122 @@
+use gix_date::Time;
+
+#[test]
+fn full_format() {
+    assert_eq!(
+        gix_date::parse("20080214T203045", None).unwrap(),
+        Time {
+            seconds: 1203021045,
+            offset: 0,
+        },
+        "20080214T203045 = Feb 14, 2008 20:30:45 UTC"
+    );
+}
+
+#[test]
+fn with_colons_in_time() {
+    assert_eq!(
+        gix_date::parse("20080214T20:30:45", None).unwrap(),
+        Time {
+            seconds: 1203021045,
+            offset: 0,
+        },
+        "20080214T20:30:45 = Feb 14, 2008 20:30:45 UTC"
+    );
+}
+
+#[test]
+fn hour_minute_only() {
+    assert_eq!(
+        gix_date::parse("20080214T2030", None).unwrap(),
+        Time {
+            seconds: 1203021000,
+            offset: 0,
+        },
+        "20080214T2030 = Feb 14, 2008 20:30:00 UTC"
+    );
+}
+
+#[test]
+fn hour_minute_with_colon() {
+    assert_eq!(
+        gix_date::parse("20080214T20:30", None).unwrap(),
+        Time {
+            seconds: 1203021000,
+            offset: 0,
+        },
+        "20080214T20:30 = Feb 14, 2008 20:30:00 UTC"
+    );
+}
+
+#[test]
+fn hour_only() {
+    assert_eq!(
+        gix_date::parse("20080214T20", None).unwrap(),
+        Time {
+            seconds: 1203019200,
+            offset: 0,
+        },
+        "20080214T20 = Feb 14, 2008 20:00:00 UTC"
+    );
+}
+
+#[test]
+fn with_timezone() {
+    assert_eq!(
+        gix_date::parse("20080214T203045-04:00", None).unwrap(),
+        Time {
+            seconds: 1203035445,
+            offset: -14400,
+        },
+        "20080214T203045-04:00 = Feb 14, 2008 20:30:45 -04:00"
+    );
+}
+
+#[test]
+fn with_space_before_timezone() {
+    assert_eq!(
+        gix_date::parse("20080214T203045 -04:00", None).unwrap(),
+        Time {
+            seconds: 1203035445,
+            offset: -14400,
+        },
+        "20080214T203045 -04:00 = Feb 14, 2008 20:30:45 -04:00"
+    );
+}
+
+#[test]
+fn with_subseconds_ignored() {
+    assert_eq!(
+        gix_date::parse("20080214T203045.019-04:00", None).unwrap(),
+        Time {
+            seconds: 1203035445,
+            offset: -14400,
+        },
+        "Subsecond precision is ignored, like Git does
+    20080214T203045.019-04:00 = Feb 14, 2008 20:30:45.019 -04:00"
+    );
+}
+
+#[test]
+fn with_subseconds_no_timezone() {
+    assert_eq!(
+        gix_date::parse("20080214T000000.20", None).unwrap(),
+        Time {
+            seconds: 1202947200,
+            offset: 0,
+        },
+        "20080214T000000.20 = Feb 14, 2008 00:00:00.20 UTC"
+    );
+}
+
+#[test]
+fn with_subseconds_colon_time() {
+    assert_eq!(
+        gix_date::parse("20080214T00:00:00.20", None).unwrap(),
+        Time {
+            seconds: 1202947200,
+            offset: 0,
+        },
+        "20080214T00:00:00.20 = Feb 14, 2008 00:00:00.20 UTC"
+    );
+}
diff --git a/gix-date/tests/time/parse/flexible_offset.rs b/gix-date/tests/time/parse/flexible_offset.rs
new file mode 100644
index 00000000000..4411af2872e
--- /dev/null
+++ b/gix-date/tests/time/parse/flexible_offset.rs
@@ -0,0 +1,46 @@
+use gix_date::Time;
+
+#[test]
+fn z_suffix_for_utc() {
+    assert_eq!(
+        gix_date::parse("1970-01-01 00:00:00 Z", None).unwrap(),
+        Time { seconds: 0, offset: 0 },
+        "1970-01-01 00:00:00 Z = Unix epoch"
+    );
+}
+
+#[test]
+fn two_digit_hour_offset() {
+    assert_eq!(
+        gix_date::parse("2008-02-14 20:30:45 -05", None).unwrap(),
+        Time {
+            seconds: 1203039045,
+            offset: -18000,
+        },
+        "2008-02-14 20:30:45 -05 = 2008-02-14 20:30:45 -0500"
+    );
+}
+
+#[test]
+fn colon_separated_offset() {
+    assert_eq!(
+        gix_date::parse("2008-02-14 20:30:45 -05:00", None).unwrap(),
+        Time {
+            seconds: 1203039045,
+            offset: -18000,
+        },
+        "2008-02-14 20:30:45 -05:00 = 2008-02-14 20:30:45 -0500"
+    );
+}
+
+#[test]
+fn fifteen_minute_offset() {
+    assert_eq!(
+        gix_date::parse("2008-02-14 20:30:45 -0015", None).unwrap(),
+        Time {
+            seconds: 1203021945,
+            offset: -900,
+        },
+        "2008-02-14 20:30:45 -0015"
+    );
+}
diff --git a/gix-date/tests/time/parse/mod.rs b/gix-date/tests/time/parse/mod.rs
new file mode 100644
index 00000000000..f8a5f858c15
--- /dev/null
+++ b/gix-date/tests/time/parse/mod.rs
@@ -0,0 +1,240 @@
+use std::time::SystemTime;
+
+use gix_date::Time;
+
+#[test]
+fn time_without_offset_defaults_to_utc() {
+    // Git parses datetime without offset and defaults to UTC (+0000)
+    let result = gix_date::parse("1979-02-26 18:30:00", Some(SystemTime::now()));
+    assert!(result.is_ok(), "Git parses datetime without offset, defaulting to UTC");
+    let time = result.unwrap();
+    assert_eq!(time.offset, 0, "Offset should default to UTC (+0000)");
+}
+
+#[test]
+fn parse_header_is_not_too_lenient() {
+    for not_a_header_str in ["2005-04-07T22:13:09", "2005-04-07 22:13:09"] {
+        assert!(
+            gix_date::parse_header(not_a_header_str).is_none(),
+            "parse_header only accepts raw format (timestamp +offset), not ISO8601"
+        );
+        // Note: gix_date::parse() DOES accept these formats, matching Git's behavior
+        // Git parses them with default UTC offset
+    }
+}
+
+#[test]
+fn short() {
+    assert_eq!(
+        gix_date::parse("1979-02-26", Some(SystemTime::now())).unwrap(),
+        Time {
+            seconds: 288835200,
+            offset: 0,
+        },
+        "could not parse with SHORT format"
+    );
+}
+
+#[test]
+fn rfc2822() {
+    assert_eq!(
+        gix_date::parse("Thu, 18 Aug 2022 12:45:06 +0800", None).unwrap(),
+        Time {
+            seconds: 1660797906,
+            offset: 28800,
+        },
+    );
+}
+
+#[test]
+fn git_rfc2822() {
+    let expected = Time {
+        seconds: 1659329106,
+        offset: 28800,
+    };
+    assert_eq!(
+        gix_date::parse("Thu, 1 Aug 2022 12:45:06 +0800", None).unwrap(),
+        expected,
+    );
+    assert_eq!(
+        gix_date::parse("Thu,  1 Aug 2022 12:45:06 +0800", None).unwrap(),
+        expected,
+    );
+}
+
+#[test]
+fn raw() -> gix_testtools::Result {
+    assert_eq!(
+        gix_date::parse("1660874655 +0800", None)?,
+        Time {
+            seconds: 1660874655,
+            offset: 28800,
+        },
+    );
+
+    assert_eq!(
+        gix_date::parse("1112911993 +0100", None)?,
+        Time {
+            seconds: 1112911993,
+            offset: 3600,
+        },
+    );
+
+    assert_eq!(
+        gix_date::parse("1313584730 +051500", None)?,
+        Time {
+            seconds: 1313584730,
+            offset: 18900,
+        },
+        "seconds for time-offsets work as well"
+    );
+
+    assert_eq!(
+        gix_date::parse("1313584730 -0230", None)?,
+        Time {
+            seconds: 1313584730,
+            offset: -150 * 60,
+        },
+    );
+
+    assert!(gix_date::parse("1313584730 +1500", None).is_err());
+    assert!(gix_date::parse("1313584730 +000001", None).is_err());
+    assert!(gix_date::parse("1313584730 +0001", None).is_err());
+    assert!(gix_date::parse("1313584730 +000100", None).is_err());
+
+    let expected = Time {
+        seconds: 1660874655,
+        offset: -28800,
+    };
+    for date_str in [
+        "1660874655 -0800",
+        "1660874655 -0800  ",
+        "  1660874655 -0800",
+        "  1660874655 -0800  ",
+        "  1660874655  -0800  ",
+        "1660874655\t-0800",
+        "1660874655\t-080000",
+    ] {
+        assert_eq!(gix_date::parse_header(date_str), Some(expected));
+    }
+    Ok(())
+}
+
+#[test]
+fn bad_raw() {
+    for bad_date_str in [
+        "123456 !0600",
+        "123456 +060",
+        "123456 -060",
+        "123456 +06000",
+        "123456 +10030",
+        "123456 06000",
+        "123456  0600",
+        "123456 +0600 extra",
+        "123456+0600",
+        "123456 + 600",
+    ] {
+        assert_eq!(
+            gix_date::parse_header(bad_date_str),
+            Some(Time {
+                seconds: 123456,
+                offset: 0
+            }),
+            "{bad_date_str}: invalid offsets default to zero (like in git2), and Git ignores them mostly"
+        );
+    }
+}
+
+#[test]
+fn double_negation_in_offset() {
+    let actual = gix_date::parse_header("1288373970 --700").unwrap();
+    assert_eq!(
+        actual,
+        gix_date::Time {
+            seconds: 1288373970,
+            offset: 0,
+        },
+        "double-negation isn't special, it's considered malformed"
+    );
+
+    assert_eq!(
+        actual.to_string(),
+        "1288373970 +0000",
+        "serialization is lossy as offset couldn't be parsed"
+    );
+}
+
+#[test]
+fn git_default() {
+    assert_eq!(
+        gix_date::parse("Thu Aug 8 12:45:06 2022 +0800", None).unwrap(),
+        Time {
+            seconds: 1659933906,
+            offset: 28800,
+        },
+    );
+}
+
+#[test]
+fn invalid_dates_can_be_produced_without_current_time() {
+    assert!(matches!(
+        gix_date::parse("foobar", None).unwrap_err(),
+        gix_date::parse::Error::InvalidDateString { input } if input == "foobar"
+    ));
+}
+
+/// Tests for compact ISO8601 formats (YYYYMMDDTHHMMSS variants)
+mod compact_iso8601;
+mod relative;
+
+/// Tests for ISO8601 with dots format (YYYY.MM.DD HH:MM:SS offset)
+mod iso8601_dots {
+    use gix_date::Time;
+
+    #[test]
+    fn basic() {
+        assert_eq!(
+            gix_date::parse("2008.02.14 20:30:45 -0500", None).unwrap(),
+            Time {
+                seconds: 1203039045,
+                offset: -18000,
+            },
+            "2008.02.14 20:30:45 -0500"
+        );
+    }
+}
+
+/// Tests for flexible timezone offset formats
+mod flexible_offset;
+
+/// Tests for subsecond precision in ISO8601 formats (ignored like Git)
+mod subsecond_precision {
+    use gix_date::Time;
+
+    #[test]
+    fn iso8601_with_subseconds() {
+        assert_eq!(
+            gix_date::parse("2008-02-14 20:30:45.019-04:00", None).unwrap(),
+            Time {
+                seconds: 1203035445,
+                offset: -14400,
+            },
+            "2008-02-14 20:30:45.019-04:00 - subseconds ignored"
+        );
+    }
+}
+
+/// Various cases the fuzzer found
+mod fuzz {
+    #[test]
+    fn reproduce_1979() {
+        gix_date::parse("fRi ", None).ok();
+    }
+
+    #[test]
+    fn invalid_but_does_not_cause_panic() {
+        for input in ["-9999-1-1", "7	-𬞋", "5 ڜ-09", "-4 week ago Z", "8960609 day ago"] {
+            gix_date::parse(input, Some(std::time::UNIX_EPOCH)).ok();
+        }
+    }
+}
diff --git a/gix-date/tests/time/parse/relative.rs b/gix-date/tests/time/parse/relative.rs
new file mode 100644
index 00000000000..c0206907c52
--- /dev/null
+++ b/gix-date/tests/time/parse/relative.rs
@@ -0,0 +1,152 @@
+use std::time::SystemTime;
+
+use jiff::{ToSpan, Zoned};
+use pretty_assertions::assert_eq;
+
+#[test]
+fn large_offsets() {
+    gix_date::parse("999999999999999 weeks ago", Some(std::time::UNIX_EPOCH)).ok();
+}
+
+#[test]
+fn large_offsets_do_not_panic() {
+    assert!(matches!(
+        gix_date::parse("9999999999 weeks ago", Some(std::time::UNIX_EPOCH)),
+        Err(gix_date::parse::Error::RelativeTimeConversion)
+    ));
+}
+
+#[test]
+fn offset_leading_to_before_unix_epoch_can_be_represented() {
+    let date = gix_date::parse("1 second ago", Some(std::time::UNIX_EPOCH)).unwrap();
+    assert_eq!(date.seconds, -1);
+}
+
+#[test]
+fn various() {
+    let now = SystemTime::now();
+    let cases = [
+        ("5 seconds ago", 5.seconds()),
+        ("12345 florx ago", 12_345.seconds()), // Anything parses as seconds
+        ("5 minutes ago", 5.minutes()),
+        ("5 hours ago", 5.hours()),
+        ("5 days ago", 5.days()),
+        ("3 weeks ago", 3.weeks()),
+        ("21 days ago", 21.days()),              // 3 weeks
+        ("504 hours ago", 504.hours()),          // 3 weeks
+        ("30240 minutes ago", 30_240.minutes()), // 3 weeks
+        ("2 months ago", 2.months()),
+        ("1460 hours ago", 1460.hours()),        // 2 months
+        ("87600 minutes ago", 87_600.minutes()), // 2 months
+        ("14 weeks ago", 14.weeks()),
+        ("98 days ago", 98.days()),                // 14 weeks
+        ("2352 hours ago", 2352.hours()),          // 14 weeks
+        ("141120 minutes ago", 141_120.minutes()), // 14 weeks
+        ("5 months ago", 5.months()),
+        ("3650 hours ago", 3650.hours()),          // 5 months
+        ("219000 minutes ago", 219_000.minutes()), // 5 months
+        ("26 weeks ago", 26.weeks()),
+        ("182 days ago", 182.days()),              // 26 weeks
+        ("4368 hours ago", 4368.hours()),          // 26 weeks
+        ("262080 minutes ago", 262_080.minutes()), // 26 weeks
+        ("8 months ago", 8.months()),
+        ("5840 hours ago", 5840.hours()),          // 8 months
+        ("350400 minutes ago", 350_400.minutes()), // 8 months
+        ("38 weeks ago", 38.weeks()),
+        ("266 days ago", 266.days()),              // 38 weeks
+        ("6384 hours ago", 6384.hours()),          // 38 weeks
+        ("383040 minutes ago", 383_040.minutes()), // 38 weeks
+        ("11 months ago", 11.months()),
+        ("8030 hours ago", 8030.hours()),          // 11 months
+        ("481800 minutes ago", 481_800.minutes()), // 11 months
+        ("14 months ago", 14.months()),            // "1 year, 2 months ago" not yet supported.
+        ("21 months ago", 21.months()),            // "1 year, 9 months ago" not yet supported.
+        ("2 years ago", 2.years()),
+        ("20 years ago", 20.years()),
+        ("630720000 seconds ago", 630_720_000.seconds()), // 20 years
+    ];
+
+    let cases_with_times = cases.map(|(input, _)| {
+        let time = gix_date::parse(input, Some(now)).expect("relative time string should parse to a Time");
+        (input, time)
+    });
+    assert_eq!(
+        cases_with_times.map(|(_, time)| time.offset),
+        cases_with_times.map(|_| 0),
+        "They don't pick up local time"
+    );
+
+    let expected = cases.map(|(input, span)| {
+        let expected = Zoned::new(
+            now.try_into().expect("system time is representable"),
+            // As relative dates are always UTC in Git, we do the same, and must
+            // compare to UTC as well or else time might be off due to daylight savings, etc.
+            jiff::tz::TimeZone::UTC,
+        )
+        // account for the loss of precision when creating `Time` with seconds
+        .round(
+            jiff::ZonedRound::new()
+                .smallest(jiff::Unit::Second)
+                .mode(jiff::RoundMode::Trunc),
+        )
+        .expect("test needs to truncate current timestamp to seconds")
+        .saturating_sub(span)
+        .timestamp();
+
+        (input, expected)
+    });
+    let actual = cases_with_times.map(|(input, time)| {
+        let actual = jiff::Timestamp::from_second(time.seconds)
+            .expect("seconds obtained from a Time should convert to Timestamp");
+        (input, actual)
+    });
+    assert_eq!(actual, expected);
+}
+
+#[test]
+fn various_examples() {
+    #[rustfmt::skip]
+    let expected = [
+    // ### 1. SHORT Format
+        "2018-12-24",
+        "1950-01-01",
+        "1970-01-01",
+        "2024-12-31",
+
+    // ### 2. RFC2822 Format
+        "Thu, 18 Aug 2022 12:45:06 +0800",
+        "Mon Oct 27 10:30:00 2023 -0800",
+
+    // ### 3. GIT_RFC2822 Format
+        "Thu, 8 Aug 2022 12:45:06 +0800",
+        "Mon Oct 27 10:30:00 2023 -0800",
+
+    // ### 4. ISO8601 Format
+        "2022-08-17 22:04:58 +0200",
+        "1970-01-01 00:00:00 -0500",
+
+    // ### 5. ISO8601_STRICT Format
+        "2022-08-17T21:43:13+08:00",
+
+    // ### 6. UNIX Timestamp (Seconds Since Epoch)
+        "123456789",
+        "0",
+        "-100",
+        "1700000000",
+
+
+    // ### 7. RAW Format
+        "1745582210 +0200",
+        "1660874655 +0800",
+        "-1660874655 +0800",
+    // ### 8. GITOXIDE Format
+        "Thu Sep 04 2022 10:45:06 -0400",
+        "Mon Oct 27 2023 10:30:00 +0000",
+    // ### 9. DEFAULT Format
+        "Thu Sep 4 10:45:06 2022 -0400",
+        "Mon Oct 27 10:30:00 2023 +0000",
+    ];
+    for date in expected {
+        _ = gix_date::parse(date, None).unwrap_or_else(|err| unreachable!("{date}: all examples can be parsed: {err}"));
+    }
+}