diff --git a/Cargo.toml b/Cargo.toml
index 72f417c75d52a..8570739a6447a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -10,7 +10,7 @@ keywords = ["game", "engine", "gamedev", "graphics", "bevy"]
 license = "MIT OR Apache-2.0"
 repository = "https://github.com/bevyengine/bevy"
 documentation = "https://docs.rs/bevy"
-rust-version = "1.89.0"
+rust-version = "1.91.0"
 
 [workspace]
 resolver = "2"
@@ -2674,6 +2674,27 @@ description = "Illustrates ticking `Timer` resources inside systems and handling
 category = "Time"
 wasm = false
 
+[[example]]
+name = "groundhog_day"
+path = "examples/time/groundhog_day.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.groundhog_day]
+name = "Groundhog Day"
+description = "Shows how `Time<TimeTravel>` can be used to go back in time."
+category = "Time"
+wasm = false
+
+[[example]]
+name = "stepped_simulation"
+path = "examples/time/stepped_simulation.rs"
+doc-scrape-examples = true
+
+[package.metadata.example.stepped_simulation]
+name = "Stepped Simulation"
+description = "Shows how `Time<SteppedTimeTravel>` can be used to track a simulation."
+category = "Time"
+wasm = false
 
 # Games
 [[example]]
diff --git a/crates/bevy_dev_tools/src/easy_screenshot.rs b/crates/bevy_dev_tools/src/easy_screenshot.rs
index 28e166e525c4e..2ee1b73cca3ce 100644
--- a/crates/bevy_dev_tools/src/easy_screenshot.rs
+++ b/crates/bevy_dev_tools/src/easy_screenshot.rs
@@ -303,7 +303,7 @@ impl Plugin for EasyScreenRecordPlugin {
                                     let img = screenshot_captured.image.clone();
                                     tx.send(RecordCommand::Frame(img)).unwrap();
                                     virtual_time.advance_by(frame_time);
-                                    *time = virtual_time.as_generic();
+                                    *time = virtual_time.as_other();
                                 },
                             );
                         }
diff --git a/crates/bevy_time/src/fixed.rs b/crates/bevy_time/src/fixed.rs
index b1483de3f6236..f90d588128bbb 100644
--- a/crates/bevy_time/src/fixed.rs
+++ b/crates/bevy_time/src/fixed.rs
@@ -249,12 +249,12 @@ pub fn run_fixed_main_schedule(world: &mut World) {
     // Run the schedule until we run out of accumulated time
     let _ = world.try_schedule_scope(FixedMain, |world, schedule| {
         while world.resource_mut::<Time<Fixed>>().expend() {
-            *world.resource_mut::<Time>() = world.resource::<Time<Fixed>>().as_generic();
+            *world.resource_mut::<Time>() = world.resource::<Time<Fixed>>().as_other();
             schedule.run(world);
         }
     });
 
-    *world.resource_mut::<Time>() = world.resource::<Time<Virtual>>().as_generic();
+    *world.resource_mut::<Time>() = world.resource::<Time<Virtual>>().as_other();
 }
 
 #[cfg(test)]
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index 37634ba8b24df..e49f8cdde0359 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -17,6 +17,7 @@ pub mod common_conditions;
 mod fixed;
 mod real;
 mod stopwatch;
+mod strange_times;
 mod time;
 mod timer;
 mod virt;
@@ -24,7 +25,8 @@ mod virt;
 pub use fixed::*;
 pub use real::*;
 pub use stopwatch::*;
-pub use time::*;
+pub use strange_times::*;
+pub use time::{Time, TimeDuration, TimeDurationPrecompute};
 pub use timer::*;
 pub use virt::*;
 
