diff --git a/Cargo.lock b/Cargo.lock
index 3c5a6159d78..954f648095b 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -1451,6 +1451,7 @@ dependencies = [
  "bstr",
  "document-features",
  "gix-chunk",
+ "gix-date 0.5.1",
  "gix-features 0.30.0",
  "gix-hash 0.11.2",
  "gix-testtools",
@@ -1856,6 +1857,7 @@ dependencies = [
  "bstr",
  "document-features",
  "gix-actor 0.21.0",
+ "gix-date 0.5.1",
  "gix-testtools",
  "serde",
  "thiserror",
@@ -1867,6 +1869,7 @@ version = "0.2.1"
 dependencies = [
  "bitflags 2.1.0",
  "gix-commitgraph",
+ "gix-date 0.5.1",
  "gix-hash 0.11.2",
  "gix-object 0.30.0",
  "gix-odb",
@@ -1908,6 +1911,7 @@ dependencies = [
  "btoi",
  "document-features",
  "gix-actor 0.21.0",
+ "gix-date 0.5.1",
  "gix-features 0.30.0",
  "gix-hash 0.11.2",
  "gix-testtools",
@@ -1930,6 +1934,7 @@ dependencies = [
  "document-features",
  "filetime",
  "gix-actor 0.21.0",
+ "gix-date 0.5.1",
  "gix-features 0.30.0",
  "gix-hash 0.11.2",
  "gix-object 0.30.0",
@@ -2066,6 +2071,7 @@ dependencies = [
  "futures-io",
  "futures-lite",
  "gix-credentials",
+ "gix-date 0.5.1",
  "gix-features 0.30.0",
  "gix-hash 0.11.2",
  "gix-packetline",
@@ -2127,6 +2133,7 @@ version = "0.30.0"
 dependencies = [
  "document-features",
  "gix-actor 0.21.0",
+ "gix-date 0.5.1",
  "gix-features 0.30.0",
  "gix-fs 0.2.0",
  "gix-hash 0.11.2",
@@ -2149,6 +2156,7 @@ name = "gix-ref-tests"
 version = "0.0.0"
 dependencies = [
  "gix-actor 0.21.0",
+ "gix-date 0.5.1",
  "gix-discover 0.19.0",
  "gix-features 0.30.0",
  "gix-fs 0.2.0",
@@ -2199,6 +2207,7 @@ name = "gix-revwalk"
 version = "0.1.0"
 dependencies = [
  "gix-commitgraph",
+ "gix-date 0.5.1",
  "gix-hash 0.11.2",
  "gix-hashtable 0.2.1",
  "gix-object 0.30.0",
@@ -2341,6 +2350,7 @@ name = "gix-traverse"
 version = "0.27.0"
 dependencies = [
  "gix-commitgraph",
+ "gix-date 0.5.1",
  "gix-hash 0.11.2",
  "gix-hashtable 0.2.1",
  "gix-object 0.30.0",
diff --git a/cargo-smart-release/src/commit/history.rs b/cargo-smart-release/src/commit/history.rs
index 3cac1df8773..2e401007fa7 100644
--- a/cargo-smart-release/src/commit/history.rs
+++ b/cargo-smart-release/src/commit/history.rs
@@ -10,7 +10,7 @@ pub struct Segment<'a> {
 pub struct Item {
     pub id: gix::ObjectId,
     pub message: Message,
-    pub commit_time: gix::actor::Time,
+    pub commit_time: gix::date::Time,
     pub tree_id: gix::ObjectId,
     pub parent_tree_id: Option<gix::ObjectId>,
 }
diff --git a/cargo-smart-release/src/utils.rs b/cargo-smart-release/src/utils.rs
index 1d3aca1e296..5b6ab738137 100644
--- a/cargo-smart-release/src/utils.rs
+++ b/cargo-smart-release/src/utils.rs
@@ -299,8 +299,8 @@ mod tests {
     }
 }
 
-pub fn time_to_offset_date_time(time: gix::actor::Time) -> OffsetDateTime {
-    time::OffsetDateTime::from_unix_timestamp(time.seconds_since_unix_epoch as i64)
+pub fn time_to_offset_date_time(time: gix::date::Time) -> OffsetDateTime {
+    time::OffsetDateTime::from_unix_timestamp(time.seconds as i64)
         .expect("always valid unix time")
-        .replace_offset(time::UtcOffset::from_whole_seconds(time.offset_in_seconds).expect("valid offset"))
+        .replace_offset(time::UtcOffset::from_whole_seconds(time.offset).expect("valid offset"))
 }
diff --git a/gitoxide-core/src/commitgraph/list.rs b/gitoxide-core/src/commitgraph/list.rs
new file mode 100644
index 00000000000..5678166aa3b
--- /dev/null
+++ b/gitoxide-core/src/commitgraph/list.rs
@@ -0,0 +1,57 @@
+pub(crate) mod function {
+    use std::borrow::Cow;
+    use std::ffi::OsString;
+
+    use anyhow::{bail, Context};
+    use gix::prelude::ObjectIdExt;
+    use gix::traverse::commit::Sorting;
+
+    use crate::OutputFormat;
+
+    pub fn list(
+        mut repo: gix::Repository,
+        spec: OsString,
+        mut out: impl std::io::Write,
+        format: OutputFormat,
+    ) -> anyhow::Result<()> {
+        if format != OutputFormat::Human {
+            bail!("Only human output is currently supported");
+        }
+        let graph = repo
+            .commit_graph()
+            .context("a commitgraph is required, but none was found")?;
+        repo.object_cache_size_if_unset(4 * 1024 * 1024);
+
+        let spec = gix::path::os_str_into_bstr(&spec)?;
+        let id = repo
+            .rev_parse_single(spec)
+            .context("Only single revisions are currently supported")?;
+        let commits = id
+            .object()?
+            .peel_to_kind(gix::object::Kind::Commit)
+            .context("Need commitish as starting point")?
+            .id()
+            .ancestors()
+            .sorting(Sorting::ByCommitTimeNewestFirst)
+            .all()?;
+        for commit in commits {
+            let commit = commit?;
+            writeln!(
+                out,
+                "{} {} {} {}",
+                commit.id().shorten_or_id(),
+                commit.commit_time.expect("traversal with date"),
+                commit.parent_ids.len(),
+                graph.commit_by_id(commit.id).map_or_else(
+                    || Cow::Borrowed("<NOT IN GRAPH-CACHE>"),
+                    |c| Cow::Owned(format!(
+                        "{} {}",
+                        c.root_tree_id().to_owned().attach(&repo).shorten_or_id(),
+                        c.generation()
+                    ))
+                )
+            )?;
+        }
+        Ok(())
+    }
+}
diff --git a/gitoxide-core/src/commitgraph/mod.rs b/gitoxide-core/src/commitgraph/mod.rs
index a8118c56ae7..f75e2f7bcf4 100644
--- a/gitoxide-core/src/commitgraph/mod.rs
+++ b/gitoxide-core/src/commitgraph/mod.rs
@@ -1 +1,5 @@
+pub mod list;
+pub use list::function::list;
+
 pub mod verify;
+pub use verify::function::verify;
diff --git a/gitoxide-core/src/commitgraph/verify.rs b/gitoxide-core/src/commitgraph/verify.rs
index aefa581fe8d..4f4b8488083 100644
--- a/gitoxide-core/src/commitgraph/verify.rs
+++ b/gitoxide-core/src/commitgraph/verify.rs
@@ -1,12 +1,7 @@
-use std::{io, path::Path};
-
-use anyhow::{Context as AnyhowContext, Result};
-use gix::commitgraph::Graph;
-
 use crate::OutputFormat;
 
 /// A general purpose context for many operations provided here
-pub struct Context<W1: io::Write, W2: io::Write> {
+pub struct Context<W1: std::io::Write, W2: std::io::Write> {
     /// A stream to which to output errors
     pub err: W2,
     /// A stream to which to output operation results
@@ -14,64 +9,62 @@ pub struct Context<W1: io::Write, W2: io::Write> {
     pub output_statistics: Option<OutputFormat>,
 }
 
-impl Default for Context<Vec<u8>, Vec<u8>> {
-    fn default() -> Self {
+pub(crate) mod function {
+    use std::io;
+
+    use crate::commitgraph::verify::Context;
+    use crate::OutputFormat;
+    use anyhow::{Context as AnyhowContext, Result};
+
+    pub fn verify<W1, W2>(
+        repo: gix::Repository,
         Context {
-            err: Vec::new(),
-            out: Vec::new(),
-            output_statistics: None,
-        }
-    }
-}
+            err: _err,
+            mut out,
+            output_statistics,
+        }: Context<W1, W2>,
+    ) -> Result<gix::commitgraph::verify::Outcome>
+    where
+        W1: io::Write,
+        W2: io::Write,
+    {
+        let g = repo.commit_graph()?;
 
-pub fn graph_or_file<W1, W2>(
-    path: impl AsRef<Path>,
-    Context {
-        err: _err,
-        mut out,
-        output_statistics,
-    }: Context<W1, W2>,
-) -> Result<gix::commitgraph::verify::Outcome>
-where
-    W1: io::Write,
-    W2: io::Write,
-{
-    let g = Graph::at(path).with_context(|| "Could not open commit graph")?;
+        #[allow(clippy::unnecessary_wraps, unknown_lints)]
+        fn noop_processor(_commit: &gix::commitgraph::file::Commit<'_>) -> std::result::Result<(), std::fmt::Error> {
+            Ok(())
+        }
+        let stats = g
+            .verify_integrity(noop_processor)
+            .with_context(|| "Verification failure")?;
 
-    #[allow(clippy::unnecessary_wraps, unknown_lints)]
-    fn noop_processor(_commit: &gix::commitgraph::file::Commit<'_>) -> std::result::Result<(), std::fmt::Error> {
-        Ok(())
-    }
-    let stats = g
-        .verify_integrity(noop_processor)
-        .with_context(|| "Verification failure")?;
+        #[cfg_attr(not(feature = "serde"), allow(clippy::single_match))]
+        match output_statistics {
+            Some(OutputFormat::Human) => drop(print_human_output(&mut out, &stats)),
+            #[cfg(feature = "serde")]
+            Some(OutputFormat::Json) => serde_json::to_writer_pretty(out, &stats)?,
+            _ => {}
+        }
 
-    #[cfg_attr(not(feature = "serde"), allow(clippy::single_match))]
-    match output_statistics {
-        Some(OutputFormat::Human) => drop(print_human_output(&mut out, &stats)),
-        #[cfg(feature = "serde")]
-        Some(OutputFormat::Json) => serde_json::to_writer_pretty(out, &stats)?,
-        _ => {}
+        Ok(stats)
     }
 
-    Ok(stats)
-}
+    fn print_human_output(out: &mut impl io::Write, stats: &gix::commitgraph::verify::Outcome) -> io::Result<()> {
+        writeln!(out, "number of commits with the given number of parents")?;
+        let mut parent_counts: Vec<_> = stats.parent_counts.iter().map(|(a, b)| (*a, *b)).collect();
+        parent_counts.sort_by_key(|e| e.0);
+        for (parent_count, commit_count) in parent_counts.into_iter() {
+            writeln!(out, "\t{parent_count:>2}: {commit_count}")?;
+        }
+        writeln!(out, "\t->: {}", stats.num_commits)?;
 
-fn print_human_output(out: &mut impl io::Write, stats: &gix::commitgraph::verify::Outcome) -> io::Result<()> {
-    writeln!(out, "number of commits with the given number of parents")?;
-    let mut parent_counts: Vec<_> = stats.parent_counts.iter().map(|(a, b)| (*a, *b)).collect();
-    parent_counts.sort_by_key(|e| e.0);
-    for (parent_count, commit_count) in parent_counts.into_iter() {
-        writeln!(out, "\t{parent_count:>2}: {commit_count}")?;
-    }
-    writeln!(out, "\t->: {}", stats.num_commits)?;
+        write!(out, "\nlongest path length between two commits: ")?;
+        if let Some(n) = stats.longest_path_length {
+            writeln!(out, "{n}")?;
+        } else {
+            writeln!(out, "unknown")?;
+        }
 
-    write!(out, "\nlongest path length between two commits: ")?;
-    if let Some(n) = stats.longest_path_length {
-        writeln!(out, "{n}")?;
-    } else {
-        writeln!(out, "unknown")?;
+        Ok(())
     }
-
-    Ok(())
 }
diff --git a/gitoxide-core/src/hours/core.rs b/gitoxide-core/src/hours/core.rs
index efb8c4c46d4..0423e10a548 100644
--- a/gitoxide-core/src/hours/core.rs
+++ b/gitoxide-core/src/hours/core.rs
@@ -24,11 +24,7 @@ pub fn estimate_hours(
     let hours_for_commits = commits.iter().map(|t| &t.1).rev().tuple_windows().fold(
         0_f32,
         |hours, (cur, next): (&gix::actor::SignatureRef<'_>, &gix::actor::SignatureRef<'_>)| {
-            let change_in_minutes = (next
-                .time
-                .seconds_since_unix_epoch
-                .saturating_sub(cur.time.seconds_since_unix_epoch)) as f32
-                / MINUTES_PER_HOUR;
+            let change_in_minutes = (next.time.seconds.saturating_sub(cur.time.seconds)) as f32 / MINUTES_PER_HOUR;
             if change_in_minutes < MAX_COMMIT_DIFFERENCE_IN_MINUTES {
                 hours + change_in_minutes / MINUTES_PER_HOUR
             } else {
diff --git a/gitoxide-core/src/hours/mod.rs b/gitoxide-core/src/hours/mod.rs
index e46409e5761..598c92ed772 100644
--- a/gitoxide-core/src/hours/mod.rs
+++ b/gitoxide-core/src/hours/mod.rs
@@ -95,12 +95,9 @@ where
                 }
                 out.shrink_to_fit();
                 out.sort_by(|a, b| {
-                    a.1.email.cmp(b.1.email).then(
-                        a.1.time
-                            .seconds_since_unix_epoch
-                            .cmp(&b.1.time.seconds_since_unix_epoch)
-                            .reverse(),
-                    )
+                    a.1.email
+                        .cmp(b.1.email)
+                        .then(a.1.time.seconds.cmp(&b.1.time.seconds).reverse())
                 });
                 Ok(out)
             });
diff --git a/gitoxide-core/src/repository/revision/list.rs b/gitoxide-core/src/repository/revision/list.rs
index b8a7330cdc5..91949503845 100644
--- a/gitoxide-core/src/repository/revision/list.rs
+++ b/gitoxide-core/src/repository/revision/list.rs
@@ -1,7 +1,7 @@
 use std::ffi::OsString;
 
 use anyhow::{bail, Context};
-use gix::prelude::ObjectIdExt;
+use gix::traverse::commit::Sorting;
 
 use crate::OutputFormat;
 
@@ -20,14 +20,23 @@ pub fn list(
     let id = repo
         .rev_parse_single(spec)
         .context("Only single revisions are currently supported")?;
-    let commit_id = id
+    let commits = id
         .object()?
         .peel_to_kind(gix::object::Kind::Commit)
         .context("Need commitish as starting point")?
-        .id
-        .attach(&repo);
-    for commit in commit_id.ancestors().all()? {
-        writeln!(out, "{}", commit?.id().to_hex())?;
+        .id()
+        .ancestors()
+        .sorting(Sorting::ByCommitTimeNewestFirst)
+        .all()?;
+    for commit in commits {
+        let commit = commit?;
+        writeln!(
+            out,
+            "{} {} {}",
+            commit.id().shorten_or_id(),
+            commit.commit_time.expect("traversal with date"),
+            commit.parent_ids.len()
+        )?;
     }
     Ok(())
 }
diff --git a/gix-actor/src/lib.rs b/gix-actor/src/lib.rs
index 93d8bdb0fd5..5a4d078be87 100644
--- a/gix-actor/src/lib.rs
+++ b/gix-actor/src/lib.rs
@@ -9,8 +9,16 @@
 #![deny(missing_docs, rust_2018_idioms)]
 #![forbid(unsafe_code)]
 
+/// The re-exported `bstr` crate.
+///
+/// For convenience to allow using `bstr` without adding it to own cargo manifest.
+pub use bstr;
 use bstr::{BStr, BString};
-pub use gix_date::{time::Sign, Time};
+/// The re-exported `gix-date` crate.
+///
+/// For convenience to allow using `gix-date` without adding it to own cargo manifest.
+pub use gix_date as date;
+use gix_date::Time;
 
 mod identity;
 ///
diff --git a/gix-actor/src/signature/decode.rs b/gix-actor/src/signature/decode.rs
index 6bd7bfed696..e80d42a1322 100644
--- a/gix-actor/src/signature/decode.rs
+++ b/gix-actor/src/signature/decode.rs
@@ -1,6 +1,8 @@
 pub(crate) mod function {
     use bstr::ByteSlice;
     use btoi::btoi;
+    use gix_date::time::Sign;
+    use gix_date::{OffsetInSeconds, SecondsSinceUnixEpoch, Time};
     use nom::{
         branch::alt,
         bytes::complete::{tag, take, take_until, take_while_m_n},
@@ -10,7 +12,7 @@ pub(crate) mod function {
         IResult,
     };
 
-    use crate::{IdentityRef, Sign, SignatureRef, Time};
+    use crate::{IdentityRef, SignatureRef};
 
     const SPACE: &[u8] = b" ";
 
@@ -25,7 +27,7 @@ pub(crate) mod function {
                 tag(b" "),
                 context("<timestamp>", |i| {
                     terminated(take_until(SPACE), take(1usize))(i).and_then(|(i, v)| {
-                        btoi::<u32>(v)
+                        btoi::<SecondsSinceUnixEpoch>(v)
                             .map(|v| (i, v))
                             .map_err(|_| nom::Err::Error(E::from_error_kind(i, nom::error::ErrorKind::MapRes)))
                     })
@@ -33,14 +35,14 @@ pub(crate) mod function {
                 context("+|-", alt((tag(b"-"), tag(b"+")))),
                 context("HH", |i| {
                     take_while_m_n(2usize, 2, is_digit)(i).and_then(|(i, v)| {
-                        btoi::<i32>(v)
+                        btoi::<OffsetInSeconds>(v)
                             .map(|v| (i, v))
                             .map_err(|_| nom::Err::Error(E::from_error_kind(i, nom::error::ErrorKind::MapRes)))
                     })
                 }),
                 context("MM", |i| {
                     take_while_m_n(2usize, 2, is_digit)(i).and_then(|(i, v)| {
-                        btoi::<i32>(v)
+                        btoi::<OffsetInSeconds>(v)
                             .map(|v| (i, v))
                             .map_err(|_| nom::Err::Error(E::from_error_kind(i, nom::error::ErrorKind::MapRes)))
                     })
@@ -58,8 +60,8 @@ pub(crate) mod function {
                 name: identity.name,
                 email: identity.email,
                 time: Time {
-                    seconds_since_unix_epoch: time,
-                    offset_in_seconds: offset,
+                    seconds: time,
+                    offset,
                     sign,
                 },
             },
@@ -93,10 +95,12 @@ pub use function::identity;
 mod tests {
     mod parse_signature {
         use bstr::ByteSlice;
+        use gix_date::time::Sign;
+        use gix_date::{OffsetInSeconds, SecondsSinceUnixEpoch};
         use gix_testtools::to_bstr_err;
         use nom::IResult;
 
-        use crate::{signature, Sign, SignatureRef, Time};
+        use crate::{signature, SignatureRef, Time};
 
         fn decode(i: &[u8]) -> IResult<&[u8], SignatureRef<'_>, nom::error::VerboseError<&[u8]>> {
             signature::decode(i)
@@ -105,18 +109,14 @@ mod tests {
         fn signature(
             name: &'static str,
             email: &'static str,
-            time: u32,
+            seconds: SecondsSinceUnixEpoch,
             sign: Sign,
-            offset: i32,
+            offset: OffsetInSeconds,
         ) -> SignatureRef<'static> {
             SignatureRef {
                 name: name.as_bytes().as_bstr(),
                 email: email.as_bytes().as_bstr(),
-                time: Time {
-                    seconds_since_unix_epoch: time,
-                    offset_in_seconds: offset,
-                    sign,
-                },
+                time: Time { seconds, offset, sign },
             }
         }
 
diff --git a/gix-actor/tests/signature/mod.rs b/gix-actor/tests/signature/mod.rs
index 6bb0da58685..417a76fc342 100644
--- a/gix-actor/tests/signature/mod.rs
+++ b/gix-actor/tests/signature/mod.rs
@@ -1,6 +1,8 @@
 mod write_to {
     mod invalid {
-        use gix_actor::{Sign, Signature, Time};
+        use gix_actor::Signature;
+        use gix_date::time::Sign;
+        use gix_date::Time;
 
         #[test]
         fn name() {
@@ -43,8 +45,8 @@ mod write_to {
 
         fn default_time() -> Time {
             Time {
-                seconds_since_unix_epoch: 0,
-                offset_in_seconds: 0,
+                seconds: 0,
+                offset: 0,
                 sign: Sign::Plus,
             }
         }
diff --git a/gix-commitgraph/Cargo.toml b/gix-commitgraph/Cargo.toml
index 2b827827b62..e6f0fb2add7 100644
--- a/gix-commitgraph/Cargo.toml
+++ b/gix-commitgraph/Cargo.toml
@@ -31,6 +31,7 @@ document-features = { version = "0.2.0", optional = true }
 
 [dev-dependencies]
 gix-testtools = { path = "../tests/tools" }
+gix-date = { path = "../gix-date" }
 
 [package.metadata.docs.rs]
 all-features = true
diff --git a/gix-commitgraph/tests/access/mod.rs b/gix-commitgraph/tests/access/mod.rs
index 9dc41c5d348..8000cbb4eb0 100644
--- a/gix-commitgraph/tests/access/mod.rs
+++ b/gix-commitgraph/tests/access/mod.rs
@@ -1,25 +1,78 @@
-use gix_commitgraph::Graph;
-
-use crate::{check_common, inspect_refs, make_readonly_repo};
+use crate::{check_common, graph_and_expected, graph_and_expected_named};
 
 #[test]
-fn single_parent() -> crate::Result {
-    let repo_dir = make_readonly_repo("single_parent.sh");
-    let refs = inspect_refs(&repo_dir, &["parent", "child"]);
-    let cg = Graph::from_info_dir(repo_dir.join(".git").join("objects").join("info"))?;
+fn single_parent() {
+    let (cg, refs) = graph_and_expected("single_parent.sh", &["parent", "child"]);
     check_common(&cg, &refs);
 
     assert_eq!(cg.commit_at(refs["parent"].pos()).generation(), 1);
     assert_eq!(cg.commit_at(refs["child"].pos()).generation(), 2);
+}
+
+#[test]
+fn single_commit_huge_dates_generation_v2_also_do_not_allow_huge_dates() {
+    let (cg, refs) = graph_and_expected_named("single_commit_huge_dates.sh", "v2", &["HEAD"]);
+    let info = &refs["HEAD"];
+    let actual = cg.commit_by_id(info.id).expect("present");
+    assert_eq!(
+        actual.committer_timestamp(),
+        1,
+        "overflow happened, can't represent huge dates"
+    );
+    assert_eq!(
+        info.time.seconds, 68719476737,
+        "this is the value we would want to see, but it's not possible in V2 either, as that is just about generations"
+    );
+    assert_eq!(actual.generation(), 1, "generations are fine though");
+}
 
-    Ok(())
+#[test]
+fn single_commit_huge_dates_overflow_v1() {
+    let (cg, refs) = graph_and_expected_named("single_commit_huge_dates.sh", "v1", &["HEAD"]);
+    let info = &refs["HEAD"];
+    let actual = cg.commit_by_id(info.id).expect("present");
+    assert_eq!(actual.committer_timestamp(), 1, "overflow happened");
+    assert_eq!(
+        info.time.seconds, 68719476737,
+        "this is the value we would want to see, but it's not possible in V1"
+    );
+    assert_eq!(actual.generation(), 1, "generations are fine though");
 }
 
 #[test]
-fn octupus_merges() -> crate::Result {
-    let repo_dir = make_readonly_repo("octopus_merges.sh");
-    let refs = inspect_refs(
-        &repo_dir,
+fn single_commit_future_64bit_dates_work() {
+    let (cg, refs) = graph_and_expected_named("single_commit_huge_dates.sh", "max-date", &["HEAD"]);
+    let info = &refs["HEAD"];
+    let actual = cg.commit_by_id(info.id).expect("present");
+    assert_eq!(
+        actual.committer_timestamp(),
+        info.time.seconds,
+        "this is close the the highest representable value in the graph, like year 2500, so we are good for longer than I should care about"
+    );
+    assert_eq!(actual.generation(), 1);
+}
+
+#[test]
+fn generation_numbers_overflow_is_handled_in_chained_graph() {
+    let names = ["extra", "old-2", "future-2", "old-1", "future-1"];
+    let (cg, mut refs) = graph_and_expected("generation_number_overflow.sh", &names);
+    for (r, expected) in names
+        .iter()
+        .map(|n| refs.remove(n.to_owned()).expect("present"))
+        .zip((1..=5).rev())
+    {
+        assert_eq!(
+            cg.commit_by_id(r.id).expect("present").generation(),
+            expected,
+            "actually, this test seems to have valid generation numbers from the get-go. How to repro the actual issue?"
+        );
+    }
+}
+
+#[test]
+fn octupus_merges() {
+    let (cg, refs) = graph_and_expected(
+        "octopus_merges.sh",
         &[
             "root",
             "parent1",
@@ -30,7 +83,6 @@ fn octupus_merges() -> crate::Result {
             "four_parents",
         ],
     );
-    let cg = Graph::at(repo_dir.join(".git").join("objects").join("info"))?;
     check_common(&cg, &refs);
 
     assert_eq!(cg.commit_at(refs["root"].pos()).generation(), 1);
@@ -40,32 +92,22 @@ fn octupus_merges() -> crate::Result {
     assert_eq!(cg.commit_at(refs["parent4"].pos()).generation(), 2);
     assert_eq!(cg.commit_at(refs["three_parents"].pos()).generation(), 3);
     assert_eq!(cg.commit_at(refs["four_parents"].pos()).generation(), 3);
-
-    Ok(())
 }
 
 #[test]
-fn single_commit() -> crate::Result {
-    let repo_dir = make_readonly_repo("single_commit.sh");
-    let refs = inspect_refs(&repo_dir, &["commit"]);
-    let cg = gix_commitgraph::at(repo_dir.join(".git").join("objects").join("info"))?;
+fn single_commit() {
+    let (cg, refs) = graph_and_expected("single_commit.sh", &["commit"]);
     check_common(&cg, &refs);
 
     assert_eq!(cg.commit_at(refs["commit"].pos()).generation(), 1);
-
-    Ok(())
 }
 
 #[test]
-fn two_parents() -> crate::Result {
-    let repo_dir = make_readonly_repo("two_parents.sh");
-    let refs = inspect_refs(&repo_dir, &["parent1", "parent2", "child"]);
-    let cg = Graph::from_info_dir(repo_dir.join(".git").join("objects").join("info"))?;
+fn two_parents() {
+    let (cg, refs) = graph_and_expected("two_parents.sh", &["parent1", "parent2", "child"]);
     check_common(&cg, &refs);
 
     assert_eq!(cg.commit_at(refs["parent1"].pos()).generation(), 1);
     assert_eq!(cg.commit_at(refs["parent2"].pos()).generation(), 1);
     assert_eq!(cg.commit_at(refs["child"].pos()).generation(), 2);
-
-    Ok(())
 }
diff --git a/gix-commitgraph/tests/commitgraph.rs b/gix-commitgraph/tests/commitgraph.rs
index f098e1c65ca..e4516c24f1f 100644
--- a/gix-commitgraph/tests/commitgraph.rs
+++ b/gix-commitgraph/tests/commitgraph.rs
@@ -8,12 +8,13 @@ use std::{
 };
 
 use gix_commitgraph::{Graph, Position as GraphPosition};
-
-type Result = std::result::Result<(), Box<dyn std::error::Error>>;
+use gix_testtools::scripted_fixture_read_only;
 
 mod access;
 
 pub fn check_common(cg: &Graph, expected: &HashMap<String, RefInfo, impl BuildHasher>) {
+    cg.verify_integrity(|_| Ok::<_, std::convert::Infallible>(()))
+        .expect("graph is valid");
     assert_eq!(
         usize::try_from(cg.num_commits()).expect("an architecture able to hold 32 bits of integer"),
         expected.len()
@@ -39,6 +40,7 @@ pub fn check_common(cg: &Graph, expected: &HashMap<String, RefInfo, impl BuildHa
 
         let commit = cg.commit_at(ref_info.pos());
         assert_eq!(commit.id(), ref_info.id());
+        assert_eq!(commit.committer_timestamp(), ref_info.time.seconds);
         assert_eq!(commit.root_tree_id(), ref_info.root_tree_id());
         assert_eq!(
             commit.parent1().expect("failed to access commit's parent1"),
@@ -59,13 +61,29 @@ pub fn check_common(cg: &Graph, expected: &HashMap<String, RefInfo, impl BuildHa
     );
 }
 
-use gix_testtools::scripted_fixture_read_only;
-pub fn make_readonly_repo(script_path: &str) -> std::path::PathBuf {
-    scripted_fixture_read_only(script_path).expect("script succeeds all the time")
+pub fn graph_and_expected(
+    script_path: &str,
+    refs: &[&'static str],
+) -> (gix_commitgraph::Graph, HashMap<String, RefInfo>) {
+    graph_and_expected_named(script_path, "", refs)
+}
+
+pub fn graph_and_expected_named(
+    script_path: &str,
+    name: &str,
+    refs: &[&'static str],
+) -> (gix_commitgraph::Graph, HashMap<String, RefInfo>) {
+    let repo_dir = scripted_fixture_read_only(script_path)
+        .expect("script succeeds all the time")
+        .join(name);
+    let expected = inspect_refs(&repo_dir, refs);
+    let cg = Graph::from_info_dir(repo_dir.join(".git").join("objects").join("info")).expect("graph present and valid");
+    (cg, expected)
 }
 
 pub struct RefInfo {
     id: gix_hash::ObjectId,
+    pub time: gix_date::Time,
     parent_ids: Vec<gix_hash::ObjectId>,
     pos: GraphPosition,
     root_tree_id: gix_hash::ObjectId,
@@ -89,13 +107,13 @@ impl RefInfo {
     }
 }
 
-pub fn inspect_refs(repo_dir: impl AsRef<Path>, refs: &[&'static str]) -> HashMap<String, RefInfo> {
+fn inspect_refs(repo_dir: impl AsRef<Path>, refs: &[&'static str]) -> HashMap<String, RefInfo> {
     let output = Command::new("git")
         .arg("-C")
         .arg(repo_dir.as_ref())
         .arg("show")
         .arg("--no-patch")
-        .arg("--pretty=format:%S %H %T %P")
+        .arg("--pretty=format:%S %H %T %ct %P")
         .args(refs)
         .arg("--")
         .env_remove("GIT_DIR")
@@ -111,7 +129,8 @@ pub fn inspect_refs(repo_dir: impl AsRef<Path>, refs: &[&'static str]) -> HashMa
                 parts[0].to_string(),
                 gix_hash::ObjectId::from_hex(parts[1].as_bytes()).expect("40 bytes hex"),
                 gix_hash::ObjectId::from_hex(parts[2].as_bytes()).expect("40 bytes hex"),
-                parts[3..]
+                gix_date::Time::new(parts[3].parse().expect("valid stamp"), 0),
+                parts[4..]
                     .iter()
                     .map(|x| gix_hash::ObjectId::from_hex(x.as_bytes()).expect("40 bytes hex"))
                     .collect(),
@@ -132,13 +151,14 @@ pub fn inspect_refs(repo_dir: impl AsRef<Path>, refs: &[&'static str]) -> HashMa
     infos
         .iter()
         .cloned()
-        .map(|(name, id, root_tree_id, parent_ids)| {
+        .map(|(name, id, root_tree_id, time, parent_ids)| {
             (
                 name,
                 RefInfo {
                     id,
                     parent_ids,
                     root_tree_id,
+                    time,
                     pos: get_pos(&id),
                 },
             )
diff --git a/gix-commitgraph/tests/fixtures/generated-archives/generation_number_overflow.tar.xz b/gix-commitgraph/tests/fixtures/generated-archives/generation_number_overflow.tar.xz
new file mode 100644
index 00000000000..53e2d7a5279
--- /dev/null
+++ b/gix-commitgraph/tests/fixtures/generated-archives/generation_number_overflow.tar.xz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:266655a2777562f495bfe6a6f9d57bef7d13fe3ff012a9a97402ca7f8801dccf
+size 12504
diff --git a/gix-commitgraph/tests/fixtures/generated-archives/octopus_merges.tar.xz b/gix-commitgraph/tests/fixtures/generated-archives/octopus_merges.tar.xz
index aae2969247c..44fdd5cfc5c 100644
--- a/gix-commitgraph/tests/fixtures/generated-archives/octopus_merges.tar.xz
+++ b/gix-commitgraph/tests/fixtures/generated-archives/octopus_merges.tar.xz
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:fdb7b214315cabdf81173aed5530c2030d3d4f5f2888ebc194f6d1268fca685a
-size 11028
+oid sha256:e52a2e28465e3ac6b64cc7d9dac2486a216a9d99175e4ade52f68ff2602ea108
+size 11104
diff --git a/gix-commitgraph/tests/fixtures/generated-archives/single_commit_huge_dates.tar.xz b/gix-commitgraph/tests/fixtures/generated-archives/single_commit_huge_dates.tar.xz
new file mode 100644
index 00000000000..8a57755d8bb
--- /dev/null
+++ b/gix-commitgraph/tests/fixtures/generated-archives/single_commit_huge_dates.tar.xz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:39cd8603f0e58ff9cf05173f2edcd9446128461bb647d8045e6d73c86205b141
+size 10900
diff --git a/gix-commitgraph/tests/fixtures/generated-archives/single_parent_huge_dates.tar.xz b/gix-commitgraph/tests/fixtures/generated-archives/single_parent_huge_dates.tar.xz
new file mode 100644
index 00000000000..22190de85b5
--- /dev/null
+++ b/gix-commitgraph/tests/fixtures/generated-archives/single_parent_huge_dates.tar.xz
@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:466157da5dcaae21d46aa5a1aa09e72e0c545eafae1c4513cfa75ad94115062f
+size 10128
diff --git a/gix-commitgraph/tests/fixtures/generation_number_overflow.sh b/gix-commitgraph/tests/fixtures/generation_number_overflow.sh
new file mode 100644
index 00000000000..2592c92d4c9
--- /dev/null
+++ b/gix-commitgraph/tests/fixtures/generation_number_overflow.sh
@@ -0,0 +1,47 @@
+#!/bin/bash
+set -eu -o pipefail
+
+function tick () {
+  if test -z "${tick+set}"
+  then
+    tick=1112911993
+  else
+    tick=$(($tick + 60))
+  fi
+  GIT_COMMITTER_DATE="$tick -0700"
+  GIT_AUTHOR_DATE="$tick -0700"
+  export GIT_COMMITTER_DATE GIT_AUTHOR_DATE
+}
+
+tick
+function commit() {
+  local message=${1:?first argument is the commit message}
+  local date=${2:-}
+  local file="$message.t"
+  echo "$1" > "$file"
+  git add -- "$file"
+  if [ -n "$date" ]; then
+    export GIT_COMMITTER_DATE="$date"
+  else
+    tick
+  fi
+  git commit -m "$message"
+  git tag "$message"
+}
+
+# adapted from git/t/t5318 'lower layers have overflow chunk'
+UNIX_EPOCH_ZERO="@0 +0000"
+FUTURE_DATE="@4147483646 +0000"
+
+git init
+git config commitGraph.generationVersion 2
+
+commit future-1 "$FUTURE_DATE"
+commit old-1 "$UNIX_EPOCH_ZERO"
+git commit-graph write --reachable
+commit future-2 "$FUTURE_DATE"
+commit old-2 "$UNIX_EPOCH_ZERO"
+git commit-graph write --reachable --split=no-merge
+commit extra
+# this makes sure it's actually in chain format.
+git commit-graph write --reachable --split=no-merge
diff --git a/gix-commitgraph/tests/fixtures/single_commit_huge_dates.sh b/gix-commitgraph/tests/fixtures/single_commit_huge_dates.sh
new file mode 100644
index 00000000000..19ffba26770
--- /dev/null
+++ b/gix-commitgraph/tests/fixtures/single_commit_huge_dates.sh
@@ -0,0 +1,20 @@
+#!/bin/bash
+set -eu -o pipefail
+
+function setup_repo() {
+  local version=${1:?need generation version}
+  local time=${2:?timestamp seconds since unix epoch}
+  git init -q
+
+  # one past the max 32bit date git can represent
+  export GIT_COMMITTER_DATE="@${time} +0000"
+  git config commitGraph.generationVersion ${version}
+
+  git commit -q --allow-empty -m c1
+
+  git commit-graph write --no-progress --reachable
+}
+
+(mkdir v1 && cd v1 && setup_repo 1 68719476737) # the year 4000 something (overflows in graph)
+(mkdir v2 && cd v2 && setup_repo 2 68719476737)
+(mkdir max-date && cd max-date && setup_repo 1 17147483646) # the year 2500ish
diff --git a/gix-date/src/lib.rs b/gix-date/src/lib.rs
index 736f5e59816..997f9167713 100644
--- a/gix-date/src/lib.rs
+++ b/gix-date/src/lib.rs
@@ -22,9 +22,14 @@ pub use parse::function::parse;
 #[cfg_attr(feature = "serde", derive(serde::Serialize, serde::Deserialize))]
 pub struct Time {
     /// time in seconds since epoch.
-    pub seconds_since_unix_epoch: u32,
+    pub seconds: SecondsSinceUnixEpoch,
     /// time offset in seconds, may be negative to match the `sign` field.
-    pub offset_in_seconds: i32,
+    pub offset: OffsetInSeconds,
     /// the sign of `offset`, used to encode `-0000` which would otherwise loose sign information.
     pub sign: time::Sign,
 }
+
+/// The amount of seconds since unix epoch.
+pub type SecondsSinceUnixEpoch = u64;
+/// time offset in seconds.
+pub type OffsetInSeconds = i32;
diff --git a/gix-date/src/parse.rs b/gix-date/src/parse.rs
index 7038a80fbd1..fc257834e10 100644
--- a/gix-date/src/parse.rs
+++ b/gix-date/src/parse.rs
@@ -7,7 +7,7 @@ pub enum Error {
     RelativeTimeConversion,
     #[error("Date string can not be parsed")]
     InvalidDateString { input: String },
-    #[error("Dates past 2038 can not be represented.")]
+    #[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,
@@ -24,7 +24,7 @@ pub(crate) mod function {
             format::{DEFAULT, GITOXIDE, ISO8601, ISO8601_STRICT, SHORT},
             Sign,
         },
-        Time,
+        SecondsSinceUnixEpoch, Time,
     };
 
     #[allow(missing_docs)]
@@ -47,7 +47,7 @@ pub(crate) mod function {
             Time::new(val.unix_timestamp().try_into()?, val.offset().whole_seconds())
         } else if let Ok(val) = OffsetDateTime::parse(input, DEFAULT) {
             Time::new(val.unix_timestamp().try_into()?, val.offset().whole_seconds())
-        } else if let Ok(val) = u32::from_str(input) {
+        } else if let Ok(val) = SecondsSinceUnixEpoch::from_str(input) {
             // Format::Unix
             Time::new(val, 0)
         } else if let Some(val) = parse_raw(input) {
@@ -60,7 +60,7 @@ pub(crate) mod function {
         })
     }
 
-    fn timestamp(date: OffsetDateTime) -> Result<u32, Error> {
+    fn timestamp(date: OffsetDateTime) -> Result<SecondsSinceUnixEpoch, Error> {
         let timestamp = date.unix_timestamp();
         if timestamp < 0 {
             Err(Error::TooEarly { timestamp })
@@ -71,7 +71,7 @@ pub(crate) mod function {
 
     fn parse_raw(input: &str) -> Option<Time> {
         let mut split = input.split_whitespace();
-        let seconds_since_unix_epoch: u32 = split.next()?.parse().ok()?;
+        let seconds: SecondsSinceUnixEpoch = split.next()?.parse().ok()?;
         let offset = split.next()?;
         if offset.len() != 5 || split.next().is_some() {
             return None;
@@ -88,8 +88,8 @@ pub(crate) mod function {
             offset_in_seconds *= -1;
         };
         let time = Time {
-            seconds_since_unix_epoch,
-            offset_in_seconds,
+            seconds,
+            offset: offset_in_seconds,
             sign,
         };
         Some(time)
diff --git a/gix-date/src/time/format.rs b/gix-date/src/time/format.rs
index 37cc12bd2bf..28a2f2a7b10 100644
--- a/gix-date/src/time/format.rs
+++ b/gix-date/src/time/format.rs
@@ -73,7 +73,7 @@ impl Time {
                 .to_time()
                 .format(&format)
                 .expect("well-known format into memory never fails"),
-            Format::Unix => self.seconds_since_unix_epoch.to_string(),
+            Format::Unix => self.seconds.to_string(),
             Format::Raw => self.to_bstring().to_string(),
         }
     }
@@ -81,8 +81,8 @@ impl Time {
 
 impl Time {
     fn to_time(self) -> time::OffsetDateTime {
-        time::OffsetDateTime::from_unix_timestamp(self.seconds_since_unix_epoch as i64)
+        time::OffsetDateTime::from_unix_timestamp(self.seconds as i64)
             .expect("always valid unix time")
-            .to_offset(time::UtcOffset::from_whole_seconds(self.offset_in_seconds).expect("valid offset"))
+            .to_offset(time::UtcOffset::from_whole_seconds(self.offset).expect("valid offset"))
     }
 }
diff --git a/gix-date/src/time/init.rs b/gix-date/src/time/init.rs
index 7e4cdefc6be..6c4cc0a1fa0 100644
--- a/gix-date/src/time/init.rs
+++ b/gix-date/src/time/init.rs
@@ -1,28 +1,28 @@
 use std::{convert::TryInto, ops::Sub};
 
-use crate::{time::Sign, Time};
+use crate::{time::Sign, OffsetInSeconds, SecondsSinceUnixEpoch, Time};
 
 /// Instantiation
 impl Time {
     /// Create a new instance from seconds and offset.
-    pub fn new(seconds_since_unix_epoch: u32, offset_in_seconds: i32) -> Self {
+    pub fn new(seconds: SecondsSinceUnixEpoch, offset: OffsetInSeconds) -> Self {
         Time {
-            seconds_since_unix_epoch,
-            offset_in_seconds,
-            sign: offset_in_seconds.into(),
+            seconds,
+            offset,
+            sign: offset.into(),
         }
     }
 
     /// Return the current time without figuring out a timezone offset
     pub fn now_utc() -> Self {
-        let seconds_since_unix_epoch = time::OffsetDateTime::now_utc()
+        let seconds = time::OffsetDateTime::now_utc()
             .sub(std::time::SystemTime::UNIX_EPOCH)
             .whole_seconds()
             .try_into()
-            .expect("this is not year 2038");
+            .expect("this is not the end of the universe");
         Self {
-            seconds_since_unix_epoch,
-            offset_in_seconds: 0,
+            seconds,
+            offset: 0,
             sign: Sign::Plus,
         }
     }
@@ -30,18 +30,18 @@ impl Time {
     /// Return the current local time, or `None` if the local time wasn't available.
     pub fn now_local() -> Option<Self> {
         let now = time::OffsetDateTime::now_utc();
-        let seconds_since_unix_epoch = now
+        let seconds = now
             .sub(std::time::SystemTime::UNIX_EPOCH)
             .whole_seconds()
             .try_into()
-            .expect("this is not year 2038");
+            .expect("this is not the end of the universe");
         // TODO: make this work without cfg(unsound_local_offset), see
         //       https://github.com/time-rs/time/issues/293#issuecomment-909158529
-        let offset_in_seconds = time::UtcOffset::local_offset_at(now).ok()?.whole_seconds();
+        let offset = time::UtcOffset::local_offset_at(now).ok()?.whole_seconds();
         Self {
-            seconds_since_unix_epoch,
-            offset_in_seconds,
-            sign: offset_in_seconds.into(),
+            seconds,
+            offset,
+            sign: offset.into(),
         }
         .into()
     }
@@ -49,20 +49,20 @@ impl Time {
     /// Return the current local time, or the one at UTC if the local time wasn't available.
     pub fn now_local_or_utc() -> Self {
         let now = time::OffsetDateTime::now_utc();
-        let seconds_since_unix_epoch = now
+        let seconds = now
             .sub(std::time::SystemTime::UNIX_EPOCH)
             .whole_seconds()
             .try_into()
-            .expect("this is not year 2038");
+            .expect("this is not the end of the universe");
         // TODO: make this work without cfg(unsound_local_offset), see
         //       https://github.com/time-rs/time/issues/293#issuecomment-909158529
-        let offset_in_seconds = time::UtcOffset::local_offset_at(now)
+        let offset = time::UtcOffset::local_offset_at(now)
             .map(|ofs| ofs.whole_seconds())
             .unwrap_or(0);
         Self {
-            seconds_since_unix_epoch,
-            offset_in_seconds,
-            sign: offset_in_seconds.into(),
+            seconds,
+            offset,
+            sign: offset.into(),
         }
     }
 }
diff --git a/gix-date/src/time/mod.rs b/gix-date/src/time/mod.rs
index 612a3cdef82..22c4e42f0a6 100644
--- a/gix-date/src/time/mod.rs
+++ b/gix-date/src/time/mod.rs
@@ -6,11 +6,6 @@ impl Time {
     pub fn is_set(&self) -> bool {
         *self != Self::default()
     }
-
-    /// Return the passed seconds since epoch since this signature was made.
-    pub fn seconds(&self) -> u32 {
-        self.seconds_since_unix_epoch
-    }
 }
 
 /// Indicates if a number is positive or negative for use in [`Time`].
@@ -58,8 +53,8 @@ mod impls {
     impl Default for Time {
         fn default() -> Self {
             Time {
-                seconds_since_unix_epoch: 0,
-                offset_in_seconds: 0,
+                seconds: 0,
+                offset: 0,
                 sign: Sign::Plus,
             }
         }
diff --git a/gix-date/src/time/write.rs b/gix-date/src/time/write.rs
index d4d017bd3d1..c21f0e8b02b 100644
--- a/gix-date/src/time/write.rs
+++ b/gix-date/src/time/write.rs
@@ -14,7 +14,7 @@ impl Time {
     /// Serialize this instance to `out` in a format suitable for use in header fields of serialized git commits or tags.
     pub fn write_to(&self, mut out: impl std::io::Write) -> std::io::Result<()> {
         let mut itoa = itoa::Buffer::new();
-        out.write_all(itoa.format(self.seconds_since_unix_epoch).as_bytes())?;
+        out.write_all(itoa.format(self.seconds).as_bytes())?;
         out.write_all(b" ")?;
         out.write_all(match self.sign {
             Sign::Plus => b"+",
@@ -24,7 +24,7 @@ impl Time {
         const ZERO: &[u8; 1] = b"0";
 
         const SECONDS_PER_HOUR: i32 = 60 * 60;
-        let offset = self.offset_in_seconds.abs();
+        let offset = self.offset.abs();
         let hours = offset / SECONDS_PER_HOUR;
         assert!(hours < 25, "offset is more than a day: {hours}");
         let minutes = (offset - (hours * SECONDS_PER_HOUR)) / 60;
@@ -40,30 +40,48 @@ impl Time {
         out.write_all(itoa.format(minutes).as_bytes()).map(|_| ())
     }
 
-    /// Computes the number of bytes necessary to render this time.
+    /// Computes the number of bytes necessary to write it using [`Time::write_to()`].
     pub fn size(&self) -> usize {
-        // TODO: this is not year 2038 safe…but we also can't parse larger numbers (or represent them) anyway. It's a trap nonetheless
-        //       that can be fixed by increasing the size to usize.
-        (if self.seconds_since_unix_epoch >= 1_000_000_000 {
+        (if self.seconds >= 10_000_000_000_000_000_000 {
+            20
+        } else if self.seconds >= 1_000_000_000_000_000_000 {
+            19
+        } else if self.seconds >= 100_000_000_000_000_000 {
+            18
+        } else if self.seconds >= 10_000_000_000_000_000 {
+            17
+        } else if self.seconds >= 1_000_000_000_000_000 {
+            16
+        } else if self.seconds >= 100_000_000_000_000 {
+            15
+        } else if self.seconds >= 10_000_000_000_000 {
+            14
+        } else if self.seconds >= 1_000_000_000_000 {
+            13
+        } else if self.seconds >= 100_000_000_000 {
+            12
+        } else if self.seconds >= 10_000_000_000 {
+            11
+        } else if self.seconds >= 1_000_000_000 {
             10
-        } else if self.seconds_since_unix_epoch >= 100_000_000 {
+        } else if self.seconds >= 100_000_000 {
             9
-        } else if self.seconds_since_unix_epoch >= 10_000_000 {
+        } else if self.seconds >= 10_000_000 {
             8
-        } else if self.seconds_since_unix_epoch >= 1_000_000 {
+        } else if self.seconds >= 1_000_000 {
             7
-        } else if self.seconds_since_unix_epoch >= 100_000 {
+        } else if self.seconds >= 100_000 {
             6
-        } else if self.seconds_since_unix_epoch >= 10_000 {
+        } else if self.seconds >= 10_000 {
             5
-        } else if self.seconds_since_unix_epoch >= 1_000 {
+        } else if self.seconds >= 1_000 {
             4
-        } else if self.seconds_since_unix_epoch >= 100 {
+        } else if self.seconds >= 100 {
             3
-        } else if self.seconds_since_unix_epoch >= 10 {
+        } else if self.seconds >= 10 {
             2
         } else {
             1
-        }) + 2 /*space + sign*/ + 2 /*hours*/ + 2 /*minutes*/
+        }) + 2 /*space + offset sign*/ + 2 /*offset hours*/ + 2 /*offset minutes*/
     }
 }
diff --git a/gix-date/tests/fixtures/generate_git_date_baseline.sh b/gix-date/tests/fixtures/generate_git_date_baseline.sh
index 7ceccf76907..e5e34d99341 100644
--- a/gix-date/tests/fixtures/generate_git_date_baseline.sh
+++ b/gix-date/tests/fixtures/generate_git_date_baseline.sh
@@ -38,7 +38,9 @@ baseline '2022-08-17T21:43:13+08:00' 'ISO8601_STRICT'
 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 '123456789' 'UNIX'
+baseline '1234567890' 'UNIX'
 # raw
 baseline '1660874655 +0800' 'RAW'
 
+# 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.xz b/gix-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar.xz
index 4e1cb3eb485..f025054e110 100644
--- a/gix-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar.xz
+++ b/gix-date/tests/fixtures/generated-archives/generate_git_date_baseline.tar.xz
@@ -1,3 +1,3 @@
 version https://git-lfs.github.com/spec/v1
-oid sha256:f78af3da4b598ccee56688adf4ff3dcc35a9e002b2b9372d17dd3b342b2bdecd
-size 9256
+oid sha256:376819eee3c7e23a16abb5ffe4540c215676c183e89c415f0a997b325a0b1331
+size 9260
diff --git a/gix-date/tests/time/baseline.rs b/gix-date/tests/time/baseline.rs
index 8854c82ae18..9ebbfd82fc8 100644
--- a/gix-date/tests/time/baseline.rs
+++ b/gix-date/tests/time/baseline.rs
@@ -1,6 +1,7 @@
 use std::{collections::HashMap, time::SystemTime};
 
 use gix_date::time::{format, Format};
+use gix_date::SecondsSinceUnixEpoch;
 use once_cell::sync::Lazy;
 
 type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
@@ -8,7 +9,7 @@ type Result<T = ()> = std::result::Result<T, Box<dyn std::error::Error>>;
 struct Sample {
     format_name: Option<String>,
     exit_code: usize,
-    time_in_seconds_since_unix_epoch: u32,
+    seconds: SecondsSinceUnixEpoch,
 }
 
 static BASELINE: Lazy<HashMap<String, Sample>> = Lazy::new(|| {
@@ -21,7 +22,7 @@ static BASELINE: Lazy<HashMap<String, Sample>> = Lazy::new(|| {
         while let Some(date_str) = lines.next() {
             let format_name = lines.next().expect("four lines per baseline").to_string();
             let exit_code = lines.next().expect("four lines per baseline").parse()?;
-            let time_in_seconds_since_unix_epoch: u32 = lines
+            let seconds: SecondsSinceUnixEpoch = lines
                 .next()
                 .expect("four lines per baseline")
                 .parse()
@@ -31,7 +32,7 @@ static BASELINE: Lazy<HashMap<String, Sample>> = Lazy::new(|| {
                 Sample {
                     format_name: (!format_name.is_empty()).then_some(format_name),
                     exit_code,
-                    time_in_seconds_since_unix_epoch,
+                    seconds,
                 },
             );
         }
@@ -47,7 +48,7 @@ fn parse_compare_format() {
         Sample {
             format_name,
             exit_code,
-            time_in_seconds_since_unix_epoch,
+            seconds: time_in_seconds_since_unix_epoch,
         },
     ) in BASELINE.iter()
     {
@@ -58,7 +59,7 @@ fn parse_compare_format() {
             "{pattern:?} disagrees with baseline: {res:?}"
         );
         if let Ok(t) = res {
-            let actual = t.seconds_since_unix_epoch;
+            let actual = t.seconds;
             assert_eq!(
                 actual, *time_in_seconds_since_unix_epoch,
                 "{pattern:?} disagrees with baseline seconds since epoch: {actual:?}"
diff --git a/gix-date/tests/time/format.rs b/gix-date/tests/time/format.rs
index d7b6d7db5b7..ddbf070b7b6 100644
--- a/gix-date/tests/time/format.rs
+++ b/gix-date/tests/time/format.rs
@@ -82,16 +82,16 @@ fn custom_compile_time() {
 
 fn time() -> Time {
     Time {
-        seconds_since_unix_epoch: 123456789,
-        offset_in_seconds: 9000,
+        seconds: 123456789,
+        offset: 9000,
         sign: Sign::Plus,
     }
 }
 
 fn time_dec1() -> Time {
     Time {
-        seconds_since_unix_epoch: 123543189,
-        offset_in_seconds: 9000,
+        seconds: 123543189,
+        offset: 9000,
         sign: Sign::Plus,
     }
 }
diff --git a/gix-date/tests/time/mod.rs b/gix-date/tests/time/mod.rs
index dbd846f5869..7f1fb5503e9 100644
--- a/gix-date/tests/time/mod.rs
+++ b/gix-date/tests/time/mod.rs
@@ -1,5 +1,5 @@
 use bstr::ByteSlice;
-use gix_date::{time::Sign, Time};
+use gix_date::{time::Sign, SecondsSinceUnixEpoch, Time};
 
 mod baseline;
 mod format;
@@ -15,7 +15,7 @@ mod init {
         ] {
             assert_eq!(
                 time.sign,
-                time.offset_in_seconds.into(),
+                time.offset.into(),
                 "the sign matches the sign of the date offset"
             );
         }
@@ -26,7 +26,7 @@ mod init {
 fn is_set() {
     assert!(!Time::default().is_set());
     assert!(Time {
-        seconds_since_unix_epoch: 1,
+        seconds: 1,
         ..Default::default()
     }
     .is_set());
@@ -34,27 +34,35 @@ fn is_set() {
 
 #[test]
 fn write_to() -> Result<(), Box<dyn std::error::Error>> {
-    for (time, expected) in &[
+    for (time, expected) in [
         (
             Time {
-                seconds_since_unix_epoch: 500,
-                offset_in_seconds: 9000,
+                seconds: SecondsSinceUnixEpoch::MAX,
+                offset: 0,
+                sign: Sign::Minus,
+            },
+            "18446744073709551615 -0000",
+        ),
+        (
+            Time {
+                seconds: 500,
+                offset: 9000,
                 sign: Sign::Plus,
             },
             "500 +0230",
         ),
         (
             Time {
-                seconds_since_unix_epoch: 189009009,
-                offset_in_seconds: 36000,
+                seconds: 189009009,
+                offset: -36000,
                 sign: Sign::Minus,
             },
             "189009009 -1000",
         ),
         (
             Time {
-                seconds_since_unix_epoch: 0,
-                offset_in_seconds: 0,
+                seconds: 0,
+                offset: 0,
                 sign: Sign::Minus,
             },
             "0 -0000",
@@ -63,6 +71,10 @@ fn write_to() -> Result<(), Box<dyn std::error::Error>> {
         let mut output = Vec::new();
         time.write_to(&mut output)?;
         assert_eq!(output.as_bstr(), expected);
+        assert_eq!(time.size(), output.len());
+
+        let actual = gix_date::parse(&output.as_bstr().to_string(), None).expect("round-trippable");
+        assert_eq!(time, actual);
     }
     Ok(())
 }
diff --git a/gix-date/tests/time/parse.rs b/gix-date/tests/time/parse.rs
index 730d910abe3..d9530ee13d2 100644
--- a/gix-date/tests/time/parse.rs
+++ b/gix-date/tests/time/parse.rs
@@ -7,8 +7,8 @@ fn special_time_is_ok_for_now() {
     assert_eq!(
         gix_date::parse("1979-02-26 18:30:00", Some(SystemTime::now())).unwrap(),
         Time {
-            seconds_since_unix_epoch: 42,
-            offset_in_seconds: 1800,
+            seconds: 42,
+            offset: 1800,
             sign: Sign::Plus,
         }
     );
@@ -19,8 +19,8 @@ fn short() {
     assert_eq!(
         gix_date::parse("1979-02-26", Some(SystemTime::now())).unwrap(),
         Time {
-            seconds_since_unix_epoch: 288835200,
-            offset_in_seconds: 0,
+            seconds: 288835200,
+            offset: 0,
             sign: Sign::Plus,
         },
         "could not parse with SHORT format"
@@ -32,8 +32,8 @@ fn rfc2822() {
     assert_eq!(
         gix_date::parse("Thu, 18 Aug 2022 12:45:06 +0800", None).unwrap(),
         Time {
-            seconds_since_unix_epoch: 1660797906,
-            offset_in_seconds: 28800,
+            seconds: 1660797906,
+            offset: 28800,
             sign: Sign::Plus,
         },
     );
@@ -42,8 +42,8 @@ fn rfc2822() {
 #[test]
 fn git_rfc2822() {
     let expected = Time {
-        seconds_since_unix_epoch: 1659329106,
-        offset_in_seconds: 28800,
+        seconds: 1659329106,
+        offset: 28800,
         sign: Sign::Plus,
     };
     assert_eq!(
@@ -61,15 +61,15 @@ fn raw() {
     assert_eq!(
         gix_date::parse("1660874655 +0800", None).unwrap(),
         Time {
-            seconds_since_unix_epoch: 1660874655,
-            offset_in_seconds: 28800,
+            seconds: 1660874655,
+            offset: 28800,
             sign: Sign::Plus,
         },
     );
 
     let expected = Time {
-        seconds_since_unix_epoch: 1660874655,
-        offset_in_seconds: -28800,
+        seconds: 1660874655,
+        offset: -28800,
         sign: Sign::Minus,
     };
     for date_str in [
@@ -107,8 +107,8 @@ fn git_default() {
     assert_eq!(
         gix_date::parse("Thu Aug 8 12:45:06 2022 +0800", None).unwrap(),
         Time {
-            seconds_since_unix_epoch: 1659933906,
-            offset_in_seconds: 28800,
+            seconds: 1659933906,
+            offset: 28800,
             sign: Sign::Plus,
         },
     );
@@ -152,12 +152,12 @@ mod relative {
         let now = Some(SystemTime::now());
         let two_weeks_ago = gix_date::parse("2 weeks ago", now).unwrap();
         assert_eq!(Sign::Plus, two_weeks_ago.sign);
-        assert_eq!(0, two_weeks_ago.offset_in_seconds);
+        assert_eq!(0, two_weeks_ago.offset);
         let expected = OffsetDateTime::from(now.unwrap()).saturating_sub(Duration::weeks(2));
         // account for the loss of precision when creating `Time` with seconds
         let expected = expected.replace_nanosecond(0).unwrap();
         assert_eq!(
-            OffsetDateTime::from_unix_timestamp(two_weeks_ago.seconds_since_unix_epoch as i64).unwrap(),
+            OffsetDateTime::from_unix_timestamp(two_weeks_ago.seconds as i64).unwrap(),
             expected,
             "relative times differ"
         );
diff --git a/gix-mailmap/Cargo.toml b/gix-mailmap/Cargo.toml
index 6d9b6733e22..5e58a12e96e 100644
--- a/gix-mailmap/Cargo.toml
+++ b/gix-mailmap/Cargo.toml
@@ -17,6 +17,7 @@ serde= ["dep:serde", "bstr/serde", "gix-actor/serde"]
 
 [dependencies]
 gix-actor = { version = "^0.21.0", path = "../gix-actor" }
+gix-date = { version = "^0.5.1", path = "../gix-date" }
 bstr = { version = "1.3.0", default-features = false, features = ["std", "unicode"]}
 thiserror = "1.0.38"
 serde = { version = "1.0.114", optional = true, default-features = false, features = ["derive"]}
diff --git a/gix-mailmap/src/snapshot/signature.rs b/gix-mailmap/src/snapshot/signature.rs
index d4c5955f53f..33f734257d7 100644
--- a/gix-mailmap/src/snapshot/signature.rs
+++ b/gix-mailmap/src/snapshot/signature.rs
@@ -11,7 +11,7 @@ pub struct Signature<'a> {
     /// The possibly mapped email.
     pub email: Cow<'a, BStr>,
     /// The time stamp at which the signature is performed.
-    pub time: gix_actor::Time,
+    pub time: gix_date::Time,
 }
 
 impl<'a> From<Signature<'a>> for gix_actor::Signature {
diff --git a/gix-mailmap/tests/snapshot/mod.rs b/gix-mailmap/tests/snapshot/mod.rs
index c82297880fe..e231665ce46 100644
--- a/gix-mailmap/tests/snapshot/mod.rs
+++ b/gix-mailmap/tests/snapshot/mod.rs
@@ -117,11 +117,11 @@ fn signature(name: &str, email: &str) -> gix_actor::Signature {
     gix_actor::Signature {
         name: name.into(),
         email: email.into(),
-        time: gix_actor::Time {
+        time: gix_date::Time {
             // marker
-            seconds_since_unix_epoch: 42,
-            offset_in_seconds: 53,
-            sign: gix_actor::Sign::Minus,
+            seconds: 42,
+            offset: 53,
+            sign: gix_date::time::Sign::Minus,
         },
     }
 }
diff --git a/gix-negotiate/Cargo.toml b/gix-negotiate/Cargo.toml
index 7300bf6a86f..928a976967f 100644
--- a/gix-negotiate/Cargo.toml
+++ b/gix-negotiate/Cargo.toml
@@ -15,6 +15,7 @@ test = false
 [dependencies]
 gix-hash = { version = "^0.11.2", path = "../gix-hash" }
 gix-object = { version = "^0.30.0", path = "../gix-object" }
+gix-date = { version = "^0.5.1", path = "../gix-date" }
 gix-commitgraph = { version = "^0.16.0", path = "../gix-commitgraph" }
 gix-revision = { version = "^0.15.2", path = "../gix-revision" }
 thiserror = "1.0.40"
diff --git a/gix-negotiate/src/consecutive.rs b/gix-negotiate/src/consecutive.rs
index f213cd94982..6a1504699e3 100644
--- a/gix-negotiate/src/consecutive.rs
+++ b/gix-negotiate/src/consecutive.rs
@@ -1,10 +1,10 @@
+use gix_date::SecondsSinceUnixEpoch;
 use gix_hash::ObjectId;
-use gix_revision::graph::CommitterTimestamp;
 
 use crate::{Error, Flags, Negotiator};
 
 pub(crate) struct Algorithm {
-    revs: gix_revision::PriorityQueue<CommitterTimestamp, ObjectId>,
+    revs: gix_revision::PriorityQueue<SecondsSinceUnixEpoch, ObjectId>,
     non_common_revs: usize,
 }
 
diff --git a/gix-negotiate/src/skipping.rs b/gix-negotiate/src/skipping.rs
index 06841b68797..28b8739198b 100644
--- a/gix-negotiate/src/skipping.rs
+++ b/gix-negotiate/src/skipping.rs
@@ -1,10 +1,10 @@
+use gix_date::SecondsSinceUnixEpoch;
 use gix_hash::ObjectId;
-use gix_revision::graph::CommitterTimestamp;
 
 use crate::{Error, Flags, Metadata, Negotiator};
 
 pub(crate) struct Algorithm {
-    revs: gix_revision::PriorityQueue<CommitterTimestamp, ObjectId>,
+    revs: gix_revision::PriorityQueue<SecondsSinceUnixEpoch, ObjectId>,
     non_common_revs: usize,
 }
 
diff --git a/gix-object/Cargo.toml b/gix-object/Cargo.toml
index bf6e3b32e30..b3785d8c885 100644
--- a/gix-object/Cargo.toml
+++ b/gix-object/Cargo.toml
@@ -26,6 +26,7 @@ gix-features = { version = "^0.30.0", path = "../gix-features", features = ["rus
 gix-hash = { version = "^0.11.2", path = "../gix-hash" }
 gix-validate = { version = "^0.7.5", path = "../gix-validate" }
 gix-actor = { version = "^0.21.0", path = "../gix-actor" }
+gix-date = { version = "^0.5.1", path = "../gix-date" }
 
 btoi = "0.4.2"
 itoa = "1.0.1"
diff --git a/gix-object/src/commit/mod.rs b/gix-object/src/commit/mod.rs
index 9e135df28ea..1e55644edab 100644
--- a/gix-object/src/commit/mod.rs
+++ b/gix-object/src/commit/mod.rs
@@ -68,7 +68,7 @@ impl<'a> CommitRef<'a> {
     }
 
     /// Returns the time at which this commit was created.
-    pub fn time(&self) -> gix_actor::Time {
+    pub fn time(&self) -> gix_date::Time {
         self.committer.time
     }
 }
diff --git a/gix-object/src/lib.rs b/gix-object/src/lib.rs
index d6c9fb760bc..4589a307e0d 100644
--- a/gix-object/src/lib.rs
+++ b/gix-object/src/lib.rs
@@ -14,6 +14,8 @@ use std::borrow::Cow;
 /// For convenience to allow using `bstr` without adding it to own cargo manifest.
 pub use bstr;
 use bstr::{BStr, BString, ByteSlice};
+/// For convenience to allow using `gix-date` without adding it to own cargo manifest.
+pub use gix_date as date;
 use smallvec::SmallVec;
 
 ///
diff --git a/gix-object/tests/commit/from_bytes.rs b/gix-object/tests/commit/from_bytes.rs
index 942c7fb4ec6..7bd39fb51ce 100644
--- a/gix-object/tests/commit/from_bytes.rs
+++ b/gix-object/tests/commit/from_bytes.rs
@@ -1,4 +1,6 @@
-use gix_actor::{Sign, SignatureRef, Time};
+use gix_actor::SignatureRef;
+use gix_date::time::Sign;
+use gix_date::Time;
 use gix_object::{bstr::ByteSlice, commit::message::body::TrailerRef, CommitRef};
 use smallvec::SmallVec;
 
@@ -139,8 +141,8 @@ fn with_trailer() -> crate::Result {
         name: "Kim Altintop".into(),
         email: "kim@eagain.st".into(),
         time: Time {
-            seconds_since_unix_epoch: 1631514803,
-            offset_in_seconds: 7200,
+            seconds: 1631514803,
+            offset: 7200,
             sign: Sign::Plus,
         },
     };
diff --git a/gix-object/tests/commit/message.rs b/gix-object/tests/commit/message.rs
index 8a81aab6b6e..1885095d3b9 100644
--- a/gix-object/tests/commit/message.rs
+++ b/gix-object/tests/commit/message.rs
@@ -223,7 +223,9 @@ mod body {
 mod summary {
     use std::borrow::Cow;
 
-    use gix_actor::{Sign, SignatureRef, Time};
+    use gix_actor::SignatureRef;
+    use gix_date::time::Sign;
+    use gix_date::Time;
     use gix_object::{
         bstr::{BStr, ByteSlice},
         commit::MessageRef,
@@ -236,8 +238,8 @@ mod summary {
             name: "name".into(),
             email: "email".into(),
             time: Time {
-                seconds_since_unix_epoch: 0,
-                offset_in_seconds: 0,
+                seconds: 0,
+                offset: 0,
                 sign: Sign::Plus,
             },
         };
diff --git a/gix-object/tests/object.rs b/gix-object/tests/object.rs
index ddd52a54817..8e343b88ff9 100644
--- a/gix-object/tests/object.rs
+++ b/gix-object/tests/object.rs
@@ -61,29 +61,29 @@ fn hex_to_id(hex: &str) -> ObjectId {
     ObjectId::from_hex(hex.as_bytes()).expect("40 bytes hex")
 }
 
-use gix_actor::{Sign, Time};
+use gix_date::{time::Sign, SecondsSinceUnixEpoch, Time};
 
-fn signature(time: u32) -> gix_actor::SignatureRef<'static> {
+fn signature(seconds: SecondsSinceUnixEpoch) -> gix_actor::SignatureRef<'static> {
     use gix_object::bstr::ByteSlice;
     gix_actor::SignatureRef {
         name: b"Sebastian Thiel".as_bstr(),
         email: b"sebastian.thiel@icloud.com".as_bstr(),
         time: Time {
-            seconds_since_unix_epoch: time,
-            offset_in_seconds: 28800,
+            seconds,
+            offset: 28800,
             sign: Sign::Plus,
         },
     }
 }
 
-fn linus_signature(time: u32) -> gix_actor::SignatureRef<'static> {
+fn linus_signature(seconds: SecondsSinceUnixEpoch) -> gix_actor::SignatureRef<'static> {
     use gix_object::bstr::ByteSlice;
     gix_actor::SignatureRef {
         name: b"Linus Torvalds".as_bstr(),
         email: b"torvalds@linux-foundation.org".as_bstr(),
         time: Time {
-            seconds_since_unix_epoch: time,
-            offset_in_seconds: -25200,
+            seconds,
+            offset: -25200,
             sign: Sign::Minus,
         },
     }
diff --git a/gix-object/tests/tag/mod.rs b/gix-object/tests/tag/mod.rs
index 0531bb67a0e..3da603c5f6b 100644
--- a/gix-object/tests/tag/mod.rs
+++ b/gix-object/tests/tag/mod.rs
@@ -1,3 +1,4 @@
+use gix_date::time::Sign;
 use gix_object::{bstr::ByteSlice, Kind, TagRef};
 
 mod method {
@@ -238,10 +239,10 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
         tagger: Some(gix_actor::SignatureRef {
             name: b"Sebastian Thiel".as_bstr(),
             email: b"byronimo@gmail.com".as_bstr(),
-            time: gix_actor::Time {
-                seconds_since_unix_epoch: 1528473343,
-                offset_in_seconds: offset,
-                sign: gix_actor::Sign::Plus,
+            time: gix_date::Time {
+                seconds: 1528473343,
+                offset,
+                sign: Sign::Plus,
             },
         }),
     }
diff --git a/gix-odb/Cargo.toml b/gix-odb/Cargo.toml
index 0a84d6a4c78..d7ce92202f6 100644
--- a/gix-odb/Cargo.toml
+++ b/gix-odb/Cargo.toml
@@ -30,6 +30,7 @@ required-features = []
 [dependencies]
 gix-features = { version = "^0.30.0", path = "../gix-features", features = ["rustsha1", "walkdir", "zlib", "crc32" ] }
 gix-hash = { version = "^0.11.2", path = "../gix-hash" }
+gix-date = { version = "^0.5.1", path = "../gix-date" }
 gix-path = { version = "^0.8.1", path = "../gix-path" }
 gix-quote = { version = "^0.4.4", path = "../gix-quote" }
 gix-object = { version = "^0.30.0", path = "../gix-object" }
diff --git a/gix-odb/tests/odb/store/loose.rs b/gix-odb/tests/odb/store/loose.rs
index d9eaba99a0b..b487d52901a 100644
--- a/gix-odb/tests/odb/store/loose.rs
+++ b/gix-odb/tests/odb/store/loose.rs
@@ -1,6 +1,6 @@
 use std::sync::atomic::AtomicBool;
 
-use gix_actor::{Sign, Time};
+use gix_date::{time::Sign, SecondsSinceUnixEpoch, Time};
 use gix_features::progress;
 use gix_object::bstr::ByteSlice;
 use gix_odb::loose::Store;
@@ -425,13 +425,13 @@ cjHJZXWmV4CcRfmLsXzU8s2cR9A0DBvOxhPD1TlKC2JhBFXigjuL9U4Rbq9tdegB
     }
 }
 
-fn signature(time: u32) -> gix_actor::SignatureRef<'static> {
+fn signature(seconds: SecondsSinceUnixEpoch) -> gix_actor::SignatureRef<'static> {
     gix_actor::SignatureRef {
         name: b"Sebastian Thiel".as_bstr(),
         email: b"byronimo@gmail.com".as_bstr(),
         time: Time {
-            seconds_since_unix_epoch: time,
-            offset_in_seconds: 7200,
+            seconds,
+            offset: 7200,
             sign: Sign::Plus,
         },
     }
diff --git a/gix-protocol/Cargo.toml b/gix-protocol/Cargo.toml
index 78ec2653d69..5f4e0bc7bbb 100644
--- a/gix-protocol/Cargo.toml
+++ b/gix-protocol/Cargo.toml
@@ -43,6 +43,7 @@ required-features = ["async-client"]
 gix-features = { version = "^0.30.0", path = "../gix-features", features = ["progress"] }
 gix-transport = { version = "^0.32.0", path = "../gix-transport" }
 gix-hash = { version = "^0.11.2", path = "../gix-hash" }
+gix-date = { version = "^0.5.1", path = "../gix-date" }
 gix-credentials = { version = "^0.15.0", path = "../gix-credentials" }
 
 thiserror = "1.0.32"
diff --git a/gix-protocol/src/fetch/arguments/mod.rs b/gix-protocol/src/fetch/arguments/mod.rs
index 1adf993bb04..d887492b4a9 100644
--- a/gix-protocol/src/fetch/arguments/mod.rs
+++ b/gix-protocol/src/fetch/arguments/mod.rs
@@ -129,11 +129,11 @@ impl Arguments {
             self.prefixed("deepen ", depth);
         }
     }
-    /// Deepen the commit history to include all commits from now to `seconds_since_unix_epoch`.
-    pub fn deepen_since(&mut self, seconds_since_unix_epoch: usize) {
+    /// Deepen the commit history to include all commits from now to (and including) `seconds` as passed since UNIX epoch.
+    pub fn deepen_since(&mut self, seconds: gix_date::SecondsSinceUnixEpoch) {
         debug_assert!(self.deepen_since, "'deepen-since' feature required");
         if self.deepen_since {
-            self.prefixed("deepen-since ", seconds_since_unix_epoch);
+            self.prefixed("deepen-since ", seconds);
         }
     }
     /// Deepen the commit history in a relative instead of absolute fashion.
diff --git a/gix-ref/Cargo.toml b/gix-ref/Cargo.toml
index 48e48ae55d6..5bb5cf580eb 100644
--- a/gix-ref/Cargo.toml
+++ b/gix-ref/Cargo.toml
@@ -23,6 +23,7 @@ gix-features = { version = "^0.30.0", path = "../gix-features", features = ["wal
 gix-fs = { version = "^0.2.0", path = "../gix-fs" }
 gix-path = { version = "^0.8.1", path = "../gix-path" }
 gix-hash = { version = "^0.11.2", path = "../gix-hash" }
+gix-date = { version = "^0.5.1", path = "../gix-date" }
 gix-object = { version = "^0.30.0", path = "../gix-object" }
 gix-validate = { version = "^0.7.5", path = "../gix-validate" }
 gix-actor = { version = "^0.21.0", path = "../gix-actor" }
diff --git a/gix-ref/src/store/file/log/line.rs b/gix-ref/src/store/file/log/line.rs
index 99c118ea74e..396e826a4c3 100644
--- a/gix-ref/src/store/file/log/line.rs
+++ b/gix-ref/src/store/file/log/line.rs
@@ -168,7 +168,7 @@ pub mod decode {
 
     #[cfg(test)]
     mod test {
-        use gix_actor::{Sign, Time};
+        use gix_date::{time::Sign, Time};
         use gix_object::bstr::ByteSlice;
 
         use super::*;
@@ -225,8 +225,8 @@ pub mod decode {
                             name: b"name".as_bstr(),
                             email: b"foo@example.com".as_bstr(),
                             time: Time {
-                                seconds_since_unix_epoch: 1234567890,
-                                offset_in_seconds: 0,
+                                seconds: 1234567890,
+                                offset: 0,
                                 sign: Sign::Minus
                             }
                         },
@@ -251,8 +251,8 @@ pub mod decode {
                         name: b"Sebastian Thiel".as_bstr(),
                         email: b"foo@example.com".as_bstr(),
                         time: Time {
-                            seconds_since_unix_epoch: 1618030561,
-                            offset_in_seconds: 28800,
+                            seconds: 1618030561,
+                            offset: 28800,
                             sign: Sign::Plus,
                         },
                     },
diff --git a/gix-ref/src/store/file/loose/reflog/create_or_update/tests.rs b/gix-ref/src/store/file/loose/reflog/create_or_update/tests.rs
index 16b9b14928c..c499b7feaac 100644
--- a/gix-ref/src/store/file/loose/reflog/create_or_update/tests.rs
+++ b/gix-ref/src/store/file/loose/reflog/create_or_update/tests.rs
@@ -1,6 +1,7 @@
 use std::{convert::TryInto, path::Path};
 
-use gix_actor::{Sign, Signature, Time};
+use gix_actor::Signature;
+use gix_date::{time::Sign, Time};
 use gix_object::bstr::ByteSlice;
 use tempfile::TempDir;
 
@@ -54,8 +55,8 @@ fn missing_reflog_creates_it_even_if_similarly_named_empty_dir_exists_and_append
             name: "committer".into(),
             email: "committer@example.com".into(),
             time: Time {
-                seconds_since_unix_epoch: 1234,
-                offset_in_seconds: 1800,
+                seconds: 1234,
+                offset: 1800,
                 sign: Sign::Plus,
             },
         };
diff --git a/gix-ref/tests/Cargo.toml b/gix-ref/tests/Cargo.toml
index 7870dc42b8f..0d4834e1bb9 100644
--- a/gix-ref/tests/Cargo.toml
+++ b/gix-ref/tests/Cargo.toml
@@ -34,6 +34,7 @@ gix-discover = { path = "../../gix-discover" }
 gix-worktree = { path = "../../gix-worktree" }
 gix-odb = { path = "../../gix-odb" }
 gix-actor = { path = "../../gix-actor" }
+gix-date = { path = "../../gix-date" }
 gix-hash = { path = "../../gix-hash" }
 gix-validate = { path = "../../gix-validate" }
 gix-lock = { path = "../../gix-lock" }
diff --git a/gix-ref/tests/file/transaction/mod.rs b/gix-ref/tests/file/transaction/mod.rs
index f411ea68946..ec1b2957101 100644
--- a/gix-ref/tests/file/transaction/mod.rs
+++ b/gix-ref/tests/file/transaction/mod.rs
@@ -1,7 +1,7 @@
 pub(crate) mod prepare_and_commit {
     use std::convert::TryInto;
 
-    use gix_actor::{Sign, Time};
+    use gix_date::{time::Sign, Time};
     use gix_hash::ObjectId;
     use gix_object::bstr::BString;
     use gix_ref::{
@@ -33,8 +33,8 @@ pub(crate) mod prepare_and_commit {
             name: "committer".into(),
             email: "committer@example.com".into(),
             time: Time {
-                seconds_since_unix_epoch: 1234,
-                offset_in_seconds: 1800,
+                seconds: 1234,
+                offset: 1800,
                 sign: Sign::Plus,
             },
         }
diff --git a/gix-revwalk/Cargo.toml b/gix-revwalk/Cargo.toml
index d9bea9a7851..bf77a9597c6 100644
--- a/gix-revwalk/Cargo.toml
+++ b/gix-revwalk/Cargo.toml
@@ -15,6 +15,7 @@ doctest = false
 [dependencies]
 gix-hash = { version = "^0.11.2", path = "../gix-hash" }
 gix-object = { version = "^0.30.0", path = "../gix-object" }
+gix-date = { version = "^0.5.1", path = "../gix-date" }
 gix-hashtable = { version = "^0.2.1", path = "../gix-hashtable" }
 gix-commitgraph = { version = "^0.16.0", path = "../gix-commitgraph" }
 
diff --git a/gix-revwalk/src/graph/commit.rs b/gix-revwalk/src/graph/commit.rs
index e11a28e36ec..fbf9ac5415a 100644
--- a/gix-revwalk/src/graph/commit.rs
+++ b/gix-revwalk/src/graph/commit.rs
@@ -1,7 +1,8 @@
+use gix_date::SecondsSinceUnixEpoch;
 use smallvec::SmallVec;
 
 use super::LazyCommit;
-use crate::graph::{Commit, CommitterTimestamp, Either, Generation};
+use crate::graph::{Commit, Either, Generation};
 
 impl<'graph> LazyCommit<'graph> {
     /// Return an iterator over the parents of this commit.
@@ -17,14 +18,9 @@ impl<'graph> LazyCommit<'graph> {
     ///
     /// This is the single-most important date for determining recency of commits.
     /// Note that this can only fail if the commit is backed by the object database *and* parsing fails.
-    pub fn committer_timestamp(&self) -> Result<CommitterTimestamp, gix_object::decode::Error> {
+    pub fn committer_timestamp(&self) -> Result<SecondsSinceUnixEpoch, gix_object::decode::Error> {
         Ok(match &self.backing {
-            Either::Left(buf) => {
-                gix_object::CommitRefIter::from_bytes(buf)
-                    .committer()?
-                    .time
-                    .seconds_since_unix_epoch as CommitterTimestamp
-            }
+            Either::Left(buf) => gix_object::CommitRefIter::from_bytes(buf).committer()?.time.seconds,
             Either::Right((cache, pos)) => cache.commit_at(*pos).committer_timestamp(),
         })
     }
@@ -53,7 +49,7 @@ impl<'graph> LazyCommit<'graph> {
                         Token::Parent { id } => parents.push(id),
                         Token::Author { .. } => {}
                         Token::Committer { signature } => {
-                            timestamp = Some(signature.time.seconds_since_unix_epoch as CommitterTimestamp);
+                            timestamp = Some(signature.time.seconds);
                             break;
                         }
                         _ => {
diff --git a/gix-revwalk/src/graph/mod.rs b/gix-revwalk/src/graph/mod.rs
index cf7e1629e51..d4290ec7e2a 100644
--- a/gix-revwalk/src/graph/mod.rs
+++ b/gix-revwalk/src/graph/mod.rs
@@ -10,9 +10,7 @@ pub mod commit;
 
 mod errors;
 pub use errors::{insert_parents, lookup};
-
-/// The time in seconds since unix epoch at which a commit was created.
-pub type CommitterTimestamp = u64;
+use gix_date::SecondsSinceUnixEpoch;
 
 /// The generation away from the HEAD of graph, useful to limit algorithms by topological depth as well.
 ///
@@ -74,7 +72,7 @@ impl<'find, T> Graph<'find, T> {
     pub fn insert_parents(
         &mut self,
         id: &gix_hash::oid,
-        mut new_parent_data: impl FnMut(gix_hash::ObjectId, CommitterTimestamp) -> T,
+        mut new_parent_data: impl FnMut(gix_hash::ObjectId, SecondsSinceUnixEpoch) -> T,
         mut update_existing: impl FnMut(gix_hash::ObjectId, &mut T),
         first_parent: bool,
     ) -> Result<(), insert_parents::Error> {
@@ -266,7 +264,7 @@ pub struct Commit<T> {
     /// The parents of the commit.
     pub parents: SmallVec<[gix_hash::ObjectId; 1]>,
     /// The time at which the commit was created.
-    pub commit_time: CommitterTimestamp,
+    pub commit_time: SecondsSinceUnixEpoch,
     /// The generation of the commit, if available.
     pub generation: Option<u32>,
     /// Any kind of data to associate with this commit.
diff --git a/gix-traverse/Cargo.toml b/gix-traverse/Cargo.toml
index ac4a4b9601e..d478ab6015d 100644
--- a/gix-traverse/Cargo.toml
+++ b/gix-traverse/Cargo.toml
@@ -16,6 +16,7 @@ doctest = false
 [dependencies]
 gix-hash = { version = "^0.11.2", path = "../gix-hash" }
 gix-object = { version = "^0.30.0", path = "../gix-object" }
+gix-date = { version = "^0.5.1", path = "../gix-date" }
 gix-hashtable = { version = "^0.2.1", path = "../gix-hashtable" }
 gix-revwalk = { version = "^0.1.0", path = "../gix-revwalk" }
 gix-commitgraph = { version = "^0.16.0", path = "../gix-commitgraph" }
diff --git a/gix-traverse/src/commit.rs b/gix-traverse/src/commit.rs
index ec1f9a3caa0..9ae1f333fae 100644
--- a/gix-traverse/src/commit.rs
+++ b/gix-traverse/src/commit.rs
@@ -64,7 +64,7 @@ pub enum Sorting {
     /// In the *sample history* and a cut-off date of 4, the returned list of commits would be `8, 7, 6, 4`
     ByCommitTimeNewestFirstCutoffOlderThan {
         /// The amount of seconds since unix epoch, the same value obtained by any `gix_date::Time` structure and the way git counts time.
-        time_in_seconds_since_epoch: u32,
+        seconds: gix_date::SecondsSinceUnixEpoch,
     },
 }
 
@@ -87,6 +87,7 @@ pub struct Info {
 
 ///
 pub mod ancestors {
+    use gix_date::SecondsSinceUnixEpoch;
     use smallvec::SmallVec;
     use std::{
         borrow::{Borrow, BorrowMut},
@@ -112,13 +113,11 @@ pub mod ancestors {
         ObjectDecode(#[from] gix_object::decode::Error),
     }
 
-    type TimeInSeconds = u32;
-
     /// The state used and potentially shared by multiple graph traversals.
     #[derive(Clone)]
     pub struct State {
         next: VecDeque<ObjectId>,
-        queue: gix_revwalk::PriorityQueue<TimeInSeconds, ObjectId>,
+        queue: gix_revwalk::PriorityQueue<SecondsSinceUnixEpoch, ObjectId>,
         buf: Vec<u8>,
         seen: HashSet<ObjectId>,
         parents_buf: Vec<u8>,
@@ -170,7 +169,7 @@ pub mod ancestors {
                                 oid: commit_id,
                                 source: err.into(),
                             })?;
-                        let time = commit_iter.committer()?.time.seconds_since_unix_epoch;
+                        let time = commit_iter.committer()?.time.seconds;
                         match cutoff_time {
                             Some(cutoff_time) if time >= cutoff_time => {
                                 state.queue.insert(time, commit_id);
@@ -316,9 +315,9 @@ pub mod ancestors {
                 match self.sorting {
                     Sorting::BreadthFirst => self.next_by_topology(),
                     Sorting::ByCommitTimeNewestFirst => self.next_by_commit_date(None),
-                    Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
-                        time_in_seconds_since_epoch,
-                    } => self.next_by_commit_date(time_in_seconds_since_epoch.into()),
+                    Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds } => {
+                        self.next_by_commit_date(seconds.into())
+                    }
                 }
             }
         }
@@ -326,11 +325,9 @@ pub mod ancestors {
 
     impl Sorting {
         /// If not topo sort, provide the cutoff date if present.
-        fn cutoff_time(&self) -> Option<u32> {
+        fn cutoff_time(&self) -> Option<gix_date::SecondsSinceUnixEpoch> {
             match self {
-                Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
-                    time_in_seconds_since_epoch,
-                } => Some(*time_in_seconds_since_epoch),
+                Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds } => Some(*seconds),
                 _ => None,
             }
         }
@@ -344,7 +341,10 @@ pub mod ancestors {
         StateMut: BorrowMut<State>,
         E: std::error::Error + Send + Sync + 'static,
     {
-        fn next_by_commit_date(&mut self, cutoff_older_than: Option<TimeInSeconds>) -> Option<Result<Info, Error>> {
+        fn next_by_commit_date(
+            &mut self,
+            cutoff_older_than: Option<SecondsSinceUnixEpoch>,
+        ) -> Option<Result<Info, Error>> {
             let state = self.state.borrow_mut();
 
             let (commit_time, oid) = state.queue.pop()?;
@@ -356,14 +356,13 @@ pub mod ancestors {
                         self.cache = None;
                         return self.next_by_commit_date(cutoff_older_than);
                     }
-                    for (id, commit_time) in state.parent_ids.drain(..) {
+                    for (id, parent_commit_time) in state.parent_ids.drain(..) {
                         parents.push(id);
                         let was_inserted = state.seen.insert(id);
                         if !(was_inserted && (self.predicate)(&id)) {
                             continue;
                         }
 
-                        let parent_commit_time = commit_time as u32; // TODO: fix this once we have 64 bit date support
                         match cutoff_older_than {
                             Some(cutoff_older_than) if parent_commit_time < cutoff_older_than => continue,
                             Some(_) | None => state.queue.insert(parent_commit_time, id),
@@ -383,12 +382,7 @@ pub mod ancestors {
 
                                 let parent = (self.find)(id.as_ref(), &mut state.parents_buf).ok();
                                 let parent_commit_time = parent
-                                    .and_then(|parent| {
-                                        parent
-                                            .committer()
-                                            .ok()
-                                            .map(|committer| committer.time.seconds_since_unix_epoch)
-                                    })
+                                    .and_then(|parent| parent.committer().ok().map(|committer| committer.time.seconds))
                                     .unwrap_or_default();
 
                                 match cutoff_older_than {
@@ -411,7 +405,7 @@ pub mod ancestors {
             Some(Ok(Info {
                 id: oid,
                 parent_ids: parents,
-                commit_time: Some(commit_time as u64),
+                commit_time: Some(commit_time),
             }))
         }
     }
diff --git a/gix-traverse/tests/commit/mod.rs b/gix-traverse/tests/commit/mod.rs
index e4e0d8ff6a6..dafe7399e34 100644
--- a/gix-traverse/tests/commit/mod.rs
+++ b/gix-traverse/tests/commit/mod.rs
@@ -388,7 +388,7 @@ mod ancestor {
                 &["bcb05040a6925f2ff5e10d3ae1f9264f2e8c43ac"], /* b1c1 */
             )
             .with_sorting(Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
-                time_in_seconds_since_epoch: 978393600, // =2001-01-02 00:00:00 +0000
+                seconds: 978393600, // =2001-01-02 00:00:00 +0000
             })
             .check()
         }
@@ -404,7 +404,7 @@ mod ancestor {
                 move |oid, buf| store.find_commit_iter(oid, buf),
             )
             .sorting(Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
-                time_in_seconds_since_epoch: 978393600, // =2001-01-02 00:00:00 +0000
+                seconds: 978393600, // =2001-01-02 00:00:00 +0000
             })?;
             assert_eq!(
                 iter.count(),
diff --git a/gix/src/commit.rs b/gix/src/commit.rs
index 68e1eeba74a..a7bd607ac71 100644
--- a/gix/src/commit.rs
+++ b/gix/src/commit.rs
@@ -91,7 +91,7 @@ pub mod describe {
                         let (prio, tag_time) = match target_id {
                             Some(target_id) if peeled_id != *target_id => {
                                 let tag = repo.find_object(target_id).ok()?.try_into_tag().ok()?;
-                                (1, tag.tagger().ok()??.time.seconds_since_unix_epoch)
+                                (1, tag.tagger().ok()??.time.seconds)
                             }
                             _ => (0, 0),
                         };
@@ -124,11 +124,7 @@ pub mod describe {
                             // TODO: we assume direct refs for tags, which is the common case, but it doesn't have to be
                             //       so rather follow symrefs till the first object and then peel tags after the first object was found.
                             let tag = r.try_id()?.object().ok()?.try_into_tag().ok()?;
-                            let tag_time = tag
-                                .tagger()
-                                .ok()
-                                .and_then(|s| s.map(|s| s.time.seconds_since_unix_epoch))
-                                .unwrap_or(0);
+                            let tag_time = tag.tagger().ok().and_then(|s| s.map(|s| s.time.seconds)).unwrap_or(0);
                             let commit_id = tag.target_id().ok()?.object().ok()?.try_into_commit().ok()?.id;
                             Some((commit_id, tag_time, Cow::<BStr>::from(r.name().shorten().to_owned())))
                         })
diff --git a/gix/src/config/cache/access.rs b/gix/src/config/cache/access.rs
index cea56f973c4..43e046aab57 100644
--- a/gix/src/config/cache/access.rs
+++ b/gix/src/config/cache/access.rs
@@ -4,6 +4,7 @@ use std::{borrow::Cow, path::PathBuf, time::Duration};
 use gix_attributes::Source;
 use gix_lock::acquire::Fail;
 
+use crate::config::cache::util::ApplyLeniencyDefaultValue;
 use crate::{
     bstr::BStr,
     config,
@@ -69,6 +70,18 @@ impl Cache {
             .get_or_try_init(|| remote::url::SchemePermission::from_config(&self.resolved, self.filter_config_section))
     }
 
+    pub(crate) fn may_use_commit_graph(&self) -> Result<bool, config::boolean::Error> {
+        const DEFAULT: bool = true;
+        self.resolved
+            .boolean_by_key("core.commitGraph")
+            .map(|res| {
+                Core::COMMIT_GRAPH
+                    .enrich_error(res)
+                    .with_lenient_default_value(self.lenient_config, DEFAULT)
+            })
+            .unwrap_or(Ok(DEFAULT))
+    }
+
     pub(crate) fn diff_renames(
         &self,
     ) -> Result<Option<crate::object::tree::diff::Rewrites>, crate::object::tree::diff::rewrites::Error> {
diff --git a/gix/src/config/cache/util.rs b/gix/src/config/cache/util.rs
index 7c478fcf9e3..a680cf1b2f8 100644
--- a/gix/src/config/cache/util.rs
+++ b/gix/src/config/cache/util.rs
@@ -124,6 +124,10 @@ pub trait ApplyLeniencyDefault {
     fn with_lenient_default(self, is_lenient: bool) -> Self;
 }
 
+pub trait ApplyLeniencyDefaultValue<T> {
+    fn with_lenient_default_value(self, is_lenient: bool, default: T) -> Self;
+}
+
 impl<T, E> ApplyLeniency for Result<Option<T>, E> {
     fn with_leniency(self, is_lenient: bool) -> Self {
         match self {
@@ -146,3 +150,13 @@ where
         }
     }
 }
+
+impl<T, E> ApplyLeniencyDefaultValue<T> for Result<T, E> {
+    fn with_lenient_default_value(self, is_lenient: bool, default: T) -> Self {
+        match self {
+            Ok(v) => Ok(v),
+            Err(_) if is_lenient => Ok(default),
+            Err(err) => Err(err),
+        }
+    }
+}
diff --git a/gix/src/config/tree/sections/core.rs b/gix/src/config/tree/sections/core.rs
index 93d2fcd017f..de1843ec3ab 100644
--- a/gix/src/config/tree/sections/core.rs
+++ b/gix/src/config/tree/sections/core.rs
@@ -66,6 +66,8 @@ impl Core {
     /// The `core.useReplaceRefs` key.
     pub const USE_REPLACE_REFS: keys::Boolean = keys::Boolean::new_boolean("useReplaceRefs", &config::Tree::CORE)
         .with_environment_override("GIT_NO_REPLACE_OBJECTS");
+    /// The `core.commitGraph` key.
+    pub const COMMIT_GRAPH: keys::Boolean = keys::Boolean::new_boolean("commitGraph", &config::Tree::CORE);
 }
 
 impl Section for Core {
@@ -96,6 +98,7 @@ impl Section for Core {
             &Self::ATTRIBUTES_FILE,
             &Self::SSH_COMMAND,
             &Self::USE_REPLACE_REFS,
+            &Self::COMMIT_GRAPH,
         ]
     }
 }
diff --git a/gix/src/object/commit.rs b/gix/src/object/commit.rs
index 5a9dfd4f399..171c6adee39 100644
--- a/gix/src/object/commit.rs
+++ b/gix/src/object/commit.rs
@@ -65,7 +65,7 @@ impl<'repo> Commit<'repo> {
     /// Decode the commit and obtain the time at which the commit was created.
     ///
     /// For the time at which it was authored, refer to `.decode()?.author.time`.
-    pub fn time(&self) -> Result<gix_actor::Time, Error> {
+    pub fn time(&self) -> Result<gix_date::Time, Error> {
         Ok(self.committer()?.time)
     }
 
diff --git a/gix/src/remote/connection/fetch/negotiate.rs b/gix/src/remote/connection/fetch/negotiate.rs
index fde2e2b2ba0..71b05a23ea2 100644
--- a/gix/src/remote/connection/fetch/negotiate.rs
+++ b/gix/src/remote/connection/fetch/negotiate.rs
@@ -1,3 +1,4 @@
+use gix_date::SecondsSinceUnixEpoch;
 use std::borrow::Cow;
 
 use gix_negotiate::Flags;
@@ -6,7 +7,7 @@ use gix_pack::Find;
 
 use crate::remote::{fetch, fetch::Shallow};
 
-type Queue = gix_revision::PriorityQueue<gix_revision::graph::CommitterTimestamp, gix_hash::ObjectId>;
+type Queue = gix_revision::PriorityQueue<SecondsSinceUnixEpoch, gix_hash::ObjectId>;
 
 /// The error returned during negotiation.
 #[derive(Debug, thiserror::Error)]
@@ -85,7 +86,7 @@ pub(crate) fn mark_complete_and_common_ref(
 
     // Compute the cut-off date by checking which of the refs advertised (and matched in refspecs) by the remote we have,
     // and keep the oldest one.
-    let mut cutoff_date = None::<gix_revision::graph::CommitterTimestamp>;
+    let mut cutoff_date = None::<SecondsSinceUnixEpoch>;
     let mut num_mappings_with_change = 0;
     let mut remote_ref_target_known: Vec<bool> = std::iter::repeat(false).take(ref_map.mappings.len()).collect();
 
@@ -228,7 +229,7 @@ pub(crate) fn add_wants(
 fn mark_recent_complete_commits(
     queue: &mut Queue,
     graph: &mut gix_negotiate::Graph<'_>,
-    cutoff: gix_revision::graph::CommitterTimestamp,
+    cutoff: SecondsSinceUnixEpoch,
 ) -> Result<(), Error> {
     while let Some(id) = queue
         .peek()
diff --git a/gix/src/remote/connection/fetch/receive_pack.rs b/gix/src/remote/connection/fetch/receive_pack.rs
index 820614647af..32581ae99b2 100644
--- a/gix/src/remote/connection/fetch/receive_pack.rs
+++ b/gix/src/remote/connection/fetch/receive_pack.rs
@@ -348,14 +348,14 @@ fn add_shallow_args(
             args.deepen_relative();
         }
         Shallow::Since { cutoff } => {
-            args.deepen_since(cutoff.seconds_since_unix_epoch as usize);
+            args.deepen_since(cutoff.seconds);
         }
         Shallow::Exclude {
             remote_refs,
             since_cutoff,
         } => {
             if let Some(cutoff) = since_cutoff {
-                args.deepen_since(cutoff.seconds_since_unix_epoch as usize);
+                args.deepen_since(cutoff.seconds);
             }
             for ref_ in remote_refs {
                 args.deepen_not(ref_.as_ref().as_bstr());
diff --git a/gix/src/remote/connection/fetch/update_refs/mod.rs b/gix/src/remote/connection/fetch/update_refs/mod.rs
index fde53c75cad..334dbd9269c 100644
--- a/gix/src/remote/connection/fetch/update_refs/mod.rs
+++ b/gix/src/remote/connection/fetch/update_refs/mod.rs
@@ -126,14 +126,14 @@ pub(crate) fn update(
                                                 .try_into_commit()
                                                 .map_err(|_| ())
                                                 .and_then(|c| {
-                                                    c.committer().map(|a| a.time.seconds_since_unix_epoch).map_err(|_| ())
+                                                    c.committer().map(|a| a.time.seconds).map_err(|_| ())
                                                 }).and_then(|local_commit_time|
                                                         remote_id
                                                             .to_owned()
                                                             .ancestors(|id, buf| repo.objects.find_commit_iter(id, buf))
                                                             .sorting(
                                                                 gix_traverse::commit::Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
-                                                                    time_in_seconds_since_epoch: local_commit_time
+                                                                    seconds: local_commit_time
                                                                 },
                                                             )
                                                             .map_err(|_| ())
diff --git a/gix/src/repository/graph.rs b/gix/src/repository/graph.rs
index a87fb8f4c56..98cc48774ef 100644
--- a/gix/src/repository/graph.rs
+++ b/gix/src/repository/graph.rs
@@ -7,6 +7,9 @@ impl crate::Repository {
     /// Note that the commitgraph will be used if it is present and readable, but it won't be an error if it is corrupted. In that case,
     /// it will just not be used.
     ///
+    /// Note that a commitgraph is only allowed to be used if `core.commitGraph` is true (the default), and that configuration errors are
+    /// ignored as well.
+    ///
     /// ### Performance
     ///
     /// Note that the [Graph][gix_revision::Graph] can be sensitive to various object database settings that may affect the performance
@@ -18,7 +21,11 @@ impl crate::Repository {
                     .try_find(id, buf)
                     .map(|r| r.and_then(|d| d.try_into_commit_iter()))
             },
-            gix_commitgraph::at(self.objects.store_ref().path().join("info")).ok(),
+            self.config
+                .may_use_commit_graph()
+                .unwrap_or(true)
+                .then(|| gix_commitgraph::at(self.objects.store_ref().path().join("info")).ok())
+                .flatten(),
         )
     }
 
diff --git a/gix/src/repository/identity.rs b/gix/src/repository/identity.rs
index 61a4b4a98be..1ba63c0cd37 100644
--- a/gix/src/repository/identity.rs
+++ b/gix/src/repository/identity.rs
@@ -73,9 +73,9 @@ impl crate::Repository {
 }
 
 fn extract_time_or_default(
-    time: Option<&Result<gix_actor::Time, gix_date::parse::Error>>,
+    time: Option<&Result<gix_date::Time, gix_date::parse::Error>>,
     config_key: &'static keys::Time,
-) -> Result<gix_actor::Time, config::time::Error> {
+) -> Result<gix_date::Time, config::time::Error> {
     match time {
         Some(Ok(t)) => Ok(*t),
         None => Ok(gix_date::Time::now_local_or_utc()),
@@ -88,7 +88,7 @@ pub(crate) struct Entity {
     pub name: Option<BString>,
     pub email: Option<BString>,
     /// A time parsed from an environment variable, handling potential errors is delayed.
-    pub time: Option<Result<gix_actor::Time, gix_date::parse::Error>>,
+    pub time: Option<Result<gix_date::Time, gix_date::parse::Error>>,
 }
 
 #[derive(Debug, Clone)]
diff --git a/gix/src/revision/walk.rs b/gix/src/revision/walk.rs
index 554a8a61217..5e55443f587 100644
--- a/gix/src/revision/walk.rs
+++ b/gix/src/revision/walk.rs
@@ -12,6 +12,8 @@ pub enum Error {
     AncestorIter(#[from] gix_traverse::commit::ancestors::Error),
     #[error(transparent)]
     ShallowCommits(#[from] crate::shallow::open::Error),
+    #[error(transparent)]
+    ConfigBoolean(#[from] crate::config::boolean::Error),
 }
 
 /// Information about a commit that we obtained naturally as part of the iteration.
@@ -92,7 +94,7 @@ pub struct Platform<'repo> {
     pub(crate) tips: Vec<ObjectId>,
     pub(crate) sorting: gix_traverse::commit::Sorting,
     pub(crate) parents: gix_traverse::commit::Parents,
-    pub(crate) use_commit_graph: bool,
+    pub(crate) use_commit_graph: Option<bool>,
     pub(crate) commit_graph: Option<gix_commitgraph::Graph>,
 }
 
@@ -103,7 +105,7 @@ impl<'repo> Platform<'repo> {
             tips: tips.into_iter().map(Into::into).collect(),
             sorting: Default::default(),
             parents: Default::default(),
-            use_commit_graph: true,
+            use_commit_graph: None,
             commit_graph: None,
         }
     }
@@ -123,12 +125,12 @@ impl<'repo> Platform<'repo> {
         self
     }
 
-    /// Allow using the commitgraph, if present, if `toggle` is `true`, or disallow it with `false`.
+    /// Allow using the commitgraph, if present, if `toggle` is `true`, or disallow it with `false`. Set it to `None` to leave
+    /// control over this to the configuration of `core.commitGraph` (the default).
     ///
-    /// Note that the commitgraph will be used by default, and that errors just lead to falling back to the object database,
-    /// it's treated as a cache.
-    pub fn use_commit_graph(mut self, toggle: bool) -> Self {
-        self.use_commit_graph = toggle;
+    /// Errors when loading the graph lead to falling back to the object database, it's treated as optional cache.
+    pub fn use_commit_graph(mut self, toggle: impl Into<Option<bool>>) -> Self {
+        self.use_commit_graph = toggle.into();
         self
     }
 
@@ -201,7 +203,12 @@ impl<'repo> Platform<'repo> {
                 )
                 .sorting(sorting)?
                 .parents(parents)
-                .commit_graph(commit_graph.or(use_commit_graph.then(|| self.repo.commit_graph().ok()).flatten())),
+                .commit_graph(
+                    commit_graph.or(use_commit_graph
+                        .map_or_else(|| self.repo.config.may_use_commit_graph(), Ok)?
+                        .then(|| self.repo.commit_graph().ok())
+                        .flatten()),
+                ),
             ),
         })
     }
diff --git a/gix/tests/id/mod.rs b/gix/tests/id/mod.rs
index 6ca5743ace1..8b57902b6bf 100644
--- a/gix/tests/id/mod.rs
+++ b/gix/tests/id/mod.rs
@@ -123,9 +123,7 @@ mod ancestors {
             for sorting in [
                 commit::Sorting::BreadthFirst,
                 commit::Sorting::ByCommitTimeNewestFirst,
-                commit::Sorting::ByCommitTimeNewestFirstCutoffOlderThan {
-                    time_in_seconds_since_epoch: 0,
-                },
+                commit::Sorting::ByCommitTimeNewestFirstCutoffOlderThan { seconds: 0 },
             ] {
                 let commits_graph_order = head
                     .ancestors()
diff --git a/gix/tests/repository/config/identity.rs b/gix/tests/repository/config/identity.rs
index e66c1e99113..ddbd0eb9607 100644
--- a/gix/tests/repository/config/identity.rs
+++ b/gix/tests/repository/config/identity.rs
@@ -48,8 +48,8 @@ fn author_and_committer_and_fallback() -> crate::Result {
                 name: "author".into(),
                 email: "author@email".into(),
                 time: gix_date::Time {
-                    seconds_since_unix_epoch: 1659329106,
-                    offset_in_seconds: 28800,
+                    seconds: 1659329106,
+                    offset: 28800,
                     sign: gix_date::time::Sign::Plus
                 }
             }
@@ -61,8 +61,8 @@ fn author_and_committer_and_fallback() -> crate::Result {
                 name: "committer".into(),
                 email: "committer@email".into(),
                 time: gix_date::Time {
-                    seconds_since_unix_epoch: 1659365106,
-                    offset_in_seconds: -7200,
+                    seconds: 1659365106,
+                    offset: -7200,
                     sign: gix_date::time::Sign::Minus
                 }
             }
@@ -167,8 +167,8 @@ fn author_from_different_config_sections() -> crate::Result {
             name: "global name".into(),
             email: "local@example.com".into(),
             time: gix_date::Time {
-                seconds_since_unix_epoch: 42,
-                offset_in_seconds: 1800,
+                seconds: 42,
+                offset: 1800,
                 sign: gix_date::time::Sign::Plus
             }
         }),
@@ -181,8 +181,8 @@ fn author_from_different_config_sections() -> crate::Result {
             name: "local committer".into(),
             email: "global-committer@example.com".into(),
             time: gix_date::Time {
-                seconds_since_unix_epoch: 320437800,
-                offset_in_seconds: 0,
+                seconds: 320437800,
+                offset: 0,
                 sign: gix_date::time::Sign::Plus,
             }
         }),
diff --git a/gix/tests/repository/object.rs b/gix/tests/repository/object.rs
index 05b7602b731..f3c4517927a 100644
--- a/gix/tests/repository/object.rs
+++ b/gix/tests/repository/object.rs
@@ -214,12 +214,12 @@ mod commit_as {
         let committer = gix::actor::Signature {
             name: "c".into(),
             email: "c@example.com".into(),
-            time: gix::actor::Time::new(1, 1800),
+            time: gix::date::Time::new(1, 1800),
         };
         let author = gix::actor::Signature {
             name: "a".into(),
             email: "a@example.com".into(),
-            time: gix::actor::Time::new(3, 3600),
+            time: gix::date::Time::new(3, 3600),
         };
 
         let commit_id = repo.commit_as(
diff --git a/src/plumbing/main.rs b/src/plumbing/main.rs
index 24ee78d4cc7..e3be8157ab5 100644
--- a/src/plumbing/main.rs
+++ b/src/plumbing/main.rs
@@ -13,6 +13,7 @@ use gitoxide_core as core;
 use gitoxide_core::pack::verify;
 use gix::bstr::io::BufReadExt;
 
+use crate::plumbing::options::commitgraph;
 use crate::{
     plumbing::{
         options::{
@@ -128,6 +129,36 @@ pub fn main() -> Result<()> {
     })?;
 
     match cmd {
+        Subcommands::CommitGraph(cmd) => match cmd {
+            commitgraph::Subcommands::List { spec } => prepare_and_run(
+                "commitgraph-list",
+                auto_verbose,
+                progress,
+                progress_keep_open,
+                None,
+                move |_progress, out, _err| core::commitgraph::list(repository(Mode::Lenient)?, spec, out, format),
+            )
+            .map(|_| ()),
+            commitgraph::Subcommands::Verify { statistics } => prepare_and_run(
+                "commitgraph-verify",
+                auto_verbose,
+                progress,
+                progress_keep_open,
+                None,
+                move |_progress, out, err| {
+                    let output_statistics = if statistics { Some(format) } else { None };
+                    core::commitgraph::verify(
+                        repository(Mode::Lenient)?,
+                        core::commitgraph::verify::Context {
+                            err,
+                            out,
+                            output_statistics,
+                        },
+                    )
+                },
+            )
+            .map(|_| ()),
+        },
         #[cfg(feature = "gitoxide-core-blocking-client")]
         Subcommands::Clone(crate::plumbing::options::clone::Platform {
             handshake_info,
@@ -270,27 +301,6 @@ pub fn main() -> Result<()> {
         )
         .map(|_| ()),
         Subcommands::Free(subcommands) => match subcommands {
-            free::Subcommands::CommitGraph(subcommands) => match subcommands {
-                free::commitgraph::Subcommands::Verify { path, statistics } => prepare_and_run(
-                    "commitgraph-verify",
-                    auto_verbose,
-                    progress,
-                    progress_keep_open,
-                    None,
-                    move |_progress, out, err| {
-                        let output_statistics = if statistics { Some(format) } else { None };
-                        core::commitgraph::verify::graph_or_file(
-                            path,
-                            core::commitgraph::verify::Context {
-                                err,
-                                out,
-                                output_statistics,
-                            },
-                        )
-                    },
-                )
-                .map(|_| ()),
-            },
             free::Subcommands::Index(free::index::Platform {
                 object_hash,
                 index_path,
diff --git a/src/plumbing/options/free.rs b/src/plumbing/options/free.rs
index 9f945c5c640..dd11acbe53c 100644
--- a/src/plumbing/options/free.rs
+++ b/src/plumbing/options/free.rs
@@ -1,9 +1,6 @@
 #[derive(Debug, clap::Subcommand)]
 #[clap(visible_alias = "no-repo")]
 pub enum Subcommands {
-    /// Subcommands for interacting with commit-graphs
-    #[clap(subcommand)]
-    CommitGraph(commitgraph::Subcommands),
     /// Subcommands for interacting with mailmaps
     Mailmap {
         #[clap(flatten)]
@@ -16,23 +13,6 @@ pub enum Subcommands {
     Index(index::Platform),
 }
 
-///
-pub mod commitgraph {
-    use std::path::PathBuf;
-
-    #[derive(Debug, clap::Subcommand)]
-    pub enum Subcommands {
-        /// Verify the integrity of a commit graph
-        Verify {
-            /// The path to '.git/objects/info/', '.git/objects/info/commit-graphs/', or '.git/objects/info/commit-graph' to validate.
-            path: PathBuf,
-            /// output statistical information about the pack
-            #[clap(long, short = 's')]
-            statistics: bool,
-        },
-    }
-}
-
 pub mod index {
     use std::path::PathBuf;
 
diff --git a/src/plumbing/options/mod.rs b/src/plumbing/options/mod.rs
index 0e3b728d8fa..3f0a9a27053 100644
--- a/src/plumbing/options/mod.rs
+++ b/src/plumbing/options/mod.rs
@@ -72,6 +72,9 @@ pub struct Args {
 
 #[derive(Debug, clap::Subcommand)]
 pub enum Subcommands {
+    /// Subcommands for interacting with commit-graphs
+    #[clap(subcommand)]
+    CommitGraph(commitgraph::Subcommands),
     /// Interact with the object database.
     #[clap(subcommand)]
     Odb(odb::Subcommands),
@@ -412,13 +415,36 @@ pub mod credential {
     }
 }
 
+///
+pub mod commitgraph {
+    #[derive(Debug, clap::Subcommand)]
+    pub enum Subcommands {
+        /// Verify the integrity of a commit graph
+        Verify {
+            /// output statistical information about the pack
+            #[clap(long, short = 's')]
+            statistics: bool,
+        },
+        /// List all entries in the commit-graph as reachable by starting from `HEAD`.
+        List {
+            /// The rev-spec to list reachable commits from.
+            #[clap(default_value = "@")]
+            spec: std::ffi::OsString,
+        },
+    }
+}
+
 pub mod revision {
     #[derive(Debug, clap::Subcommand)]
     #[clap(visible_alias = "rev", visible_alias = "r")]
     pub enum Subcommands {
         /// List all commits reachable from the given rev-spec.
         #[clap(visible_alias = "l")]
-        List { spec: std::ffi::OsString },
+        List {
+            /// The rev-spec to list reachable commits from.
+            #[clap(default_value = "@")]
+            spec: std::ffi::OsString,
+        },
         /// Provide the revision specification like `@~1` to explain.
         #[clap(visible_alias = "e")]
         Explain { spec: std::ffi::OsString },
diff --git a/src/plumbing/progress.rs b/src/plumbing/progress.rs
index 659e7d11e69..668f3121429 100644
--- a/src/plumbing/progress.rs
+++ b/src/plumbing/progress.rs
@@ -180,6 +180,18 @@ static GIT_CONFIG: &[Record] = &[
         config: "core.preloadIndex",
         usage: Planned {note: Some("it's enabled by default and allows parallel stat checks - it's using a lot of CPU for just minor performance boosts though")},
     },
+    Record {
+        config: "commitGraph.generationVersion",
+        usage: NotPlanned { reason: "couldn't find a test that would require corrected generation numbers, even `git` has no test for this." },
+    },
+    Record {
+        config: "commitGraph.maxNewFilters",
+        usage: NotPlanned { reason: "can be considered when the underlying feature is actually used or needed" },
+    },
+    Record {
+        config: "commitGraph.readChangedPaths",
+        usage: NotPlanned { reason: "can be considered when the underlying feature is actually used or needed" },
+    },
     Record {
         config: "index.sparse",
         usage: Planned {note: Some("we can read sparse indices and support for it will be added early on")},
diff --git a/tests/journey/gix.sh b/tests/journey/gix.sh
index 50a4b3efde1..d7d5dfd6050 100644
--- a/tests/journey/gix.sh
+++ b/tests/journey/gix.sh
@@ -167,6 +167,35 @@ title "gix attributes"
   )
 )
 
+title "gix commit-graph"
+(when "running 'commit-graph'"
+  snapshot="$snapshot/commit-graph"
+  title "gix commit-graph verify"
+  (with "the 'verify' sub-command"
+    snapshot="$snapshot/verify"
+
+    (small-repo-in-sandbox
+      (with "a valid and complete commit-graph file"
+        git commit-graph write --reachable
+        (with "statistics"
+          it "generates the correct output" && {
+            WITH_SNAPSHOT="$snapshot/statistics-success" \
+            expect_run $SUCCESSFULLY "$exe_plumbing" --no-verbose commit-graph verify -s
+          }
+        )
+        if test "$kind" = "max" || test "$kind" = "max-pure"; then
+        (with "statistics --format json"
+          it "generates the correct output" && {
+            WITH_SNAPSHOT="$snapshot/statistics-json-success" \
+            expect_run $SUCCESSFULLY "$exe_plumbing" --no-verbose --format json commit-graph verify -s
+          }
+        )
+        fi
+      )
+    )
+  )
+)
+
 (with "gix free"
   snapshot="$snapshot/no-repo"
   title "gix free pack"
@@ -625,33 +654,4 @@ title "gix attributes"
       )
     )
   )
-
-  title "gix free commit-graph"
-  (when "running 'commit-graph'"
-    snapshot="$snapshot/commit-graph"
-    title "gix free commit-graph verify"
-    (with "the 'verify' sub-command"
-      snapshot="$snapshot/verify"
-
-      (small-repo-in-sandbox
-        (with "a valid and complete commit-graph file"
-          git commit-graph write --reachable
-          (with "statistics"
-            it "generates the correct output" && {
-              WITH_SNAPSHOT="$snapshot/statistics-success" \
-              expect_run $SUCCESSFULLY "$exe_plumbing" --no-verbose free commit-graph verify -s .git/objects/info
-            }
-          )
-          if test "$kind" = "max" || test "$kind" = "max-pure"; then
-          (with "statistics --format json"
-            it "generates the correct output" && {
-              WITH_SNAPSHOT="$snapshot/statistics-json-success" \
-              expect_run $SUCCESSFULLY "$exe_plumbing" --no-verbose --format json free commit-graph verify -s .git/objects/info
-            }
-          )
-          fi
-        )
-      )
-    )
-  )
 )
diff --git a/tests/snapshots/plumbing/no-repo/commit-graph/verify/statistics-json-success b/tests/snapshots/plumbing/commit-graph/verify/statistics-json-success
similarity index 100%
rename from tests/snapshots/plumbing/no-repo/commit-graph/verify/statistics-json-success
rename to tests/snapshots/plumbing/commit-graph/verify/statistics-json-success
diff --git a/tests/snapshots/plumbing/no-repo/commit-graph/verify/statistics-success b/tests/snapshots/plumbing/commit-graph/verify/statistics-success
similarity index 100%
rename from tests/snapshots/plumbing/no-repo/commit-graph/verify/statistics-success
rename to tests/snapshots/plumbing/commit-graph/verify/statistics-success