diff --git a/crates/bevy_time/src/fixed.rs b/crates/bevy_time/src/fixed.rs
index f1c67ea4a0ca9..b1b6398604685 100644
--- a/crates/bevy_time/src/fixed.rs
+++ b/crates/bevy_time/src/fixed.rs
@@ -10,7 +10,7 @@ use crate::{time::Time, virt::Virtual};
 ///
 /// A specialization of the [`Time`] structure. **For method documentation, see
 /// [`Time<Fixed>#impl-Time<Fixed>`].**
-///     
+///
 /// It is automatically inserted as a resource by
 /// [`TimePlugin`](crate::TimePlugin) and updated based on
 /// [`Time<Virtual>`](Virtual). The fixed clock is automatically set as the
@@ -243,12 +243,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 3d515597ac6e8..238369e1af4e3 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::*;
 
@@ -71,6 +73,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")]
@@ -78,12 +84,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 real_time: ResMut<Time<Real>>,
     mut virtual_time: ResMut<Time<Virtual>>,
     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>,
@@ -178,6 +189,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..4d7ea464d6345
--- /dev/null
+++ b/crates/bevy_time/src/strange_times.rs
@@ -0,0 +1,151 @@
+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, Default)]
+#[cfg_attr(feature = "bevy_reflect", derive(Reflect), reflect(Clone))]
+pub struct SteppedVirtual {
+    paused: bool,
+    relative_speed: u32,
+    effective_speed: u32,
+}
+
+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..8ffc21d4e91b7 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,
@@ -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 146c754891859..cfc7b8ad7e9b8 100644
--- a/crates/bevy_time/src/virt.rs
+++ b/crates/bevy_time/src/virt.rs
@@ -273,7 +273,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)]