@@ -67,6 +69,10 @@ impl Plugin for TimePlugin {
             .init_resource::<Time<Real>>()
             .init_resource::<Time<Virtual>>()
             .init_resource::<Time<Fixed>>()
+            .init_resource::<Time<TimeTravel>>()
+            .init_resource::<Time<Stepped, u32>>()
+            .init_resource::<Time<SteppedVirtual, u32>>()
+            .init_resource::<Time<SteppedTimeTravel, u32>>()
             .init_resource::<TimeUpdateStrategy>();
 
         #[cfg(feature = "bevy_reflect")]
@@ -74,12 +80,16 @@ impl Plugin for TimePlugin {
             app.register_type::<Time>()
                 .register_type::<Time<Real>>()
                 .register_type::<Time<Virtual>>()
-                .register_type::<Time<Fixed>>();
+                .register_type::<Time<Fixed>>()
+                .register_type::<Time<TimeTravel>>()
+                .register_type::<Time<Stepped, u32>>()
+                .register_type::<Time<SteppedVirtual, u32>>()
+                .register_type::<Time<SteppedTimeTravel, u32>>();
         }
 
         app.add_systems(
             First,
-            time_system
+            (time_system, stepped_time_system)
                 .in_set(TimeSystems)
                 .ambiguous_with(message_update_system),
         )
@@ -145,6 +155,7 @@ pub fn time_system(
     mut virtual_time: ResMut<Time<Virtual>>,
     fixed_time: Res<Time<Fixed>>,
     mut time: ResMut<Time>,
+    mut time_travel: ResMut<Time<TimeTravel>>,
     update_strategy: Res<TimeUpdateStrategy>,
     #[cfg(feature = "std")] time_recv: Option<Res<TimeReceiver>>,
     #[cfg(feature = "std")] mut has_received_time: Local<bool>,
@@ -181,6 +192,18 @@ pub fn time_system(
     }
 
     update_virtual_time(&mut time, &mut virtual_time, &real_time);
+    time_travel.advance_by(time.delta);
+}
+
+/// The system used to update the [`Time`] over stepped contexts.
+pub fn stepped_time_system(
+    mut virtual_time: ResMut<Time<SteppedVirtual, u32>>,
+    mut time: ResMut<Time<Stepped, u32>>,
+    mut time_travel: ResMut<Time<SteppedTimeTravel, u32>>,
+) {
+    virtual_time.advance_with_step_count(1);
+    *time = virtual_time.as_other();
+    time_travel.advance_by(time.delta);
 }
 
 #[cfg(test)]
diff --git a/crates/bevy_time/src/strange_times.rs b/crates/bevy_time/src/strange_times.rs
new file mode 100644
index 0000000000000..b0c90a8b51a50
--- /dev/null
+++ b/crates/bevy_time/src/strange_times.rs
@@ -0,0 +1,161 @@
+use core::time::Duration;
+
+#[cfg(feature = "bevy_reflect")]
+use bevy_reflect::Reflect;
+
+use crate::{Time, TimeDuration, TimeDurationPrecompute};
+
+/// Stepped time, augmented by 1 every frame
+#[derive(Debug, Copy, Clone, Default)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Clone))]
+pub struct Stepped;
+
+/// Stepped time, augmented by a relative speed every frame
+#[derive(Debug, Copy, Clone)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Clone))]
+pub struct SteppedVirtual {
+    paused: bool,
+    relative_speed: u32,
+    effective_speed: u32,
+}
+
+impl Default for SteppedVirtual {
+    fn default() -> Self {
+        Self {
+            paused: false,
+            relative_speed: 1,
+            effective_speed: 1,
+        }
+    }
+}
+
+impl TimeDuration for u32 {
+    type Precompute = ();
+
+    const ZERO: Self = 0;
+
+    const DEFAULT_WRAP_PERIOD: Self = u32::MAX;
+
+    fn wrap(value: Self, wrap_period: Self) -> Self {
+        value % wrap_period
+    }
+}
+
+impl Time<SteppedVirtual, u32> {
+    /// Returns the speed the clock advances relative to the number of frames.
+    #[inline]
+    pub fn relative_speed(&self) -> u32 {
+        self.context().relative_speed
+    }
+
+    /// Returns the speed the clock advanced relative to the number of frames in
+    /// this update.
+    ///
+    /// Returns `0` if the game was paused or what the `relative_speed` value
+    /// was at the start of this update.
+    #[inline]
+    pub fn effective_speed(&self) -> u32 {
+        self.context().effective_speed
+    }
+
+    /// Sets the speed the clock advances relative to the number of frames.
+    ///
+    /// For example, setting this to `2` will make the clock advance twice as fast as the
+    /// number of frames.
+    #[inline]
+    pub fn set_relative_speed(&mut self, ratio: u32) {
+        self.context_mut().relative_speed = ratio;
+    }
+
+    /// Stops the clock, preventing it from advancing until resumed.
+    #[inline]
+    pub fn pause(&mut self) {
+        self.context_mut().paused = true;
+    }
+
+    /// Resumes the clock if paused.
+    #[inline]
+    pub fn unpause(&mut self) {
+        self.context_mut().paused = false;
+    }
+
+    /// Returns `true` if the clock is currently paused.
+    #[inline]
+    pub fn is_paused(&self) -> bool {
+        self.context().paused
+    }
+
+    /// Returns `true` if the clock was paused at the start of this update.
+    #[inline]
+    pub fn was_paused(&self) -> bool {
+        self.context().effective_speed == 0
+    }
+
+    pub(crate) fn advance_with_step_count(&mut self, step_count: u32) {
+        let effective_speed = if self.context().paused {
+            0
+        } else {
+            self.context().relative_speed
+        };
+        let delta = step_count * effective_speed;
+        self.context_mut().effective_speed = effective_speed;
+        self.advance_by(delta);
+    }
+}
+
+/// Stepped time that can go back.
+#[derive(Debug, Copy, Clone, Default)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Clone))]
+pub struct SteppedTimeTravel;
+
+impl Time<SteppedTimeTravel, u32> {
+    /// Set the time to a specific value.
+    pub fn set_to(&mut self, target: u32) {
+        if target > self.elapsed {
+            self.advance_by(target - self.elapsed);
+        } else {
+            assert!(
+                self.elapsed > target,
+                "tried to move time backwards to before the start"
+            );
+            self.recede_by(self.elapsed - target);
+        }
+    }
+
+    /// Recede the time by a specific amount.
+    pub fn recede_by(&mut self, delta: u32) {
+        self.delta = delta;
+        self.elapsed -= delta;
+        self.elapsed_wrapped = u32::wrap(self.elapsed, self.wrap_period);
+    }
+}
+
+/// Time that can go back.
+#[derive(Debug, Copy, Clone, Default)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Clone))]
+pub struct TimeTravel;
+
+impl Time<TimeTravel, Duration> {
+    /// Set the time to a specific duration.
+    pub fn set_to(&mut self, target: Duration) {
+        if self.elapsed <= target {
+            self.advance_by(target - self.elapsed);
+        } else {
+            assert!(
+                self.elapsed > target,
+                "tried to move time backwards to before the start"
+            );
+            self.recede_by(self.elapsed - target);
+        }
+    }
+
+    /// Recede the time by a specific amount.
+    pub fn recede_by(&mut self, delta: Duration) {
+        self.delta = delta;
+        self.precompute.update_delta(self.delta);
+        self.elapsed -= delta;
+        self.precompute.update_elapsed(self.elapsed);
+        self.elapsed_wrapped = Duration::wrap(self.elapsed, self.wrap_period);
+        self.precompute.update_elapsed_wrapped(self.elapsed_wrapped);
+    }
+}
diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index 1494afaadfddc..edac80986b592 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -1,5 +1,9 @@
 use bevy_ecs::resource::Resource;
-use core::time::Duration;
+use core::{
+    ops::{Add, AddAssign, Sub},
+    time::Duration,
+};
+
 #[cfg(feature = "bevy_reflect")]
 use {
     bevy_ecs::reflect::ReflectResource,
@@ -151,7 +155,7 @@ use {
 ///
 /// You can also replace the "generic" `Time` clock resource if the "default"
 /// time for your game should not be the default virtual time provided. You can
-/// get a "generic" snapshot of your clock by calling `as_generic()` and then
+/// get a "generic" snapshot of your clock by calling `as_other()` and then
 /// overwrite the [`Time`] resource with it. The default systems added by
 /// [`TimePlugin`](crate::TimePlugin) will overwrite the [`Time`] clock during
 /// [`First`](bevy_app::First) and [`FixedUpdate`](bevy_app::FixedUpdate)
@@ -189,26 +193,102 @@ use {
 /// ```
 #[derive(Resource, Debug, Copy, Clone)]
 #[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Resource, Default))]
-pub struct Time<T: Default = ()> {
-    context: T,
-    wrap_period: Duration,
-    delta: Duration,
-    delta_secs: f32,
-    delta_secs_f64: f64,
-    elapsed: Duration,
-    elapsed_secs: f32,
-    elapsed_secs_f64: f64,
-    elapsed_wrapped: Duration,
-    elapsed_secs_wrapped: f32,
-    elapsed_secs_wrapped_f64: f64,
+pub struct Time<CONTEXT: Default = (), STEP: TimeDuration = Duration> {
+    pub(crate) context: CONTEXT,
+    pub(crate) wrap_period: STEP,
+    pub(crate) delta: STEP,
+    pub(crate) elapsed: STEP,
+    pub(crate) elapsed_wrapped: STEP,
+    pub(crate) precompute: STEP::Precompute,
+}
+
+/// Type that represents a duration of time.
+pub trait TimeDuration:
+    Default + Clone + Copy + PartialOrd + Add<Self> + AddAssign<Self> + Sub<Self, Output = Self>
+{
+    /// Used to store precomputed value about the time elapsed and the duration
+    type Precompute: TimeDurationPrecompute<Self>;
+    /// Empty duration
+    const ZERO: Self;
+    /// Default duration for a wrap period
+    const DEFAULT_WRAP_PERIOD: Self;
+
+    /// Wrap the given duration within the specified period.
+    fn wrap(value: Self, wrap_period: Self) -> Self;
+
+    /// Is this duration empty
+    fn is_zero(&self) -> bool {
+        *self == Self::ZERO
+    }
+}
+
+/// Type that represents a precomputed value about the time elapsed and the duration
+pub trait TimeDurationPrecompute<STEP>: Default + Clone + Copy {
+    /// Update the precomputed value with the given delta.
+    fn update_delta(&mut self, delta: STEP);
+    /// Update the precomputed value with the given elapsed time.
+    fn update_elapsed(&mut self, elapsed: STEP);
+    /// Update the precomputed value with the given elapsed time and wrap period.
+    fn update_elapsed_wrapped(&mut self, elapsed: STEP);
+}
+
+impl<STEP> TimeDurationPrecompute<STEP> for () {
+    fn update_delta(&mut self, _delta: STEP) {}
+    fn update_elapsed(&mut self, _elapsed: STEP) {}
+    fn update_elapsed_wrapped(&mut self, _elapsed: STEP) {}
 }
 
-impl<T: Default> Time<T> {
+#[derive(Default, Clone, Copy)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Default))]
+pub struct DurationPreCompute {
+    delta_f32: f32,
+    delta_f64: f64,
+    elapsed_f32: f32,
+    elapsed_f64: f64,
+    elapsed_wrapped_f32: f32,
+    elapsed_wrapped_f64: f64,
+}
+
+impl TimeDurationPrecompute<Duration> for DurationPreCompute {
+    #[inline]
+    fn update_delta(&mut self, delta: Duration) {
+        self.delta_f32 = delta.as_secs_f32();
+        self.delta_f64 = delta.as_secs_f64();
+    }
+
+    #[inline]
+    fn update_elapsed(&mut self, elapsed: Duration) {
+        self.elapsed_f32 = elapsed.as_secs_f32();
+        self.elapsed_f64 = elapsed.as_secs_f64();
+    }
+
+    #[inline]
+    fn update_elapsed_wrapped(&mut self, elapsed_wrapped: Duration) {
+        self.elapsed_wrapped_f32 = elapsed_wrapped.as_secs_f32();
+        self.elapsed_wrapped_f64 = elapsed_wrapped.as_secs_f64();
+    }
+}
+
+impl TimeDuration for Duration {
+    type Precompute = DurationPreCompute;
+    const ZERO: Duration = Duration::ZERO;
     const DEFAULT_WRAP_PERIOD: Duration = Duration::from_secs(3600); // 1 hour
 
+    fn wrap(dividend: Duration, divisor: Duration) -> Duration {
+        // `Duration` does not have a built-in modulo operation
+        let quotient = (dividend.as_nanos() / divisor.as_nanos()) as u32;
+        dividend - (quotient * divisor)
+    }
+
+    fn is_zero(&self) -> bool {
+        self.is_zero()
+    }
+}
+
+impl<CONTEXT: Default, STEP: TimeDuration> Time<CONTEXT, STEP> {
     /// Create a new clock from context with [`Self::delta`] and [`Self::elapsed`] starting from
     /// zero.
-    pub fn new_with(context: T) -> Self {
+    pub fn new_with(context: CONTEXT) -> Self {
         Self {
             context,
             ..Default::default()
@@ -220,16 +300,13 @@ impl<T: Default> Time<T> {
     /// The added duration will be returned by [`Self::delta`] and
     /// [`Self::elapsed`] will be increased by the duration. Adding
     /// [`Duration::ZERO`] is allowed and will set [`Self::delta`] to zero.
-    pub fn advance_by(&mut self, delta: Duration) {
+    pub fn advance_by(&mut self, delta: STEP) {
         self.delta = delta;
-        self.delta_secs = self.delta.as_secs_f32();
-        self.delta_secs_f64 = self.delta.as_secs_f64();
+        self.precompute.update_delta(self.delta);
         self.elapsed += delta;
-        self.elapsed_secs = self.elapsed.as_secs_f32();
-        self.elapsed_secs_f64 = self.elapsed.as_secs_f64();
-        self.elapsed_wrapped = duration_rem(self.elapsed, self.wrap_period);
-        self.elapsed_secs_wrapped = self.elapsed_wrapped.as_secs_f32();
-        self.elapsed_secs_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
+        self.precompute.update_elapsed(self.elapsed);
+        self.elapsed_wrapped = STEP::wrap(self.elapsed, self.wrap_period);
+        self.precompute.update_elapsed_wrapped(self.elapsed_wrapped);
     }
 
     /// Advance this clock to a specific `elapsed` time.
@@ -241,7 +318,7 @@ impl<T: Default> Time<T> {
     /// # Panics
     ///
     /// Panics if `elapsed` is less than `Self::elapsed()`.
-    pub fn advance_to(&mut self, elapsed: Duration) {
+    pub fn advance_to(&mut self, elapsed: STEP) {
         assert!(
             elapsed >= self.elapsed,
             "tried to move time backwards to an earlier elapsed moment"
@@ -253,7 +330,7 @@ impl<T: Default> Time<T> {
     ///
     /// **Note:** The default modulus is one hour.
     #[inline]
-    pub fn wrap_period(&self) -> Duration {
+    pub fn wrap_period(&self) -> STEP {
         self.wrap_period
     }
 
@@ -265,7 +342,7 @@ impl<T: Default> Time<T> {
     ///
     /// Panics if `wrap_period` is a zero-length duration.
     #[inline]
-    pub fn set_wrap_period(&mut self, wrap_period: Duration) {
+    pub fn set_wrap_period(&mut self, wrap_period: STEP) {
         assert!(!wrap_period.is_zero(), "division by zero");
         self.wrap_period = wrap_period;
     }
@@ -273,28 +350,62 @@ impl<T: Default> Time<T> {
     /// Returns how much time has advanced since the last [`update`](#method.update), as a
     /// [`Duration`].
     #[inline]
-    pub fn delta(&self) -> Duration {
+    pub fn delta(&self) -> STEP {
         self.delta
     }
 
+    /// Returns how much time has advanced since [`startup`](#method.startup), as [`Duration`].
+    #[inline]
+    pub fn elapsed(&self) -> STEP {
+        self.elapsed
+    }
+
+    /// Returns how much time has advanced since [`startup`](#method.startup) modulo
+    /// the [`wrap_period`](#method.wrap_period), as [`Duration`].
+    #[inline]
+    pub fn elapsed_wrapped(&self) -> STEP {
+        self.elapsed_wrapped
+    }
+
+    /// Returns a reference to the context of this specific clock.
+    #[inline]
+    pub fn context(&self) -> &CONTEXT {
+        &self.context
+    }
+
+    /// Returns a mutable reference to the context of this specific clock.
+    #[inline]
+    pub fn context_mut(&mut self) -> &mut CONTEXT {
+        &mut self.context
+    }
+
+    /// Returns a copy of this clock as fully generic clock without context.
+    #[inline]
+    pub fn as_other<OtherContext: Default>(&self) -> Time<OtherContext, STEP> {
+        Time {
+            context: OtherContext::default(),
+            wrap_period: self.wrap_period,
+            delta: self.delta,
+            elapsed: self.elapsed,
+            elapsed_wrapped: self.elapsed_wrapped,
+            precompute: self.precompute,
+        }
+    }
+}
+
+impl<CONTEXT: Default> Time<CONTEXT, Duration> {
     /// Returns how much time has advanced since the last [`update`](#method.update), as [`f32`]
     /// seconds.
     #[inline]
     pub fn delta_secs(&self) -> f32 {
-        self.delta_secs
+        self.precompute.delta_f32
     }
 
     /// Returns how much time has advanced since the last [`update`](#method.update), as [`f64`]
     /// seconds.
     #[inline]
     pub fn delta_secs_f64(&self) -> f64 {
-        self.delta_secs_f64
-    }
-
-    /// Returns how much time has advanced since [`startup`](#method.startup), as [`Duration`].
-    #[inline]
-    pub fn elapsed(&self) -> Duration {
-        self.elapsed
+        self.precompute.delta_f64
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`f32`] seconds.
@@ -304,20 +415,13 @@ impl<T: Default> Time<T> {
     /// use [`elapsed_secs_wrapped`](#method.elapsed_secs_wrapped).
     #[inline]
     pub fn elapsed_secs(&self) -> f32 {
-        self.elapsed_secs
+        self.precompute.elapsed_f32
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`f64`] seconds.
     #[inline]
     pub fn elapsed_secs_f64(&self) -> f64 {
-        self.elapsed_secs_f64
-    }
-
-    /// Returns how much time has advanced since [`startup`](#method.startup) modulo
-    /// the [`wrap_period`](#method.wrap_period), as [`Duration`].
-    #[inline]
-    pub fn elapsed_wrapped(&self) -> Duration {
-        self.elapsed_wrapped
+        self.precompute.elapsed_f64
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup) modulo
@@ -327,71 +431,30 @@ impl<T: Default> Time<T> {
     /// suffer from the gradual precision loss of [`elapsed_secs`](#method.elapsed_secs).
     #[inline]
     pub fn elapsed_secs_wrapped(&self) -> f32 {
-        self.elapsed_secs_wrapped
+        self.precompute.elapsed_wrapped_f32
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup) modulo
     /// the [`wrap_period`](#method.wrap_period), as [`f64`] seconds.
     #[inline]
     pub fn elapsed_secs_wrapped_f64(&self) -> f64 {
-        self.elapsed_secs_wrapped_f64
-    }
-
-    /// Returns a reference to the context of this specific clock.
-    #[inline]
-    pub fn context(&self) -> &T {
-        &self.context
-    }
-
-    /// Returns a mutable reference to the context of this specific clock.
-    #[inline]
-    pub fn context_mut(&mut self) -> &mut T {
-        &mut self.context
-    }
-
-    /// Returns a copy of this clock as fully generic clock without context.
-    #[inline]
-    pub fn as_generic(&self) -> Time<()> {
-        Time {
-            context: (),
-            wrap_period: self.wrap_period,
-            delta: self.delta,
-            delta_secs: self.delta_secs,
-            delta_secs_f64: self.delta_secs_f64,
-            elapsed: self.elapsed,
-            elapsed_secs: self.elapsed_secs,
-            elapsed_secs_f64: self.elapsed_secs_f64,
-            elapsed_wrapped: self.elapsed_wrapped,
-            elapsed_secs_wrapped: self.elapsed_secs_wrapped,
-            elapsed_secs_wrapped_f64: self.elapsed_secs_wrapped_f64,
-        }
+        self.precompute.elapsed_wrapped_f64
     }
 }
 
-impl<T: Default> Default for Time<T> {
+impl<CONTEXT: Default, STEP: Default + TimeDuration> Default for Time<CONTEXT, STEP> {
     fn default() -> Self {
         Self {
             context: Default::default(),
-            wrap_period: Self::DEFAULT_WRAP_PERIOD,
-            delta: Duration::ZERO,
-            delta_secs: 0.0,
-            delta_secs_f64: 0.0,
-            elapsed: Duration::ZERO,
-            elapsed_secs: 0.0,
-            elapsed_secs_f64: 0.0,
-            elapsed_wrapped: Duration::ZERO,
-            elapsed_secs_wrapped: 0.0,
-            elapsed_secs_wrapped_f64: 0.0,
+            wrap_period: STEP::DEFAULT_WRAP_PERIOD,
+            delta: STEP::ZERO,
+            elapsed: STEP::ZERO,
+            elapsed_wrapped: STEP::ZERO,
+            precompute: STEP::Precompute::default(),
         }
     }
 }
 
-fn duration_rem(dividend: Duration, divisor: Duration) -> Duration {
-    // `Duration` does not have a built-in modulo operation
-    let quotient = (dividend.as_nanos() / divisor.as_nanos()) as u32;
-    dividend - (quotient * divisor)
-}
-
 #[cfg(test)]
 mod test {
     use super::*;
@@ -400,7 +463,7 @@ mod test {
     fn test_initial_state() {
         let time: Time = Time::default();
 
-        assert_eq!(time.wrap_period(), Time::<()>::DEFAULT_WRAP_PERIOD);
+        assert_eq!(time.wrap_period(), Duration::DEFAULT_WRAP_PERIOD);
         assert_eq!(time.delta(), Duration::ZERO);
         assert_eq!(time.delta_secs(), 0.0);
         assert_eq!(time.delta_secs_f64(), 0.0);
diff --git a/crates/bevy_time/src/virt.rs b/crates/bevy_time/src/virt.rs
index 45fa4c23eb987..7eaf6d1ff095d 100644
--- a/crates/bevy_time/src/virt.rs
+++ b/crates/bevy_time/src/virt.rs
@@ -280,7 +280,7 @@ impl Default for Virtual {
 pub fn update_virtual_time(current: &mut Time, virt: &mut Time<Virtual>, real: &Time<Real>) {
     let raw_delta = real.delta();
     virt.advance_with_raw_delta(raw_delta);
-    *current = virt.as_generic();
+    *current = virt.as_other();
 }
 
 #[cfg(test)]
diff --git a/examples/README.md b/examples/README.md
index f639f6b50adbc..ac4867b63e564 100644
--- a/examples/README.md
+++ b/examples/README.md
@@ -539,6 +539,8 @@ Example | Description
 
 Example | Description
 --- | ---
+[Groundhog Day](../examples/time/groundhog_day.rs) | Shows how `Time<TimeTravel>` can be used to go back in time.
+[Stepped Simulation](../examples/time/stepped_simulation.rs) | Shows how `Time<SteppedTimeTravel>` can be used to track a simulation.
 [Time handling](../examples/time/time.rs) | Explains how Time is handled in ECS
 [Timers](../examples/time/timers.rs) | Illustrates ticking `Timer` resources inside systems and handling their state
 [Virtual time](../examples/time/virtual_time.rs) | Shows how `Time<Virtual>` can be used to pause, resume, slow down and speed up a game.
diff --git a/examples/time/groundhog_day.rs b/examples/time/groundhog_day.rs
new file mode 100644
index 0000000000000..80fab42d84c5c
--- /dev/null
+++ b/examples/time/groundhog_day.rs
@@ -0,0 +1,168 @@
+//! Shows how `Time<TimeTravel>` can be used to go back in time.
+
+use std::time::Duration;
+
+use bevy::{
+    color::palettes::css::*,
+    prelude::*,
+    time::{common_conditions::on_real_timer, TimeTravel},
+};
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+#[derive(Resource, Deref, DerefMut)]
+struct SeededRng(ChaCha8Rng);
+impl Default for SeededRng {
+    fn default() -> Self {
+        Self(ChaCha8Rng::seed_from_u64(10223163112))
+    }
+}
+
+#[derive(Resource)]
+struct TimeOfReset(Duration);
+
+const START: Duration = Duration::from_hours(6);
+const END: Duration = Duration::from_mins(START.as_secs() / 60 + 5);
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .init_resource::<SeededRng>()
+        .add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (
+                progress,
+                (
+                    update_virtual_time_info_text,
+                    update_real_time_info_text,
+                    reset,
+                )
+                    .run_if(on_real_timer(Duration::from_millis(250))),
+            ),
+        )
+        .run();
+}
+
+/// `Real` time related marker
+#[derive(Component)]
+struct RealTime;
+
+/// `Virtual` time related marker
+#[derive(Component)]
+struct VirtualTime;
+
+fn setup(
+    mut commands: Commands,
+    mut time: ResMut<Time<Virtual>>,
+    mut time_travel: ResMut<Time<TimeTravel>>,
+    mut rng: ResMut<SeededRng>,
+) {
+    time.set_relative_speed(25.);
+
+    time_travel.advance_to(START);
+
+    commands.insert_resource(TimeOfReset(rng.random_range(START..END)));
+
+    commands.spawn(Camera2d);
+
+    // info UI
+    let font_size = 33.;
+
+    commands.spawn((
+        Node {
+            display: Display::Flex,
+            justify_content: JustifyContent::SpaceBetween,
+            width: percent(100),
+            position_type: PositionType::Absolute,
+            top: px(0),
+            padding: UiRect::all(px(20)),
+            ..default()
+        },
+        children![
+            (
+                Text::default(),
+                TextFont {
+                    font_size,
+                    ..default()
+                },
+                RealTime,
+            ),
+            (
+                Text::default(),
+                TextFont {
+                    font_size,
+                    ..default()
+                },
+                TextColor(GOLD.into()),
+                TextLayout::new_with_justify(Justify::Right),
+                VirtualTime,
+            ),
+        ],
+    ));
+}
+
+/// Update the `Real` time info text
+fn update_real_time_info_text(time: Res<Time<Real>>, mut query: Query<&mut Text, With<RealTime>>) {
+    for mut text in &mut query {
+        **text = format!("REAL TIME\nElapsed: {:.1?}", time.elapsed());
+    }
+}
+
+/// Update the `Virtual` time info text
+fn update_virtual_time_info_text(
+    time: Res<Time<TimeTravel>>,
+    end_of_day: Res<TimeOfReset>,
+    mut query: Query<&mut Text, With<VirtualTime>>,
+) {
+    for mut text in &mut query {
+        **text = format!(
+            "LOOPING TIME\nTime: {}\nLoop At: {}",
+            pretty_duration(time.elapsed()),
+            pretty_duration(end_of_day.0),
+        );
+    }
+}
+
+fn pretty_duration(duration: Duration) -> String {
+    let secs = duration.as_secs();
+    format!(
+        "{:2}h{:2}m{:2}s",
+        (secs / 3600) % 24,
+        (secs / 60) % 60,
+        secs % 60
+    )
+}
+
+fn reset(
+    mut time: ResMut<Time<TimeTravel>>,
+    mut end_of_day: ResMut<TimeOfReset>,
+    mut rng: ResMut<SeededRng>,
+) {
+    if time.elapsed() > end_of_day.0 {
+        time.set_to(START);
+        end_of_day.0 = rng.random_range(START..END);
+    }
+}
+
+fn progress(time: Res<Time<TimeTravel>>, end_of_day: Res<TimeOfReset>, mut gizmos: Gizmos) {
+    let total = (END - START).as_secs();
+    let target = (end_of_day.0 - START).as_secs();
+    let current = (time.elapsed() - START).as_secs();
+    // println!("{} -> {} / {}", current, target, total);
+
+    let width = 500.0;
+    let position = |value: u64| (value as f32 / total as f32) * width - width / 2.0;
+
+    gizmos.rect_2d(Isometry2d::default(), Vec2::new(500.0, 5.0), BLUE);
+    gizmos.line_2d(
+        Vec2::new(position(0), 0.0),
+        Vec2::new(position(current), 0.0),
+        GREEN,
+    );
+    gizmos.line_2d(
+        Vec2::new(position(target), -10.0),
+        Vec2::new(position(target), 10.0),
+        RED,
+    );
+}
diff --git a/examples/time/stepped_simulation.rs b/examples/time/stepped_simulation.rs
new file mode 100644
index 0000000000000..49978818a47d2
--- /dev/null
+++ b/examples/time/stepped_simulation.rs
@@ -0,0 +1,172 @@
+//! Shows how to use `Time<SteppedTimeTravel, u32>` to track a simulation,
+//! and be able to move forward or backward.
+
+use bevy::{
+    color::palettes::css::*,
+    input::common_conditions::input_just_pressed,
+    prelude::*,
+    time::{SteppedTimeTravel, SteppedVirtual},
+};
+use rand::{Rng, SeedableRng};
+use rand_chacha::ChaCha8Rng;
+
+fn main() {
+    App::new()
+        .add_plugins(DefaultPlugins)
+        .add_systems(Startup, setup)
+        .add_systems(
+            Update,
+            (
+                apply_cost,
+                update_virtual_time_info_text,
+                manual_progress::<1>.run_if(input_just_pressed(KeyCode::ArrowRight)),
+                manual_progress::<-1>.run_if(input_just_pressed(KeyCode::ArrowLeft)),
+            ),
+        )
+        .run();
+}
+
+#[derive(Component)]
+struct Steps;
+
+#[derive(Component)]
+struct Task;
+
+#[derive(Resource)]
+struct TasksCost(Vec<u32>);
+
+#[derive(Resource)]
+struct CurrentTask(usize);
+
+const TASK_COLOR: Color = Color::srgb(0.21, 0.21, 0.21);
+const TASK_COLOR_DONE: Color = Color::srgb(0.21, 0.8, 0.21);
+
+fn setup(mut commands: Commands, mut time: ResMut<Time<SteppedVirtual, u32>>) {
+    time.pause();
+
+    commands.spawn(Camera2d);
+
+    let mut rng = ChaCha8Rng::seed_from_u64(10223163112);
+
+    let mut tasks_cost = vec![0];
+    tasks_cost.extend((0..20).map(|_| rng.random_range(3..10)));
+
+    commands.insert_resource(TasksCost(tasks_cost.clone()));
+    commands.insert_resource(CurrentTask(0));
+
+    commands
+        .spawn((Node {
+            display: Display::Flex,
+            justify_content: JustifyContent::SpaceBetween,
+            align_items: AlignItems::End,
+            width: percent(100),
+            position_type: PositionType::Absolute,
+            top: percent(50),
+            padding: UiRect::all(px(20)),
+            ..default()
+        },))
+        .with_children(|spawner| {
+            tasks_cost.iter().for_each(|cost| {
+                spawner.spawn((
+                    Node {
+                        width: px(30),
+                        height: px(25 * cost),
+                        ..default()
+                    },
+                    BackgroundColor(TASK_COLOR),
+                    Text::new(format!("{}", cost)),
+                    Task,
+                    TextLayout::new_with_justify(Justify::Center),
+                ));
+            });
+        });
+
+    // info UI
+    let font_size = 33.;
+
+    commands.spawn((
+        Node {
+            display: Display::Flex,
+            justify_content: JustifyContent::SpaceBetween,
+            width: percent(100),
+            position_type: PositionType::Absolute,
+            top: px(0),
+            padding: UiRect::all(px(20)),
+            ..default()
+        },
+        children![
+            (
+                Text::new("CONTROLS\nNext Task: Right\nPrevious Task: Left"),
+                TextFont {
+                    font_size,
+                    ..default()
+                },
+                TextColor(Color::srgb(0.85, 0.85, 0.85)),
+                TextLayout::new_with_justify(Justify::Center),
+            ),
+            (
+                Text::default(),
+                TextFont {
+                    font_size,
+                    ..default()
+                },
+                TextColor(GOLD.into()),
+                TextLayout::new_with_justify(Justify::Right),
+                Steps,
+            ),
+        ],
+    ));
+}
+
+/// Update the `Virtual` time info text
+fn update_virtual_time_info_text(
+    time: Res<Time<SteppedTimeTravel, u32>>,
+    mut query: Query<&mut Text, With<Steps>>,
+) {
+    if time.is_changed() {
+        for mut text in &mut query {
+            **text = format!("Steps: {:3}", time.elapsed());
+        }
+    }
+}
+
+fn apply_cost(
+    mut time: ResMut<Time<SteppedTimeTravel, u32>>,
+    mut current_task: ResMut<CurrentTask>,
+    tasks_cost: Res<TasksCost>,
+    mut task_boxes: Query<&mut BackgroundColor, With<Task>>,
+    mut last_task: Local<usize>,
+) {
+    if !current_task.is_changed() {
+        return;
+    }
+
+    if current_task.0 == tasks_cost.0.len() {
+        for mut background in &mut task_boxes {
+            background.0 = TASK_COLOR;
+        }
+        current_task.0 = 0;
+        *last_task = 0;
+        time.set_to(0);
+        return;
+    }
+
+    for (i, mut background) in task_boxes.iter_mut().enumerate() {
+        if i < current_task.0 + 1 {
+            background.0 = TASK_COLOR_DONE;
+        } else {
+            background.0 = TASK_COLOR;
+        }
+    }
+
+    if current_task.0 > *last_task {
+        time.advance_by(tasks_cost.0[current_task.0]);
+    } else {
+        time.recede_by(tasks_cost.0[*last_task]);
+    }
+    *last_task = current_task.0;
+}
+
+fn manual_progress<const DELTA: i8>(mut current_task: ResMut<CurrentTask>) {
+    current_task.0 = (current_task.0 as i8 + DELTA).clamp(0, 21) as usize;
+}