diff --git a/crates/bevy_time/src/clock.rs b/crates/bevy_time/src/clock.rs
new file mode 100644
index 0000000000000..cf927eedb769d
--- /dev/null
+++ b/crates/bevy_time/src/clock.rs
@@ -0,0 +1,106 @@
+use bevy_reflect::{FromReflect, Reflect};
+use bevy_utils::Duration;
+
+#[derive(Debug, Copy, Clone, Reflect, FromReflect)]
+pub struct Clock {
+    wrap_seconds: u64,
+    delta: Duration,
+    delta_seconds: f32,
+    delta_seconds_f64: f64,
+    elapsed: Duration,
+    elapsed_seconds: f32,
+    elapsed_seconds_f64: f64,
+    elapsed_wrapped: Duration,
+    elapsed_seconds_wrapped: f32,
+    elapsed_seconds_wrapped_f64: f64,
+}
+
+impl Clock {
+    const DEFAULT_WRAP_SECONDS: u64 = 3600; // 1 hour
+
+    pub fn new(wrap_seconds: u64) -> Clock {
+        Clock {
+            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,
+            elapsed_wrapped: Duration::ZERO,
+            elapsed_seconds_wrapped: 0.0,
+            elapsed_seconds_wrapped_f64: 0.0,
+        }
+    }
+
+    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.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();
+    }
+
+    pub fn advance_to(&mut self, elapsed: Duration) {
+        self.advance_by(elapsed - self.elapsed)
+    }
+
+    pub fn wrap_period(&self) -> Duration {
+        Duration::from_secs(self.wrap_seconds)
+    }
+
+    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();        
+    }
+
+    pub fn delta(&self) -> Duration {
+        self.delta
+    }
+
+    pub fn delta_seconds(&self) -> f32 {
+        self.delta_seconds
+    }
+
+    pub fn delta_seconds_f64(&self) -> f64 {
+        self.delta_seconds_f64
+    }
+
+    pub fn elapsed(&self) -> Duration {
+        self.elapsed
+    }
+
+    pub fn elapsed_seconds(&self) -> f32 {
+        self.elapsed_seconds
+    }
+
+    pub fn elapsed_seconds_f64(&self) -> f64 {
+        self.elapsed_seconds_f64
+    }
+
+    pub fn elapsed_wrapped(&self) -> Duration {
+        self.elapsed_wrapped
+    }
+
+    pub fn elapsed_seconds_wrapped(&self) -> f32 {
+        self.elapsed_seconds_wrapped
+    }
+
+    pub fn elapsed_seconds_wrapped_f64(&self) -> f64 {
+        self.elapsed_seconds_wrapped_f64
+    }
+}
+
+impl Default for Clock {
+    fn default() -> Self {
+        Self::new(Self::DEFAULT_WRAP_SECONDS)
+    }
+}
diff --git a/crates/bevy_time/src/common_conditions.rs b/crates/bevy_time/src/common_conditions.rs
index 974de24dfae2c..82e74e325a592 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;
 
