diff --git a/crates/bevy_time/src/common_conditions.rs b/crates/bevy_time/src/common_conditions.rs
index 974de24dfae2ce..b2b0b0c8438cf9 100644
--- a/crates/bevy_time/src/common_conditions.rs
+++ b/crates/bevy_time/src/common_conditions.rs
@@ -1,4 +1,4 @@
-use crate::{fixed_timestep::FixedTime, Time, Timer, TimerMode};
+use crate::{Time, Timer, TimerMode};
 use bevy_ecs::system::Res;
 use bevy_utils::Duration;
 
@@ -40,40 +40,6 @@ pub fn on_timer(duration: Duration) -> impl FnMut(Res<Time>) -> bool + Clone {
     }
 }
 
-/// Run condition that is active on a regular time interval, using [`FixedTime`] to
-/// advance the timer.
-///
-/// If used for a non-fixed timestep system, use [`on_timer`] instead.
-///
-/// ```rust,no_run
-/// # use bevy_app::{App, NoopPluginGroup as DefaultPlugins, PluginGroup, FixedUpdate};
-/// # use bevy_ecs::schedule::IntoSystemConfigs;
-/// # use bevy_utils::Duration;
-/// # use bevy_time::common_conditions::on_fixed_timer;
-/// fn main() {
-///     App::new()
-///         .add_plugins(DefaultPlugins)
-///         .add_systems(FixedUpdate,
-///             tick.run_if(on_fixed_timer(Duration::from_secs(1))),
-///         )
-///         .run();
-/// }
-/// fn tick() {
-///     // ran once a second
-/// }
-/// ```
-///
-/// Note that this run condition may not behave as expected if `duration` is smaller
-/// than the fixed timestep period, since the timer may complete multiple times in
-/// one fixed update.
-pub fn on_fixed_timer(duration: Duration) -> impl FnMut(Res<FixedTime>) -> bool + Clone {
-    let mut timer = Timer::new(duration, TimerMode::Repeating);
-    move |time: Res<FixedTime>| {
-        timer.tick(time.period);
-        timer.just_finished()
-    }
-}
-
 #[cfg(test)]
 mod tests {
     use super::*;
diff --git a/crates/bevy_time/src/fixed.rs b/crates/bevy_time/src/fixed.rs
new file mode 100644
index 00000000000000..e2ec77e79d8b21
--- /dev/null
+++ b/crates/bevy_time/src/fixed.rs
@@ -0,0 +1,64 @@
+use bevy_utils::Duration;
+use bevy_ecs::world::World;
+use bevy_ecs::{reflect::ReflectResource, system::Resource};
+use bevy_reflect::{FromReflect, Reflect};
+
+use crate::FixedUpdate;
+use crate::time::Time;
+use crate::virt::Virtual;
+
+#[derive(Resource, Debug, Copy, Clone, Reflect, FromReflect)]
+#[reflect(Resource)]
+pub struct Fixed {
+    period: Duration,
+    accumulated: Duration,
+}
+
+impl Time<Fixed> {
+    pub fn period(&self) -> Duration {
+        self.context().period
+    }
+
+    pub fn set_period(&mut self, period: Duration) {
+        assert_ne!(period, Duration::ZERO, "attempted to set fixed time period to zero");
+        self.context_mut().period = period;
+    }
+
+    fn expend(&mut self) -> bool {
+        let period = self.period();
+        if let Some(new_value) = self.context_mut().accumulated.checked_sub(period) {
+            // reduce accumulated and increase elapsed by period
+            self.context_mut().accumulated = new_value;
+            self.advance_by(period);
+            true
+        } else {
+            // no more periods left in accumulated
+            false
+        }
+    }
+}
+
+impl Default for Fixed {
+    fn default() -> Self {
+        Self {
+            period: Duration::from_secs_f64(1. / 60.),
+            accumulated: Duration::ZERO,
+        }
+    }
+}
+
+pub fn run_fixed_update_schedule(
+    world: &mut World
+) {
+    let delta = world.resource::<Time<Virtual>>().delta();
+    world.resource_mut::<Time<Fixed>>().context_mut().accumulated += delta;
+
+    // Run the schedule until we run out of accumulated time
+    let _ = world.try_schedule_scope(FixedUpdate, |world, schedule| {
+        while world.resource_mut::<Time<Fixed>>().expend() {
+            world.resource::<Time<Fixed>>().as_current().clone_into(world.resource_mut::<Time>().as_mut());
+            schedule.run(world);
+        }
+    });
+    world.resource::<Time<Virtual>>().as_current().clone_into(world.resource_mut::<Time>().as_mut());
+}
diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
deleted file mode 100644
index 66be2f41ef2ffb..00000000000000
--- a/crates/bevy_time/src/fixed_timestep.rs
+++ /dev/null
@@ -1,158 +0,0 @@
-//! Tools to run systems at a regular interval.
-//! This can be extremely useful for steady, frame-rate independent gameplay logic and physics.
-//!
-//! To run a system on a fixed timestep, add it to the [`FixedUpdate`] [`Schedule`](bevy_ecs::schedule::Schedule).
-//! This schedule is run in [`RunFixedUpdateLoop`](bevy_app::RunFixedUpdateLoop) near the start of each frame,
-//! via the [`run_fixed_update_schedule`] exclusive system.
-//!
-//! This schedule will be run a number of times each frame,
-//! equal to the accumulated divided by the period resource, rounded down,
-//! as tracked in the [`FixedTime`] resource.
-//! Unused time will be carried over.
-//!
-//! This does not guarantee that the time elapsed between executions is exact,
-//! and systems in this schedule can run 0, 1 or more times on any given frame.
-//!
-//! For example, a system with a fixed timestep run criteria of 120 times per second will run
-//! two times during a ~16.667ms frame, once during a ~8.333ms frame, and once every two frames
-//! with ~4.167ms frames. However, the same criteria may not result in exactly 8.333ms passing
-//! between each execution.
-//!
-//! When using fixed time steps, it is advised not to rely on [`Time::delta`] or any of it's
-//! variants for game simulation, but rather use the value of [`FixedTime`] instead.
-
-use crate::Time;
-use bevy_app::FixedUpdate;
-use bevy_ecs::{system::Resource, world::World};
-use bevy_utils::Duration;
-use thiserror::Error;
-
-/// The amount of time that must pass before the fixed timestep schedule is run again.
-#[derive(Resource, Debug)]
-pub struct FixedTime {
-    accumulated: Duration,
-    /// Defaults to 1/60th of a second.
-    /// To configure this value, simply mutate or overwrite this resource.
-    pub period: Duration,
-}
-
-impl FixedTime {
-    /// Creates a new [`FixedTime`] struct
-    pub fn new(period: Duration) -> Self {
-        FixedTime {
-            accumulated: Duration::ZERO,
-            period,
-        }
-    }
-
-    /// Creates a new [`FixedTime`] struct with a period specified in `f32` seconds
-    pub fn new_from_secs(period: f32) -> Self {
-        FixedTime {
-            accumulated: Duration::ZERO,
-            period: Duration::from_secs_f32(period),
-        }
-    }
-
-    /// Adds the `delta_time` to the accumulated time so far.
-    pub fn tick(&mut self, delta_time: Duration) {
-        self.accumulated += delta_time;
-    }
-
-    /// Returns the current amount of accumulated time
-    pub fn accumulated(&self) -> Duration {
-        self.accumulated
-    }
-
-    /// Expends one `period` of accumulated time.
-    ///
-    /// [`Err(FixedUpdateError`)] will be returned if there is
-    /// not enough accumulated time to span an entire period.
-    pub fn expend(&mut self) -> Result<(), FixedUpdateError> {
-        if let Some(new_value) = self.accumulated.checked_sub(self.period) {
-            self.accumulated = new_value;
-            Ok(())
-        } else {
-            Err(FixedUpdateError::NotEnoughTime {
-                accumulated: self.accumulated,
-                period: self.period,
-            })
-        }
-    }
-}
-
-impl Default for FixedTime {
-    fn default() -> Self {
-        FixedTime {
-            accumulated: Duration::ZERO,
-            period: Duration::from_secs_f32(1. / 60.),
-        }
-    }
-}
-
-/// An error returned when working with [`FixedTime`].
-#[derive(Debug, Error)]
-pub enum FixedUpdateError {
-    #[error("At least one period worth of time must be accumulated.")]
-    NotEnoughTime {
-        accumulated: Duration,
-        period: Duration,
-    },
-}
-
-/// Ticks the [`FixedTime`] resource then runs the [`FixedUpdate`].
-pub fn run_fixed_update_schedule(world: &mut World) {
-    // Tick the time
-    let delta_time = world.resource::<Time>().delta();
-    let mut fixed_time = world.resource_mut::<FixedTime>();
-    fixed_time.tick(delta_time);
-
-    // Run the schedule until we run out of accumulated time
-    let _ = world.try_schedule_scope(FixedUpdate, |world, schedule| {
-        while world.resource_mut::<FixedTime>().expend().is_ok() {
-            schedule.run(world);
-        }
-    });
-}
-
-#[cfg(test)]
-mod test {
-    use super::*;
-
-    #[test]
-    fn fixed_time_starts_at_zero() {
-        let new_time = FixedTime::new_from_secs(42.);
-        assert_eq!(new_time.accumulated(), Duration::ZERO);
-
-        let default_time = FixedTime::default();
-        assert_eq!(default_time.accumulated(), Duration::ZERO);
-    }
-
-    #[test]
-    fn fixed_time_ticks_up() {
-        let mut fixed_time = FixedTime::default();
-        fixed_time.tick(Duration::from_secs(1));
-        assert_eq!(fixed_time.accumulated(), Duration::from_secs(1));
-    }
-
-    #[test]
-    fn enough_accumulated_time_is_required() {
-        let mut fixed_time = FixedTime::new(Duration::from_secs(2));
-        fixed_time.tick(Duration::from_secs(1));
-        assert!(fixed_time.expend().is_err());
-        assert_eq!(fixed_time.accumulated(), Duration::from_secs(1));
-
-        fixed_time.tick(Duration::from_secs(1));
-        assert!(fixed_time.expend().is_ok());
-        assert_eq!(fixed_time.accumulated(), Duration::ZERO);
-    }
-
-    #[test]
-    fn repeatedly_expending_time() {
-        let mut fixed_time = FixedTime::new(Duration::from_secs(1));
-        fixed_time.tick(Duration::from_secs_f32(3.2));
-        assert!(fixed_time.expend().is_ok());
-        assert!(fixed_time.expend().is_ok());
-        assert!(fixed_time.expend().is_ok());
-        assert!(fixed_time.expend().is_err());
-    }
-}
diff --git a/crates/bevy_time/src/lib.rs b/crates/bevy_time/src/lib.rs
index 704d54d860452e..442d76de60819a 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -2,13 +2,14 @@
 
 /// Common run conditions
 pub mod common_conditions;
-pub mod fixed_timestep;
 mod stopwatch;
 #[allow(clippy::module_inception)]
 mod time;
 mod timer;
+mod real;
+mod fixed;
+mod virt;
 
-use fixed_timestep::FixedTime;
 pub use stopwatch::*;
 pub use time::*;
 pub use timer::*;
@@ -20,13 +21,17 @@ use crossbeam_channel::{Receiver, Sender};
 pub mod prelude {
     //! The Bevy Time Prelude.
     #[doc(hidden)]
-    pub use crate::{fixed_timestep::FixedTime, Time, Timer, TimerMode};
+    pub use crate::{Time, Timer, TimerMode};
 }
 
 use bevy_app::{prelude::*, RunFixedUpdateLoop};
 use bevy_ecs::prelude::*;
 
-use crate::fixed_timestep::run_fixed_update_schedule;
+use crate::real::Real;
+use crate::virt::Virtual;
+use crate::virt::virtual_time_system;
+use crate::fixed::Fixed;
+use crate::fixed::run_fixed_update_schedule;
 
 /// Adds time functionality to Apps.
 #[derive(Default)]
@@ -40,12 +45,17 @@ pub struct TimeSystem;
 impl Plugin for TimePlugin {
     fn build(&self, app: &mut App) {
         app.init_resource::<Time>()
+            .init_resource::<Time<Real>>()
+            .init_resource::<Time<Virtual>>()
+            .init_resource::<Time<Fixed>>()
             .init_resource::<TimeUpdateStrategy>()
-            .register_type::<Timer>()
             .register_type::<Time>()
+            .register_type::<Time<Real>>()
+            .register_type::<Time<Virtual>>()
+            .register_type::<Time<Fixed>>()
+            .register_type::<Timer>()
             .register_type::<Stopwatch>()
-            .init_resource::<FixedTime>()
-            .add_systems(First, time_system.in_set(TimeSystem))
+            .add_systems(First, (time_system, virtual_time_system.after(time_system)).in_set(TimeSystem))
             .add_systems(RunFixedUpdateLoop, run_fixed_update_schedule);
 
         #[cfg(feature = "bevy_ci_testing")]
@@ -96,7 +106,7 @@ pub fn create_time_channels() -> (TimeSender, TimeReceiver) {
 /// The system used to update the [`Time`] used by app logic. If there is a render world the time is sent from
 /// there to this system through channels. Otherwise the time is updated in this system.
 fn time_system(
-    mut time: ResMut<Time>,
+    mut time: ResMut<Time<Real>>,
     update_strategy: Res<TimeUpdateStrategy>,
     time_recv: Option<Res<TimeReceiver>>,
     mut has_received_time: Local<bool>,
@@ -119,9 +129,6 @@ fn time_system(
     match update_strategy.as_ref() {
         TimeUpdateStrategy::Automatic => time.update_with_instant(new_time),
         TimeUpdateStrategy::ManualInstant(instant) => time.update_with_instant(*instant),
-        TimeUpdateStrategy::ManualDuration(duration) => {
-            let last_update = time.last_update().unwrap_or_else(|| time.startup());
-            time.update_with_instant(last_update + *duration);
-        }
+        TimeUpdateStrategy::ManualDuration(duration) => time.update_with_duration(*duration),
     }
 }
diff --git a/crates/bevy_time/src/real.rs b/crates/bevy_time/src/real.rs
new file mode 100644
index 00000000000000..6a14fe35c01d7a
--- /dev/null
+++ b/crates/bevy_time/src/real.rs
@@ -0,0 +1,46 @@
+use bevy_utils::{Duration, Instant};
+use bevy_ecs::{reflect::ReflectResource, system::Resource};
+use bevy_reflect::{FromReflect, Reflect};
+
+use crate::time::Time;
+
+#[derive(Resource, Debug, Copy, Clone, Reflect, FromReflect)]
+#[reflect(Resource)]
+pub struct Real {
+    startup: Instant,
+    first_update: Option<Instant>,
+    last_update: Option<Instant>,
+}
+
+impl Default for Real {
+    fn default() -> Self {
+        Self {
+            startup: Instant::now(),
+            first_update: None,
+            last_update: None,
+        }
+    }
+}
+
+impl Time<Real> {
+    pub fn update(&mut self) {
+        let instant = Instant::now();
+        self.update_with_instant(instant);
+    }
+
+    pub fn update_with_duration(&mut self, duration: Duration) {
+        let last_update = self.context().last_update.unwrap_or(self.context().startup);
+        self.update_with_instant(last_update + duration);
+    }
+
+    pub fn update_with_instant(&mut self, instant: Instant) {
+        let Some(last_update) = self.context().last_update else {
+            let mut context = self.context_mut();
+            context.first_update = Some(instant);
+            context.last_update = Some(instant);
+            return;
+        };
+        let delta = instant - last_update;
+        self.advance_by(delta);
+    }
+}
diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index f462296ad6aef9..29902a1b40a388 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -1,728 +1,134 @@
 use bevy_ecs::{reflect::ReflectResource, system::Resource};
 use bevy_reflect::{FromReflect, Reflect};
-use bevy_utils::{Duration, Instant};
+use bevy_utils::Duration;
 
-/// A clock that tracks how much it has advanced (and how much real time has elapsed) since
-/// its previous update and since its creation.
-#[derive(Resource, Reflect, FromReflect, Debug, Clone)]
+#[derive(Resource, Debug, Copy, Clone, Reflect, FromReflect)]
 #[reflect(Resource)]
-pub struct Time {
-    startup: Instant,
-    first_update: Option<Instant>,
-    last_update: Option<Instant>,
-    // pausing
-    paused: bool,
-    // scaling
-    relative_speed: f64, // using `f64` instead of `f32` to minimize drift from rounding errors
+pub struct Time<T: Default = ()> {
+    context: T,
+    wrap_seconds: u64,
     delta: Duration,
     delta_seconds: f32,
     delta_seconds_f64: f64,
     elapsed: Duration,
     elapsed_seconds: f32,
     elapsed_seconds_f64: f64,
-    raw_delta: Duration,
-    raw_delta_seconds: f32,
-    raw_delta_seconds_f64: f64,
-    raw_elapsed: Duration,
-    raw_elapsed_seconds: f32,
-    raw_elapsed_seconds_f64: f64,
-    // wrapping
-    wrap_period: Duration,
     elapsed_wrapped: Duration,
     elapsed_seconds_wrapped: f32,
     elapsed_seconds_wrapped_f64: f64,
-    raw_elapsed_wrapped: Duration,
-    raw_elapsed_seconds_wrapped: f32,
-    raw_elapsed_seconds_wrapped_f64: f64,
 }
 
-impl Default for Time {
-    fn default() -> Self {
+impl<T: Default> Time<T> {
+    const DEFAULT_WRAP_SECONDS: u64 = 3600; // 1 hour
+
+    pub fn new(context: T, wrap_seconds: u64) -> Self {
         Self {
-            startup: Instant::now(),
-            first_update: None,
-            last_update: None,
-            paused: false,
-            relative_speed: 1.0,
+            context,
+            wrap_seconds,
             delta: Duration::ZERO,
             delta_seconds: 0.0,
             delta_seconds_f64: 0.0,
             elapsed: Duration::ZERO,
             elapsed_seconds: 0.0,
             elapsed_seconds_f64: 0.0,
-            raw_delta: Duration::ZERO,
-            raw_delta_seconds: 0.0,
-            raw_delta_seconds_f64: 0.0,
-            raw_elapsed: Duration::ZERO,
-            raw_elapsed_seconds: 0.0,
-            raw_elapsed_seconds_f64: 0.0,
-            wrap_period: Duration::from_secs(3600), // 1 hour
             elapsed_wrapped: Duration::ZERO,
             elapsed_seconds_wrapped: 0.0,
             elapsed_seconds_wrapped_f64: 0.0,
-            raw_elapsed_wrapped: Duration::ZERO,
-            raw_elapsed_seconds_wrapped: 0.0,
-            raw_elapsed_seconds_wrapped_f64: 0.0,
         }
     }
-}
-
-impl Time {
-    /// Constructs a new `Time` instance with a specific startup `Instant`.
-    pub fn new(startup: Instant) -> Self {
-        Self {
-            startup,
-            ..Default::default()
-        }
-    }
-
-    /// Updates the internal time measurements.
-    ///
-    /// Calling this method as part of your app will most likely result in inaccurate timekeeping,
-    /// as the `Time` resource is ordinarily managed by the [`TimePlugin`](crate::TimePlugin).
-    pub fn update(&mut self) {
-        let now = Instant::now();
-        self.update_with_instant(now);
-    }
-
-    /// Updates time with a specified [`Instant`].
-    ///
-    /// This method is provided for use in tests. Calling this method as part of your app will most
-    /// likely result in inaccurate timekeeping, as the `Time` resource is ordinarily managed by the
-    /// [`TimePlugin`](crate::TimePlugin).
-    ///
-    /// # Examples
-    ///
-    /// ```
-    /// # use bevy_time::prelude::*;
-    /// # use bevy_ecs::prelude::*;
-    /// # use bevy_utils::Duration;
-    /// # fn main () {
-    /// #     test_health_system();
-    /// # }
-    /// #[derive(Resource)]
-    /// struct Health {
-    ///     // Health value between 0.0 and 1.0
-    ///     health_value: f32,
-    /// }
-    ///
-    /// fn health_system(time: Res<Time>, mut health: ResMut<Health>) {
-    ///     // Increase health value by 0.1 per second, independent of frame rate,
-    ///     // but not beyond 1.0
-    ///     health.health_value = (health.health_value + 0.1 * time.delta_seconds()).min(1.0);
-    /// }
-    ///
-    /// // Mock time in tests
-    /// fn test_health_system() {
-    ///     let mut world = World::default();
-    ///     let mut time = Time::default();
-    ///     time.update();
-    ///     world.insert_resource(time);
-    ///     world.insert_resource(Health { health_value: 0.2 });
-    ///
-    ///     let mut schedule = Schedule::new();
-    ///     schedule.add_systems(health_system);
-    ///
-    ///     // Simulate that 30 ms have passed
-    ///     let mut time = world.resource_mut::<Time>();
-    ///     let last_update = time.last_update().unwrap();
-    ///     time.update_with_instant(last_update + Duration::from_millis(30));
-    ///
-    ///     // Run system
-    ///     schedule.run(&mut world);
-    ///
-    ///     // Check that 0.003 has been added to the health value
-    ///     let expected_health_value = 0.2 + 0.1 * 0.03;
-    ///     let actual_health_value = world.resource::<Health>().health_value;
-    ///     assert_eq!(expected_health_value, actual_health_value);
-    /// }
-    /// ```
-    pub fn update_with_instant(&mut self, instant: Instant) {
-        let raw_delta = instant - self.last_update.unwrap_or(self.startup);
-        let delta = if self.paused {
-            Duration::ZERO
-        } else if self.relative_speed != 1.0 {
-            raw_delta.mul_f64(self.relative_speed)
-        } else {
-            // avoid rounding when at normal speed
-            raw_delta
-        };
-
-        if self.last_update.is_some() {
-            self.delta = delta;
-            self.delta_seconds = self.delta.as_secs_f32();
-            self.delta_seconds_f64 = self.delta.as_secs_f64();
-            self.raw_delta = raw_delta;
-            self.raw_delta_seconds = self.raw_delta.as_secs_f32();
-            self.raw_delta_seconds_f64 = self.raw_delta.as_secs_f64();
-        } else {
-            self.first_update = Some(instant);
-        }
 
+    pub fn advance_by(&mut self, delta: Duration) {
+        self.delta = delta;
+        self.delta_seconds = self.delta.as_secs_f32();
+        self.delta_seconds_f64 = self.delta.as_secs_f64();
         self.elapsed += delta;
         self.elapsed_seconds = self.elapsed.as_secs_f32();
         self.elapsed_seconds_f64 = self.elapsed.as_secs_f64();
-        self.raw_elapsed += raw_delta;
-        self.raw_elapsed_seconds = self.raw_elapsed.as_secs_f32();
-        self.raw_elapsed_seconds_f64 = self.raw_elapsed.as_secs_f64();
-
-        self.elapsed_wrapped = duration_div_rem(self.elapsed, self.wrap_period).1;
+        self.elapsed_wrapped = Duration::new(self.elapsed.as_secs() % self.wrap_seconds, self.elapsed.subsec_nanos());
         self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
         self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();
-        self.raw_elapsed_wrapped = duration_div_rem(self.raw_elapsed, self.wrap_period).1;
-        self.raw_elapsed_seconds_wrapped = self.raw_elapsed_wrapped.as_secs_f32();
-        self.raw_elapsed_seconds_wrapped_f64 = self.raw_elapsed_wrapped.as_secs_f64();
-
-        self.last_update = Some(instant);
     }
 
-    /// Returns the [`Instant`] the clock was created.
-    ///
-    /// This usually represents when the app was started.
-    #[inline]
-    pub fn startup(&self) -> Instant {
-        self.startup
+    pub fn advance_to(&mut self, elapsed: Duration) {
+        self.advance_by(elapsed - self.elapsed)
     }
 
-    /// Returns the [`Instant`] when [`update`](#method.update) was first called, if it exists.
-    ///
-    /// This usually represents when the first app update started.
-    #[inline]
-    pub fn first_update(&self) -> Option<Instant> {
-        self.first_update
+    pub fn wrap_period(&self) -> Duration {
+        Duration::from_secs(self.wrap_seconds)
     }
 
-    /// Returns the [`Instant`] when [`update`](#method.update) was last called, if it exists.
-    ///
-    /// This usually represents when the current app update started.
-    #[inline]
-    pub fn last_update(&self) -> Option<Instant> {
-        self.last_update
+    pub fn set_wrap_period(&mut self, wrap_period: Duration) {
+        assert!(!wrap_period.is_zero(), "division by zero");
+        assert_eq!(wrap_period.subsec_nanos(), 0, "wrap period must be integral seconds");
+        self.wrap_seconds = wrap_period.as_secs();
+        self.elapsed_wrapped = Duration::new(self.elapsed.as_secs() % self.wrap_seconds, self.elapsed.subsec_nanos());
+        self.elapsed_seconds_wrapped = self.elapsed_wrapped.as_secs_f32();
+        self.elapsed_seconds_wrapped_f64 = self.elapsed_wrapped.as_secs_f64();        
     }
 
-    /// Returns how much time has advanced since the last [`update`](#method.update), as a [`Duration`].
-    #[inline]
     pub fn delta(&self) -> Duration {
         self.delta
     }
 
-    /// Returns how much time has advanced since the last [`update`](#method.update), as [`f32`] seconds.
-    #[inline]
     pub fn delta_seconds(&self) -> f32 {
         self.delta_seconds
     }
 
-    /// Returns how much time has advanced since the last [`update`](#method.update), as [`f64`] seconds.
-    #[inline]
     pub fn delta_seconds_f64(&self) -> f64 {
         self.delta_seconds_f64
     }
 
-    /// Returns how much time has advanced since [`startup`](#method.startup), as [`Duration`].
-    #[inline]
     pub fn elapsed(&self) -> Duration {
         self.elapsed
     }
 
-    /// Returns how much time has advanced since [`startup`](#method.startup), as [`f32`] seconds.
-    ///
-    /// **Note:** This is a monotonically increasing value. It's precision will degrade over time.
-    /// If you need an `f32` but that precision loss is unacceptable,
-    /// use [`elapsed_seconds_wrapped`](#method.elapsed_seconds_wrapped).
-    #[inline]
     pub fn elapsed_seconds(&self) -> f32 {
         self.elapsed_seconds
     }
 
-    /// Returns how much time has advanced since [`startup`](#method.startup), as [`f64`] seconds.
-    #[inline]
     pub fn elapsed_seconds_f64(&self) -> f64 {
         self.elapsed_seconds_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
     }
 
-    /// Returns how much time has advanced since [`startup`](#method.startup) modulo
-    /// the [`wrap_period`](#method.wrap_period), as [`f32`] seconds.
-    ///
-    /// This method is intended for applications (e.g. shaders) that require an [`f32`] value but
-    /// suffer from the gradual precision loss of [`elapsed_seconds`](#method.elapsed_seconds).
-    #[inline]
     pub fn elapsed_seconds_wrapped(&self) -> f32 {
         self.elapsed_seconds_wrapped
     }
 
-    /// Returns how much time has advanced since [`startup`](#method.startup) modulo
-    /// the [`wrap_period`](#method.wrap_period), as [`f64`] seconds.
-    #[inline]
     pub fn elapsed_seconds_wrapped_f64(&self) -> f64 {
         self.elapsed_seconds_wrapped_f64
     }
 
-    /// Returns how much real time has elapsed since the last [`update`](#method.update), as a [`Duration`].
-    #[inline]
-    pub fn raw_delta(&self) -> Duration {
-        self.raw_delta
-    }
-
-    /// Returns how much real time has elapsed since the last [`update`](#method.update), as [`f32`] seconds.
-    #[inline]
-    pub fn raw_delta_seconds(&self) -> f32 {
-        self.raw_delta_seconds
-    }
-
-    /// Returns how much real time has elapsed since the last [`update`](#method.update), as [`f64`] seconds.
-    #[inline]
-    pub fn raw_delta_seconds_f64(&self) -> f64 {
-        self.raw_delta_seconds_f64
+    pub fn context(&self) -> &T {
+        &self.context
     }
 
-    /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`Duration`].
-    #[inline]
-    pub fn raw_elapsed(&self) -> Duration {
-        self.raw_elapsed
+    pub fn context_mut(&mut self) -> &mut T {
+        &mut self.context
     }
 
-    /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`f32`] seconds.
-    ///
-    /// **Note:** This is a monotonically increasing value. It's precision will degrade over time.
-    /// If you need an `f32` but that precision loss is unacceptable,
-    /// use [`raw_elapsed_seconds_wrapped`](#method.raw_elapsed_seconds_wrapped).
-    #[inline]
-    pub fn raw_elapsed_seconds(&self) -> f32 {
-        self.raw_elapsed_seconds
-    }
-
-    /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`f64`] seconds.
-    #[inline]
-    pub fn raw_elapsed_seconds_f64(&self) -> f64 {
-        self.raw_elapsed_seconds_f64
-    }
-
-    /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
-    /// the [`wrap_period`](#method.wrap_period), as [`Duration`].
-    #[inline]
-    pub fn raw_elapsed_wrapped(&self) -> Duration {
-        self.raw_elapsed_wrapped
-    }
-
-    /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
-    /// the [`wrap_period`](#method.wrap_period), as [`f32`] seconds.
-    ///
-    /// This method is intended for applications (e.g. shaders) that require an [`f32`] value but
-    /// suffer from the gradual precision loss of [`raw_elapsed_seconds`](#method.raw_elapsed_seconds).
-    #[inline]
-    pub fn raw_elapsed_seconds_wrapped(&self) -> f32 {
-        self.raw_elapsed_seconds_wrapped
-    }
-
-    /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
-    /// the [`wrap_period`](#method.wrap_period), as [`f64`] seconds.
-    #[inline]
-    pub fn raw_elapsed_seconds_wrapped_f64(&self) -> f64 {
-        self.raw_elapsed_seconds_wrapped_f64
-    }
-
-    /// Returns the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
-    /// [`raw_elapsed_wrapped`](#method.raw_elapsed_wrapped).
-    ///
-    /// **Note:** The default modulus is one hour.
-    #[inline]
-    pub fn wrap_period(&self) -> Duration {
-        self.wrap_period
-    }
-
-    /// Sets the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
-    /// [`raw_elapsed_wrapped`](#method.raw_elapsed_wrapped).
-    ///
-    /// **Note:** This will not take effect until the next update.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `wrap_period` is a zero-length duration.
-    #[inline]
-    pub fn set_wrap_period(&mut self, wrap_period: Duration) {
-        assert!(!wrap_period.is_zero(), "division by zero");
-        self.wrap_period = wrap_period;
-    }
-
-    /// Returns the speed the clock advances relative to your system clock, as [`f32`].
-    /// This is known as "time scaling" or "time dilation" in other engines.
-    ///
-    /// **Note:** This function will return zero when time is paused.
-    #[inline]
-    pub fn relative_speed(&self) -> f32 {
-        self.relative_speed_f64() as f32
-    }
-
-    /// Returns the speed the clock advances relative to your system clock, as [`f64`].
-    /// This is known as "time scaling" or "time dilation" in other engines.
-    ///
-    /// **Note:** This function will return zero when time is paused.
-    #[inline]
-    pub fn relative_speed_f64(&self) -> f64 {
-        if self.paused {
-            0.0
-        } else {
-            self.relative_speed
+    pub fn as_current(&self) -> Time<()> {
+        Time {
+            context: (),
+            wrap_seconds: self.wrap_seconds,
+            delta: self.delta,
+            delta_seconds: self.delta_seconds,
+            delta_seconds_f64: self.delta_seconds_f64,
+            elapsed: self.elapsed,
+            elapsed_seconds: self.elapsed_seconds,
+            elapsed_seconds_f64: self.elapsed_seconds_f64,
+            elapsed_wrapped: self.elapsed_wrapped,
+            elapsed_seconds_wrapped: self.elapsed_seconds_wrapped,
+            elapsed_seconds_wrapped_f64: self.elapsed_seconds_wrapped_f64,
         }
     }
-
-    /// Sets the speed the clock advances relative to your system clock, given as an [`f32`].
-    ///
-    /// For example, setting this to `2.0` will make the clock advance twice as fast as your system clock.
-    ///
-    /// **Note:** This does not affect the `raw_*` measurements.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `ratio` is negative or not finite.
-    #[inline]
-    pub fn set_relative_speed(&mut self, ratio: f32) {
-        self.set_relative_speed_f64(ratio as f64);
-    }
-
-    /// Sets the speed the clock advances relative to your system clock, given as an [`f64`].
-    ///
-    /// For example, setting this to `2.0` will make the clock advance twice as fast as your system clock.
-    ///
-    /// **Note:** This does not affect the `raw_*` measurements.
-    ///
-    /// # Panics
-    ///
-    /// Panics if `ratio` is negative or not finite.
-    #[inline]
-    pub fn set_relative_speed_f64(&mut self, ratio: f64) {
-        assert!(ratio.is_finite(), "tried to go infinitely fast");
-        assert!(ratio >= 0.0, "tried to go back in time");
-        self.relative_speed = ratio;
-    }
-
-    /// Stops the clock, preventing it from advancing until resumed.
-    ///
-    /// **Note:** This does not affect the `raw_*` measurements.
-    #[inline]
-    pub fn pause(&mut self) {
-        self.paused = true;
-    }
-
-    /// Resumes the clock if paused.
-    #[inline]
-    pub fn unpause(&mut self) {
-        self.paused = false;
-    }
-
-    /// Returns `true` if the clock is currently paused.
-    #[inline]
-    pub fn is_paused(&self) -> bool {
-        self.paused
-    }
 }
 
-fn duration_div_rem(dividend: Duration, divisor: Duration) -> (u32, Duration) {
-    // `Duration` does not have a built-in modulo operation
-    let quotient = (dividend.as_nanos() / divisor.as_nanos()) as u32;
-    let remainder = dividend - (quotient * divisor);
-    (quotient, remainder)
-}
-
-#[cfg(test)]
-#[allow(clippy::float_cmp)]
-mod tests {
-    use super::Time;
-    use bevy_utils::{Duration, Instant};
-
-    fn assert_float_eq(a: f32, b: f32) {
-        assert!((a - b).abs() <= f32::EPSILON, "{a} != {b}");
-    }
-
-    #[test]
-    fn update_test() {
-        let start_instant = Instant::now();
-        let mut time = Time::new(start_instant);
-
-        // Ensure `time` was constructed correctly.
-        assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.first_update(), None);
-        assert_eq!(time.last_update(), None);
-        assert_eq!(time.relative_speed(), 1.0);
-        assert_eq!(time.delta(), Duration::ZERO);
-        assert_eq!(time.delta_seconds(), 0.0);
-        assert_eq!(time.delta_seconds_f64(), 0.0);
-        assert_eq!(time.raw_delta(), Duration::ZERO);
-        assert_eq!(time.raw_delta_seconds(), 0.0);
-        assert_eq!(time.raw_delta_seconds_f64(), 0.0);
-        assert_eq!(time.elapsed(), Duration::ZERO);
-        assert_eq!(time.elapsed_seconds(), 0.0);
-        assert_eq!(time.elapsed_seconds_f64(), 0.0);
-        assert_eq!(time.raw_elapsed(), Duration::ZERO);
-        assert_eq!(time.raw_elapsed_seconds(), 0.0);
-        assert_eq!(time.raw_elapsed_seconds_f64(), 0.0);
-
-        // Update `time` and check results.
-        // The first update to `time` normally happens before other systems have run,
-        // so the first delta doesn't appear until the second update.
-        let first_update_instant = Instant::now();
-        time.update_with_instant(first_update_instant);
-
-        assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.first_update(), Some(first_update_instant));
-        assert_eq!(time.last_update(), Some(first_update_instant));
-        assert_eq!(time.relative_speed(), 1.0);
-        assert_eq!(time.delta(), Duration::ZERO);
-        assert_eq!(time.delta_seconds(), 0.0);
-        assert_eq!(time.delta_seconds_f64(), 0.0);
-        assert_eq!(time.raw_delta(), Duration::ZERO);
-        assert_eq!(time.raw_delta_seconds(), 0.0);
-        assert_eq!(time.raw_delta_seconds_f64(), 0.0);
-        assert_eq!(time.elapsed(), first_update_instant - start_instant,);
-        assert_eq!(
-            time.elapsed_seconds(),
-            (first_update_instant - start_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.elapsed_seconds_f64(),
-            (first_update_instant - start_instant).as_secs_f64(),
-        );
-        assert_eq!(time.raw_elapsed(), first_update_instant - start_instant,);
-        assert_eq!(
-            time.raw_elapsed_seconds(),
-            (first_update_instant - start_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.raw_elapsed_seconds_f64(),
-            (first_update_instant - start_instant).as_secs_f64(),
-        );
-
-        // Update `time` again and check results.
-        // At this point its safe to use time.delta().
-        let second_update_instant = Instant::now();
-        time.update_with_instant(second_update_instant);
-        assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.first_update(), Some(first_update_instant));
-        assert_eq!(time.last_update(), Some(second_update_instant));
-        assert_eq!(time.relative_speed(), 1.0);
-        assert_eq!(time.delta(), second_update_instant - first_update_instant);
-        assert_eq!(
-            time.delta_seconds(),
-            (second_update_instant - first_update_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.delta_seconds_f64(),
-            (second_update_instant - first_update_instant).as_secs_f64(),
-        );
-        assert_eq!(
-            time.raw_delta(),
-            second_update_instant - first_update_instant,
-        );
-        assert_eq!(
-            time.raw_delta_seconds(),
-            (second_update_instant - first_update_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.raw_delta_seconds_f64(),
-            (second_update_instant - first_update_instant).as_secs_f64(),
-        );
-        assert_eq!(time.elapsed(), second_update_instant - start_instant,);
-        assert_eq!(
-            time.elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
-        );
-        assert_eq!(time.raw_elapsed(), second_update_instant - start_instant,);
-        assert_eq!(
-            time.raw_elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.raw_elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
-        );
-    }
-
-    #[test]
-    fn wrapping_test() {
-        let start_instant = Instant::now();
-
-        let mut time = Time {
-            startup: start_instant,
-            wrap_period: Duration::from_secs(3),
-            ..Default::default()
-        };
-
-        assert_eq!(time.elapsed_seconds_wrapped(), 0.0);
-
-        time.update_with_instant(start_instant + Duration::from_secs(1));
-        assert_float_eq(time.elapsed_seconds_wrapped(), 1.0);
-
-        time.update_with_instant(start_instant + Duration::from_secs(2));
-        assert_float_eq(time.elapsed_seconds_wrapped(), 2.0);
-
-        time.update_with_instant(start_instant + Duration::from_secs(3));
-        assert_float_eq(time.elapsed_seconds_wrapped(), 0.0);
-
-        time.update_with_instant(start_instant + Duration::from_secs(4));
-        assert_float_eq(time.elapsed_seconds_wrapped(), 1.0);
-    }
-
-    #[test]
-    fn relative_speed_test() {
-        let start_instant = Instant::now();
-        let mut time = Time::new(start_instant);
-
-        let first_update_instant = Instant::now();
-        time.update_with_instant(first_update_instant);
-
-        // Update `time` again and check results.
-        // At this point its safe to use time.delta().
-        let second_update_instant = Instant::now();
-        time.update_with_instant(second_update_instant);
-        assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.first_update(), Some(first_update_instant));
-        assert_eq!(time.last_update(), Some(second_update_instant));
-        assert_eq!(time.relative_speed(), 1.0);
-        assert_eq!(time.delta(), second_update_instant - first_update_instant);
-        assert_eq!(
-            time.delta_seconds(),
-            (second_update_instant - first_update_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.delta_seconds_f64(),
-            (second_update_instant - first_update_instant).as_secs_f64(),
-        );
-        assert_eq!(
-            time.raw_delta(),
-            second_update_instant - first_update_instant,
-        );
-        assert_eq!(
-            time.raw_delta_seconds(),
-            (second_update_instant - first_update_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.raw_delta_seconds_f64(),
-            (second_update_instant - first_update_instant).as_secs_f64(),
-        );
-        assert_eq!(time.elapsed(), second_update_instant - start_instant,);
-        assert_eq!(
-            time.elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
-        );
-        assert_eq!(time.raw_elapsed(), second_update_instant - start_instant,);
-        assert_eq!(
-            time.raw_elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
-        );
-        assert_eq!(
-            time.raw_elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
-        );
-
-        // Make app time advance at 2x the rate of your system clock.
-        time.set_relative_speed(2.0);
-
-        // Update `time` again 1 second later.
-        let elapsed = Duration::from_secs(1);
-        let third_update_instant = second_update_instant + elapsed;
-        time.update_with_instant(third_update_instant);
-
-        // Since app is advancing 2x your system clock, expect time
-        // to have advanced by twice the amount of real time elapsed.
-        assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.first_update(), Some(first_update_instant));
-        assert_eq!(time.last_update(), Some(third_update_instant));
-        assert_eq!(time.relative_speed(), 2.0);
-        assert_eq!(time.delta(), elapsed.mul_f32(2.0));
-        assert_eq!(time.delta_seconds(), elapsed.mul_f32(2.0).as_secs_f32());
-        assert_eq!(time.delta_seconds_f64(), elapsed.mul_f32(2.0).as_secs_f64());
-        assert_eq!(time.raw_delta(), elapsed);
-        assert_eq!(time.raw_delta_seconds(), elapsed.as_secs_f32());
-        assert_eq!(time.raw_delta_seconds_f64(), elapsed.as_secs_f64());
-        assert_eq!(
-            time.elapsed(),
-            second_update_instant - start_instant + elapsed.mul_f32(2.0),
-        );
-        assert_eq!(
-            time.elapsed_seconds(),
-            (second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f32(),
-        );
-        assert_eq!(
-            time.elapsed_seconds_f64(),
-            (second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f64(),
-        );
-        assert_eq!(
-            time.raw_elapsed(),
-            second_update_instant - start_instant + elapsed,
-        );
-        assert_eq!(
-            time.raw_elapsed_seconds(),
-            (second_update_instant - start_instant + elapsed).as_secs_f32(),
-        );
-        assert_eq!(
-            time.raw_elapsed_seconds_f64(),
-            (second_update_instant - start_instant + elapsed).as_secs_f64(),
-        );
-    }
-
-    #[test]
-    fn pause_test() {
-        let start_instant = Instant::now();
-        let mut time = Time::new(start_instant);
-
-        let first_update_instant = Instant::now();
-        time.update_with_instant(first_update_instant);
-
-        assert!(!time.is_paused());
-        assert_eq!(time.relative_speed(), 1.0);
-
-        time.pause();
-
-        assert!(time.is_paused());
-        assert_eq!(time.relative_speed(), 0.0);
-
-        let second_update_instant = Instant::now();
-        time.update_with_instant(second_update_instant);
-        assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.first_update(), Some(first_update_instant));
-        assert_eq!(time.last_update(), Some(second_update_instant));
-        assert_eq!(time.delta(), Duration::ZERO);
-        assert_eq!(
-            time.raw_delta(),
-            second_update_instant - first_update_instant,
-        );
-        assert_eq!(time.elapsed(), first_update_instant - start_instant);
-        assert_eq!(time.raw_elapsed(), second_update_instant - start_instant);
-
-        time.unpause();
-
-        assert!(!time.is_paused());
-        assert_eq!(time.relative_speed(), 1.0);
-
-        let third_update_instant = Instant::now();
-        time.update_with_instant(third_update_instant);
-        assert_eq!(time.startup(), start_instant);
-        assert_eq!(time.first_update(), Some(first_update_instant));
-        assert_eq!(time.last_update(), Some(third_update_instant));
-        assert_eq!(time.delta(), third_update_instant - second_update_instant);
-        assert_eq!(
-            time.raw_delta(),
-            third_update_instant - second_update_instant,
-        );
-        assert_eq!(
-            time.elapsed(),
-            (third_update_instant - second_update_instant) + (first_update_instant - start_instant),
-        );
-        assert_eq!(time.raw_elapsed(), third_update_instant - start_instant);
+impl<T: Default> Default for Time<T> {
+    fn default() -> Self {
+        Self::new(Default::default(), Self::DEFAULT_WRAP_SECONDS)
     }
 }
diff --git a/crates/bevy_time/src/virt.rs b/crates/bevy_time/src/virt.rs
new file mode 100644
index 00000000000000..636b6d8ac4405f
--- /dev/null
+++ b/crates/bevy_time/src/virt.rs
@@ -0,0 +1,89 @@
+use bevy_utils::Duration;
+use bevy_ecs::system::{Res, ResMut};
+use bevy_ecs::{reflect::ReflectResource, system::Resource};
+use bevy_reflect::{FromReflect, Reflect};
+
+use crate::time::Time;
+use crate::real::Real;
+
+#[derive(Resource, Debug, Copy, Clone, Reflect, FromReflect)]
+#[reflect(Resource)]
+pub struct Virtual {
+    max_delta: Option<Duration>,
+    relative_speed: f64,
+    paused: bool,
+}
+
+impl Time<Virtual> {
+    pub fn max_delta(&self) -> Option<Duration> {
+        self.context().max_delta
+    }
+
+    pub fn set_max_delta(&mut self, max_delta: Option<Duration>) {
+        self.context_mut().max_delta = max_delta;
+    }
+
+    pub fn relative_speed(&self) -> f32 {
+        self.relative_speed_f64() as f32
+    }
+
+    pub fn relative_speed_f64(&self) -> f64 {
+        self.context().relative_speed
+    }
+
+    pub fn set_relative_speed(&mut self, ratio: f32) {
+        self.set_relative_speed_f64(ratio as f64)
+    }
+
+    pub fn set_relative_speed_f64(&mut self, ratio: f64) {
+        assert!(ratio.is_finite(), "tried to go infinitely fast");
+        assert!(ratio >= 0.0, "tried to go back in time");
+        self.context_mut().relative_speed = ratio;
+    }
+
+    pub fn pause(&mut self) {
+        self.context_mut().paused = true;
+    }
+
+    pub fn unpause(&mut self) {
+        self.context_mut().paused = false;
+    }
+
+    pub fn is_paused(&self) -> bool {
+        self.context().paused
+    }
+}
+
+impl Default for Virtual {
+    fn default() -> Self {
+        Self {
+            max_delta: Some(Duration::from_millis(333)),
+            relative_speed: 1.0,
+            paused: false,
+        }
+    }
+}
+
+pub fn virtual_time_system(
+    mut current: ResMut<Time>,
+    mut virt: ResMut<Time<Virtual>>,
+    real: Res<Time<Real>>,
+) {
+    let context = virt.context();
+    let raw_delta = real.delta();
+    let clamped_delta = if let Some(max_delta) = context.max_delta {
+        std::cmp::min(raw_delta, max_delta)
+    } else {
+        raw_delta
+    };
+    let delta = if context.paused {
+        Duration::ZERO
+    } else if context.relative_speed != 1.0 {
+        clamped_delta.mul_f64(context.relative_speed)
+    } else {
+        // avoid rounding when at normal speed
+        clamped_delta
+    };
+    virt.advance_by(delta);
+    virt.as_current().clone_into(current.as_mut());
+}