diff --git a/crates/benches_common_3d/src/lib.rs b/crates/benches_common_3d/src/lib.rs
index 5875ece5..f6b622b6 100644
--- a/crates/benches_common_3d/src/lib.rs
+++ b/crates/benches_common_3d/src/lib.rs
@@ -18,7 +18,7 @@ pub fn bench_app<M: Measurement>(
                 PhysicsPlugins::default(),
             ));
 
-            app.insert_resource(PhysicsTimestep::FixedOnce(1.0 / 60.0));
+            app.insert_resource(Time::new_with(Physics::fixed_once_hz(1.0 / 60.0)));
 
             setup(&mut app);
 
diff --git a/crates/bevy_xpbd_3d/examples/basic_dynamic_character.rs b/crates/bevy_xpbd_3d/examples/basic_dynamic_character.rs
index b47aa521..f8e2593d 100644
--- a/crates/bevy_xpbd_3d/examples/basic_dynamic_character.rs
+++ b/crates/bevy_xpbd_3d/examples/basic_dynamic_character.rs
@@ -238,7 +238,7 @@ fn movement(
     // both the `f32` and `f64` features. Otherwise you don't need this.
     let delta_time = time.delta_seconds_f64().adjust_precision();
 
-    for event in movement_event_reader.iter() {
+    for event in movement_event_reader.read() {
         for (movement_acceleration, jump_impulse, mut linear_velocity, is_grounded) in
             &mut controllers
         {
diff --git a/crates/bevy_xpbd_3d/examples/basic_kinematic_character.rs b/crates/bevy_xpbd_3d/examples/basic_kinematic_character.rs
index f254f3c8..7b370b37 100644
--- a/crates/bevy_xpbd_3d/examples/basic_kinematic_character.rs
+++ b/crates/bevy_xpbd_3d/examples/basic_kinematic_character.rs
@@ -255,7 +255,7 @@ fn movement(
     // both the `f32` and `f64` features. Otherwise you don't need this.
     let delta_time = time.delta_seconds_f64().adjust_precision();
 
-    for event in movement_event_reader.iter() {
+    for event in movement_event_reader.read() {
         for (movement_acceleration, jump_impulse, mut linear_velocity, is_grounded) in
             &mut controllers
         {
diff --git a/crates/bevy_xpbd_3d/snapshots/bevy_xpbd_3d__tests__cubes_simulation_is_deterministic_across_machines.snap b/crates/bevy_xpbd_3d/snapshots/bevy_xpbd_3d__tests__cubes_simulation_is_deterministic_across_machines.snap
index c9bef862..e992a5ef 100644
--- a/crates/bevy_xpbd_3d/snapshots/bevy_xpbd_3d__tests__cubes_simulation_is_deterministic_across_machines.snap
+++ b/crates/bevy_xpbd_3d/snapshots/bevy_xpbd_3d__tests__cubes_simulation_is_deterministic_across_machines.snap
@@ -9,15 +9,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -4.3423853,
-                0.49998048,
-                -5.2260904,
+                -4.5413985,
+                0.49999854,
+                -5.812303,
             ),
             rotation: Quat(
-                7.0508534e-8,
-                -0.089453705,
-                6.083998e-7,
-                0.995991,
+                3.129878e-6,
+                0.10535714,
+                -3.053036e-6,
+                0.9944345,
             ),
             scale: Vec3(
                 1.0,
@@ -32,15 +32,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -4.418144,
-                0.49997675,
-                -2.319346,
+                -4.106035,
+                0.49994144,
+                -2.6481476,
             ),
             rotation: Quat(
-                5.2947416e-6,
-                -0.02984577,
-                -1.8464465e-5,
-                0.9995545,
+                7.5037683e-6,
+                -0.15262182,
+                -2.0970647e-5,
+                0.98828465,
             ),
             scale: Vec3(
                 1.0,
@@ -55,15 +55,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -5.8100367,
-                0.49999845,
-                0.14385882,
+                -4.611196,
+                0.49995783,
+                -0.34869525,
             ),
             rotation: Quat(
-                1.0953618e-6,
-                0.4049569,
-                -1.3033888e-6,
-                0.9143358,
+                -1.42509e-5,
+                -0.1841588,
+                -1.738285e-5,
+                0.9828965,
             ),
             scale: Vec3(
                 1.0,
@@ -78,15 +78,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -5.864746,
-                0.49999946,
-                10.72942,
+                -4.586858,
+                0.49993232,
+                2.755423,
             ),
             rotation: Quat(
-                7.0495884e-7,
-                0.044847287,
-                -4.824935e-7,
-                0.9989939,
+                -1.952987e-5,
+                0.028491925,
+                -6.243225e-6,
+                0.99959403,
             ),
             scale: Vec3(
                 1.0,
@@ -101,15 +101,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -2.002046,
-                0.49996984,
-                -6.000447,
+                -1.4441824,
+                0.49993822,
+                -5.2373285,
             ),
             rotation: Quat(
-                1.1079425e-5,
-                0.11743741,
-                -3.759696e-7,
-                0.99308026,
+                -2.5923798e-6,
+                -0.010303094,
+                5.548739e-6,
+                0.99994695,
             ),
             scale: Vec3(
                 1.0,
@@ -124,15 +124,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -1.9987766,
-                0.49999425,
-                -2.0733616,
+                -1.9532473,
+                0.499997,
+                -2.6331823,
             ),
             rotation: Quat(
-                7.4080567e-6,
-                -0.09336918,
-                -4.787302e-6,
-                0.9956316,
+                4.5943334e-6,
+                -0.13999754,
+                -1.9448112e-6,
+                0.9901519,
             ),
             scale: Vec3(
                 1.0,
@@ -147,15 +147,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -2.0880558,
-                0.49999642,
-                -0.017637428,
+                -2.0969713,
+                0.49996477,
+                0.6139536,
             ),
             rotation: Quat(
-                4.727055e-6,
-                -0.10346992,
-                -2.2053052e-6,
-                0.9946326,
+                2.196806e-5,
+                0.16460687,
+                3.748077e-6,
+                0.98635924,
             ),
             scale: Vec3(
                 1.0,
@@ -170,15 +170,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -2.1696157,
-                0.49999964,
-                2.2321312,
+                -2.0876007,
+                0.49996525,
+                3.1129513,
             ),
             rotation: Quat(
-                6.511592e-7,
-                0.008408211,
-                -4.7466727e-7,
-                0.99996465,
+                -1.3366616e-5,
+                0.088801324,
+                -4.3129737e-7,
+                0.99604934,
             ),
             scale: Vec3(
                 1.0,
@@ -193,15 +193,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.4415929,
-                0.49995127,
-                -5.2534013,
+                0.86435765,
+                0.4999979,
+                -5.4886947,
             ),
             rotation: Quat(
-                6.3904095e-6,
-                -0.18920605,
-                -6.5382255e-7,
-                0.9819374,
+                4.5033175e-6,
+                -0.004078502,
+                -2.4095154e-6,
+                0.99999166,
             ),
             scale: Vec3(
                 1.0,
@@ -216,15 +216,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.1919279,
-                0.49992722,
-                -2.4087517,
+                0.31714392,
+                0.4999555,
+                -2.8910909,
             ),
             rotation: Quat(
-                -3.3877075e-6,
-                -0.13829833,
-                -9.278761e-6,
-                0.9903906,
+                1.1530377e-5,
+                -0.11013199,
+                -1.6434492e-6,
+                0.993917,
             ),
             scale: Vec3(
                 1.0,
@@ -239,15 +239,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.09996043,
-                0.49993744,
-                -0.17984411,
+                0.12120628,
+                0.49995583,
+                0.16215812,
             ),
             rotation: Quat(
-                2.442432e-6,
-                -0.13113676,
-                4.214775e-6,
-                0.9913643,
+                -1.2795071e-5,
+                0.06465573,
+                -2.9045584e-6,
+                0.99790764,
             ),
             scale: Vec3(
                 1.0,
@@ -262,15 +262,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -0.051802184,
-                0.49998862,
-                2.0947423,
+                0.008304957,
+                0.49996242,
+                2.9027696,
             ),
             rotation: Quat(
-                9.652017e-6,
-                -0.015585309,
-                7.912948e-6,
-                0.9998785,
+                -1.1133008e-5,
+                0.038613528,
+                1.0067933e-7,
+                0.9992542,
             ),
             scale: Vec3(
                 1.0,
@@ -285,15 +285,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.7893236,
-                0.4999985,
-                -5.2901754,
+                2.9220781,
+                0.49997145,
+                -5.256576,
             ),
             rotation: Quat(
-                2.594992e-6,
-                -0.11510058,
-                -1.3799596e-6,
-                0.99335384,
+                3.5157368e-6,
+                -0.02764599,
+                3.0049337e-6,
+                0.99961776,
             ),
             scale: Vec3(
                 1.0,
@@ -308,15 +308,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.4225495,
-                0.49998072,
-                -2.4689758,
+                2.684553,
+                0.49993816,
+                -2.6182067,
             ),
             rotation: Quat(
-                1.859268e-5,
-                -0.10815832,
-                -1.1543215e-5,
-                0.9941337,
+                1.3352204e-5,
+                -0.131964,
+                -1.6313822e-6,
+                0.9912545,
             ),
             scale: Vec3(
                 1.0,
@@ -331,15 +331,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.3873122,
-                0.49993768,
-                -0.24063475,
+                2.9588585,
+                0.4999956,
+                0.04658448,
             ),
             rotation: Quat(
-                2.4468218e-6,
-                -0.16636215,
-                -8.848898e-6,
-                0.98606473,
+                6.2459617e-6,
+                0.038999673,
+                -5.0032672e-6,
+                0.9992392,
             ),
             scale: Vec3(
                 1.0,
@@ -354,15 +354,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                1.9841691,
-                0.49994135,
-                2.2754827,
+                2.2449956,
+                0.49992496,
+                2.2596865,
             ),
             rotation: Quat(
-                1.1781266e-5,
-                -0.023749417,
-                -4.3152977e-5,
-                0.99971795,
+                1.9367231e-5,
+                -0.06939591,
+                -2.0735426e-5,
+                0.9975892,
             ),
             scale: Vec3(
                 1.0,
@@ -377,15 +377,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -4.529952,
-                2.4999797,
-                -5.612147,
+                -5.0492163,
+                2.499931,
+                -6.0282993,
             ),
             rotation: Quat(
-                3.3643862e-6,
-                -0.03329149,
-                -9.2582775e-7,
-                0.9994457,
+                7.3457845e-6,
+                0.2680555,
+                9.548841e-6,
+                0.96340346,
             ),
             scale: Vec3(
                 1.0,
@@ -400,15 +400,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -7.554939,
-                0.49999902,
-                -3.4886525,
+                -4.2983556,
+                2.4999576,
+                -2.6122365,
             ),
             rotation: Quat(
-                -0.21654743,
-                -0.21654907,
-                0.6731332,
-                0.67313105,
+                1.9716752e-5,
+                0.0059951264,
+                -2.8919663e-5,
+                0.999982,
             ),
             scale: Vec3(
                 1.0,
@@ -423,15 +423,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -4.1945376,
-                2.499955,
-                -0.85283583,
+                -5.7273064,
+                2.4999127,
+                0.27412993,
             ),
             rotation: Quat(
-                4.944634e-6,
-                -0.026082661,
-                -1.6879303e-5,
-                0.9996598,
+                1.3019328e-5,
+                -0.0023009102,
+                -4.6772425e-6,
+                0.9999974,
             ),
             scale: Vec3(
                 1.0,
@@ -446,15 +446,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -7.0669084,
-                0.4999817,
-                5.029825,
+                -4.6012526,
+                2.4998872,
+                2.3980725,
             ),
             rotation: Quat(
-                0.24390373,
-                0.24391572,
-                0.6637086,
-                0.663707,
+                -1.559511e-5,
+                0.12684205,
+                -8.130988e-6,
+                0.9919229,
             ),
             scale: Vec3(
                 1.0,
@@ -469,15 +469,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -2.0876231,
-                2.4999635,
-                -5.7480035,
+                -2.0423634,
+                2.4999042,
+                -5.741327,
             ),
             rotation: Quat(
-                5.8374267e-6,
-                0.06578543,
-                -6.170088e-6,
-                0.9978338,
+                7.3595934e-6,
+                -0.08775672,
+                5.5570363e-6,
+                0.9961419,
             ),
             scale: Vec3(
                 1.0,
@@ -492,15 +492,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -3.1656625,
-                2.4999433,
-                -3.4006693,
+                -2.0788274,
+                2.499925,
+                -3.1981113,
             ),
             rotation: Quat(
-                -1.0061125e-5,
-                0.054074667,
-                -1.8010569e-5,
-                0.9985369,
+                1.7169506e-6,
+                0.0031044492,
+                -2.4486344e-6,
+                0.9999952,
             ),
             scale: Vec3(
                 1.0,
@@ -515,15 +515,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -2.0551093,
-                2.499902,
-                -0.59087205,
+                -2.7910721,
+                2.499912,
+                -0.1088266,
             ),
             rotation: Quat(
-                1.4003897e-5,
-                -0.008215803,
-                5.9098907e-6,
-                0.99996626,
+                4.0439677e-6,
+                0.02391229,
+                -1.3426011e-5,
+                0.9997141,
             ),
             scale: Vec3(
                 1.0,
@@ -538,15 +538,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -1.8675312,
-                2.4999292,
-                2.4463406,
+                -2.1026957,
+                2.4999423,
+                2.126103,
             ),
             rotation: Quat(
-                1.6631959e-5,
-                0.010085788,
-                2.8320439e-5,
-                0.99994916,
+                -1.6472013e-5,
+                0.07974657,
+                1.6223809e-6,
+                0.99681515,
             ),
             scale: Vec3(
                 1.0,
@@ -561,15 +561,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.20580432,
-                2.4999607,
-                -5.553546,
+                0.4159867,
+                2.4999456,
+                -5.671932,
             ),
             rotation: Quat(
-                6.2164586e-6,
-                -0.070013724,
-                1.2371928e-6,
-                0.997546,
+                4.7749563e-6,
+                -0.039806098,
+                -9.192825e-6,
+                0.99920744,
             ),
             scale: Vec3(
                 1.0,
@@ -584,15 +584,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -0.046197403,
-                2.4999087,
-                -3.1004553,
+                0.009944088,
+                2.4999382,
+                -2.9049952,
             ),
             rotation: Quat(
-                9.907863e-6,
-                -0.07425172,
-                6.9092234e-6,
-                0.99723953,
+                1.9832803e-5,
+                0.025701132,
+                -7.679594e-6,
+                0.9996697,
             ),
             scale: Vec3(
                 1.0,
@@ -607,15 +607,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.43064442,
-                2.499901,
-                -0.7200156,
+                -0.027705673,
+                2.4999232,
+                -0.5255546,
             ),
             rotation: Quat(
-                -9.297384e-6,
-                -0.16916226,
-                6.2180707e-6,
-                0.9855882,
+                -1.3373039e-5,
+                -0.01249971,
+                -5.143375e-6,
+                0.99992186,
             ),
             scale: Vec3(
                 1.0,
@@ -630,15 +630,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.33319852,
-                2.49993,
-                1.7533458,
+                0.15756427,
+                0.4999831,
+                6.2050114,
             ),
             rotation: Quat(
-                5.2576897e-6,
-                0.059048217,
-                3.0032135e-5,
-                0.99825513,
+                0.70335186,
+                -0.07272717,
+                0.07272766,
+                0.7033617,
             ),
             scale: Vec3(
                 1.0,
@@ -653,15 +653,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.5240598,
-                2.49996,
-                -5.153598,
+                2.7432377,
+                2.4999712,
+                -5.2332006,
             ),
             rotation: Quat(
-                5.4377747e-6,
-                0.021316562,
-                -3.2456228e-6,
-                0.9997728,
+                2.948699e-6,
+                -0.109006666,
+                6.1619716e-7,
+                0.994041,
             ),
             scale: Vec3(
                 1.0,
@@ -676,15 +676,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.2167573,
-                2.4999037,
-                -3.0990813,
+                2.3952043,
+                2.499925,
+                -2.9313323,
             ),
             rotation: Quat(
-                8.897506e-6,
-                0.024538169,
-                -7.983371e-6,
-                0.9996989,
+                1.1294509e-5,
+                0.057740428,
+                -4.81759e-6,
+                0.9983316,
             ),
             scale: Vec3(
                 1.0,
@@ -699,15 +699,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.777542,
-                2.4999046,
-                -1.0145668,
+                2.7014956,
+                2.4999084,
+                -0.87327075,
             ),
             rotation: Quat(
-                3.320995e-6,
-                -0.022053385,
-                -9.2231585e-6,
-                0.9997568,
+                4.2539327e-6,
+                0.047411464,
+                -2.3938906e-6,
+                0.99887544,
             ),
             scale: Vec3(
                 1.0,
@@ -722,15 +722,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.9648414,
-                2.5094926,
-                2.0242882,
+                2.5445023,
+                2.4998665,
+                2.3220227,
             ),
             rotation: Quat(
-                0.011472185,
-                0.16150488,
-                -0.05372108,
-                0.98534185,
+                2.1606564e-5,
+                0.0590353,
+                -3.931226e-6,
+                0.9982559,
             ),
             scale: Vec3(
                 1.0,
@@ -745,15 +745,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -5.765128,
-                2.4999764,
-                -3.0840755,
+                -4.923007,
+                4.49984,
+                -5.5812387,
             ),
             rotation: Quat(
-                0.70354617,
-                -0.07088181,
-                0.070885,
-                0.7035438,
+                2.8722194e-5,
+                0.20180498,
+                2.2941827e-5,
+                0.9794257,
             ),
             scale: Vec3(
                 1.0,
@@ -768,15 +768,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -13.816517,
-                0.49999946,
-                -2.6666658,
+                -4.3314514,
+                4.4999013,
+                -2.0581,
             ),
             rotation: Quat(
-                0.39274207,
-                0.39274085,
-                0.5880086,
-                0.58800864,
+                2.7312024e-5,
+                0.066441074,
+                -1.8625373e-5,
+                0.99779034,
             ),
             scale: Vec3(
                 1.0,
@@ -791,15 +791,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -4.890072,
-                0.49999946,
-                4.149463,
+                -4.310249,
+                4.4998846,
+                0.4880767,
             ),
             rotation: Quat(
-                0.9906625,
-                -3.4722166e-7,
-                -0.13633691,
-                7.805152e-7,
+                1.5218269e-5,
+                0.00909351,
+                6.987888e-8,
+                0.99995863,
             ),
             scale: Vec3(
                 1.0,
@@ -814,15 +814,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -5.3232884,
-                0.49999946,
-                7.5046816,
+                -4.576476,
+                4.4998965,
+                2.7488616,
             ),
             rotation: Quat(
-                0.17287572,
-                -0.17287457,
-                -0.6856489,
-                0.68564856,
+                -1.1975025e-5,
+                0.034274474,
+                -3.9548036e-6,
+                0.9994125,
             ),
             scale: Vec3(
                 1.0,
@@ -837,15 +837,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -2.519231,
-                4.4999247,
-                -4.939171,
+                -2.1803253,
+                4.499893,
+                -4.761975,
             ),
             rotation: Quat(
-                8.879804e-6,
-                -0.062154848,
-                -9.166951e-6,
-                0.99806654,
+                4.559176e-6,
+                0.03340758,
+                6.472455e-6,
+                0.9994418,
             ),
             scale: Vec3(
                 1.0,
@@ -860,15 +860,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -2.1316211,
-                4.4999175,
-                -2.5869262,
+                -2.0722492,
+                4.4999146,
+                -1.794916,
             ),
             rotation: Quat(
-                -5.219531e-6,
-                0.14853707,
-                -1.6233678e-5,
-                0.98890686,
+                1.0337201e-5,
+                0.0155743975,
+                -3.2420721e-6,
+                0.9998787,
             ),
             scale: Vec3(
                 1.0,
@@ -883,15 +883,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -1.9301183,
-                4.4998198,
-                0.39429086,
+                -2.307627,
+                4.49988,
+                0.61351854,
             ),
             rotation: Quat(
-                5.590077e-6,
-                0.037300963,
-                -3.5825815e-7,
-                0.99930406,
+                -8.7578326e-7,
+                0.009089355,
+                -8.641349e-7,
+                0.9999587,
             ),
             scale: Vec3(
                 1.0,
@@ -906,15 +906,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -1.9454087,
-                4.499897,
-                2.6208901,
+                -2.3021808,
+                4.4998846,
+                2.7617326,
             ),
             rotation: Quat(
-                1.2467614e-5,
-                -0.011406328,
-                9.658577e-6,
-                0.999935,
+                -8.255966e-6,
+                0.037309136,
+                8.012342e-6,
+                0.99930376,
             ),
             scale: Vec3(
                 1.0,
@@ -929,15 +929,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.023093386,
-                4.499903,
-                -4.805308,
+                0.21563683,
+                4.499931,
+                -5.2085485,
             ),
             rotation: Quat(
-                1.35582595e-5,
-                -0.05320665,
-                -4.983353e-6,
-                0.9985835,
+                7.0251995e-6,
+                0.09304502,
+                -1.8975404e-6,
+                0.9956619,
             ),
             scale: Vec3(
                 1.0,
@@ -952,15 +952,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.2381041,
-                4.499887,
-                -2.1646936,
+                0.07514802,
+                4.4999037,
+                -1.7679547,
             ),
             rotation: Quat(
-                -3.4829784e-6,
-                0.081186235,
-                1.0766839e-5,
-                0.996699,
+                -6.8500353e-6,
+                0.06929297,
+                -8.173861e-6,
+                0.9975964,
             ),
             scale: Vec3(
                 1.0,
@@ -975,15 +975,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.123668894,
-                4.499909,
-                0.13765599,
+                0.21849424,
+                2.4999511,
+                2.268026,
             ),
             rotation: Quat(
-                -1.2879159e-5,
-                0.0511759,
-                1.0409426e-5,
-                0.99868965,
+                0.7050691,
+                0.05347584,
+                -0.053473327,
+                0.70509464,
             ),
             scale: Vec3(
                 1.0,
@@ -998,15 +998,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.38199478,
-                4.4998755,
-                2.155535,
+                -0.15893307,
+                0.49999946,
+                14.054075,
             ),
             rotation: Quat(
-                1.7575554e-5,
-                0.03409461,
-                1.6102516e-5,
-                0.9994186,
+                0.24499272,
+                -0.6633089,
+                0.66330916,
+                0.24499154,
             ),
             scale: Vec3(
                 1.0,
@@ -1021,15 +1021,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.3284,
-                4.499923,
-                -4.5088305,
+                2.741496,
+                4.4999495,
+                -4.399559,
             ),
             rotation: Quat(
-                1.7217164e-6,
-                0.03293351,
-                -6.5417835e-6,
-                0.99945754,
+                -4.817967e-7,
+                0.12594306,
+                -1.3559584e-7,
+                0.9920375,
             ),
             scale: Vec3(
                 1.0,
@@ -1044,15 +1044,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.3431964,
-                4.499921,
-                -2.214988,
+                2.2909536,
+                4.4998837,
+                -1.8916278,
             ),
             rotation: Quat(
-                -3.5771816e-7,
-                0.0518102,
-                -7.923867e-6,
-                0.9986569,
+                1.621344e-5,
+                -0.010875906,
+                -7.4107456e-6,
+                0.9999409,
             ),
             scale: Vec3(
                 1.0,
@@ -1067,15 +1067,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.7946022,
-                4.4998875,
-                -0.0139336735,
+                2.6957374,
+                4.4998984,
+                0.84554696,
             ),
             rotation: Quat(
-                1.5601541e-5,
-                0.0833966,
-                -1.4010156e-5,
-                0.9965164,
+                -9.056017e-6,
+                0.10746751,
+                -4.5834727e-6,
+                0.9942086,
             ),
             scale: Vec3(
                 1.0,
@@ -1090,15 +1090,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                3.0126758,
-                4.515729,
-                2.1400247,
+                2.3865237,
+                4.499817,
+                3.011156,
             ),
             rotation: Quat(
-                0.006832012,
-                0.076710194,
-                -0.05451029,
-                0.9955388,
+                3.0853287e-5,
+                0.06858917,
+                3.6555857e-6,
+                0.99764496,
             ),
             scale: Vec3(
                 1.0,
@@ -1113,15 +1113,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -5.9567966,
-                0.49999946,
-                -15.039063,
+                -5.356343,
+                6.499813,
+                -5.3526754,
             ),
             rotation: Quat(
-                -0.6367192,
-                -0.30755216,
-                -0.30755338,
-                0.6367191,
+                3.338445e-5,
+                -0.1598523,
+                1.0022045e-5,
+                0.98714095,
             ),
             scale: Vec3(
                 1.0,
@@ -1136,15 +1136,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -9.057555,
-                0.49999946,
-                -16.593468,
+                -4.5087557,
+                6.499899,
+                -1.9152997,
             ),
             rotation: Quat(
-                -5.39113e-7,
-                -0.3264162,
-                6.6266443e-7,
-                -0.94522613,
+                2.3485596e-5,
+                -0.04065414,
+                -2.5801583e-5,
+                0.9991733,
             ),
             scale: Vec3(
                 1.0,
@@ -1159,15 +1159,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -7.4289837,
-                2.49997,
-                4.1270623,
+                -4.3715563,
+                6.4998913,
+                0.37903965,
             ),
             rotation: Quat(
-                0.40007415,
-                -0.5830352,
-                0.58305484,
-                0.40007216,
+                1.587369e-5,
+                -0.04997984,
+                -2.3563673e-6,
+                0.9987502,
             ),
             scale: Vec3(
                 1.0,
@@ -1182,15 +1182,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -1.3038301,
-                0.49999946,
-                6.2001443,
+                -4.3700805,
+                6.4998794,
+                2.4656587,
             ),
             rotation: Quat(
-                0.051233403,
-                -0.051232334,
-                -0.7052486,
-                0.70524806,
+                7.448714e-7,
+                -0.014588609,
+                -5.77096e-6,
+                0.9998936,
             ),
             scale: Vec3(
                 1.0,
@@ -1205,15 +1205,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -3.125293,
-                0.49999946,
-                -11.440222,
+                -2.0031815,
+                6.4998455,
+                -5.58802,
             ),
             rotation: Quat(
-                0.6702525,
-                -0.22530505,
-                -0.22530428,
-                -0.6702516,
+                -2.2420523e-5,
+                0.083723344,
+                -7.609045e-8,
+                0.99648905,
             ),
             scale: Vec3(
                 1.0,
@@ -1228,15 +1228,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -1.343801,
-                8.49984,
-                -1.39195,
+                -2.1030593,
+                6.499881,
+                -1.6630093,
             ),
             rotation: Quat(
-                -9.068188e-6,
-                0.1468774,
-                1.5842481e-5,
-                0.9891547,
+                1.4350294e-5,
+                -0.027450336,
+                9.11208e-7,
+                0.9996232,
             ),
             scale: Vec3(
                 1.0,
@@ -1251,15 +1251,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -1.9640384,
-                6.4998183,
-                0.043135934,
+                -2.2546158,
+                6.4998837,
+                1.0217232,
             ),
             rotation: Quat(
-                7.724208e-7,
-                0.05969343,
-                -5.3838295e-7,
-                0.99821675,
+                -3.3091305e-6,
+                -0.048803434,
+                -1.8368564e-7,
+                0.9988084,
             ),
             scale: Vec3(
                 1.0,
@@ -1274,15 +1274,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                -2.1944664,
-                6.49986,
-                2.2293992,
+                -2.223439,
+                6.4998918,
+                3.0436418,
             ),
             rotation: Quat(
-                1.1161066e-5,
-                0.051818613,
-                1.1157999e-5,
-                0.9986565,
+                -3.5988558e-6,
+                -0.04613042,
+                9.794142e-6,
+                0.9989354,
             ),
             scale: Vec3(
                 1.0,
@@ -1297,15 +1297,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.10358212,
-                6.499878,
-                -4.4241066,
+                -0.34121677,
+                0.49999946,
+                -12.28647,
             ),
             rotation: Quat(
-                6.104767e-6,
-                0.053888626,
-                -5.7036636e-6,
-                0.99854696,
+                -0.7058801,
+                -0.04163728,
+                0.04163834,
+                -0.7058795,
             ),
             scale: Vec3(
                 1.0,
@@ -1320,15 +1320,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.20536682,
-                6.499875,
-                -2.253804,
+                0.21524978,
+                6.499891,
+                -2.1798837,
             ),
             rotation: Quat(
-                -8.429002e-6,
-                0.050227713,
-                1.5702573e-5,
-                0.9987378,
+                -2.7827295e-7,
+                0.028934516,
+                -1.21381645e-5,
+                0.99958134,
             ),
             scale: Vec3(
                 1.0,
@@ -1343,15 +1343,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.17854159,
-                6.4999056,
-                -0.03477119,
+                0.21331881,
+                4.4999504,
+                1.0747148,
             ),
             rotation: Quat(
-                -1.2174453e-5,
-                0.09614292,
-                1.2362508e-5,
-                0.9953675,
+                0.70372194,
+                0.069124065,
+                -0.06912637,
+                0.7037178,
             ),
             scale: Vec3(
                 1.0,
@@ -1366,15 +1366,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                0.5086605,
-                6.4998803,
-                2.1787782,
+                0.04732995,
+                2.4999766,
+                5.526497,
             ),
             rotation: Quat(
-                1.47881665e-5,
-                0.074487105,
-                2.0442863e-5,
-                0.997222,
+                -6.6093203e-6,
+                -0.19084512,
+                -4.316239e-7,
+                0.98162013,
             ),
             scale: Vec3(
                 1.0,
@@ -1389,15 +1389,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.1565268,
-                6.499895,
-                -4.180186,
+                2.5132034,
+                0.49999946,
+                -12.6818905,
             ),
             rotation: Quat(
-                1.2203349e-6,
-                0.05432318,
-                -7.3620336e-6,
-                0.9985234,
+                0.4015998,
+                -0.58199495,
+                -0.5819949,
+                -0.4015986,
             ),
             scale: Vec3(
                 1.0,
@@ -1412,15 +1412,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.2868984,
-                6.499886,
-                -1.9875554,
+                2.3392503,
+                6.499887,
+                -2.1237445,
             ),
             rotation: Quat(
-                -6.299892e-6,
-                0.06857006,
-                -1.2678447e-5,
-                0.99764633,
+                1.4020251e-5,
+                -0.024601525,
+                -1.0950789e-5,
+                0.9996973,
             ),
             scale: Vec3(
                 1.0,
@@ -1435,15 +1435,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                2.5892315,
-                6.572279,
-                0.19461481,
+                3.0234728,
+                6.499886,
+                -0.015130474,
             ),
             rotation: Quat(
-                -0.006034577,
-                0.16051215,
-                -0.037162755,
-                0.98631555,
+                -6.812577e-6,
+                -0.011945665,
+                -4.023148e-6,
+                0.99992865,
             ),
             scale: Vec3(
                 1.0,
@@ -1458,15 +1458,15 @@ expression: bodies
         ),
         Transform {
             translation: Vec3(
-                3.456651,
-                6.4772625,
-                2.4567757,
+                2.1512942,
+                6.4998126,
+                3.0366783,
             ),
             rotation: Quat(
-                0.01399032,
-                0.20793366,
-                -0.053124662,
-                0.97659904,
+                3.4144425e-5,
+                0.06691018,
+                8.9876676e-7,
+                0.997759,
             ),
             scale: Vec3(
                 1.0,
diff --git a/crates/examples_common_2d/src/lib.rs b/crates/examples_common_2d/src/lib.rs
index 51283b73..ccbfa54b 100644
--- a/crates/examples_common_2d/src/lib.rs
+++ b/crates/examples_common_2d/src/lib.rs
@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 use bevy::{
     diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin},
     prelude::*,
@@ -12,8 +14,14 @@ impl Plugin for XpbdExamplePlugin {
         app.add_plugins((PhysicsPlugins::default(), FrameTimeDiagnosticsPlugin))
             .add_state::<AppState>()
             .add_systems(Startup, setup)
-            .add_systems(OnEnter(AppState::Paused), bevy_xpbd_2d::pause)
-            .add_systems(OnExit(AppState::Paused), bevy_xpbd_2d::resume)
+            .add_systems(
+                OnEnter(AppState::Paused),
+                |mut time: ResMut<Time<Physics>>| time.pause(),
+            )
+            .add_systems(
+                OnExit(AppState::Paused),
+                |mut time: ResMut<Time<Physics>>| time.unpause(),
+            )
             .add_systems(Update, update_fps_text)
             .add_systems(Update, pause_button)
             .add_systems(Update, step_button.run_if(in_state(AppState::Paused)));
@@ -41,9 +49,9 @@ fn pause_button(
     }
 }
 
-fn step_button(mut physics_loop: ResMut<PhysicsLoop>, keys: Res<Input<KeyCode>>) {
+fn step_button(mut time: ResMut<Time<Physics>>, keys: Res<Input<KeyCode>>) {
     if keys.just_pressed(KeyCode::Return) {
-        physics_loop.step();
+        time.advance_by(Duration::from_secs_f64(1.0 / 60.0));
     }
 }
 
diff --git a/crates/examples_common_3d/src/lib.rs b/crates/examples_common_3d/src/lib.rs
index 6be41ad8..25f301c2 100644
--- a/crates/examples_common_3d/src/lib.rs
+++ b/crates/examples_common_3d/src/lib.rs
@@ -1,3 +1,5 @@
+use std::time::Duration;
+
 use bevy::{
     diagnostic::{DiagnosticsStore, FrameTimeDiagnosticsPlugin},
     prelude::*,
@@ -12,8 +14,14 @@ impl Plugin for XpbdExamplePlugin {
         app.add_plugins((PhysicsPlugins::default(), FrameTimeDiagnosticsPlugin))
             .add_state::<AppState>()
             .add_systems(Startup, setup)
-            .add_systems(OnEnter(AppState::Paused), bevy_xpbd_3d::pause)
-            .add_systems(OnExit(AppState::Paused), bevy_xpbd_3d::resume)
+            .add_systems(
+                OnEnter(AppState::Paused),
+                |mut time: ResMut<Time<Physics>>| time.pause(),
+            )
+            .add_systems(
+                OnExit(AppState::Paused),
+                |mut time: ResMut<Time<Physics>>| time.unpause(),
+            )
             .add_systems(Update, update_fps_text)
             .add_systems(Update, pause_button)
             .add_systems(Update, step_button.run_if(in_state(AppState::Paused)));
@@ -41,9 +49,9 @@ fn pause_button(
     }
 }
 
-fn step_button(mut physics_loop: ResMut<PhysicsLoop>, keys: Res<Input<KeyCode>>) {
+fn step_button(mut time: ResMut<Time<Physics>>, keys: Res<Input<KeyCode>>) {
     if keys.just_pressed(KeyCode::Return) {
-        physics_loop.step();
+        time.advance_by(Duration::from_secs_f64(1.0 / 60.0));
     }
 }
 
diff --git a/src/constraints/mod.rs b/src/constraints/mod.rs
index 3900ab7b..92073295 100644
--- a/src/constraints/mod.rs
+++ b/src/constraints/mod.rs
@@ -133,7 +133,7 @@
 //! ```
 //!
 //! where `w_i` is the inverse mass of particle `i`, `|▽C_i|` is the length of the gradient vector for particle `i`,
-//! `α` is the constraint's compliance (inverse of stiffness) and `h` is the [substep size](SubDeltaTime). Using `α = 0`
+//! `α` is the constraint's compliance (inverse of stiffness) and `h` is the substep size. Using `α = 0`
 //! corresponds to infinite stiffness.
 //!
 //! The minus sign is there because the gradients point in the direction in which `C` increases the most,
diff --git a/src/lib.rs b/src/lib.rs
index bffd1d2f..0f7153c9 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -164,8 +164,8 @@
 //! ### Configuration
 //!
 //! - [Gravity]
-//! - [Physics timestep](PhysicsTimestep)
-//! - [Speed up or slow down time](PhysicsTimescale)
+//! - [Physics timestep](Physics#usage)
+//! - [Physics speed](Physics#physics-speed)
 //! - [Configure simulation fidelity with substeps](SubstepCount)
 //! - [Render physics objects for debugging](PhysicsDebugPlugin)
 //!
@@ -177,8 +177,7 @@
 //!     - [`SubstepSchedule`] and [`SubstepSet`]
 //!     - [`PostProcessCollisions`] schedule
 //! - [Configure the schedule used for running physics](PhysicsPlugins#custom-schedule)
-//! - [Pausing, resuming and stepping the physics loop](PhysicsLoop)
-//! - [Running physics manually](PhysicsPlugins#running-physics-manually)
+//! - [Pausing, resuming and stepping physics](Physics#pausing-resuming-and-stepping-physics)
 //! - [Usage on servers](#can-the-engine-be-used-on-servers)
 //!
 //! ### Architecture
@@ -315,11 +314,12 @@
 //! ### Can the engine be used on servers?
 //!
 //! Yes! Networking often requires running the simulation in a specific schedule, and in Bevy XPBD you can
-//! [set the schedule that runs physics](PhysicsPlugins#custom-schedule) and [configure the timestep](PhysicsTimestep)
+//! [set the schedule that runs physics](PhysicsPlugins#custom-schedule) and [configure the timestep](Physics)
 //! to whatever you want.
 //!
-//! One configuration is to run the client in `FixedUpdate`, and to use [`PhysicsTimestep::FixedOnce`] on both the
-//! server and the client to make sure the physics simulation is only advanced by one step each time the schedule runs.
+//! One configuration is to run the client in `FixedUpdate`, and to use a fixed timestep for `Time<Physics>`
+//! on both the server and the client to make sure the physics simulation is only advanced by one step
+//! each time the schedule runs.
 //!
 //! Note that while Bevy XPBD should be locally deterministic, it can produce slightly different results on different
 //! machines.
@@ -393,7 +393,7 @@
 //!         solve_velocities(particles and bodies)
 //! ```
 //!
-//! where `h` is the [substep size](SubDeltaTime), `q` is the [rotation](Rotation) as a quaternion,
+//! where `h` is the substep size, `q` is the [rotation](Rotation) as a quaternion,
 //! `ω` is the [angular velocity](AngularVelocity), `I` is the [angular inertia tensor](`Inertia`) and `τ` is the
 //! [external torque](ExternalTorque).
 //!
@@ -498,7 +498,6 @@ pub mod prelude {
     pub(crate) use crate::{math::*, *};
     pub use bevy_xpbd_derive::*;
 }
-pub use prelude::setup::{pause, resume};
 
 mod utils;
 
diff --git a/src/plugins/collision/broad_phase.rs b/src/plugins/collision/broad_phase.rs
index 15e33239..a7fec4f1 100644
--- a/src/plugins/collision/broad_phase.rs
+++ b/src/plugins/collision/broad_phase.rs
@@ -68,10 +68,10 @@ fn update_aabb(
         (&Position, Option<&LinearVelocity>, Option<&AngularVelocity>),
         With<Children>,
     >,
-    dt: Res<DeltaTime>,
+    dt: Res<Time>,
 ) {
     // Safety margin multiplier bigger than DELTA_TIME to account for sudden accelerations
-    let safety_margin_factor = 2.0 * dt.0;
+    let safety_margin_factor = 2.0 * dt.delta_seconds_adjusted();
 
     for (collider, mut aabb, pos, rot, collider_parent, lin_vel, ang_vel) in &mut colliders {
         let (lin_vel, ang_vel) = if let (Some(lin_vel), Some(ang_vel)) = (lin_vel, ang_vel) {
diff --git a/src/plugins/integrator.rs b/src/plugins/integrator.rs
index fc306af4..05873c3a 100644
--- a/src/plugins/integrator.rs
+++ b/src/plugins/integrator.rs
@@ -50,8 +50,10 @@ type PosIntegrationComponents = (
 fn integrate_pos(
     mut bodies: Query<PosIntegrationComponents, Without<Sleeping>>,
     gravity: Res<Gravity>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (
         rb,
         pos,
@@ -78,7 +80,7 @@ fn integrate_pos(
         if rb.is_dynamic() {
             // Apply damping
             if let Some(damping) = lin_damping {
-                lin_vel.0 *= 1.0 / (1.0 + sub_dt.0 * damping.0);
+                lin_vel.0 *= 1.0 / (1.0 + delta_secs * damping.0);
             }
 
             let effective_mass = locked_axes.apply_to_vec(Vector::splat(mass.0));
@@ -88,14 +90,14 @@ fn integrate_pos(
             let gravitation_force =
                 effective_mass * gravity.0 * gravity_scale.map_or(1.0, |scale| scale.0);
             let external_forces = gravitation_force + external_force.force();
-            let delta_lin_vel = sub_dt.0 * external_forces * effective_inv_mass;
+            let delta_lin_vel = delta_secs * external_forces * effective_inv_mass;
             // avoid triggering bevy's change detection unnecessarily
             if delta_lin_vel != Vector::ZERO {
                 lin_vel.0 += delta_lin_vel;
             }
         }
         if lin_vel.0 != Vector::ZERO {
-            translation.0 += locked_axes.apply_to_vec(sub_dt.0 * lin_vel.0);
+            translation.0 += locked_axes.apply_to_vec(delta_secs * lin_vel.0);
         }
     }
 }
@@ -116,10 +118,9 @@ type RotIntegrationComponents = (
 /// Explicitly integrates the rotations and angular velocities of bodies taking only external torque into account.
 /// This acts as a prediction for the next rotations of the bodies.
 #[cfg(feature = "2d")]
-fn integrate_rot(
-    mut bodies: Query<RotIntegrationComponents, Without<Sleeping>>,
-    sub_dt: Res<SubDeltaTime>,
-) {
+fn integrate_rot(mut bodies: Query<RotIntegrationComponents, Without<Sleeping>>, time: Res<Time>) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (
         rb,
         mut rot,
@@ -147,14 +148,14 @@ fn integrate_rot(
             if let Some(damping) = ang_damping {
                 // avoid triggering bevy's change detection unnecessarily
                 if ang_vel.0 != 0.0 && damping.0 != 0.0 {
-                    ang_vel.0 *= 1.0 / (1.0 + sub_dt.0 * damping.0);
+                    ang_vel.0 *= 1.0 / (1.0 + delta_secs * damping.0);
                 }
             }
 
             let effective_inv_inertia = locked_axes.apply_to_rotation(inv_inertia.0);
 
             // Apply external torque
-            let delta_ang_vel = sub_dt.0
+            let delta_ang_vel = delta_secs
                 * effective_inv_inertia
                 * (external_torque.torque() + external_force.torque());
             // avoid triggering bevy's change detection unnecessarily
@@ -163,7 +164,7 @@ fn integrate_rot(
             }
         }
         // avoid triggering bevy's change detection unnecessarily
-        let delta = locked_axes.apply_to_angular_velocity(sub_dt.0 * ang_vel.0);
+        let delta = locked_axes.apply_to_angular_velocity(delta_secs * ang_vel.0);
         if delta != 0.0 {
             *rot += Rotation::from_radians(delta);
         }
@@ -173,10 +174,9 @@ fn integrate_rot(
 /// Explicitly integrates the rotations and angular velocities of bodies taking only external torque into account.
 /// This acts as a prediction for the next rotations of the bodies.
 #[cfg(feature = "3d")]
-fn integrate_rot(
-    mut bodies: Query<RotIntegrationComponents, Without<Sleeping>>,
-    sub_dt: Res<SubDeltaTime>,
-) {
+fn integrate_rot(mut bodies: Query<RotIntegrationComponents, Without<Sleeping>>, time: Res<Time>) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (
         rb,
         mut rot,
@@ -204,7 +204,7 @@ fn integrate_rot(
             if let Some(damping) = ang_damping {
                 // avoid triggering bevy's change detection unnecessarily
                 if ang_vel.0 != Vector::ZERO && damping.0 != 0.0 {
-                    ang_vel.0 *= 1.0 / (1.0 + sub_dt.0 * damping.0);
+                    ang_vel.0 *= 1.0 / (1.0 + delta_secs * damping.0);
                 }
             }
 
@@ -212,7 +212,7 @@ fn integrate_rot(
             let effective_inv_inertia = locked_axes.apply_to_rotation(inv_inertia.rotated(&rot).0);
 
             // Apply external torque
-            let delta_ang_vel = sub_dt.0
+            let delta_ang_vel = delta_secs
                 * effective_inv_inertia
                 * ((external_torque.torque() + external_force.torque())
                     - ang_vel.0.cross(effective_inertia * ang_vel.0));
@@ -224,8 +224,8 @@ fn integrate_rot(
 
         let q = Quaternion::from_vec4(ang_vel.0.extend(0.0)) * rot.0;
         let effective_dq = locked_axes
-            .apply_to_angular_velocity(sub_dt.0 * 0.5 * q.xyz())
-            .extend(sub_dt.0 * 0.5 * q.w);
+            .apply_to_angular_velocity(delta_secs * 0.5 * q.xyz())
+            .extend(delta_secs * 0.5 * q.w);
         // avoid triggering bevy's change detection unnecessarily
         let delta = Quaternion::from_vec4(effective_dq);
         if delta != Quaternion::IDENTITY {
diff --git a/src/plugins/mod.rs b/src/plugins/mod.rs
index 62ba9aba..b383c78d 100644
--- a/src/plugins/mod.rs
+++ b/src/plugins/mod.rs
@@ -90,40 +90,10 @@ use bevy::prelude::*;
 /// }
 /// ```
 ///
-/// Note that using `FixedUpdate` with [`PhysicsTimestep::Fixed`] can produce unexpected results due to two separate
+/// Note that using `FixedUpdate` with a fixed [physics timestep](Physics) can produce unexpected results due to two separate
 /// fixed timesteps. However, using `FixedUpdate` can be useful for [networking usage](crate#can-the-engine-be-used-on-servers)
 /// when you need to keep the client and server in sync.
 ///
-/// ## Running physics manually
-///
-/// You can pause, step and resume the simulation with the [`PhysicsLoop`] resource, but the changes
-/// only take affect the next frame.
-///
-/// To advance the simulation by a certain amount of time instantly, you can set the value of
-/// the [`DeltaTime`] resource and manually run the [`PhysicsSchedule`] in an exclusive system:
-///
-/// ```
-/// use bevy::prelude::*;
-#[cfg_attr(
-    feature = "2d",
-    doc = "use bevy_xpbd_2d::{prelude::*, PhysicsSchedule};"
-)]
-#[cfg_attr(
-    feature = "3d",
-    doc = "use bevy_xpbd_3d::{prelude::*, PhysicsSchedule};"
-)]
-///
-/// fn run_physics(world: &mut World) {
-///     // Set the amount of time a step should take
-///     world.resource_mut::<DeltaTime>().0 = 1.0 / 120.0;
-///
-///     // Advance the simulation by 10 steps at 120 Hz
-///     for _ in 0..10 {
-///         world.run_schedule(PhysicsSchedule);
-///     }
-/// }
-/// ```
-///
 /// ## Custom plugins
 ///
 /// First, create a new plugin. If you want to run your systems in the engine's schedules, get either the [`PhysicsSchedule`]
diff --git a/src/plugins/setup.rs b/src/plugins/setup/mod.rs
similarity index 59%
rename from src/plugins/setup.rs
rename to src/plugins/setup/mod.rs
index 9e2c76a3..84d5fbe9 100644
--- a/src/plugins/setup.rs
+++ b/src/plugins/setup/mod.rs
@@ -2,16 +2,21 @@
 //!
 //! See [`PhysicsSetupPlugin`].
 
+mod time;
+
+use std::time::Duration;
+
+pub use time::*;
+
+use super::sync::PreviousGlobalTransform;
+use crate::prelude::*;
 use bevy::{
     ecs::schedule::{ExecutorKind, ScheduleBuildSettings},
+    prelude::*,
     transform::TransformSystem,
+    utils::intern::Interned,
 };
 
-use crate::prelude::*;
-
-use super::sync::PreviousGlobalTransform;
-use bevy::utils::intern::Interned;
-
 /// Sets up the physics engine by initializing the necessary schedules, sets and resources.
 ///
 /// This plugin does *not* initialize any other plugins or physics systems.
@@ -57,24 +62,19 @@ impl Default for PhysicsSetupPlugin {
 impl Plugin for PhysicsSetupPlugin {
     fn build(&self, app: &mut App) {
         // Init resources and register component types
-        app.init_resource::<PhysicsTimestep>()
-            .init_resource::<PhysicsTimescale>()
-            .init_resource::<DeltaTime>()
-            .init_resource::<SubDeltaTime>()
+        app.insert_resource(Time::new_with(Physics::default()))
+            .insert_resource(Time::new_with(Substeps))
             .init_resource::<SubstepCount>()
             .init_resource::<BroadCollisionPairs>()
             .init_resource::<SleepingThreshold>()
             .init_resource::<DeactivationTime>()
             .init_resource::<Gravity>()
-            .register_type::<PhysicsTimestep>()
-            .register_type::<PhysicsTimescale>()
-            .register_type::<DeltaTime>()
-            .register_type::<SubDeltaTime>()
+            .register_type::<Time<Physics>>()
+            .register_type::<Time<Substeps>>()
             .register_type::<SubstepCount>()
             .register_type::<BroadCollisionPairs>()
             .register_type::<SleepingThreshold>()
             .register_type::<DeactivationTime>()
-            .register_type::<PhysicsLoop>()
             .register_type::<Gravity>()
             .register_type::<RigidBody>()
             .register_type::<Sleeping>()
@@ -129,14 +129,6 @@ impl Plugin for PhysicsSetupPlugin {
                 .before(TransformSystem::TransformPropagate),
         );
 
-        // Check and store if schedule is configured to run in FixedUpdate.
-        let fixed_update = schedule == FixedUpdate.intern();
-
-        app.insert_resource(PhysicsLoop {
-            fixed_update,
-            ..Default::default()
-        });
-
         // Create physics schedule, the schedule that advances the physics simulation
         let mut physics_schedule = Schedule::new(PhysicsSchedule);
 
@@ -216,76 +208,6 @@ impl Plugin for PhysicsSetupPlugin {
     }
 }
 
-/// Controls the physics simulation loop.
-///
-/// ## Example
-///
-/// ```no_run
-/// use bevy::prelude::*;
-#[cfg_attr(feature = "2d", doc = "use bevy_xpbd_2d::prelude::*;")]
-#[cfg_attr(feature = "3d", doc = "use bevy_xpbd_3d::prelude::*;")]
-///
-/// fn main() {
-///     App::new()
-///         .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
-///         // `pause` is a provided system that calls `PhysicsLoop::pause`
-#[cfg_attr(
-    feature = "2d",
-    doc = "        .add_systems(Startup, bevy_xpbd_2d::pause)"
-)]
-#[cfg_attr(
-    feature = "3d",
-    doc = "        .add_systems(Startup, bevy_xpbd_3d::pause)"
-)]
-///         .add_systems(Update, step_manually)
-///         .run();
-/// }
-///
-/// fn step_manually(input: Res<Input<KeyCode>>, mut physics_loop: ResMut<PhysicsLoop>) {
-///     // Advance the simulation by one frame every time Space is pressed
-///     if input.just_pressed(KeyCode::Space) {
-///         physics_loop.step();
-///     }
-/// }
-/// ```
-#[derive(Reflect, Resource, Debug, Default)]
-#[reflect(Resource)]
-pub struct PhysicsLoop {
-    /// Time accumulated into the physics loop. This is consumed by the [`PhysicsSchedule`].
-    pub accumulator: Scalar,
-    /// Number of steps queued by the user. Time will be added to the accumulator according to the number of queued step.
-    pub queued_steps: u32,
-    /// If [`PhysicsSchedule`] runs in [`FixedUpdate`]. Determines the delta time for the simulation.
-    pub(crate) fixed_update: bool,
-    /// Determines if the simulation is paused.
-    pub paused: bool,
-}
-
-impl PhysicsLoop {
-    /// Add a step to be run on the next run of the [`PhysicsSchedule`].
-    pub fn step(&mut self) {
-        self.queued_steps += 1;
-    }
-    /// Pause the simulation.
-    pub fn pause(&mut self) {
-        self.paused = true;
-    }
-    /// Resume the simulation.
-    pub fn resume(&mut self) {
-        self.paused = false;
-    }
-}
-
-/// Pause the simulation.
-pub fn pause(mut physics_loop: ResMut<PhysicsLoop>) {
-    physics_loop.pause();
-}
-
-/// Resume the simulation.
-pub fn resume(mut physics_loop: ResMut<PhysicsLoop>) {
-    physics_loop.resume();
-}
-
 /// True if a system is running for the first time.
 struct IsFirstRun(bool);
 
@@ -297,90 +219,92 @@ impl Default for IsFirstRun {
 
 /// Runs the [`PhysicsSchedule`].
 fn run_physics_schedule(world: &mut World, mut is_first_run: Local<IsFirstRun>) {
-    let mut physics_loop = world
-        .remove_resource::<PhysicsLoop>()
-        .expect("no PhysicsLoop resource");
-
-    #[cfg(feature = "f32")]
-    let mut delta_seconds = if physics_loop.fixed_update {
-        world.resource::<Time<Fixed>>().delta_seconds()
-    } else {
-        world.resource::<Time>().delta_seconds()
-    };
-
-    #[cfg(feature = "f64")]
-    let mut delta_seconds = if physics_loop.fixed_update {
-        world.resource::<Time<Fixed>>().delta_seconds_f64()
-    } else {
-        world.resource::<Time>().delta_seconds_f64()
-    };
-
-    let time_step = *world.resource::<PhysicsTimestep>();
-    let time_scale = world.resource::<PhysicsTimescale>().0.max(0.0);
-
-    // Update `DeltaTime` according to the `PhysicsTimestep` configuration
-    let (raw_dt, accumulate) = match time_step {
-        PhysicsTimestep::Fixed(fixed_delta_seconds) => (fixed_delta_seconds, true),
-        PhysicsTimestep::FixedOnce(fixed_delta_seconds) => (fixed_delta_seconds, false),
-        PhysicsTimestep::Variable { max_dt } => (delta_seconds.min(max_dt), true),
-    };
-
-    // On the first run of the schedule, `delta_seconds` could be 0.0.
-    // In that case, replace it with the fixed timestep amount.
-    // With a variable timestep, the physics accumulator might not increase
-    // until the second run of the system.
-    if is_first_run.0 {
-        delta_seconds = raw_dt;
-        is_first_run.0 = false;
-    }
-
-    let dt = raw_dt * time_scale;
-    world.resource_mut::<DeltaTime>().0 = dt;
-
-    match accumulate {
-        false if physics_loop.paused && physics_loop.queued_steps == 0 => {}
-        false => {
-            if physics_loop.queued_steps > 0 {
-                physics_loop.queued_steps -= 1;
+    let _ = world.try_schedule_scope(PhysicsSchedule, |world, schedule| {
+        let real_delta = world.resource::<Time<Real>>().delta();
+        let old_delta = world.resource::<Time<Physics>>().delta();
+        let is_paused = world.resource::<Time<Physics>>().is_paused();
+        let physics_clock = world.resource_mut::<Time<Physics>>();
+
+        // Get the scaled timestep delta time based on the timestep mode.
+        let timestep = match physics_clock.timestep_mode() {
+            TimestepMode::Fixed { delta, .. } => delta.mul_f64(physics_clock.relative_speed_f64()),
+            TimestepMode::FixedOnce { delta } => delta.mul_f64(physics_clock.relative_speed_f64()),
+            TimestepMode::Variable { max_delta } => {
+                let scaled_delta = real_delta.mul_f64(physics_clock.relative_speed_f64());
+                scaled_delta.min(max_delta)
             }
-            debug!("running PhysicsSchedule");
-            world.run_schedule(PhysicsSchedule);
-        }
-        true => {
-            // Add time to the accumulator
-            if physics_loop.paused {
-                physics_loop.accumulator += dt * physics_loop.queued_steps as Scalar;
-                physics_loop.queued_steps = 0;
+        };
+
+        // How many steps should be run during this frame.
+        // For `TimestepMode::Fixed`, this is computed using the accumulated overstep.
+        let mut queued_steps = 1;
+
+        if let TimestepMode::Fixed { delta, overstep } =
+            world.resource_mut::<Time<Physics>>().timestep_mode_mut()
+        {
+            // If paused, add the `Physics` delta time, otherwise add real time.
+            if is_paused {
+                *overstep += old_delta;
             } else {
-                physics_loop.accumulator += delta_seconds * time_scale;
+                // TODO: This should probably use real time and not the fixed timestep,
+                //       but it seems to quickly lag and fall into the "spiral of death".
+                *overstep += timestep;
             }
 
-            // Step the simulation until the accumulator has been consumed.
-            // Note that a small remainder may be passed on to the next run of the physics schedule.
-            while physics_loop.accumulator >= dt && dt > 0.0 {
+            // Consume as many steps as possible with the fixed `delta`.
+            queued_steps = (overstep.as_secs_f64() / delta.as_secs_f64()) as usize;
+            *overstep -= delta.mul_f64(queued_steps as f64);
+        };
+
+        // Advance physics clock by timestep if not paused.
+        if !is_paused {
+            world.resource_mut::<Time<Physics>>().advance_by(timestep);
+        }
+
+        if world.resource::<Time<Physics>>().delta() >= timestep {
+            // Set generic `Time` resource to `Time<Physics>`.
+            *world.resource_mut::<Time>() = world.resource::<Time<Physics>>().as_generic();
+
+            // Advance simulation by the number of queued steps.
+            for _ in 0..queued_steps {
                 debug!("running PhysicsSchedule");
-                world.run_schedule(PhysicsSchedule);
-                physics_loop.accumulator -= dt;
+                schedule.run(world);
             }
         }
-    }
 
-    world.insert_resource(physics_loop);
+        // If physics is paused, reset delta time to stop simulation
+        // unless users manually advance `Time<Physics>`.
+        if is_paused {
+            world
+                .resource_mut::<Time<Physics>>()
+                .advance_by(Duration::ZERO);
+        }
+    });
+
+    is_first_run.0 = false;
+
+    // Set generic `Time` resource back to `Time<Virtual>`.
+    *world.resource_mut::<Time>() = world.resource::<Time<Virtual>>().as_generic();
 }
 
 /// Runs the [`SubstepSchedule`].
 fn run_substep_schedule(world: &mut World) {
+    let delta = world.resource::<Time<Physics>>().delta();
     let SubstepCount(substeps) = *world.resource::<SubstepCount>();
-    let dt = world.resource::<DeltaTime>().0;
+    let sub_delta = delta.div_f64(substeps as f64);
 
-    // Update `SubDeltaTime`
-    let mut sub_delta_time = world.resource_mut::<SubDeltaTime>();
-    sub_delta_time.0 = dt / substeps as Scalar;
+    let mut sub_delta_time = world.resource_mut::<Time<Substeps>>();
+    sub_delta_time.advance_by(sub_delta);
 
-    for i in 0..substeps {
-        debug!("running SubstepSchedule: {i}");
-        world.run_schedule(SubstepSchedule);
-    }
+    let _ = world.try_schedule_scope(SubstepSchedule, |world, schedule| {
+        for i in 0..substeps {
+            debug!("running SubstepSchedule: {i}");
+            *world.resource_mut::<Time>() = world.resource::<Time<Substeps>>().as_generic();
+            schedule.run(world);
+        }
+    });
+
+    *world.resource_mut::<Time>() = world.resource::<Time<Virtual>>().as_generic();
 }
 
 /// Runs the [`PostProcessCollisions`] schedule.
diff --git a/src/plugins/setup/time.rs b/src/plugins/setup/time.rs
new file mode 100644
index 00000000..8b2c6fcc
--- /dev/null
+++ b/src/plugins/setup/time.rs
@@ -0,0 +1,492 @@
+//! Clocks used for tracking physics simulation time.
+
+use std::time::Duration;
+
+use bevy::prelude::*;
+
+use crate::prelude::*;
+
+/// The type of timestep used for the [`Time<Physics>`](Physics) clock.
+#[derive(Reflect, Clone, Copy, Debug, PartialEq)]
+pub enum TimestepMode {
+    /// **Fixed timestep**: The physics simulation will be advanced by a fixed `delta`
+    /// amount of time every frame until the accumulated `overstep` value has been consumed.
+    /// This means that physics can run 0, 1, 2 or more times per frame based on how long the
+    /// previous frames took.
+    ///
+    /// A fixed timestep allows consistent behavior across different machines and frame rates.
+    Fixed {
+        /// The amount of time that the simulation should be advanced by during a step.
+        delta: Duration,
+        /// The amount of accumulated time. The simulation will consume it in steps of `delta`
+        /// to try to catch up to real time.
+        overstep: Duration,
+    },
+    /// **Fixed delta, once per frame**: The physics simulation will be advanced by
+    /// a fixed `delta` amount of time once per frame. This should only be used
+    /// in cases where you can guarantee a fixed number of executions,
+    /// like in `FixedUpdate` or on a server.
+    FixedOnce {
+        /// The amount of time that the simulation should be advanced by during a step.
+        delta: Duration,
+    },
+    /// **Variable timestep**: The physics simulation will be advanced by
+    /// `Time::delta_seconds().min(max_delta)` seconds at each Bevy tick.
+    /// Frame rate will affect the simulation result.
+    Variable {
+        /// The maximum amount of time the physics simulation can be advanced at once.
+        /// This makes sure that the simulation doesn't break when the delta time is large.
+        ///
+        /// A good default is `1.0 / 60.0` (60 Hz)
+        max_delta: Duration,
+    },
+}
+
+/// The clock representing physics time, following `Time<Real>`.
+/// Can be configured to use a fixed or variable timestep.
+///
+/// The clock is automatically set as the generic `Time` resource for
+/// the [`PhysicsSchedule`].
+///
+/// By default, a fixed timestep of 60 Hz is used.
+///
+/// ## Usage
+///
+/// The timestep used for advancing the simulation can be configured by overwriting
+/// the [`Time<Physics>`](Physics) resource:
+///
+/// ```no_run
+/// use bevy::{prelude::*, utils::Duration};
+#[cfg_attr(feature = "2d", doc = "use bevy_xpbd_2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "use bevy_xpbd_3d::prelude::*;")]
+///
+/// fn main() {
+///     App::new()
+///         .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
+///         .insert_resource(Time::new_with(Physics::fixed_hz(1.0 / 144.0)))
+///         .run();
+/// }
+///```
+///
+/// In the [`PhysicsSchedule`], the generic `Time` resource is automatically
+/// replaced by [`Time<Physics>`](Physics), so time works in a unified
+/// way across schedules:
+///
+/// ```
+/// # use bevy::prelude::*;
+/// #
+/// // In `Update`, `Time` is `Time<Virtual>`, but in `PhysicsSchedule` it's `Time<Physics>`
+/// fn print_delta_time(time: Res<Time>) {
+///     println!("{}", time.delta_seconds());
+/// }
+/// ```
+///
+/// ### Physics speed
+///
+/// The relative speed of physics can be configured at startup using
+/// [`with_relative_speed`](PhysicsTime::with_relative_speed) or when the app is running
+/// using [`set_relative_speed`](PhysicsTime::set_relative_speed):
+///
+/// ```no_run
+/// use bevy::{prelude::*, utils::Duration};
+#[cfg_attr(
+    feature = "2d",
+    doc = "use bevy_xpbd_2d::{prelude::*, PhysicsSchedule, PhysicsStepSet};"
+)]
+#[cfg_attr(
+    feature = "3d",
+    doc = "use bevy_xpbd_3d::{prelude::*, PhysicsSchedule, PhysicsStepSet};"
+)]
+///
+/// fn main() {
+///     App::new()
+///         .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
+///         // Run physics at 0.5 speed
+///         .insert_resource(Time::<Physics>::default().with_relative_speed(0.5))
+///         .run();
+/// }
+///```
+///
+/// ### Pausing, resuming and stepping physics
+///
+/// [`Time<Physics>`](Physics) can be used to pause and resume the simulation:
+///
+/// ```
+/// use bevy::prelude::*;
+#[cfg_attr(feature = "2d", doc = "use bevy_xpbd_2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "use bevy_xpbd_3d::prelude::*;")]
+///
+/// fn pause(mut time: ResMut<Time<Physics>>) {
+///     time.pause();
+/// }
+///
+/// fn unpause(mut time: ResMut<Time<Physics>>) {
+///     time.unpause();
+/// }
+/// ```
+///
+/// To advance the simulation by a certain amount of time instantly, you can advance the
+/// [`Time<Physics>`] clock and manually run the [`PhysicsSchedule`] in an exclusive system:
+///
+/// ```
+/// use bevy::{prelude::*, utils::Duration};
+#[cfg_attr(
+    feature = "2d",
+    doc = "use bevy_xpbd_2d::{prelude::*, PhysicsSchedule};"
+)]
+#[cfg_attr(
+    feature = "3d",
+    doc = "use bevy_xpbd_3d::{prelude::*, PhysicsSchedule};"
+)]
+///
+/// fn run_physics(world: &mut World) {
+///     // Advance the simulation by 10 steps at 120 Hz
+///     for _ in 0..10 {
+///         world
+///             .resource_mut::<Time<Physics>>()
+///             .advance_by(Duration::from_secs_f64(1.0 / 120.0));
+///         world.run_schedule(PhysicsSchedule);
+///     }
+/// }
+/// ```
+///
+/// ## When to multiply by delta time?
+///
+/// Schedules like `Update` use a variable timestep, which can often cause frame rate dependent
+/// behavior when moving bodies. One way to help address the issue is by multiplying by delta time.
+///
+/// In general, if you're doing a *continuous* operation, you should always multiply by delta time,
+/// but for *instantaneous* operations it's not necessary.
+///
+/// Continuous operations move or accelerate bodies over time:
+///
+/// ```
+/// # use bevy::math::Vec3;
+/// #
+/// # let mut position = Vec3::default();
+/// # let mut velocity = Vec3::default();
+/// # let mut acceleration = Vec3::default();
+/// # let mut delta_time = 1.0 / 60.0;
+/// #
+/// // Move continuously over time
+/// position += velocity * delta_time;
+/// // Accelerate continuously
+/// velocity += acceleration * delta_time;
+/// ```
+///
+/// Instantaneous operations apply a singular sudden burst of velocity
+/// or set it to a specific value:
+///
+/// ```
+/// # use bevy::math::Vec3;
+/// #
+/// # let mut velocity = Vec3::default();
+/// # let mut impulse = Vec3::default();
+/// # let mut target_velocity = Vec3::default();
+/// #
+/// // Apply a burst of speed once (jumps, explosions and so on)
+/// velocity += impulse;
+/// // Set velocity to a specific value
+/// velocity = target_velocity;
+/// ```
+///
+/// For systems using a fixed timestep, using delta time is not necessary for frame rate
+/// independence, but it's still recommended so that the physical units are more logical.
+
+#[derive(Reflect, Clone, Copy, Debug, PartialEq)]
+pub struct Physics {
+    timestep_mode: TimestepMode,
+    paused: bool,
+    relative_speed: f64,
+}
+
+impl Default for Physics {
+    fn default() -> Self {
+        // Corresponds to 60 Hz.
+        // TODO: Bevy's fixed timestep is 64 Hz, but it causes physics
+        //       to be run twice in a single frame every 0.25 seconds.
+        //       It would be nice to have the timestep be more unified though.
+        Self::fixed_hz(1.0 / 60.0)
+    }
+}
+
+impl Physics {
+    /// Creates a new [`Physics`] clock with the given type of [timestep](TimestepMode).
+    pub const fn from_timestep(timestep_mode: TimestepMode) -> Self {
+        Self {
+            timestep_mode,
+            paused: false,
+            relative_speed: 1.0,
+        }
+    }
+
+    /// Returns a new [`Time<Physics>`](Physics) clock with a [`TimestepMode::Fixed`]
+    /// using the given frequency in Hertz (1/second).
+    ///
+    /// # Panics
+    ///
+    /// Panics if `hz` is zero, negative or not finite.
+    pub fn fixed_hz(hz: f64) -> Self {
+        assert!(hz > 0.0, "Hz less than or equal to zero");
+        assert!(hz.is_finite(), "Hz is infinite");
+        Self::from_timestep(TimestepMode::Fixed {
+            delta: Duration::from_secs_f64(hz),
+            overstep: Duration::ZERO,
+        })
+    }
+
+    /// Returns a new [`Time<Physics>`](Physics) clock with a [`TimestepMode::FixedOnce`]
+    /// using the given frequency in Hertz (1/second).
+    ///
+    /// Unlike with [`TimestepMode::Fixed`], the [`PhysicsSchedule`] will only be run once per frame
+    /// instead of accumulating time and running physics until the accumulator has been consumed.
+    /// This can be useful for [server usage](crate#can-the-engine-be-used-on-servers)
+    /// where the server and client must be kept in sync.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `hz` is zero, negative or not finite.
+    pub fn fixed_once_hz(hz: f64) -> Self {
+        assert!(hz > 0.0, "Hz less than or equal to zero");
+        assert!(hz.is_finite(), "Hz is infinite");
+        Self::from_timestep(TimestepMode::FixedOnce {
+            delta: Duration::from_secs_f64(hz),
+        })
+    }
+
+    /// Returns a new [`Time<Physics>`](Physics) clock with a [`TimestepMode::Variable`]
+    /// using the given frequency in Hertz (1/second).
+    ///
+    /// # Panics
+    ///
+    /// Panics if `max_delta_seconds` is zero or negative.
+    pub fn variable(max_delta_seconds: f64) -> Self {
+        assert!(
+            max_delta_seconds > 0.0,
+            "max delta less than or equal to zero"
+        );
+        Self::from_timestep(TimestepMode::Variable {
+            max_delta: Duration::from_secs_f64(max_delta_seconds),
+        })
+    }
+}
+
+/// An extension trait for [`Time<Physics>`](Physics).
+pub trait PhysicsTime {
+    /// Creates a new [`Time<Physics>`](Physics) clock with the given type
+    /// of [timestep](TimestepMode).
+    fn from_timestep(timestep_mode: TimestepMode) -> Self;
+
+    /// Gets the type of [timestep](TimestepMode) used for running physics.
+    fn timestep_mode(&self) -> TimestepMode;
+
+    /// Mutably gets the type of [timestep](TimestepMode) used for running physics.
+    fn timestep_mode_mut(&mut self) -> &mut TimestepMode;
+
+    /// Sets the type of [timestep](TimestepMode) used for running physics.
+    fn set_timestep_mode(&mut self, timestep_mode: TimestepMode);
+
+    /// Returns the speed of physics relative to your system clock as an `f32`.
+    /// This is also known as "time scaling" or "time dilation" in other engines.
+    ///
+    /// The speed impacts the accuracy of the simulation, and large values may
+    /// cause jittering or missed collisions. You can improve simulation consistency
+    /// by adjusting your [timestep](`TimestepMode`) at the cost of performance.
+    fn relative_speed(&self) -> f32;
+
+    /// Returns the speed of physics relative to your system clock as an `f64`.
+    /// This is also known as "time scaling" or "time dilation" in other engines.
+    ///
+    /// The speed impacts the accuracy of the simulation, and large values may
+    /// cause jittering or missed collisions. You can improve simulation consistency
+    /// by adjusting your [timestep](`TimestepMode`) at the cost of performance.
+    fn relative_speed_f64(&self) -> f64;
+
+    /// Sets the speed of physics relative to your system clock, given as an `f32`.
+    ///
+    /// For example, setting this to `2.0` will make the physics clock advance twice
+    /// as fast as your system clock.
+    ///
+    /// The speed impacts the accuracy of the simulation, and large values may
+    /// cause jittering or missed collisions. You can improve simulation consistency
+    /// by adjusting your [timestep](`TimestepMode`) at the cost of performance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `ratio` is negative or not finite.
+    fn with_relative_speed(self, ratio: f32) -> Self;
+
+    /// Sets the speed of physics relative to your system clock, given as an `f64`.
+    ///
+    /// For example, setting this to `2.0` will make the physics clock advance twice
+    /// as fast as your system clock.
+    ///
+    /// The speed impacts the accuracy of the simulation, and large values may
+    /// cause jittering or missed collisions. You can improve simulation consistency
+    /// by adjusting your [timestep](`TimestepMode`) at the cost of performance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `ratio` is negative or not finite.
+    fn with_relative_speed_f64(self, ratio: f64) -> Self;
+
+    /// Sets the speed of physics relative to your system clock, given as an `f32`.
+    ///
+    /// For example, setting this to `2.0` will make the physics clock advance twice
+    /// as fast as your system clock.
+    ///
+    /// The speed impacts the accuracy of the simulation, and large values may
+    /// cause jittering or missed collisions. You can improve simulation consistency
+    /// by adjusting your [timestep](`TimestepMode`) at the cost of performance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `ratio` is negative or not finite.
+    fn set_relative_speed(&mut self, ratio: f32);
+
+    /// Sets the speed of physics relative to your system clock, given as an `f64`.
+    ///
+    /// For example, setting this to `2.0` will make the physics clock advance twice
+    /// as fast as your system clock.
+    ///
+    /// The speed impacts the accuracy of the simulation, and large values may
+    /// cause jittering or missed collisions. You can improve simulation consistency
+    /// by adjusting your [timestep](`TimestepMode`) at the cost of performance.
+    ///
+    /// # Panics
+    ///
+    /// Panics if `ratio` is negative or not finite.
+    fn set_relative_speed_f64(&mut self, ratio: f64);
+
+    /// Returns `true` if the physics clock is currently paused.
+    fn is_paused(&self) -> bool;
+
+    /// Stops the clock, preventing the physics simulation from advancing until resumed.
+    fn pause(&mut self);
+
+    /// Resumes the clock if paused.
+    #[doc(alias = "resume")]
+    fn unpause(&mut self);
+}
+
+impl PhysicsTime for Time<Physics> {
+    fn from_timestep(timestep_mode: TimestepMode) -> Self {
+        Self::new_with(Physics::from_timestep(timestep_mode))
+    }
+
+    fn timestep_mode(&self) -> TimestepMode {
+        self.context().timestep_mode
+    }
+
+    fn timestep_mode_mut(&mut self) -> &mut TimestepMode {
+        &mut self.context_mut().timestep_mode
+    }
+
+    fn set_timestep_mode(&mut self, timestep_mode: TimestepMode) {
+        self.context_mut().timestep_mode = timestep_mode;
+    }
+
+    fn with_relative_speed(self, ratio: f32) -> Self {
+        self.with_relative_speed_f64(ratio as f64)
+    }
+
+    fn with_relative_speed_f64(mut self, ratio: f64) -> Self {
+        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;
+        self
+    }
+
+    fn relative_speed(&self) -> f32 {
+        self.relative_speed_f64() as f32
+    }
+
+    fn relative_speed_f64(&self) -> f64 {
+        self.context().relative_speed
+    }
+
+    fn set_relative_speed(&mut self, ratio: f32) {
+        self.set_relative_speed_f64(ratio as f64);
+    }
+
+    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;
+    }
+
+    fn pause(&mut self) {
+        self.context_mut().paused = true;
+    }
+
+    fn unpause(&mut self) {
+        self.context_mut().paused = false;
+    }
+
+    fn is_paused(&self) -> bool {
+        self.context().paused
+    }
+}
+
+/// The clock representing physics substep time. It is updated based on
+/// [`Time<Physics>`](Physics) and the [`SubstepCount`] resource.
+///
+/// The clock is automatically set as the generic `Time` resource for
+/// the [`SubstepSchedule`].
+#[derive(Reflect, Clone, Copy, Debug, Default, PartialEq)]
+pub struct Substeps;
+
+pub(crate) trait TimePrecisionAdjusted {
+    /// Returns how much time has advanced since the last update
+    /// as [`Scalar`] seconds.
+    fn delta_seconds_adjusted(&self) -> Scalar;
+}
+
+pub(crate) trait DurationPrecisionAdjusted {
+    /// Returns the number of seconds contained by this Duration as [`Scalar`].
+    ///
+    /// The returned value does include the fractional (nanosecond) part of the duration.
+    fn as_secs_adjusted(&self) -> Scalar;
+
+    /// Creates a new Duration from the specified number of seconds represented as [`Scalar`].
+    fn from_secs_adjusted(secs: Scalar) -> Self;
+}
+
+impl TimePrecisionAdjusted for Time {
+    /// Returns how much time has advanced since the last [`update`](#method.update)
+    /// as [`Scalar`] seconds.
+    fn delta_seconds_adjusted(&self) -> Scalar {
+        #[cfg(feature = "f32")]
+        {
+            self.delta_seconds()
+        }
+        #[cfg(feature = "f64")]
+        {
+            self.delta_seconds_f64()
+        }
+    }
+}
+
+impl DurationPrecisionAdjusted for Duration {
+    fn as_secs_adjusted(&self) -> Scalar {
+        #[cfg(feature = "f32")]
+        {
+            self.as_secs_f32()
+        }
+        #[cfg(feature = "f64")]
+        {
+            self.as_secs_f64()
+        }
+    }
+
+    fn from_secs_adjusted(secs: Scalar) -> Self {
+        #[cfg(feature = "f32")]
+        {
+            Self::from_secs_f32(secs)
+        }
+        #[cfg(feature = "f64")]
+        {
+            Self::from_secs_f64(secs)
+        }
+    }
+}
diff --git a/src/plugins/sleeping.rs b/src/plugins/sleeping.rs
index 8fad8889..35d41338 100644
--- a/src/plugins/sleeping.rs
+++ b/src/plugins/sleeping.rs
@@ -51,7 +51,7 @@ fn mark_sleeping_bodies(
     mut bodies: Query<SleepingQueryComponents, (Without<Sleeping>, Without<SleepingDisabled>)>,
     deactivation_time: Res<DeactivationTime>,
     sleep_threshold: Res<SleepingThreshold>,
-    dt: Res<DeltaTime>,
+    dt: Res<Time>,
 ) {
     for (entity, rb, mut lin_vel, mut ang_vel, mut time_sleeping) in &mut bodies {
         // Only dynamic bodies can sleep.
@@ -73,7 +73,7 @@ fn mark_sleeping_bodies(
         // If linear and angular velocity are below the sleeping threshold,
         // add delta time to the time sleeping, i.e. the time that the body has remained still.
         if lin_vel_sq < lin_sleeping_threshold_sq && ang_vel_sq < ang_sleeping_threshold_sq {
-            time_sleeping.0 += dt.0;
+            time_sleeping.0 += dt.delta_seconds_adjusted();
         } else {
             time_sleeping.0 = 0.0;
         }
diff --git a/src/plugins/solver.rs b/src/plugins/solver.rs
index 6c281d45..dd422de3 100644
--- a/src/plugins/solver.rs
+++ b/src/plugins/solver.rs
@@ -98,8 +98,10 @@ fn penetration_constraints(
     colliders: Query<ColliderQuery>,
     mut penetration_constraints: ResMut<PenetrationConstraints>,
     mut collisions: ResMut<Collisions>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     penetration_constraints.0.clear();
 
     for ((collider_entity1, collider_entity2), contacts) in collisions
@@ -192,7 +194,7 @@ fn penetration_constraints(
                         restitution_coefficient,
                         ..PenetrationConstraint::new(&body1, &body2, contact)
                     };
-                    constraint.solve([&mut body1, &mut body2], sub_dt.0);
+                    constraint.solve([&mut body1, &mut body2], delta_secs);
                     penetration_constraints.0.push(constraint);
 
                     // Set collision as penetrating for this frame and substep.
@@ -235,8 +237,10 @@ pub fn solve_constraint<C: XpbdConstraint<ENTITY_COUNT> + Component, const ENTIT
     mut commands: Commands,
     mut bodies: Query<(RigidBodyQuery, Option<&Sleeping>)>,
     mut constraints: Query<&mut C, Without<RigidBody>>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     // Clear Lagrange multipliers
     constraints
         .iter_mut()
@@ -270,7 +274,7 @@ pub fn solve_constraint<C: XpbdConstraint<ENTITY_COUNT> + Component, const ENTIT
                 .collect::<Vec<&mut RigidBodyQueryItem>>()
                 .try_into()
             {
-                constraint.solve(bodies, sub_dt.0);
+                constraint.solve(bodies, delta_secs);
             }
         }
     }
@@ -290,8 +294,10 @@ fn update_lin_vel(
         ),
         Without<Sleeping>,
     >,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (rb, pos, prev_pos, translation, mut lin_vel, mut pre_solve_lin_vel) in &mut bodies {
         // Static bodies have no velocity
         if rb.is_static() && lin_vel.0 != Vector::ZERO {
@@ -302,9 +308,9 @@ fn update_lin_vel(
 
         if rb.is_dynamic() {
             // v = (x - x_prev) / h
-            let new_lin_vel = (pos.0 - prev_pos.0 + translation.0) / sub_dt.0;
+            let new_lin_vel = (pos.0 - prev_pos.0 + translation.0) / delta_secs;
             // avoid triggering bevy's change detection unnecessarily
-            if new_lin_vel != lin_vel.0 {
+            if new_lin_vel != lin_vel.0 && new_lin_vel.is_finite() {
                 lin_vel.0 = new_lin_vel;
             }
         }
@@ -324,8 +330,10 @@ fn update_ang_vel(
         ),
         Without<Sleeping>,
     >,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (rb, rot, prev_rot, mut ang_vel, mut pre_solve_ang_vel) in &mut bodies {
         // Static bodies have no velocity
         if rb.is_static() && ang_vel.0 != 0.0 {
@@ -335,9 +343,9 @@ fn update_ang_vel(
         pre_solve_ang_vel.0 = ang_vel.0;
 
         if rb.is_dynamic() {
-            let new_ang_vel = (rot.mul(prev_rot.inverse())).as_radians() / sub_dt.0;
+            let new_ang_vel = (rot.mul(prev_rot.inverse())).as_radians() / delta_secs;
             // avoid triggering bevy's change detection unnecessarily
-            if new_ang_vel != ang_vel.0 {
+            if new_ang_vel != ang_vel.0 && new_ang_vel.is_finite() {
                 ang_vel.0 = new_ang_vel;
             }
         }
@@ -357,8 +365,10 @@ fn update_ang_vel(
         ),
         Without<Sleeping>,
     >,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for (rb, rot, prev_rot, mut ang_vel, mut pre_solve_ang_vel) in &mut bodies {
         // Static bodies have no velocity
         if rb.is_static() && ang_vel.0 != Vector::ZERO {
@@ -369,12 +379,12 @@ fn update_ang_vel(
 
         if rb.is_dynamic() {
             let delta_rot = rot.mul_quat(prev_rot.inverse().0);
-            let mut new_ang_vel = 2.0 * delta_rot.xyz() / sub_dt.0;
+            let mut new_ang_vel = 2.0 * delta_rot.xyz() / delta_secs;
             if delta_rot.w < 0.0 {
                 new_ang_vel = -new_ang_vel;
             }
             // avoid triggering bevy's change detection unnecessarily
-            if new_ang_vel != ang_vel.0 {
+            if new_ang_vel != ang_vel.0 && new_ang_vel.is_finite() {
                 ang_vel.0 = new_ang_vel;
             }
         }
@@ -387,8 +397,10 @@ fn solve_vel(
     mut bodies: Query<RigidBodyQuery, Without<Sleeping>>,
     penetration_constraints: Res<PenetrationConstraints>,
     gravity: Res<Gravity>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for constraint in penetration_constraints.0.iter() {
         if let Ok([mut body1, mut body2]) = bodies.get_many_mut(constraint.entities()) {
             if !body1.rb.is_dynamic() && !body2.rb.is_dynamic() {
@@ -442,7 +454,7 @@ fn solve_vel(
                 pre_solve_normal_speed,
                 constraint.restitution_coefficient,
                 gravity.0,
-                sub_dt.0,
+                delta_secs,
             );
             if restitution_speed.abs() > Scalar::EPSILON {
                 let w1 = constraint.compute_generalized_inverse_mass(&body1, r1, normal);
@@ -460,7 +472,7 @@ fn solve_vel(
                     w1 + w2,
                     constraint.dynamic_friction_coefficient,
                     constraint.normal_lagrange,
-                    sub_dt.0,
+                    delta_secs,
                 );
                 p += friction_impulse * tangent_dir;
             }
@@ -505,15 +517,17 @@ pub fn joint_damping<T: Joint>(
         Without<Sleeping>,
     >,
     joints: Query<&T, Without<RigidBody>>,
-    sub_dt: Res<SubDeltaTime>,
+    time: Res<Time>,
 ) {
+    let delta_secs = time.delta_seconds_adjusted();
+
     for joint in &joints {
         if let Ok(
             [(rb1, mut lin_vel1, mut ang_vel1, inv_mass1, dominance1), (rb2, mut lin_vel2, mut ang_vel2, inv_mass2, dominance2)],
         ) = bodies.get_many_mut(joint.entities())
         {
             let delta_omega =
-                (ang_vel2.0 - ang_vel1.0) * (joint.damping_angular() * sub_dt.0).min(1.0);
+                (ang_vel2.0 - ang_vel1.0) * (joint.damping_angular() * delta_secs).min(1.0);
 
             if rb1.is_dynamic() {
                 ang_vel1.0 += delta_omega;
@@ -522,7 +536,8 @@ pub fn joint_damping<T: Joint>(
                 ang_vel2.0 -= delta_omega;
             }
 
-            let delta_v = (lin_vel2.0 - lin_vel1.0) * (joint.damping_linear() * sub_dt.0).min(1.0);
+            let delta_v =
+                (lin_vel2.0 - lin_vel1.0) * (joint.damping_linear() * delta_secs).min(1.0);
 
             let w1 = if rb1.is_dynamic() { inv_mass1.0 } else { 0.0 };
             let w2 = if rb2.is_dynamic() { inv_mass2.0 } else { 0.0 };
diff --git a/src/resources.rs b/src/resources.rs
index 80efa1aa..6dc7202e 100644
--- a/src/resources.rs
+++ b/src/resources.rs
@@ -4,101 +4,9 @@ use bevy::prelude::Resource;
 
 use crate::prelude::*;
 
-/// Configures how many times per second the physics simulation is run.
-///
-/// ## Example
-///
-/// You can change the timestep by inserting the [`PhysicsTimestep`] resource:
-///
-/// ```no_run
-/// use bevy::prelude::*;
-#[cfg_attr(feature = "2d", doc = "use bevy_xpbd_2d::prelude::*;")]
-#[cfg_attr(feature = "3d", doc = "use bevy_xpbd_3d::prelude::*;")]
-///
-/// fn main() {
-///     App::new()
-///         .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
-///         // Use a 120 Hz fixed timestep instead of the default 60 Hz
-///         .insert_resource(PhysicsTimestep::Fixed(1.0 / 120.0))
-///         .run();
-/// }
-/// ```
-#[derive(Reflect, Resource, Clone, Copy, Debug, PartialEq)]
-#[reflect(Resource)]
-pub enum PhysicsTimestep {
-    /// **Fixed timestep**: the physics simulation will be advanced by a fixed value `dt` for every `dt` seconds passed since the previous physics frame. This allows consistent behavior across different machines and framerates.
-    Fixed(Scalar),
-    /// **Fixed delta, once per frame**: the physics simulation will be advanced by a fixed value `dt` once every frame. This should only be used in cases where you can guarantee a fixed number of executions, like in FixedUpdate or on a server.
-    FixedOnce(Scalar),
-    /// **Variable timestep**: the physics simulation will be advanced by `Time::delta_seconds().min(max_dt)` seconds at each Bevy tick.
-    Variable {
-        /// The maximum amount of time the physics simulation can be advanced at each Bevy tick. This makes sure that the simulation doesn't break when the delta time is large.
-        ///
-        /// A good default is `1.0 / 60.0` (60 Hz)
-        max_dt: Scalar,
-    },
-}
-
-impl Default for PhysicsTimestep {
-    fn default() -> Self {
-        Self::Fixed(1.0 / 60.0)
-    }
-}
-
-/// Configures the ratio of physics seconds per real second.
-///
-/// The default time scale is 1.0, meaning the simulation runs in real time.
-/// Reduce this for slow motion, increase for fast forward.
-///
-/// This changes the [`DeltaTime`] that the simulation is advanced by for each
-/// iteration. The frequency of physics updates, set using [`PhysicsTimestep`],
-/// remains unchanged.
-///
-/// The time scale impacts the accuracy of the simulation and large values may
-/// cause jittering or missed collisions. You may keep a consistent simulation
-/// behaviour by adjusting your [timestep](`PhysicsTimestep::Fixed`)
-/// at the cost of performance.
-///
-/// ## Example
-///
-/// You can change the time scale by inserting the [`PhysicsTimescale`] resource:
-///
-/// ```no_run
-/// use bevy::prelude::*;
-#[cfg_attr(feature = "2d", doc = "use bevy_xpbd_2d::prelude::*;")]
-#[cfg_attr(feature = "3d", doc = "use bevy_xpbd_3d::prelude::*;")]
-///
-/// fn main() {
-///     App::new()
-///         .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
-///         // Run the simulation at half speed, in slow motion
-///         .insert_resource(PhysicsTimescale(0.5))
-///         .run();
-/// }
-/// ```
-#[derive(Reflect, Resource, Clone, Copy, Debug, PartialEq)]
-#[reflect(Resource)]
-pub struct PhysicsTimescale(pub Scalar);
-
-impl Default for PhysicsTimescale {
-    fn default() -> Self {
-        Self(1.0)
-    }
-}
-
-/// How much time the previous physics frame took. The timestep can be configured with the [`PhysicsTimestep`] resource.
-#[derive(Reflect, Resource, Default)]
-#[reflect(Resource)]
-pub struct DeltaTime(pub Scalar);
-
-/// How much time the previous physics substep took. This depends on the [`DeltaTime`] and [`SubstepCount`] resources.
-#[derive(Reflect, Resource, Default)]
-#[reflect(Resource)]
-pub struct SubDeltaTime(pub Scalar);
-
 /// The number of substeps used in the simulation.
 ///
-/// A higher number of substeps reduces the value of [`SubDeltaTime`],
+/// A higher number of substeps reduces the value of [`Time`],
 /// which results in a more accurate simulation, but also reduces performance. The default
 /// substep count is currently 12.
 ///