diff --git a/Cargo.lock b/Cargo.lock
index 80dee5e77..7711a8297 100644
--- a/Cargo.lock
+++ b/Cargo.lock
@@ -200,6 +200,15 @@ dependencies = [
  "typenum",
 ]
 
+[[package]]
+name = "deranged"
+version = "0.5.8"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "7cd812cc2bc1d69d4764bd80df88b4317eaef9e773c75226407d9bc0876b211c"
+dependencies = [
+ "powerfmt",
+]
+
 [[package]]
 name = "digest"
 version = "0.10.7"
@@ -416,6 +425,28 @@ version = "1.0.18"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "8f42a60cbdf9a97f5d2305f08a87dc4e09308d1276d28c869c684d7777685682"
 
+[[package]]
+name = "jiff"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "1a3546dc96b6d42c5f24902af9e2538e82e39ad350b0c766eb3fbf2d8f3d8359"
+dependencies = [
+ "jiff-static",
+ "portable-atomic",
+ "portable-atomic-util",
+]
+
+[[package]]
+name = "jiff-static"
+version = "0.2.23"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "2a8c8b344124222efd714b73bb41f8b5120b27a7cc1c75593a6ff768d9d05aa4"
+dependencies = [
+ "proc-macro2",
+ "quote",
+ "syn",
+]
+
 [[package]]
 name = "leb128fmt"
 version = "0.1.0"
@@ -499,6 +530,12 @@ dependencies = [
  "libc",
 ]
 
+[[package]]
+name = "num-conv"
+version = "0.1.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "51d515d32fb182ee37cda2ccdcb92950d6a3c2893aa280e540671c2cd0f3b1d9"
+
 [[package]]
 name = "once_cell"
 version = "1.21.4"
@@ -530,6 +567,27 @@ version = "0.2.3"
 source = "registry+https://github.com/rust-lang/crates.io-index"
 checksum = "b4596b6d070b27117e987119b4dac604f3c58cfb0b191112e24771b2faeac1a6"
 
+[[package]]
+name = "portable-atomic"
+version = "1.13.1"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "c33a9471896f1c69cecef8d20cbe2f7accd12527ce60845ff44c153bb2a21b49"
+
+[[package]]
+name = "portable-atomic-util"
+version = "0.2.6"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "091397be61a01d4be58e7841595bd4bfedb15f1cd54977d79b8271e94ed799a3"
+dependencies = [
+ "portable-atomic",
+]
+
+[[package]]
+name = "powerfmt"
+version = "0.2.0"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "439ee305def115ba05938db6eb1644ff94165c5ab5e9420d1c1bcedbba909391"
+
 [[package]]
 name = "prettyplease"
 version = "0.2.37"
@@ -890,6 +948,24 @@ dependencies = [
  "syn",
 ]
 
+[[package]]
+name = "time"
+version = "0.3.45"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "f9e442fc33d7fdb45aa9bfeb312c095964abdf596f7567261062b2a7107aaabd"
+dependencies = [
+ "deranged",
+ "num-conv",
+ "powerfmt",
+ "time-core",
+]
+
+[[package]]
+name = "time-core"
+version = "0.1.7"
+source = "registry+https://github.com/rust-lang/crates.io-index"
+checksum = "8b36ee98fd31ec7426d599183e8fe26932a8dc1fb76ddb6214d05493377d34ca"
+
 [[package]]
 name = "toml"
 version = "1.0.7+spec-1.1.0"
