diff --git a/gix-date/src/parse.rs b/gix-date/src/parse.rs
index 7f71c95180c..4ce2c964ea5 100644
--- a/gix-date/src/parse.rs
+++ b/gix-date/src/parse.rs
@@ -156,6 +156,9 @@ pub(crate) mod function {
             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 Some(val) = parse_git_date_format(input) {
+            // Git-style flexible date parsing (ISO8601 with dots, compact formats, Z suffix, etc.)
+            val
         } 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) {
@@ -282,6 +285,329 @@ pub(crate) mod function {
         Time { seconds, offset }.into()
     }
 
+    /// 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`
+    fn parse_git_date_format(input: &str) -> Option<Time> {
+        // Try ISO8601 with dots: YYYY.MM.DD HH:MM:SS offset
+        if let Some(time) = parse_iso8601_dots(input) {
+            return Some(time);
+        }
+        // Try compact ISO8601: YYYYMMDDTHHMMSS or YYYYMMDDT...
+        if let Some(time) = parse_compact_iso8601(input) {
+            return Some(time);
+        }
+        // Try ISO8601 with Z suffix or flexible timezone
+        if let Some(time) = parse_flexible_iso8601(input) {
+            return Some(time);
+        }
+        None
+    }
+
+    /// 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();
+        if input.len() < 10 || !input.is_char_boundary(10) {
+            return None;
+        }
+        let first_10 = &input[..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 || !input.is_char_boundary(8) || !input.is_char_boundary(9) {
+            return None;
+        }
+
+        let date_part = &input[..8];
+        // Verify date part is ASCII (valid date chars are all ASCII)
+        if !date_part.is_ascii() {
+            return None;
+        }
+        let rest = &input[9..]; // after T
+
+        // 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()?;
+
+        if !(1..=12).contains(&month) || !(1..=31).contains(&day) {
+            return None;
+        }
+
+        // Parse time part - may have colons or not, may have subseconds, may have timezone
+        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 date = jiff::civil::Date::new(year as i16, month as i8, day as i8).ok()?;
+        let time = jiff::civil::Time::new(hour as i8, minute as i8, second as i8, 0).ok()?;
+        let datetime = date.at(time.hour(), time.minute(), time.second(), 0);
+        let tz_offset = jiff::tz::Offset::from_seconds(offset).ok()?;
+        let zoned = datetime.to_zoned(tz_offset.to_time_zone()).ok()?;
+
+        Some(Time::new(zoned.timestamp().as_second(), offset))
+    }
+
+    /// 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)
+        // Must be at least 10 ASCII chars and first 10 chars must be ASCII
+        if input.len() < 10 || !input.is_char_boundary(10) {
+            return None;
+        }
+        let date_part = &input[..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()?;
+
+        if !(1..=12).contains(&month) || !(1..=31).contains(&day) {
+            return None;
+        }
+
+        // Rest after date
+        let rest = &input[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 date = jiff::civil::Date::new(year as i16, month as i8, day as i8).ok()?;
+        let time = jiff::civil::Time::new(hour as i8, minute as i8, second as i8, 0).ok()?;
+        let datetime = date.at(time.hour(), time.minute(), time.second(), 0);
+        let tz_offset = jiff::tz::Offset::from_seconds(offset).ok()?;
+        let zoned = datetime.to_zoned(tz_offset.to_time_zone()).ok()?;
+
+        Some(Time::new(zoned.timestamp().as_second(), offset))
+    }
+
+    /// 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;
+        }
+
+        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()?;
+            if hour > 23 || minute > 59 || second > 59 {
+                return None;
+            }
+            Some((hour, minute, second))
+        } else {
+            // Compact: HHMMSS, HHMM, or HH
+            match time.len() {
+                2 => {
+                    let hour: u32 = time.parse().ok()?;
+                    if hour > 23 {
+                        return None;
+                    }
+                    Some((hour, 0, 0))
+                }
+                4 => {
+                    let hour: u32 = time[0..2].parse().ok()?;
+                    let minute: u32 = time[2..4].parse().ok()?;
+                    if hour > 23 || minute > 59 {
+                        return None;
+                    }
+                    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()?;
+                    if hour > 23 || minute > 59 || second > 59 {
+                        return None;
+                    }
+                    Some((hour, minute, second))
+                }
+                _ => None,
+            }
+        }
+    }
+
+    /// 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('+') {
+            (1i32, stripped)
+        } else if let Some(stripped) = offset.strip_prefix('-') {
+            (-1i32, 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 > 14 || minutes > 59 {
+            return None;
+        }
+
+        Some(sign * (hours * 3600 + minutes * 60))
+    }
+
     /// 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
diff --git a/gix-date/tests/fixtures/generate_git_date_baseline.sh b/gix-date/tests/fixtures/generate_git_date_baseline.sh
index 1b241350b1d..07517becc10 100755
--- a/gix-date/tests/fixtures/generate_git_date_baseline.sh
+++ b/gix-date/tests/fixtures/generate_git_date_baseline.sh
@@ -22,25 +22,166 @@ 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' ''
+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
+
+# 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' ''
+
+# 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' ''
+
+# 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' ''
+
+# 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' ''
+
+# 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' ''
+
+# 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..61507a34ec8 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..d983a5bf121 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,13 @@ fn parse_compare_format() {
         },
     ) in BASELINE.iter()
     {
-        let res = gix_date::parse(pattern.as_str(), Some(SystemTime::now()));
+        // Use fixed_now() for relative dates, current time for absolute dates
+        let now = if is_relative_date(pattern) {
+            Some(fixed_now())
+        } else {
+            Some(SystemTime::now())
+        };
+        let res = gix_date::parse(pattern.as_str(), now);
         assert_eq!(
             res.is_ok(),
             *exit_code == 0,
@@ -68,6 +90,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
index fd4ab2c5a78..ae573a35b63 100644
--- a/gix-date/tests/time/parse.rs
+++ b/gix-date/tests/time/parse.rs
@@ -3,25 +3,23 @@ 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"
-    );
+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() {
-    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"
+            "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
     }
 }
 