@@ -66,10 +66,10 @@ pub fn on_timer(duration: Duration) -> impl FnMut(Res<Time>) -> bool + Clone {
 /// 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 {
+pub fn on_fixed_timer(duration: Duration) -> impl FnMut(Res<Time>) -> bool + Clone {
     let mut timer = Timer::new(duration, TimerMode::Repeating);
-    move |time: Res<FixedTime>| {
-        timer.tick(time.period);
+    move |time: Res<Time>| {
+        timer.tick(time.fixed_period());
         timer.just_finished()
     }
 }
diff --git a/crates/bevy_time/src/fixed_timestep.rs b/crates/bevy_time/src/fixed_timestep.rs
deleted file mode 100644
index 66be2f41ef2ff..0000000000000
--- 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 704d54d860452..807927aba22dc 100644
--- a/crates/bevy_time/src/lib.rs
+++ b/crates/bevy_time/src/lib.rs
@@ -2,13 +2,12 @@
 
 /// Common run conditions
 pub mod common_conditions;
-pub mod fixed_timestep;
 mod stopwatch;
 #[allow(clippy::module_inception)]
 mod time;
 mod timer;
+mod clock;
 
-use fixed_timestep::FixedTime;
 pub use stopwatch::*;
 pub use time::*;
 pub use timer::*;
@@ -20,13 +19,13 @@ 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::time::run_fixed_update_schedule;
 
 /// Adds time functionality to Apps.
 #[derive(Default)]
@@ -44,7 +43,6 @@ impl Plugin for TimePlugin {
             .register_type::<Timer>()
             .register_type::<Time>()
             .register_type::<Stopwatch>()
-            .init_resource::<FixedTime>()
             .add_systems(First, time_system.in_set(TimeSystem))
             .add_systems(RunFixedUpdateLoop, run_fixed_update_schedule);
 
diff --git a/crates/bevy_time/src/time.rs b/crates/bevy_time/src/time.rs
index f462296ad6aef..100a8ee22ecc4 100644
--- a/crates/bevy_time/src/time.rs
+++ b/crates/bevy_time/src/time.rs
@@ -1,6 +1,9 @@
-use bevy_ecs::{reflect::ReflectResource, system::Resource};
+use bevy_ecs::{reflect::ReflectResource, system::Resource, world::World};
 use bevy_reflect::{FromReflect, Reflect};
 use bevy_utils::{Duration, Instant};
+use bevy_app::FixedUpdate;
+
+use crate::clock::Clock;
 
 /// A clock that tracks how much it has advanced (and how much real time has elapsed) since
 /// its previous update and since its creation.
@@ -10,30 +13,15 @@ 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
-    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,
+    maximum_delta: Option<Duration>,
+    fixed_accumulated: Duration,
+    fixed_period: Duration,
+    raw_clock: Clock,
+    virtual_clock: Clock,
+    fixed_clock: Clock,
+    current_clock: Clock,
 }
 
 impl Default for Time {
@@ -44,25 +32,13 @@ impl Default for Time {
             last_update: None,
             paused: false,
             relative_speed: 1.0,
-            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,
+            maximum_delta: Some(Duration::from_millis(333)), // XXX: From Unity, maybe we should do better
+            fixed_accumulated: Duration::ZERO,
+            fixed_period: Duration::from_secs_f32(1. / 60.), // XXX
+            raw_clock: Clock::default(),
+            virtual_clock: Clock::default(),
+            fixed_clock: Clock::default(),
+            current_clock: Clock::default(),
         }
     }
 }
@@ -138,8 +114,14 @@ impl Time {
     /// }
     /// ```
     pub fn update_with_instant(&mut self, instant: Instant) {
+        if self.last_update.is_none() {
+            self.first_update = Some(instant);
+            self.last_update = Some(instant);
+            return;
+        }
         let raw_delta = instant - self.last_update.unwrap_or(self.startup);
-        let delta = if self.paused {
+        self.raw_clock.advance_by(raw_delta);
+        let scaled_delta = if self.paused {
             Duration::ZERO
         } else if self.relative_speed != 1.0 {
             raw_delta.mul_f64(self.relative_speed)
@@ -147,33 +129,30 @@ impl Time {
             // 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();
+        let delta = if let Some(maximum_delta) = self.maximum_delta {
+            std::cmp::min(scaled_delta, maximum_delta)
         } else {
-            self.first_update = Some(instant);
-        }
-
-        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_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();
+            scaled_delta
+        };
+        self.virtual_clock.advance_by(delta);
+        self.fixed_accumulated += delta;
 
         self.last_update = Some(instant);
+        self.current_clock = self.virtual_clock;
+    }
+
+    pub fn expend_fixed(&mut self) -> bool {
+        if let Some(new_value) = self.fixed_accumulated.checked_sub(self.fixed_period) {
+            // reduce accumulated and increase elapsed by period
+            self.fixed_accumulated = new_value;
+            self.fixed_clock.advance_by(self.fixed_period);
+            self.current_clock = self.fixed_clock;
+            true
+        } else {
+            // no more periods left in accumulated
+            self.current_clock = self.virtual_clock;
+            false
+        }
     }
 
     /// Returns the [`Instant`] the clock was created.
@@ -203,25 +182,25 @@ impl Time {
     /// Returns how much time has advanced since the last [`update`](#method.update), as a [`Duration`].
     #[inline]
     pub fn delta(&self) -> Duration {
-        self.delta
+        self.current_clock.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
+        self.current_clock.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
+        self.current_clock.delta_seconds_f64()
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`Duration`].
     #[inline]
     pub fn elapsed(&self) -> Duration {
-        self.elapsed
+        self.current_clock.elapsed()
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup), as [`f32`] seconds.
@@ -231,20 +210,20 @@ impl Time {
     /// use [`elapsed_seconds_wrapped`](#method.elapsed_seconds_wrapped).
     #[inline]
     pub fn elapsed_seconds(&self) -> f32 {
-        self.elapsed_seconds
+        self.current_clock.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
+        self.current_clock.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
+        self.current_clock.elapsed_wrapped()
     }
 
     /// Returns how much time has advanced since [`startup`](#method.startup) modulo
@@ -254,38 +233,38 @@ impl Time {
     /// suffer from the gradual precision loss of [`elapsed_seconds`](#method.elapsed_seconds).
     #[inline]
     pub fn elapsed_seconds_wrapped(&self) -> f32 {
-        self.elapsed_seconds_wrapped
+        self.current_clock.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
+        self.current_clock.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
+        self.raw_clock.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
+        self.raw_clock.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
+        self.raw_clock.delta_seconds_f64()
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`Duration`].
     #[inline]
     pub fn raw_elapsed(&self) -> Duration {
-        self.raw_elapsed
+        self.raw_clock.elapsed()
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup), as [`f32`] seconds.
@@ -295,20 +274,20 @@ impl Time {
     /// use [`raw_elapsed_seconds_wrapped`](#method.raw_elapsed_seconds_wrapped).
     #[inline]
     pub fn raw_elapsed_seconds(&self) -> f32 {
-        self.raw_elapsed_seconds
+        self.raw_clock.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
+        self.raw_clock.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
+        self.raw_clock.elapsed_wrapped()
     }
 
     /// Returns how much real time has elapsed since [`startup`](#method.startup) modulo
@@ -318,14 +297,14 @@ impl Time {
     /// 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
+        self.raw_clock.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
+        self.raw_clock.elapsed_seconds_wrapped_f64()
     }
 
     /// Returns the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
@@ -334,7 +313,7 @@ impl Time {
     /// **Note:** The default modulus is one hour.
     #[inline]
     pub fn wrap_period(&self) -> Duration {
-        self.wrap_period
+        self.current_clock.wrap_period()
     }
 
     /// Sets the modulus used to calculate [`elapsed_wrapped`](#method.elapsed_wrapped) and
@@ -347,8 +326,30 @@ impl Time {
     /// 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;
+        self.raw_clock.set_wrap_period(wrap_period);
+        self.virtual_clock.set_wrap_period(wrap_period);
+        self.fixed_clock.set_wrap_period(wrap_period);
+        self.current_clock.set_wrap_period(wrap_period);
+    }
+
+    pub fn fixed_period(&self) -> Duration {
+        self.fixed_period
+    }
+
+    pub fn set_fixed_period(&mut self, period: Duration) {
+        self.fixed_period = period;
+    }
+
+    pub fn maximum_delta(&self) -> Option<Duration> {
+        self.maximum_delta
+    }
+
+    pub fn set_maximum_delta(&mut self, maximum_delta: Option<Duration>) {
+        self.maximum_delta = maximum_delta;
+    }
+    
+    pub fn set_maximum_fixed_ticks(&mut self, ticks: u32) {
+        self.maximum_delta = Some(self.fixed_period * ticks);
     }
 
     /// Returns the speed the clock advances relative to your system clock, as [`f32`].
@@ -422,13 +423,32 @@ impl Time {
     pub fn is_paused(&self) -> bool {
         self.paused
     }
+
+    pub fn raw_clock(&self) -> &Clock {
+        &self.raw_clock
+    }
+
+    pub fn virtual_clock(&self) -> &Clock {
+        &self.virtual_clock
+    }
+
+    pub fn fixed_clock(&self) -> &Clock {
+        &self.fixed_clock
+    }
+
+    pub fn current_clock(&self) -> &Clock {
+        &self.current_clock
+    }
 }
 
-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)
+/// Ticks the [`FixedTime`] resource then runs the [`FixedUpdate`].
+pub fn run_fixed_update_schedule(world: &mut World) {
+    // Run the schedule until we run out of accumulated time
+    let _ = world.try_schedule_scope(FixedUpdate, |world, schedule| {
+        while world.resource_mut::<Time>().expend_fixed() {
+            schedule.run(world);
+        }
+    });
 }
 
 #[cfg(test)]
@@ -436,6 +456,7 @@ fn duration_div_rem(dividend: Duration, divisor: Duration) -> (u32, Duration) {
 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}");
@@ -480,23 +501,23 @@ mod tests {
         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(), Duration::ZERO);
         assert_eq!(
             time.elapsed_seconds(),
-            (first_update_instant - start_instant).as_secs_f32(),
+            0.0
         );
         assert_eq!(
             time.elapsed_seconds_f64(),
-            (first_update_instant - start_instant).as_secs_f64(),
+            0.0
         );
-        assert_eq!(time.raw_elapsed(), first_update_instant - start_instant,);
+        assert_eq!(time.raw_elapsed(), Duration::ZERO);
         assert_eq!(
             time.raw_elapsed_seconds(),
-            (first_update_instant - start_instant).as_secs_f32(),
+            0.0
         );
         assert_eq!(
             time.raw_elapsed_seconds_f64(),
-            (first_update_instant - start_instant).as_secs_f64(),
+            0.0
         );
 
         // Update `time` again and check results.
@@ -528,23 +549,23 @@ mod tests {
             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(), second_update_instant - first_update_instant,);
         assert_eq!(
             time.elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
+            (second_update_instant - first_update_instant).as_secs_f32(),
         );
         assert_eq!(
             time.elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
+            (second_update_instant - first_update_instant).as_secs_f64(),
         );
-        assert_eq!(time.raw_elapsed(), second_update_instant - start_instant,);
+        assert_eq!(time.raw_elapsed(), second_update_instant - first_update_instant,);
         assert_eq!(
             time.raw_elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
+            (second_update_instant - first_update_instant).as_secs_f32(),
         );
         assert_eq!(
             time.raw_elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
+            (second_update_instant - first_update_instant).as_secs_f64(),
         );
     }
 
@@ -552,11 +573,10 @@ mod tests {
     fn wrapping_test() {
         let start_instant = Instant::now();
 
-        let mut time = Time {
-            startup: start_instant,
-            wrap_period: Duration::from_secs(3),
-            ..Default::default()
-        };
+        let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
+        time.set_wrap_period(Duration::from_secs(3));
+        time.update_with_instant(start_instant);
 
         assert_eq!(time.elapsed_seconds_wrapped(), 0.0);
 
@@ -577,6 +597,7 @@ mod tests {
     fn relative_speed_test() {
         let start_instant = Instant::now();
         let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
 
         let first_update_instant = Instant::now();
         time.update_with_instant(first_update_instant);
@@ -610,23 +631,23 @@ mod tests {
             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(), second_update_instant - first_update_instant,);
         assert_eq!(
             time.elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
+            (second_update_instant - first_update_instant).as_secs_f32(),
         );
         assert_eq!(
             time.elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
+            (second_update_instant - first_update_instant).as_secs_f64(),
         );
-        assert_eq!(time.raw_elapsed(), second_update_instant - start_instant,);
+        assert_eq!(time.raw_elapsed(), second_update_instant - first_update_instant,);
         assert_eq!(
             time.raw_elapsed_seconds(),
-            (second_update_instant - start_instant).as_secs_f32(),
+            (second_update_instant - first_update_instant).as_secs_f32(),
         );
         assert_eq!(
             time.raw_elapsed_seconds_f64(),
-            (second_update_instant - start_instant).as_secs_f64(),
+            (second_update_instant - first_update_instant).as_secs_f64(),
         );
 
         // Make app time advance at 2x the rate of your system clock.
@@ -651,27 +672,27 @@ mod tests {
         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),
+            second_update_instant - first_update_instant + elapsed.mul_f32(2.0),
         );
         assert_eq!(
             time.elapsed_seconds(),
-            (second_update_instant - start_instant + elapsed.mul_f32(2.0)).as_secs_f32(),
+            (second_update_instant - first_update_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(),
+            (second_update_instant - first_update_instant + elapsed.mul_f32(2.0)).as_secs_f64(),
         );
         assert_eq!(
             time.raw_elapsed(),
-            second_update_instant - start_instant + elapsed,
+            second_update_instant - first_update_instant + elapsed,
         );
         assert_eq!(
             time.raw_elapsed_seconds(),
-            (second_update_instant - start_instant + elapsed).as_secs_f32(),
+            (second_update_instant - first_update_instant + elapsed).as_secs_f32(),
         );
         assert_eq!(
             time.raw_elapsed_seconds_f64(),
-            (second_update_instant - start_instant + elapsed).as_secs_f64(),
+            (second_update_instant - first_update_instant + elapsed).as_secs_f64(),
         );
     }
 
@@ -701,8 +722,8 @@ mod tests {
             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);
+        assert_eq!(time.elapsed(), first_update_instant - first_update_instant);
+        assert_eq!(time.raw_elapsed(), second_update_instant - first_update_instant);
 
         time.unpause();
 
@@ -721,8 +742,61 @@ mod tests {
         );
         assert_eq!(
             time.elapsed(),
-            (third_update_instant - second_update_instant) + (first_update_instant - start_instant),
+            (third_update_instant - second_update_instant) + (first_update_instant - first_update_instant),
         );
-        assert_eq!(time.raw_elapsed(), third_update_instant - start_instant);
+        assert_eq!(time.raw_elapsed(), third_update_instant - first_update_instant);
+    }
+
+    #[test]
+    fn fixed_time_starts_at_zero() {
+        let start_instant = Instant::now();
+
+        let time = Time::new(start_instant);
+
+        assert_eq!(time.fixed_accumulated, Duration::ZERO);
+    }
+
+    #[test]
+    fn fixed_time_ticks_up() {
+        let start_instant = Instant::now();
+        let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
+        time.update_with_instant(start_instant);
+
+        time.update_with_instant(start_instant + Duration::from_secs(1));
+        assert_eq!(time.fixed_accumulated, Duration::from_secs(1));
+    }
+
+    #[test]
+    fn enough_accumulated_time_is_required() {
+        let start_instant = Instant::now();
+        let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
+        time.set_fixed_period(Duration::from_secs(2));
+        time.update_with_instant(start_instant);
+
+        time.update_with_instant(start_instant + Duration::from_secs(1));
+        assert_eq!(time.expend_fixed(), false);
+        assert_eq!(time.fixed_accumulated, Duration::from_secs(1));
+
+        time.update_with_instant(start_instant + Duration::from_secs(2));
+        assert_eq!(time.expend_fixed(), true);
+        assert_eq!(time.fixed_accumulated, Duration::ZERO);
+        assert_eq!(time.expend_fixed(), false);
+    }
+
+    #[test]
+    fn repeatedly_expending_time() {
+        let start_instant = Instant::now();
+        let mut time = Time::new(start_instant);
+        time.set_maximum_delta(None);
+        time.set_fixed_period(Duration::from_secs(1));
+        time.update_with_instant(start_instant);
+
+        time.update_with_instant(start_instant + Duration::new(3, 200_000_000));
+        assert_eq!(time.expend_fixed(), true);
+        assert_eq!(time.expend_fixed(), true);
+        assert_eq!(time.expend_fixed(), true);
+        assert_eq!(time.expend_fixed(), false);
     }
 }