@@ -965,9 +1041,11 @@ version = "0.36.1"
 dependencies = [
  "bitflags 2.11.0",
  "cfg-if",
+ "jiff",
  "log",
  "ptr_meta",
  "qemu-exit",
+ "time",
  "ucs2",
  "uefi-macros",
  "uefi-raw",
diff --git a/Cargo.toml b/Cargo.toml
index 155fb93f4..77d6df882 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -22,7 +22,9 @@ rust-version = "1.88"
 [workspace.dependencies]
 bitflags = "2.0.0"
 log = { version = "0.4.5", default-features = false }
+jiff = { version = "0.2", default-features = false }
 ptr_meta = { version = "0.3.0", default-features = false, features = ["derive"] }
+time = { version = "0.3", default-features = false }
 uguid = "2.2.1"
 
 [patch.crates-io]
diff --git a/uefi/CHANGELOG.md b/uefi/CHANGELOG.md
index 45826f65a..5a733a816 100644
--- a/uefi/CHANGELOG.md
+++ b/uefi/CHANGELOG.md
@@ -19,6 +19,12 @@
 - Added `Handle::component_name()` and `Handle::device_path()` to simplify the
   common use-case of querying more information about a handle.
 - Added `fs::path::Path::join()`.
+- Integration of `Time` with `time` crate
+  - `TryFrom`: `time::PrimitiveDateTime <--> Time` (without timezone)
+  - `TryFrom`: `time::OffsetDateTime <--> Time` (with timezone)
+- Integration of `Time` with `jiff` crate
+  - `TryFrom`: `jiff::DateTime <--> Time` (without timezone)
+  - `TryFrom`: `jiff::Zoned <--> Time` (with timezone)
 
 ## Changed
 - export all `text::{input, output}::*` types
@@ -42,6 +48,8 @@
 - **Breaking:** Renamed `DevicePathNode::to_string()` to `DevicePathNode::to_string16()`
   to better differentiate with the new `to_string()` coming from the new
   `Display`.
+- `runtime::set_time()` now consumes `&T` where `T: Clone + TryInto<Time>`
+  instead of `&Time` to improve the integration with other time types.
 
 # uefi - v0.36.1 (2025-11-05)
 
diff --git a/uefi/Cargo.toml b/uefi/Cargo.toml
index e436fb083..7332f3ce3 100644
--- a/uefi/Cargo.toml
+++ b/uefi/Cargo.toml
@@ -20,6 +20,10 @@ rust-version.workspace = true
 # KEEP this feature list in sync with doc in uefi/lib.rs!
 default = [ ]
 alloc = []
+# Integration with jiff crate `>= v0.2`
+jiff02 = ["dep:jiff"]
+# Integration with time crate `>= v0.3`
+time03 = ["dep:time"]
 
 # Generic gate to code that uses unstable features of Rust, needing a nightly
 # toolchain.
@@ -39,6 +43,8 @@ log-debugcon = []
 bitflags.workspace = true
 log.workspace = true
 ptr_meta.workspace = true
+jiff = { workspace = true, optional = true }
+time = { workspace = true, optional = true }
 uguid.workspace = true
 cfg-if = "1.0.0"
 ucs2 = "0.3.3"
diff --git a/uefi/src/lib.rs b/uefi/src/lib.rs
index 32f405495..7a462982e 100644
--- a/uefi/src/lib.rs
+++ b/uefi/src/lib.rs
@@ -142,12 +142,18 @@
 //!   using this feature, or no allocator at all if you don't need to
 //!   dynamically allocate any memory. Note that even without that feature,
 //!   some code might use the internal UEFI allocator.
+//! - `jiff02`: Integration of [`runtime::Time`] with the `jiff` crate
+//!   (version 0.2 and possible above). Specifically, it integrates the time
+//!   struct with `DateTime` and `Zoned` via `TryFrom`.
 //! - `logger`: Logging implementation for the standard [`log`] crate
 //!   that prints output to the UEFI console. No buffering is done; this
 //!   is not a high-performance logger.
 //! - `log-debugcon`: Whether the logger set up by `logger` should also log
 //!   to the debugcon device (available in QEMU or Cloud Hypervisor on x86).
 //! - `panic_handler`: Add a default panic handler that logs to `stdout`.
+//! - `time03`: Integration of [`runtime::Time`] with the `time` crate
+//!   (version 0.3 and possible above). Specifically, it integrates the time
+//!   struct with `PrimitiveDateTime` and `OffsetDateTime` via `TryFrom`.
 //! - `unstable`: Enable functionality that depends on [unstable features] in
 //!   the Rust compiler (nightly version).
 //! - `qemu`: Enable some code paths to adapt their execution when executed
diff --git a/uefi/src/runtime.rs b/uefi/src/runtime/mod.rs
similarity index 71%
rename from uefi/src/runtime.rs
rename to uefi/src/runtime/mod.rs
index b54389818..f6a079984 100644
--- a/uefi/src/runtime.rs
+++ b/uefi/src/runtime/mod.rs
@@ -7,10 +7,16 @@
 //! functions after exiting boot services; see the "Calling Convention" section
 //! of the UEFI specification for details.
 
+mod time_defs;
+
+pub use time_defs::{Time, TimeByteConversionError, TimeError, TimeParams};
+
 use crate::data_types::PhysicalAddress;
 use crate::table::{self, Revision};
 use crate::{CStr16, Error, Result, Status, StatusExt};
-use core::fmt::{self, Debug, Display, Formatter};
+use core::fmt::Debug;
+#[cfg(feature = "alloc")]
+use core::fmt::{self, Display, Formatter};
 use core::ptr::{self, NonNull};
 use uefi_raw::table::boot::MemoryDescriptor;
 
@@ -67,11 +73,15 @@ pub fn get_time_and_caps() -> Result<(Time, TimeCapabilities)> {
 ///
 /// Undefined behavior could happen if multiple tasks try to
 /// use this function at the same time without synchronisation.
-pub unsafe fn set_time(time: &Time) -> Result {
+pub unsafe fn set_time<T: Clone + TryInto<Time>>(time: &T) -> Result {
+    let time: Time = time
+        .clone()
+        .try_into()
+        .map_err(|_| Status::INVALID_PARAMETER)?;
     let rt = runtime_services_raw_panicking();
     let rt = unsafe { rt.as_ref() };
 
-    let time: *const Time = time;
+    let time = &raw const time;
     unsafe { (rt.set_time)(time.cast()) }.to_result()
 }
 
@@ -549,317 +559,6 @@ pub unsafe fn set_virtual_address_map(
     Ok(())
 }
 
-/// Date and time representation.
-#[derive(Copy, Clone, Eq, PartialEq)]
-#[repr(transparent)]
-pub struct Time(uefi_raw::time::Time);
-
-/// Input parameters for [`Time::new`].
-#[derive(Copy, Clone, Debug)]
-pub struct TimeParams {
-    /// Year in the range `1900..=9999`.
-    pub year: u16,
-
-    /// Month in the range `1..=12`.
-    pub month: u8,
-
-    /// Day in the range `1..=31`.
-    pub day: u8,
-
-    /// Hour in the range `0.=23`.
-    pub hour: u8,
-
-    /// Minute in the range `0..=59`.
-    pub minute: u8,
-
-    /// Second in the range `0..=59`.
-    pub second: u8,
-
-    /// Fraction of a second represented as nanoseconds in the range
-    /// `0..=999_999_999`.
-    pub nanosecond: u32,
-
-    /// Offset in minutes from UTC in the range `-1440..=1440`, or
-    /// local time if `None`.
-    pub time_zone: Option<i16>,
-
-    /// Daylight savings time information.
-    pub daylight: Daylight,
-}
-
-/// Error returned by [`Time`] methods. A bool value of `true` means
-/// the specified field is outside its valid range.
-#[allow(missing_docs)]
-#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
-pub struct TimeError {
-    pub year: bool,
-    pub month: bool,
-    pub day: bool,
-    pub hour: bool,
-    pub minute: bool,
-    pub second: bool,
-    pub nanosecond: bool,
-    pub timezone: bool,
-    pub daylight: bool,
-}
-
-impl core::error::Error for TimeError {}
-
-impl Display for TimeError {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        if self.year {
-            writeln!(f, "year not within `1900..=9999`")?;
-        }
-        if self.month {
-            writeln!(f, "month not within `1..=12")?;
-        }
-        if self.day {
-            writeln!(f, "day not within `1..=31`")?;
-        }
-        if self.hour {
-            writeln!(f, "hour not within `0..=23`")?;
-        }
-        if self.minute {
-            writeln!(f, "minute not within `0..=59`")?;
-        }
-        if self.second {
-            writeln!(f, "second not within `0..=59`")?;
-        }
-        if self.nanosecond {
-            writeln!(f, "nanosecond not within `0..=999_999_999`")?;
-        }
-        if self.timezone {
-            writeln!(
-                f,
-                "time_zone not `Time::UNSPECIFIED_TIMEZONE` nor within `-1440..=1440`"
-            )?;
-        }
-        if self.daylight {
-            writeln!(f, "unknown bits set for daylight")?;
-        }
-        Ok(())
-    }
-}
-
-impl Time {
-    /// Unspecified Timezone/local time.
-    const UNSPECIFIED_TIMEZONE: i16 = uefi_raw::time::Time::UNSPECIFIED_TIMEZONE;
-
-    /// Create a `Time` value. If a field is not in the valid range,
-    /// [`TimeError`] is returned.
-    pub fn new(params: TimeParams) -> core::result::Result<Self, TimeError> {
-        let time = Self(uefi_raw::time::Time {
-            year: params.year,
-            month: params.month,
-            day: params.day,
-            hour: params.hour,
-            minute: params.minute,
-            second: params.second,
-            pad1: 0,
-            nanosecond: params.nanosecond,
-            time_zone: params.time_zone.unwrap_or(Self::UNSPECIFIED_TIMEZONE),
-            daylight: params.daylight,
-            pad2: 0,
-        });
-
-        time.is_valid().map(|_| time)
-    }
-
-    /// Create an invalid `Time` with all fields set to zero. This can
-    /// be used with [`FileInfo`] to indicate a field should not be
-    /// updated when calling [`File::set_info`].
-    ///
-    /// [`FileInfo`]: uefi::proto::media::file::FileInfo
-    /// [`File::set_info`]: uefi::proto::media::file::File::set_info
-    #[must_use]
-    pub const fn invalid() -> Self {
-        Self(uefi_raw::time::Time::invalid())
-    }
-
-    /// `Ok()` if all fields are within valid ranges, `Err(TimeError)` otherwise.
-    pub fn is_valid(&self) -> core::result::Result<(), TimeError> {
-        let mut err = TimeError::default();
-        if !(1900..=9999).contains(&self.year()) {
-            err.year = true;
-        }
-        if !(1..=12).contains(&self.month()) {
-            err.month = true;
-        }
-        if !(1..=31).contains(&self.day()) {
-            err.day = true;
-        }
-        if self.hour() > 23 {
-            err.hour = true;
-        }
-        if self.minute() > 59 {
-            err.minute = true;
-        }
-        if self.second() > 59 {
-            err.second = true;
-        }
-        if self.nanosecond() > 999_999_999 {
-            err.nanosecond = true;
-        }
-        if self.time_zone().is_some() && !((-1440..=1440).contains(&self.time_zone().unwrap())) {
-            err.timezone = true;
-        }
-        // All fields are false, i.e., within their valid range.
-        if err == TimeError::default() {
-            Ok(())
-        } else {
-            Err(err)
-        }
-    }
-
-    /// Query the year.
-    #[must_use]
-    pub const fn year(&self) -> u16 {
-        self.0.year
-    }
-
-    /// Query the month.
-    #[must_use]
-    pub const fn month(&self) -> u8 {
-        self.0.month
-    }
-
-    /// Query the day.
-    #[must_use]
-    pub const fn day(&self) -> u8 {
-        self.0.day
-    }
-
-    /// Query the hour.
-    #[must_use]
-    pub const fn hour(&self) -> u8 {
-        self.0.hour
-    }
-
-    /// Query the minute.
-    #[must_use]
-    pub const fn minute(&self) -> u8 {
-        self.0.minute
-    }
-
-    /// Query the second.
-    #[must_use]
-    pub const fn second(&self) -> u8 {
-        self.0.second
-    }
-
-    /// Query the nanosecond.
-    #[must_use]
-    pub const fn nanosecond(&self) -> u32 {
-        self.0.nanosecond
-    }
-
-    /// Query the time offset in minutes from UTC, or None if using local time.
-    #[must_use]
-    pub const fn time_zone(&self) -> Option<i16> {
-        if self.0.time_zone == Self::UNSPECIFIED_TIMEZONE {
-            None
-        } else {
-            Some(self.0.time_zone)
-        }
-    }
-
-    /// Query the daylight savings time information.
-    #[must_use]
-    pub const fn daylight(&self) -> Daylight {
-        self.0.daylight
-    }
-}
-
-impl Debug for Time {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        write!(
-            f,
-            "{:04}-{:02}-{:02} ",
-            self.0.year, self.0.month, self.0.day
-        )?;
-        write!(
-            f,
-            "{:02}:{:02}:{:02}.{:09}",
-            self.0.hour, self.0.minute, self.0.second, self.0.nanosecond
-        )?;
-        if self.0.time_zone == Self::UNSPECIFIED_TIMEZONE {
-            write!(f, ", Timezone=local")?;
-        } else {
-            write!(f, ", Timezone={}", self.0.time_zone)?;
-        }
-        write!(f, ", Daylight={:?}", self.0.daylight)
-    }
-}
-
-impl Display for Time {
-    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
-        write!(f, "{}", self.0)
-    }
-}
-
-/// Error returned from failing to convert a byte slice into a [`Time`].
-#[derive(Clone, Copy, Debug, PartialEq, Eq)]
-pub enum TimeByteConversionError {
-    /// One or more fields of the converted [`Time`] is invalid.
-    InvalidFields(TimeError),
-    /// The byte slice is not large enough to hold a [`Time`].
-    InvalidSize,
-}
-
-impl Display for TimeByteConversionError {
-    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
-        match self {
-            Self::InvalidFields(error) => write!(f, "{error}"),
-            Self::InvalidSize => write!(
-                f,
-                "the byte slice is not large enough to hold a Time struct"
-            ),
-        }
-    }
-}
-
-impl TryFrom<&[u8]> for Time {
-    type Error = TimeByteConversionError;
-
-    fn try_from(bytes: &[u8]) -> core::result::Result<Self, Self::Error> {
-        if size_of::<Self>() <= bytes.len() {
-            let year = u16::from_le_bytes(bytes[0..2].try_into().unwrap());
-            let month = bytes[2];
-            let day = bytes[3];
-            let hour = bytes[4];
-            let minute = bytes[5];
-            let second = bytes[6];
-            let nanosecond = u32::from_le_bytes(bytes[8..12].try_into().unwrap());
-            let time_zone = match i16::from_le_bytes(bytes[12..14].try_into().unwrap()) {
-                Self::UNSPECIFIED_TIMEZONE => None,
-                num => Some(num),
-            };
-            let daylight = Daylight::from_bits(bytes[14]).ok_or_else(|| {
-                TimeByteConversionError::InvalidFields(TimeError {
-                    daylight: true,
-                    ..Default::default()
-                })
-            })?;
-
-            let time_params = TimeParams {
-                year,
-                month,
-                day,
-                hour,
-                minute,
-                second,
-                nanosecond,
-                time_zone,
-                daylight,
-            };
-
-            Self::new(time_params).map_err(TimeByteConversionError::InvalidFields)
-        } else {
-            Err(TimeByteConversionError::InvalidSize)
-        }
-    }
-}
-
 /// Unique key for a variable.
 #[cfg(feature = "alloc")]
 #[derive(Clone, Debug, Eq, PartialEq, Ord, PartialOrd, Hash)]