@@ -341,6 +339,227 @@ mod relative {
     }
 }
 
+/// Tests for compact ISO8601 formats (YYYYMMDDTHHMMSS variants)
+/// These formats are parsed by gix-date but may not be universally
+/// supported across all Git versions, so they have dedicated unit tests
+/// rather than baseline tests.
+mod compact_iso8601 {
+    use gix_date::Time;
+
+    #[test]
+    fn full_format() {
+        // 20080214T203045 = Feb 14, 2008 20:30:45 UTC
+        assert_eq!(
+            gix_date::parse("20080214T203045", None).unwrap(),
+            Time {
+                seconds: 1203021045,
+                offset: 0,
+            },
+        );
+    }
+
+    #[test]
+    fn with_colons_in_time() {
+        // 20080214T20:30:45 = Feb 14, 2008 20:30:45 UTC
+        assert_eq!(
+            gix_date::parse("20080214T20:30:45", None).unwrap(),
+            Time {
+                seconds: 1203021045,
+                offset: 0,
+            },
+        );
+    }
+
+    #[test]
+    fn hour_minute_only() {
+        // 20080214T2030 = Feb 14, 2008 20:30:00 UTC
+        assert_eq!(
+            gix_date::parse("20080214T2030", None).unwrap(),
+            Time {
+                seconds: 1203021000,
+                offset: 0,
+            },
+        );
+    }
+
+    #[test]
+    fn hour_minute_with_colon() {
+        // 20080214T20:30 = Feb 14, 2008 20:30:00 UTC
+        assert_eq!(
+            gix_date::parse("20080214T20:30", None).unwrap(),
+            Time {
+                seconds: 1203021000,
+                offset: 0,
+            },
+        );
+    }
+
+    #[test]
+    fn hour_only() {
+        // 20080214T20 = Feb 14, 2008 20:00:00 UTC
+        assert_eq!(
+            gix_date::parse("20080214T20", None).unwrap(),
+            Time {
+                seconds: 1203019200,
+                offset: 0,
+            },
+        );
+    }
+
+    #[test]
+    fn with_timezone() {
+        // 20080214T203045-04:00 = Feb 14, 2008 20:30:45 -04:00
+        // UTC seconds = local time + 4 hours = 1203021045 + 14400 = 1203035445
+        assert_eq!(
+            gix_date::parse("20080214T203045-04:00", None).unwrap(),
+            Time {
+                seconds: 1203035445,
+                offset: -14400,
+            },
+        );
+    }
+
+    #[test]
+    fn with_space_before_timezone() {
+        // 20080214T203045 -04:00 = Feb 14, 2008 20:30:45 -04:00
+        // UTC seconds = local time + 4 hours = 1203021045 + 14400 = 1203035445
+        assert_eq!(
+            gix_date::parse("20080214T203045 -04:00", None).unwrap(),
+            Time {
+                seconds: 1203035445,
+                offset: -14400,
+            },
+        );
+    }
+
+    #[test]
+    fn with_subseconds_ignored() {
+        // Subsecond precision is ignored, like Git does
+        // 20080214T203045.019-04:00 = Feb 14, 2008 20:30:45.019 -04:00
+        // UTC seconds = local time + 4 hours = 1203021045 + 14400 = 1203035445
+        assert_eq!(
+            gix_date::parse("20080214T203045.019-04:00", None).unwrap(),
+            Time {
+                seconds: 1203035445,
+                offset: -14400,
+            },
+        );
+    }
+
+    #[test]
+    fn with_subseconds_no_timezone() {
+        // 20080214T000000.20 = Feb 14, 2008 00:00:00.20 UTC
+        assert_eq!(
+            gix_date::parse("20080214T000000.20", None).unwrap(),
+            Time {
+                seconds: 1202947200,
+                offset: 0,
+            },
+        );
+    }
+
+    #[test]
+    fn with_subseconds_colon_time() {
+        // 20080214T00:00:00.20 = Feb 14, 2008 00:00:00.20 UTC
+        assert_eq!(
+            gix_date::parse("20080214T00:00:00.20", None).unwrap(),
+            Time {
+                seconds: 1202947200,
+                offset: 0,
+            },
+        );
+    }
+}
+
+/// Tests for ISO8601 with dots format (YYYY.MM.DD HH:MM:SS offset)
+mod iso8601_dots {
+    use gix_date::Time;
+
+    #[test]
+    fn basic() {
+        // 2008.02.14 20:30:45 -0500
+        // UTC seconds = local time + 5 hours = 1203021045 + 18000 = 1203039045
+        assert_eq!(
+            gix_date::parse("2008.02.14 20:30:45 -0500", None).unwrap(),
+            Time {
+                seconds: 1203039045,
+                offset: -18000,
+            },
+        );
+    }
+}
+
+/// Tests for flexible timezone offset formats
+mod flexible_offset {
+    use gix_date::Time;
+
+    #[test]
+    fn z_suffix_for_utc() {
+        // 1970-01-01 00:00:00 Z = Unix epoch
+        assert_eq!(
+            gix_date::parse("1970-01-01 00:00:00 Z", None).unwrap(),
+            Time { seconds: 0, offset: 0 },
+        );
+    }
+
+    #[test]
+    fn two_digit_hour_offset() {
+        // 2008-02-14 20:30:45 -05 = 2008-02-14 20:30:45 -0500
+        // UTC seconds = local time + 5 hours = 1203021045 + 18000 = 1203039045
+        assert_eq!(
+            gix_date::parse("2008-02-14 20:30:45 -05", None).unwrap(),
+            Time {
+                seconds: 1203039045,
+                offset: -18000,
+            },
+        );
+    }
+
+    #[test]
+    fn colon_separated_offset() {
+        // 2008-02-14 20:30:45 -05:00 = 2008-02-14 20:30:45 -0500
+        // UTC seconds = local time + 5 hours = 1203021045 + 18000 = 1203039045
+        assert_eq!(
+            gix_date::parse("2008-02-14 20:30:45 -05:00", None).unwrap(),
+            Time {
+                seconds: 1203039045,
+                offset: -18000,
+            },
+        );
+    }
+
+    #[test]
+    fn fifteen_minute_offset() {
+        // 2008-02-14 20:30:45 -0015
+        // UTC seconds = local time + 15 min = 1203021045 + 900 = 1203021945
+        assert_eq!(
+            gix_date::parse("2008-02-14 20:30:45 -0015", None).unwrap(),
+            Time {
+                seconds: 1203021945,
+                offset: -900,
+            },
+        );
+    }
+}
+
+/// Tests for subsecond precision in ISO8601 formats (ignored like Git)
+mod subsecond_precision {
+    use gix_date::Time;
+
+    #[test]
+    fn iso8601_with_subseconds() {
+        // 2008-02-14 20:30:45.019-04:00 - subseconds ignored
+        // UTC seconds = local time + 4 hours = 1203021045 + 14400 = 1203035445
+        assert_eq!(
+            gix_date::parse("2008-02-14 20:30:45.019-04:00", None).unwrap(),
+            Time {
+                seconds: 1203035445,
+                offset: -14400,
+            },
+        );
+    }
+}
+
 /// Various cases the fuzzer found
 mod fuzz {
     #[test]