diff --git a/uefi/src/runtime/time_defs/integration_common.rs b/uefi/src/runtime/time_defs/integration_common.rs
new file mode 100644
index 000000000..660c337a2
--- /dev/null
+++ b/uefi/src/runtime/time_defs/integration_common.rs
@@ -0,0 +1,181 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Provides common helpers for the integration and conversion with
+//! different time crates from the ecosystem.
+
+use crate::runtime::TimeError;
+use core::error::Error;
+use core::fmt;
+use core::fmt::{Display, Formatter};
+
+/// An opaque error type indicating a UEFI [`Time`] could not be converted.
+///
+/// [`Time`]: super::Time
+#[derive(Debug)]
+pub struct ConversionError(pub(super) ConversionErrorInner);
+
+impl Display for ConversionError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "Time conversion error: {}", self.0)
+    }
+}
+
+impl Error for ConversionError {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        // Don't expose the inner error, it is not useful to the user.
+        None
+    }
+}
+
+#[derive(Debug)]
+pub(super) enum ConversionErrorInner {
+    /// Invalid component.
+    InvalidComponent,
+    /// Invalid UEFI time: [`Time::is_valid`][tiv] reported an error.
+    ///
+    /// [tiv]: crate::runtime::Time::is_valid
+    InvalidUefiTime(TimeError),
+    /// A timezone was required for the conversion, but the UEFI time indicates
+    /// [`Time::UNSPECIFIED_TIMEZONE`].
+    ///
+    /// [`Time::UNSPECIFIED_TIMEZONE`]: super::Time::UNSPECIFIED_TIMEZONE
+    UnspecifiedTimezone,
+    /// Errors raised in the [`time`] crate.
+    #[cfg(feature = "time03")]
+    TimeCrateError(time::Error),
+    /// Errors raised in the [`jiff`] crate.
+    #[cfg(feature = "jiff02")]
+    JiffCrateError(jiff::Error),
+}
+
+impl Display for ConversionErrorInner {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        match self {
+            Self::InvalidComponent => write!(f, "Invalid component"),
+            Self::InvalidUefiTime(e) => write!(f, "Invalid UEFI time: {e}"),
+            Self::UnspecifiedTimezone => write!(f, "Unspecified timezone"),
+            #[cfg(feature = "time03")]
+            Self::TimeCrateError(e) => write!(f, "Time crate error: {}", e),
+            #[cfg(feature = "jiff02")]
+            Self::JiffCrateError(e) => write!(f, "Jiff crate error: {}", e),
+        }
+    }
+}
+
+impl Error for ConversionErrorInner {
+    fn source(&self) -> Option<&(dyn Error + 'static)> {
+        match self {
+            Self::InvalidComponent => None,
+            Self::InvalidUefiTime(e) => Some(e),
+            Self::UnspecifiedTimezone => None,
+            #[cfg(feature = "time03")]
+            Self::TimeCrateError(e) => Some(e),
+            // None: Missing Error trait
+            #[cfg(feature = "jiff02")]
+            Self::JiffCrateError(_e) => None,
+        }
+    }
+}
+
+#[cfg(test)]
+pub(super) mod test_helpers {
+    use super::*;
+    use crate::runtime::TimeParams;
+    use uefi::runtime::Time;
+    use uefi_raw::time::Daylight;
+
+    pub fn sample_time(tz: i16) -> Time {
+        let params = TimeParams {
+            year: 2024,
+            month: 3,
+            day: 14,
+            hour: 12,
+            minute: 34,
+            second: 56,
+            nanosecond: 123_456_789,
+            time_zone: Some(tz),
+            daylight: Daylight::default(),
+        };
+        Time::new(params).unwrap()
+    }
+
+    fn invalid_date() -> Time {
+        let mut t = sample_time(0);
+        t.0.month = 2;
+        t.0.day = 31;
+        t
+    }
+
+    pub fn primitive_roundtrip<T>()
+    where
+        T: TryFrom<Time, Error = ConversionError> + TryInto<Time, Error = ConversionError>,
+    {
+        let t = sample_time(Time::UNSPECIFIED_TIMEZONE);
+
+        let dt: T = t.try_into().unwrap();
+        let back: Time = dt.try_into().unwrap();
+
+        assert_eq!(back.0.year, t.0.year);
+        assert_eq!(back.0.month, t.0.month);
+        assert_eq!(back.0.day, t.0.day);
+        assert_eq!(back.0.hour, t.0.hour);
+        assert_eq!(back.0.minute, t.0.minute);
+        assert_eq!(back.0.second, t.0.second);
+        assert_eq!(back.0.nanosecond, t.0.nanosecond);
+    }
+
+    pub fn zoned_roundtrip<T>()
+    where
+        T: TryFrom<Time, Error = ConversionError> + TryInto<Time, Error = ConversionError>,
+    {
+        let t = sample_time(120);
+
+        let dt: T = t.try_into().unwrap();
+        let back: Time = dt.try_into().unwrap();
+
+        assert_eq!(back.0.time_zone, 120);
+        assert_eq!(back.0.hour, t.0.hour);
+        assert_eq!(back.0.minute, t.0.minute);
+    }
+
+    pub fn negative_offset_roundtrip<T>()
+    where
+        T: TryFrom<Time, Error = ConversionError> + TryInto<Time, Error = ConversionError>,
+    {
+        let t = sample_time(-330);
+
+        let dt: T = t.try_into().unwrap();
+        let back: Time = dt.try_into().unwrap();
+
+        assert_eq!(back.0.time_zone, -330);
+    }
+
+    pub fn preserves_nanoseconds<T>()
+    where
+        T: TryFrom<Time, Error = ConversionError> + TryInto<Time, Error = ConversionError>,
+    {
+        let t = sample_time(60);
+
+        let dt: T = t.try_into().unwrap();
+        let back: Time = dt.try_into().unwrap();
+
+        assert_eq!(back.0.nanosecond, 123_456_789);
+    }
+
+    pub fn unspecified_timezone_fails<T>()
+    where
+        T: TryFrom<Time, Error = ConversionError>,
+    {
+        let t = sample_time(Time::UNSPECIFIED_TIMEZONE);
+        let result: Result<T, _> = t.try_into();
+        assert!(result.is_err());
+    }
+
+    pub fn invalid_calendar_date_fails<T>()
+    where
+        T: TryFrom<Time, Error = ConversionError>,
+    {
+        let result: Result<T, _> = invalid_date().try_into();
+        assert!(result.is_err());
+    }
+}
diff --git a/uefi/src/runtime/time_defs/integration_jiff_crate.rs b/uefi/src/runtime/time_defs/integration_jiff_crate.rs
new file mode 100644
index 000000000..b47926995
--- /dev/null
+++ b/uefi/src/runtime/time_defs/integration_jiff_crate.rs
@@ -0,0 +1,177 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Integration of the UEFI [`Time`] type with the [`jiff`] crate.
+
+use super::Time;
+use super::integration_common::{ConversionError, ConversionErrorInner};
+use jiff::Zoned;
+use jiff::civil::DateTime;
+use jiff::tz::{Offset, TimeZone};
+use uefi::runtime::TimeParams;
+
+// Timezone unaware
+impl TryFrom<Time> for DateTime {
+    type Error = ConversionError;
+
+    fn try_from(value: Time) -> Result<Self, Self::Error> {
+        if let Err(e) = value.is_valid() {
+            return Err(ConversionError(ConversionErrorInner::InvalidUefiTime(e)));
+        }
+
+        let datetime = Self::new(
+            // Cannot fail as the value is valid and in range (we checked that).
+            i16::try_from(value.0.year).unwrap(),
+            // Cannot fail as the value is valid and in range (we checked that).
+            i8::try_from(value.0.month).unwrap(),
+            // Cannot fail as the value is valid and in range (we checked that).
+            i8::try_from(value.0.day).unwrap(),
+            // Cannot fail as the value is valid and in range (we checked that).
+            i8::try_from(value.0.hour).unwrap(),
+            // Cannot fail as the value is valid and in range (we checked that).
+            i8::try_from(value.0.minute).unwrap(),
+            // Cannot fail as the value is valid and in range (we checked that).
+            i8::try_from(value.0.second).unwrap(),
+            // Cannot fail as the value is valid and in range (we checked that).
+            i32::try_from(value.0.nanosecond).unwrap(),
+        )
+        .map_err(|e| ConversionError(ConversionErrorInner::JiffCrateError(e)))?;
+
+        Ok(datetime)
+    }
+}
+
+// Timezone aware
+impl TryFrom<Time> for Zoned {
+    type Error = ConversionError;
+
+    fn try_from(value: Time) -> Result<Self, Self::Error> {
+        if let Err(e) = value.is_valid() {
+            return Err(ConversionError(ConversionErrorInner::InvalidUefiTime(e)));
+        }
+
+        if value.0.time_zone == Time::UNSPECIFIED_TIMEZONE {
+            return Err(ConversionError(ConversionErrorInner::UnspecifiedTimezone));
+        }
+
+        let datetime = DateTime::try_from(value)?;
+        let seconds = value.0.time_zone as i32 * 60 /* seconds per minute */;
+        let offset = Offset::from_seconds(seconds)
+            .map_err(|e| ConversionError(ConversionErrorInner::JiffCrateError(e)))?;
+        let timezone = TimeZone::fixed(offset);
+        let zoned = datetime
+            .to_zoned(timezone)
+            .map_err(|e| ConversionError(ConversionErrorInner::JiffCrateError(e)))?;
+        Ok(zoned)
+    }
+}
+
+impl TryFrom<DateTime> for Time {
+    type Error = ConversionError;
+
+    fn try_from(value: DateTime) -> Result<Self, Self::Error> {
+        let params = TimeParams {
+            year: u16::try_from(value.year())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            month: u8::try_from(value.month())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            day: u8::try_from(value.day())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            hour: u8::try_from(value.hour())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            minute: u8::try_from(value.minute())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            second: u8::try_from(value.second())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            nanosecond: u32::try_from(value.subsec_nanosecond())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            time_zone: None,
+            daylight: Default::default(),
+        };
+        Self::new(params).map_err(|e| ConversionError(ConversionErrorInner::InvalidUefiTime(e)))
+    }
+}
+
+impl TryFrom<Zoned> for Time {
+    type Error = ConversionError;
+    fn try_from(value: Zoned) -> Result<Self, Self::Error> {
+        let params = TimeParams {
+            year: u16::try_from(value.year())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            month: u8::try_from(value.month())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            day: u8::try_from(value.day())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            hour: u8::try_from(value.hour())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            minute: u8::try_from(value.minute())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            second: u8::try_from(value.second())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            nanosecond: u32::try_from(value.subsec_nanosecond())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            time_zone: Some(
+                i16::try_from(value.offset().seconds() / 60 /* seconds per minute */)
+                    .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            ),
+            daylight: Default::default(),
+        };
+        Self::new(params).map_err(|e| ConversionError(ConversionErrorInner::InvalidUefiTime(e)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::integration_common::test_helpers;
+    use super::*;
+
+    #[test]
+    fn primitive_roundtrip_basic() {
+        test_helpers::primitive_roundtrip::<DateTime>();
+    }
+
+    #[test]
+    fn zoned_roundtrip_positive_offset() {
+        test_helpers::zoned_roundtrip::<Zoned>();
+    }
+
+    #[test]
+    fn zoned_roundtrip_negative_offset() {
+        test_helpers::negative_offset_roundtrip::<Zoned>();
+    }
+
+    #[test]
+    fn nanoseconds_preserved() {
+        test_helpers::preserves_nanoseconds::<Zoned>();
+    }
+
+    #[test]
+    fn unspecified_timezone_is_rejected() {
+        test_helpers::unspecified_timezone_fails::<Zoned>();
+    }
+
+    #[test]
+    fn invalid_date_is_rejected() {
+        test_helpers::invalid_calendar_date_fails::<DateTime>();
+    }
+
+    // jiff-specific edge case: offset minute precision
+    #[test]
+    fn half_hour_timezone_roundtrip() {
+        let t = test_helpers::sample_time(90); // +01:30
+
+        let z: Zoned = t.try_into().unwrap();
+        let back: Time = z.try_into().unwrap();
+
+        assert_eq!(back.0.time_zone, 90);
+    }
+
+    #[test]
+    fn negative_half_hour_timezone_roundtrip() {
+        let t = test_helpers::sample_time(-330); // -05:30
+
+        let z: Zoned = t.try_into().unwrap();
+        let back: Time = z.try_into().unwrap();
+
+        assert_eq!(back.0.time_zone, -330);
+    }
+}
diff --git a/uefi/src/runtime/time_defs/integration_time_crate.rs b/uefi/src/runtime/time_defs/integration_time_crate.rs
new file mode 100644
index 000000000..597def8d0
--- /dev/null
+++ b/uefi/src/runtime/time_defs/integration_time_crate.rs
@@ -0,0 +1,167 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Integration of the UEFI [`Time`] type with the [`time`] crate.
+
+use super::Time;
+use super::integration_common::{ConversionError, ConversionErrorInner};
+use crate::runtime::TimeParams;
+use time::{OffsetDateTime, PrimitiveDateTime, UtcOffset};
+
+impl TryFrom<Time> for PrimitiveDateTime {
+    type Error = ConversionError;
+
+    fn try_from(value: Time) -> Result<Self, Self::Error> {
+        if let Err(e) = value.is_valid() {
+            return Err(ConversionError(ConversionErrorInner::InvalidUefiTime(e)));
+        }
+
+        // Emulated try {} block to keep the `?` error propagation scoped
+        // (we have a different error type here)
+        let datetime: Result<Self, time::error::ComponentRange> = (|| {
+            let month = time::Month::try_from(value.0.month)?;
+            let date = time::Date::from_calendar_date(value.0.year as i32, month, value.0.day)?;
+            let time = time::Time::from_hms_nano(
+                value.0.hour,
+                value.0.minute,
+                value.0.second,
+                value.0.nanosecond,
+            )?;
+            Ok(Self::new(date, time))
+        })();
+
+        datetime
+            .map_err(time::Error::ComponentRange)
+            .map_err(|e| ConversionError(ConversionErrorInner::TimeCrateError(e)))
+    }
+}
+
+impl TryFrom<Time> for OffsetDateTime {
+    type Error = ConversionError;
+
+    fn try_from(value: Time) -> Result<Self, Self::Error> {
+        if let Err(e) = value.is_valid() {
+            return Err(ConversionError(ConversionErrorInner::InvalidUefiTime(e)));
+        }
+
+        let primitive_date_time: PrimitiveDateTime = value.try_into()?;
+
+        if value.0.time_zone == Time::UNSPECIFIED_TIMEZONE {
+            return Err(ConversionError(ConversionErrorInner::UnspecifiedTimezone));
+        }
+
+        let h = (value.0.time_zone / 60) as i8;
+        let m = (value.0.time_zone % 60) as i8;
+
+        let offset = UtcOffset::from_hms(h, m, 0)
+            .map_err(time::Error::ComponentRange)
+            .map_err(|e| ConversionError(ConversionErrorInner::TimeCrateError(e)))?;
+        Ok(primitive_date_time.assume_offset(offset))
+    }
+}
+
+impl TryFrom<PrimitiveDateTime> for Time {
+    type Error = ConversionError;
+
+    fn try_from(value: PrimitiveDateTime) -> Result<Self, Self::Error> {
+        let params = TimeParams {
+            year: u16::try_from(value.year())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            month: u8::from(value.month()),
+            day: value.day(),
+            hour: value.hour(),
+            minute: value.minute(),
+            second: value.second(),
+            nanosecond: value.nanosecond(),
+            time_zone: None,
+            daylight: Default::default(),
+        };
+        Self::new(params).map_err(|e| ConversionError(ConversionErrorInner::InvalidUefiTime(e)))
+    }
+}
+
+impl TryFrom<OffsetDateTime> for Time {
+    type Error = ConversionError;
+
+    fn try_from(value: OffsetDateTime) -> Result<Self, Self::Error> {
+        let timezone_offset_minutes = value.offset().whole_seconds() / 60;
+        if value.offset().whole_seconds() % 60 != 0 {
+            return Err(ConversionError(ConversionErrorInner::InvalidComponent));
+        }
+
+        let params = TimeParams {
+            year: u16::try_from(value.year())
+                .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            month: u8::from(value.month()),
+            day: value.day(),
+            hour: value.hour(),
+            minute: value.minute(),
+            second: value.second(),
+            nanosecond: value.nanosecond(),
+            time_zone: Some(
+                i16::try_from(timezone_offset_minutes)
+                    .map_err(|_e| ConversionError(ConversionErrorInner::InvalidComponent))?,
+            ),
+            daylight: Default::default(),
+        };
+
+        Self::new(params).map_err(|e| ConversionError(ConversionErrorInner::InvalidUefiTime(e)))
+    }
+}
+
+#[cfg(test)]
+mod tests {
+    use super::super::integration_common::test_helpers;
+    use super::*;
+    use time::{OffsetDateTime, PrimitiveDateTime};
+
+    #[test]
+    fn primitive_roundtrip_basic() {
+        test_helpers::primitive_roundtrip::<PrimitiveDateTime>();
+    }
+
+    #[test]
+    fn zoned_roundtrip_positive_offset() {
+        test_helpers::zoned_roundtrip::<OffsetDateTime>();
+    }
+
+    #[test]
+    fn zoned_roundtrip_negative_offset() {
+        test_helpers::negative_offset_roundtrip::<OffsetDateTime>();
+    }
+
+    #[test]
+    fn nanoseconds_preserved() {
+        test_helpers::preserves_nanoseconds::<OffsetDateTime>();
+    }
+
+    #[test]
+    fn unspecified_timezone_is_rejected() {
+        test_helpers::unspecified_timezone_fails::<OffsetDateTime>();
+    }
+
+    #[test]
+    fn invalid_date_is_rejected() {
+        test_helpers::invalid_calendar_date_fails::<PrimitiveDateTime>();
+    }
+
+    // important real-world offset edge case
+    #[test]
+    fn half_hour_timezone_roundtrip() {
+        let t = test_helpers::sample_time(90); // +01:30
+
+        let dt: OffsetDateTime = t.try_into().unwrap();
+        let back: Time = dt.try_into().unwrap();
+
+        assert_eq!(back.0.time_zone, 90);
+    }
+
+    #[test]
+    fn negative_half_hour_timezone_roundtrip() {
+        let t = test_helpers::sample_time(-330); // -05:30
+
+        let dt: OffsetDateTime = t.try_into().unwrap();
+        let back: Time = dt.try_into().unwrap();
+
+        assert_eq!(back.0.time_zone, -330);
+    }
+}
diff --git a/uefi/src/runtime/time_defs/mod.rs b/uefi/src/runtime/time_defs/mod.rs
new file mode 100644
index 000000000..f7f6e0b4f
--- /dev/null
+++ b/uefi/src/runtime/time_defs/mod.rs
@@ -0,0 +1,345 @@
+// SPDX-License-Identifier: MIT OR Apache-2.0
+
+//! Module for UEFI time-related types and definitions and convenience and
+//! abstractions build around these.
+
+use core::fmt;
+use core::fmt::{Debug, Display, Formatter};
+use uefi_raw::time::Daylight;
+
+#[cfg(any(feature = "jiff02", feature = "time03"))]
+mod integration_common;
+#[cfg(feature = "jiff02")]
+mod integration_jiff_crate;
+#[cfg(feature = "time03")]
+mod integration_time_crate;
+
+/// Date and time representation.
+///
+/// # Integration with Time-related Crates of the Ecosystem
+///
+/// Handling time is complicated. Therefore, we do not reinvent the wheel and
+/// forward all complexity of time to well-known crates of the ecosystem. For
+/// that, we provide integrations with various crates:
+///
+/// ## Integration with [`time`][time crate] crate
+///
+/// - [`TryFrom`]: `PrimitiveDateTime` <--> [`Time`] (without timezone)
+/// - [`TryFrom`]: `OffsetDateTime` <--> [`Time`] (with timezone)
+///
+/// ## Integration with [`jiff`][jiff crate] crate
+///
+/// - [`TryFrom`]: `DateTime` <--> [`Time`] (without timezone)
+/// - [`TryFrom`]: `Zoned` <--> [`Time`] (with timezone)
+///
+/// [time crate]: https://crates.io/crates/time
+/// [jiff crate]: https://crates.io/crates/jiff
+#[derive(Copy, Clone, Eq, PartialEq)]
+#[repr(transparent)]
+pub struct Time(uefi_raw::time::Time);
+
+/// Input parameters for [`Time::new`].
+#[derive(Copy, Clone, Debug)]
+pub struct TimeParams {
+    /// Year in the range `1900..=9999`.
+    pub year: u16,
+
+    /// Month in the range `1..=12`.
+    pub month: u8,
+
+    /// Day in the range `1..=31`.
+    pub day: u8,
+
+    /// Hour in the range `0.=23`.
+    pub hour: u8,
+
+    /// Minute in the range `0..=59`.
+    pub minute: u8,
+
+    /// Second in the range `0..=59`.
+    pub second: u8,
+
+    /// Fraction of a second represented as nanoseconds in the range
+    /// `0..=999_999_999`.
+    pub nanosecond: u32,
+
+    /// Offset in minutes from UTC in the range `-1440..=1440`, or
+    /// local time if `None`.
+    pub time_zone: Option<i16>,
+
+    /// Daylight savings time information.
+    pub daylight: Daylight,
+}
+
+/// Error returned by [`Time`] methods. A bool value of `true` means
+/// the specified field is outside its valid range.
+#[allow(missing_docs)]
+#[derive(Clone, Copy, Debug, Default, PartialEq, Eq)]
+pub struct TimeError {
+    pub year: bool,
+    pub month: bool,
+    pub day: bool,
+    pub hour: bool,
+    pub minute: bool,
+    pub second: bool,
+    pub nanosecond: bool,
+    pub timezone: bool,
+    pub daylight: bool,
+}
+
+impl core::error::Error for TimeError {}
+
+impl Display for TimeError {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        if self.year {
+            writeln!(f, "year not within `1900..=9999`")?;
+        }
+        if self.month {
+            writeln!(f, "month not within `1..=12")?;
+        }
+        if self.day {
+            writeln!(f, "day not within `1..=31`")?;
+        }
+        if self.hour {
+            writeln!(f, "hour not within `0..=23`")?;
+        }
+        if self.minute {
+            writeln!(f, "minute not within `0..=59`")?;
+        }
+        if self.second {
+            writeln!(f, "second not within `0..=59`")?;
+        }
+        if self.nanosecond {
+            writeln!(f, "nanosecond not within `0..=999_999_999`")?;
+        }
+        if self.timezone {
+            writeln!(
+                f,
+                "time_zone not `Time::UNSPECIFIED_TIMEZONE` nor within `-1440..=1440`"
+            )?;
+        }
+        if self.daylight {
+            writeln!(f, "unknown bits set for daylight")?;
+        }
+        Ok(())
+    }
+}
+
+impl Time {
+    /// Unspecified Timezone/local time.
+    const UNSPECIFIED_TIMEZONE: i16 = uefi_raw::time::Time::UNSPECIFIED_TIMEZONE;
+
+    /// Create a `Time` value. If a field is not in the valid range,
+    /// [`TimeError`] is returned.
+    pub fn new(params: TimeParams) -> core::result::Result<Self, TimeError> {
+        let time = Self(uefi_raw::time::Time {
+            year: params.year,
+            month: params.month,
+            day: params.day,
+            hour: params.hour,
+            minute: params.minute,
+            second: params.second,
+            pad1: 0,
+            nanosecond: params.nanosecond,
+            time_zone: params.time_zone.unwrap_or(Self::UNSPECIFIED_TIMEZONE),
+            daylight: params.daylight,
+            pad2: 0,
+        });
+
+        time.is_valid().map(|_| time)
+    }
+
+    /// Create an invalid `Time` with all fields set to zero. This can
+    /// be used with [`FileInfo`] to indicate a field should not be
+    /// updated when calling [`File::set_info`].
+    ///
+    /// [`FileInfo`]: uefi::proto::media::file::FileInfo
+    /// [`File::set_info`]: uefi::proto::media::file::File::set_info
+    #[must_use]
+    pub const fn invalid() -> Self {
+        Self(uefi_raw::time::Time::invalid())
+    }
+
+    /// `Ok()` if all fields are within valid ranges, `Err(TimeError)` otherwise.
+    pub fn is_valid(&self) -> core::result::Result<(), TimeError> {
+        let mut err = TimeError::default();
+        if !(1900..=9999).contains(&self.year()) {
+            err.year = true;
+        }
+        if !(1..=12).contains(&self.month()) {
+            err.month = true;
+        }
+        if !(1..=31).contains(&self.day()) {
+            err.day = true;
+        }
+        if self.hour() > 23 {
+            err.hour = true;
+        }
+        if self.minute() > 59 {
+            err.minute = true;
+        }
+        if self.second() > 59 {
+            err.second = true;
+        }
+        if self.nanosecond() > 999_999_999 {
+            err.nanosecond = true;
+        }
+        if self.time_zone().is_some() && !((-1440..=1440).contains(&self.time_zone().unwrap())) {
+            err.timezone = true;
+        }
+        // All fields are false, i.e., within their valid range.
+        if err == TimeError::default() {
+            Ok(())
+        } else {
+            Err(err)
+        }
+    }
+
+    /// Query the year.
+    #[must_use]
+    pub const fn year(&self) -> u16 {
+        self.0.year
+    }
+
+    /// Query the month.
+    #[must_use]
+    pub const fn month(&self) -> u8 {
+        self.0.month
+    }
+
+    /// Query the day.
+    #[must_use]
+    pub const fn day(&self) -> u8 {
+        self.0.day
+    }
+
+    /// Query the hour.
+    #[must_use]
+    pub const fn hour(&self) -> u8 {
+        self.0.hour
+    }
+
+    /// Query the minute.
+    #[must_use]
+    pub const fn minute(&self) -> u8 {
+        self.0.minute
+    }
+
+    /// Query the second.
+    #[must_use]
+    pub const fn second(&self) -> u8 {
+        self.0.second
+    }
+
+    /// Query the nanosecond.
+    #[must_use]
+    pub const fn nanosecond(&self) -> u32 {
+        self.0.nanosecond
+    }
+
+    /// Query the time offset in minutes from UTC, or None if using local time.
+    #[must_use]
+    pub const fn time_zone(&self) -> Option<i16> {
+        if self.0.time_zone == Self::UNSPECIFIED_TIMEZONE {
+            None
+        } else {
+            Some(self.0.time_zone)
+        }
+    }
+
+    /// Query the daylight savings time information.
+    #[must_use]
+    pub const fn daylight(&self) -> Daylight {
+        self.0.daylight
+    }
+}
+
+impl Debug for Time {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        write!(
+            f,
+            "{:04}-{:02}-{:02} ",
+            self.0.year, self.0.month, self.0.day
+        )?;
+        write!(
+            f,
+            "{:02}:{:02}:{:02}.{:09}",
+            self.0.hour, self.0.minute, self.0.second, self.0.nanosecond
+        )?;
+        if self.0.time_zone == Self::UNSPECIFIED_TIMEZONE {
+            write!(f, ", Timezone=local")?;
+        } else {
+            write!(f, ", Timezone={}", self.0.time_zone)?;
+        }
+        write!(f, ", Daylight={:?}", self.0.daylight)
+    }
+}
+
+impl Display for Time {
+    fn fmt(&self, f: &mut Formatter<'_>) -> fmt::Result {
+        write!(f, "{}", self.0)
+    }
+}
+
+/// Error returned from failing to convert a byte slice into a [`Time`].
+#[derive(Clone, Copy, Debug, PartialEq, Eq)]
+pub enum TimeByteConversionError {
+    /// One or more fields of the converted [`Time`] is invalid.
+    InvalidFields(TimeError),
+    /// The byte slice is not large enough to hold a [`Time`].
+    InvalidSize,
+}
+
+impl Display for TimeByteConversionError {
+    fn fmt(&self, f: &mut Formatter) -> fmt::Result {
+        match self {
+            Self::InvalidFields(error) => write!(f, "{error}"),
+            Self::InvalidSize => write!(
+                f,
+                "the byte slice is not large enough to hold a Time struct"
+            ),
+        }
+    }
+}
+
+impl TryFrom<&[u8]> for Time {
+    type Error = TimeByteConversionError;
+
+    fn try_from(bytes: &[u8]) -> core::result::Result<Self, Self::Error> {
+        if size_of::<Self>() <= bytes.len() {
+            let year = u16::from_le_bytes(bytes[0..2].try_into().unwrap());
+            let month = bytes[2];
+            let day = bytes[3];
+            let hour = bytes[4];
+            let minute = bytes[5];
+            let second = bytes[6];
+            let nanosecond = u32::from_le_bytes(bytes[8..12].try_into().unwrap());
+            let time_zone = match i16::from_le_bytes(bytes[12..14].try_into().unwrap()) {
+                Self::UNSPECIFIED_TIMEZONE => None,
+                num => Some(num),
+            };
+            let daylight = Daylight::from_bits(bytes[14]).ok_or_else(|| {
+                TimeByteConversionError::InvalidFields(TimeError {
+                    daylight: true,
+                    ..Default::default()
+                })
+            })?;
+
+            let time_params = TimeParams {
+                year,
+                month,
+                day,
+                hour,
+                minute,
+                second,
+                nanosecond,
+                time_zone,
+                daylight,
+            };
+
+            Self::new(time_params).map_err(TimeByteConversionError::InvalidFields)
+        } else {
+            Err(TimeByteConversionError::InvalidSize)
+        }
+    }
+}
diff --git a/xtask/src/cargo.rs b/xtask/src/cargo.rs
index cfaa574b7..ddf50dcf8 100644
--- a/xtask/src/cargo.rs
+++ b/xtask/src/cargo.rs
@@ -56,6 +56,8 @@ pub enum Feature {
     Unstable,
     PanicHandler,
     Qemu,
+    Jiff02,
+    Time03,
 
     // `uefi-test-runner` features.
     DebugSupport,
@@ -76,6 +78,8 @@ impl Feature {
             Self::Unstable => "unstable",
             Self::PanicHandler => "panic_handler",
             Self::Qemu => "qemu",
+            Self::Jiff02 => "jiff02",
+            Self::Time03 => "time03",
 
             Self::DebugSupport => "uefi-test-runner/debug_support",
             Self::MultiProcessor => "uefi-test-runner/multi_processor",
@@ -117,7 +121,13 @@ impl Feature {
     /// - `include_unstable` - add all functionality behind the `unstable` feature
     /// - `runtime_features` - add all functionality that effect the runtime of Rust
     pub fn more_code(include_unstable: bool, runtime_features: bool) -> Vec<Self> {
-        let mut base_features = vec![Self::Alloc, Self::LogDebugcon, Self::Logger];
+        let mut base_features = vec![
+            Self::Alloc,
+            Self::Jiff02,
+            Self::LogDebugcon,
+            Self::Logger,
+            Self::Time03,
+        ];
         if include_unstable {
             base_features.extend([Self::Unstable])
         }
@@ -387,19 +397,19 @@ mod tests {
     fn test_comma_separated_features() {
         assert_eq!(
             Feature::comma_separated_string(&Feature::more_code(false, false)),
-            "alloc,log-debugcon,logger"
+            "alloc,jiff02,log-debugcon,logger,time03"
         );
         assert_eq!(
             Feature::comma_separated_string(&Feature::more_code(false, true)),
-            "alloc,log-debugcon,logger,global_allocator"
+            "alloc,jiff02,log-debugcon,logger,time03,global_allocator"
         );
         assert_eq!(
             Feature::comma_separated_string(&Feature::more_code(true, false)),
-            "alloc,log-debugcon,logger,unstable"
+            "alloc,jiff02,log-debugcon,logger,time03,unstable"
         );
         assert_eq!(
             Feature::comma_separated_string(&Feature::more_code(true, true)),
-            "alloc,log-debugcon,logger,unstable,global_allocator"
+            "alloc,jiff02,log-debugcon,logger,time03,unstable,global_allocator"
         );
     }