diff --git a/.github/workflows/rapier-ci-bench.yml b/.github/workflows/rapier-ci-bench.yml
index aa6e6ca..29653e8 100644
--- a/.github/workflows/rapier-ci-bench.yml
+++ b/.github/workflows/rapier-ci-bench.yml
@@ -3,7 +3,7 @@ name: Rapier CI bench
 on:
   push:
     branches: [ master ]
-  pull_request:
+  pull_request_target:
     branches: [ master ]
   workflow_dispatch:
 
@@ -14,21 +14,23 @@ jobs:
       BENCHBOT_AMQP_PASS: ${{ secrets.BENCHBOT_AMQP_PASS }}
       BENCHBOT_AMQP_VHOST: ${{ secrets.BENCHBOT_AMQP_VHOST }}
       BENCHBOT_AMQP_HOST: ${{ secrets.BENCHBOT_AMQP_HOST }}
-      BENCHBOT_TARGET_REPO: ${{ github.repository }}
+      BENCHBOT_TARGET_REPO: ${{ github.event.pull_request.head.repo.clone_url }}
       BENCHBOT_TARGET_COMMIT: ${{ github.event.pull_request.head.sha }}
       BENCHBOT_SHA: ${{ github.sha }}
-      BENCHBOT_HEAD_REF: ${{github.head_ref}}
+      BENCHBOT_HEAD_REF: ${{ github.head_ref }}
       BENCHBOT_OTHER_BACKENDS: false
     runs-on: ubuntu-latest
     steps:
-      - name: Find commit SHA
-        if: github.ref == 'refs/heads/master'
+      - name: Set env on master
+        if: github.head_ref == ''
         run: |
           echo "BENCHBOT_TARGET_COMMIT=$BENCHBOT_SHA" >> $GITHUB_ENV
+          echo "BENCHBOT_TARGET_REPO=https://github.com/dimforge/rapier" >> $GITHUB_ENV
+          echo "BENCHBOT_HEAD_REF=master" >> $GITHUB_ENV
           echo "BENCHBOT_OTHER_BACKENDS=true" >> $GITHUB_ENV
       - name: Send 3D bench message
         shell: bash
         run: curl -u $BENCHBOT_AMQP_USER:$BENCHBOT_AMQP_PASS
              -i -H "content-type:application/json" -X POST
              https://$BENCHBOT_AMQP_HOST/api/exchanges/$BENCHBOT_AMQP_VHOST//publish
-            -d'{"properties":{},"routing_key":"benchmark","payload":"{ \"repository\":\"https://github.com/'$BENCHBOT_TARGET_REPO'\", \"branch\":\"'$GITHUB_REF'\", \"commit\":\"'$BENCHBOT_TARGET_COMMIT'\", \"other_backends\":'$BENCHBOT_OTHER_BACKENDS' }","payload_encoding":"string"}'
\ No newline at end of file
+            -d'{"properties":{},"routing_key":"benchmark","payload":"{ \"repository\":\"'$BENCHBOT_TARGET_REPO'\", \"branch\":\"'$BENCHBOT_HEAD_REF'\", \"commit\":\"'$BENCHBOT_TARGET_COMMIT'\", \"other_backends\":'$BENCHBOT_OTHER_BACKENDS' }","payload_encoding":"string"}'
\ No newline at end of file
diff --git a/examples2d/add_remove2.rs b/examples2d/add_remove2.rs
index a3d223d..0aeffbe 100644
--- a/examples2d/add_remove2.rs
+++ b/examples2d/add_remove2.rs
@@ -10,7 +10,7 @@ pub fn init_world(testbed: &mut Testbed) {
     let rad = 0.5;
 
     // Callback that will be executed on the main loop to handle proximities.
-    testbed.add_callback(move |window, physics, _, graphics, _| {
+    testbed.add_callback(move |mut window, mut graphics, physics, _, _| {
         let rigid_body = RigidBodyBuilder::new_dynamic()
             .translation(0.0, 10.0)
             .build();
@@ -19,7 +19,10 @@ pub fn init_world(testbed: &mut Testbed) {
         physics
             .colliders
             .insert(collider, handle, &mut physics.bodies);
-        graphics.add(window, handle, &physics.bodies, &physics.colliders);
+
+        if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
+            graphics.add(*window, handle, &physics.bodies, &physics.colliders);
+        }
 
         let to_remove: Vec<_> = physics
             .bodies
@@ -31,7 +34,10 @@ pub fn init_world(testbed: &mut Testbed) {
             physics
                 .bodies
                 .remove(handle, &mut physics.colliders, &mut physics.joints);
-            graphics.remove_body_nodes(window, handle);
+
+            if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
+                graphics.remove_body_nodes(*window, handle);
+            }
         }
     });
 
diff --git a/examples2d/platform2.rs b/examples2d/platform2.rs
index 20b2e59..afd4d64 100644
--- a/examples2d/platform2.rs
+++ b/examples2d/platform2.rs
@@ -60,13 +60,13 @@ pub fn init_world(testbed: &mut Testbed) {
     /*
      * Setup a callback to control the platform.
      */
-    testbed.add_callback(move |_, physics, _, _, time| {
+    testbed.add_callback(move |_, _, physics, _, run_state| {
         let platform = physics.bodies.get_mut(platform_handle).unwrap();
         let mut next_pos = *platform.position();
 
         let dt = 0.016;
-        next_pos.translation.vector.y += (time * 5.0).sin() * dt;
-        next_pos.translation.vector.x += time.sin() * 5.0 * dt;
+        next_pos.translation.vector.y += (run_state.time * 5.0).sin() * dt;
+        next_pos.translation.vector.x += run_state.time.sin() * 5.0 * dt;
 
         if next_pos.translation.vector.x >= rad * 10.0 {
             next_pos.translation.vector.x -= dt;
diff --git a/examples2d/sensor2.rs b/examples2d/sensor2.rs
index 6649a43..e53abe3 100644
--- a/examples2d/sensor2.rs
+++ b/examples2d/sensor2.rs
@@ -69,7 +69,7 @@ pub fn init_world(testbed: &mut Testbed) {
     testbed.set_body_color(sensor_handle, Point3::new(0.5, 1.0, 1.0));
 
     // Callback that will be executed on the main loop to handle proximities.
-    testbed.add_callback(move |_, physics, events, graphics, _| {
+    testbed.add_callback(move |_, mut graphics, physics, events, _| {
         while let Ok(prox) = events.intersection_events.try_recv() {
             let color = if prox.intersecting {
                 Point3::new(1.0, 1.0, 0.0)
@@ -79,12 +79,13 @@ pub fn init_world(testbed: &mut Testbed) {
 
             let parent_handle1 = physics.colliders.get(prox.collider1).unwrap().parent();
             let parent_handle2 = physics.colliders.get(prox.collider2).unwrap().parent();
-
-            if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
-                graphics.set_body_color(parent_handle1, color);
-            }
-            if parent_handle2 != ground_handle && parent_handle2 != sensor_handle {
-                graphics.set_body_color(parent_handle2, color);
+            if let Some(graphics) = &mut graphics {
+                if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
+                    graphics.set_body_color(parent_handle1, color);
+                }
+                if parent_handle2 != ground_handle && parent_handle2 != sensor_handle {
+                    graphics.set_body_color(parent_handle2, color);
+                }
             }
         }
     });
diff --git a/examples3d/debug_add_remove_collider3.rs b/examples3d/debug_add_remove_collider3.rs
index a42dc97..f353162 100644
--- a/examples3d/debug_add_remove_collider3.rs
+++ b/examples3d/debug_add_remove_collider3.rs
@@ -34,7 +34,7 @@ pub fn init_world(testbed: &mut Testbed) {
     let collider = ColliderBuilder::ball(ball_rad).density(100.0).build();
     colliders.insert(collider, ball_handle, &mut bodies);
 
-    testbed.add_callback(move |window, physics, _, graphics, _| {
+    testbed.add_callback(move |mut window, mut graphics, physics, _, _| {
         // Remove then re-add the ground collider.
         let coll = physics
             .colliders
@@ -43,7 +43,10 @@ pub fn init_world(testbed: &mut Testbed) {
         ground_collider_handle = physics
             .colliders
             .insert(coll, ground_handle, &mut physics.bodies);
-        graphics.add_collider(window, ground_collider_handle, &physics.colliders);
+
+        if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
+            graphics.add_collider(window, ground_collider_handle, &physics.colliders);
+        }
     });
 
     /*
diff --git a/examples3d/debug_dynamic_collider_add3.rs b/examples3d/debug_dynamic_collider_add3.rs
index a71e95e..bd7205e 100644
--- a/examples3d/debug_dynamic_collider_add3.rs
+++ b/examples3d/debug_dynamic_collider_add3.rs
@@ -45,7 +45,7 @@ pub fn init_world(testbed: &mut Testbed) {
     let mut extra_colliders = Vec::new();
     let snapped_frame = 51;
 
-    testbed.add_callback(move |window, physics, _, graphics, _| {
+    testbed.add_callback(move |mut window, mut graphics, physics, _, _| {
         step += 1;
 
         // Add a bigger ball collider
@@ -56,7 +56,11 @@ pub fn init_world(testbed: &mut Testbed) {
             physics
                 .colliders
                 .insert(collider, ball_handle, &mut physics.bodies);
-        graphics.add_collider(window, new_ball_collider_handle, &physics.colliders);
+
+        if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
+            graphics.add_collider(window, new_ball_collider_handle, &physics.colliders);
+        }
+
         extra_colliders.push(new_ball_collider_handle);
 
         // Snap the ball velocity or restore it.
@@ -95,7 +99,11 @@ pub fn init_world(testbed: &mut Testbed) {
             physics
                 .colliders
                 .insert(coll, ground_handle, &mut physics.bodies);
-        graphics.add_collider(window, new_ground_collider_handle, &physics.colliders);
+
+        if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
+            graphics.add_collider(window, new_ground_collider_handle, &physics.colliders);
+        }
+
         extra_colliders.push(new_ground_collider_handle);
     });
 
diff --git a/examples3d/debug_rollback3.rs b/examples3d/debug_rollback3.rs
index 19f9474..27b27cf 100644
--- a/examples3d/debug_rollback3.rs
+++ b/examples3d/debug_rollback3.rs
@@ -44,7 +44,7 @@ pub fn init_world(testbed: &mut Testbed) {
     let mut step = 0;
     let snapped_frame = 51;
 
-    testbed.add_callback(move |_, physics, _, _, _| {
+    testbed.add_callback(move |_, _, physics, _, _| {
         step += 1;
 
         // Snap the ball velocity or restore it.
diff --git a/examples3d/fountain3.rs b/examples3d/fountain3.rs
index fafa988..5acc2e8 100644
--- a/examples3d/fountain3.rs
+++ b/examples3d/fountain3.rs
@@ -26,7 +26,7 @@ pub fn init_world(testbed: &mut Testbed) {
     let mut k = 0;
 
     // Callback that will be executed on the main loop to handle proximities.
-    testbed.add_callback(move |window, physics, _, graphics, _| {
+    testbed.add_callback(move |mut window, mut graphics, physics, _, _| {
         k += 1;
         let rigid_body = RigidBodyBuilder::new_dynamic()
             .translation(0.0, 10.0, 0.0)
@@ -41,7 +41,10 @@ pub fn init_world(testbed: &mut Testbed) {
         physics
             .colliders
             .insert(collider, handle, &mut physics.bodies);
-        graphics.add(window, handle, &physics.bodies, &physics.colliders);
+
+        if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
+            graphics.add(window, handle, &physics.bodies, &physics.colliders);
+        }
 
         if physics.bodies.len() > MAX_NUMBER_OF_BODIES {
             let mut to_remove: Vec<_> = physics
@@ -67,7 +70,10 @@ pub fn init_world(testbed: &mut Testbed) {
                 physics
                     .narrow_phase
                     .maintain(&mut physics.colliders, &mut physics.bodies);
-                graphics.remove_body_nodes(window, *handle);
+
+                if let (Some(graphics), Some(window)) = (&mut graphics, &mut window) {
+                    graphics.remove_body_nodes(window, *handle);
+                }
             }
         }
     });
diff --git a/examples3d/platform3.rs b/examples3d/platform3.rs
index 0975f39..7b5c986 100644
--- a/examples3d/platform3.rs
+++ b/examples3d/platform3.rs
@@ -65,7 +65,7 @@ pub fn init_world(testbed: &mut Testbed) {
      * Setup a callback to control the platform.
      */
     let mut count = 0;
-    testbed.add_callback(move |_, physics, _, _, time| {
+    testbed.add_callback(move |_, _, physics, _, run_state| {
         count += 1;
         if count % 100 > 50 {
             return;
@@ -75,8 +75,8 @@ pub fn init_world(testbed: &mut Testbed) {
             let mut next_pos = *platform.position();
 
             let dt = 0.016;
-            next_pos.translation.vector.y += (time * 5.0).sin() * dt;
-            next_pos.translation.vector.z += time.sin() * 5.0 * dt;
+            next_pos.translation.vector.y += (run_state.time * 5.0).sin() * dt;
+            next_pos.translation.vector.z += run_state.time.sin() * 5.0 * dt;
 
             if next_pos.translation.vector.z >= rad * 10.0 {
                 next_pos.translation.vector.z -= dt;
diff --git a/examples3d/sensor3.rs b/examples3d/sensor3.rs
index 234eaf3..641e93d 100644
--- a/examples3d/sensor3.rs
+++ b/examples3d/sensor3.rs
@@ -73,7 +73,7 @@ pub fn init_world(testbed: &mut Testbed) {
     testbed.set_body_color(sensor_handle, Point3::new(0.5, 1.0, 1.0));
 
     // Callback that will be executed on the main loop to handle proximities.
-    testbed.add_callback(move |_, physics, events, graphics, _| {
+    testbed.add_callback(move |_, mut graphics, physics, events, _| {
         while let Ok(prox) = events.intersection_events.try_recv() {
             let color = if prox.intersecting {
                 Point3::new(1.0, 1.0, 0.0)
@@ -84,11 +84,13 @@ pub fn init_world(testbed: &mut Testbed) {
             let parent_handle1 = physics.colliders.get(prox.collider1).unwrap().parent();
             let parent_handle2 = physics.colliders.get(prox.collider2).unwrap().parent();
 
-            if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
-                graphics.set_body_color(parent_handle1, color);
-            }
-            if parent_handle2 != ground_handle && parent_handle2 != sensor_handle {
-                graphics.set_body_color(parent_handle2, color);
+            if let Some(graphics) = &mut graphics {
+                if parent_handle1 != ground_handle && parent_handle1 != sensor_handle {
+                    graphics.set_body_color(parent_handle1, color);
+                }
+                if parent_handle2 != ground_handle && parent_handle2 != sensor_handle {
+                    graphics.set_body_color(parent_handle2, color);
+                }
             }
         }
     });
diff --git a/src/dynamics/integration_parameters.rs b/src/dynamics/integration_parameters.rs
index 706fb3f..0d4d3b6 100644
--- a/src/dynamics/integration_parameters.rs
+++ b/src/dynamics/integration_parameters.rs
@@ -5,9 +5,8 @@ use crate::math::Real;
 #[cfg_attr(feature = "serde-serialize", derive(Serialize, Deserialize))]
 pub struct IntegrationParameters {
     /// The timestep length (default: `1.0 / 60.0`)
-    dt: Real,
-    /// The inverse of `dt`.
-    inv_dt: Real,
+    pub dt: Real,
+
     //    /// If `true` and if rapier is compiled with the `parallel` feature, this will enable rayon-based multithreading (default: `true`).
     //    ///
     //    /// This parameter is ignored if rapier is not compiled with is `parallel` feature.
@@ -31,7 +30,7 @@ pub struct IntegrationParameters {
     /// Contacts at points where the involved bodies have a relative
     /// velocity smaller than this threshold wont be affected by the restitution force (default: `1.0`).
     pub restitution_velocity_threshold: Real,
-    /// Amount of penetration the engine wont attempt to correct (default: `0.001m`).
+    /// Amount of penetration the engine wont attempt to correct (default: `0.005m`).
     pub allowed_linear_error: Real,
     /// The maximal distance separating two objects that will generate predictive contacts (default: `0.002`).
     pub prediction_distance: Real,
@@ -89,6 +88,7 @@ pub struct IntegrationParameters {
 
 impl IntegrationParameters {
     /// Creates a set of integration parameters with the given values.
+    #[deprecated = "Use `IntegrationParameters { dt: 60.0, ..Default::default() }` instead"]
     pub fn new(
         dt: Real,
         //        multithreading_enabled: bool,
@@ -112,7 +112,6 @@ impl IntegrationParameters {
     ) -> Self {
         IntegrationParameters {
             dt,
-            inv_dt: if dt == 0.0 { 0.0 } else { 1.0 / dt },
             //            multithreading_enabled,
             erp,
             joint_erp,
@@ -142,30 +141,29 @@ impl IntegrationParameters {
 
     /// The current time-stepping length.
     #[inline(always)]
+    #[deprecated = "You can just read the `IntegrationParams::dt` value directly"]
     pub fn dt(&self) -> Real {
         self.dt
     }
 
-    /// The inverse of the time-stepping length.
+    /// The inverse of the time-stepping length, i.e. the steps per seconds (Hz).
     ///
     /// This is zero if `self.dt` is zero.
     #[inline(always)]
     pub fn inv_dt(&self) -> Real {
-        self.inv_dt
+        if self.dt == 0.0 {
+            0.0
+        } else {
+            1.0 / self.dt
+        }
     }
 
     /// Sets the time-stepping length.
-    ///
-    /// This automatically recompute `self.inv_dt`.
     #[inline]
+    #[deprecated = "You can just set the `IntegrationParams::dt` value directly"]
     pub fn set_dt(&mut self, dt: Real) {
         assert!(dt >= 0.0, "The time-stepping length cannot be negative.");
         self.dt = dt;
-        if dt == 0.0 {
-            self.inv_dt = 0.0
-        } else {
-            self.inv_dt = 1.0 / dt
-        }
     }
 
     /// Sets the inverse time-stepping length (i.e. the frequency).
@@ -173,7 +171,6 @@ impl IntegrationParameters {
     /// This automatically recompute `self.dt`.
     #[inline]
     pub fn set_inv_dt(&mut self, inv_dt: Real) {
-        self.inv_dt = inv_dt;
         if inv_dt == 0.0 {
             self.dt = 0.0
         } else {
@@ -184,26 +181,32 @@ impl IntegrationParameters {
 
 impl Default for IntegrationParameters {
     fn default() -> Self {
-        Self::new(
-            1.0 / 60.0,
-            //            true,
-            0.2,
-            0.2,
-            1.0,
-            1.0,
-            0.005,
-            0.001,
-            0.2,
-            0.2,
-            0.002,
-            0.2,
-            4,
-            1,
-            10,
-            1,
-            false,
-            false,
-            false,
-        )
+        Self {
+            dt: 1.0 / 60.0,
+            //        multithreading_enabled:             true,
+            return_after_ccd_substep: false,
+            erp: 0.2,
+            joint_erp: 0.2,
+            warmstart_coeff: 1.0,
+            restitution_velocity_threshold: 1.0,
+            allowed_linear_error: 0.005,
+            prediction_distance: 0.002,
+            allowed_angular_error: 0.001,
+            max_linear_correction: 0.2,
+            max_angular_correction: 0.2,
+            max_stabilization_multiplier: 0.2,
+            max_velocity_iterations: 4,
+            max_position_iterations: 1,
+            // FIXME: what is the optimal value for min_island_size?
+            // It should not be too big so that we don't end up with
+            // huge islands that don't fit in cache.
+            // However we don't want it to be too small and end up with
+            // tons of islands, reducing SIMD parallelism opportunities.
+            min_island_size: 128,
+            max_ccd_position_iterations: 10,
+            max_ccd_substeps: 1,
+            multiple_ccd_substep_sensor_events_enabled: false,
+            ccd_on_penetration_enabled: false,
+        }
     }
 }
diff --git a/src/dynamics/solver/island_solver.rs b/src/dynamics/solver/island_solver.rs
index 46d6b75..deed8c2 100644
--- a/src/dynamics/solver/island_solver.rs
+++ b/src/dynamics/solver/island_solver.rs
@@ -57,8 +57,7 @@ impl IslandSolver {
         }
 
         counters.solver.velocity_update_time.resume();
-        bodies
-            .foreach_active_island_body_mut_internal(island_id, |_, rb| rb.integrate(params.dt()));
+        bodies.foreach_active_island_body_mut_internal(island_id, |_, rb| rb.integrate(params.dt));
         counters.solver.velocity_update_time.pause();
 
         if manifold_indices.len() != 0 || joint_indices.len() != 0 {
diff --git a/src/dynamics/solver/parallel_island_solver.rs b/src/dynamics/solver/parallel_island_solver.rs
index 389b6e6..24435db 100644
--- a/src/dynamics/solver/parallel_island_solver.rs
+++ b/src/dynamics/solver/parallel_island_solver.rs
@@ -251,7 +251,7 @@ impl ParallelIslandSolver {
                         let dvel = mj_lambdas[rb.active_set_offset];
                         rb.linvel += dvel.linear;
                         rb.angvel += rb.effective_world_inv_inertia_sqrt.transform_vector(dvel.angular);
-                        rb.integrate(params.dt());
+                        rb.integrate(params.dt));
                         positions[rb.active_set_offset] = rb.position;
                     }
                 }
diff --git a/src/dynamics/solver/velocity_constraint.rs b/src/dynamics/solver/velocity_constraint.rs
index c2aa6f5..9d75830 100644
--- a/src/dynamics/solver/velocity_constraint.rs
+++ b/src/dynamics/solver/velocity_constraint.rs
@@ -144,6 +144,7 @@ impl VelocityConstraint {
         out_constraints: &mut Vec<AnyVelocityConstraint>,
         push: bool,
     ) {
+        let inv_dt = params.inv_dt();
         let rb1 = &bodies[manifold.data.body_pair.body1];
         let rb2 = &bodies[manifold.data.body_pair.body2];
         let mj_lambda1 = rb1.active_set_offset;
@@ -244,7 +245,7 @@ impl VelocityConstraint {
                         rhs += manifold_point.restitution * rhs
                     }
 
-                    rhs += manifold_point.dist.max(0.0) * params.inv_dt();
+                    rhs += manifold_point.dist.max(0.0) * inv_dt;
 
                     let impulse = manifold_point.data.impulse * warmstart_coeff;
 
diff --git a/src/dynamics/solver/velocity_ground_constraint.rs b/src/dynamics/solver/velocity_ground_constraint.rs
index 7ea4fbb..49bb465 100644
--- a/src/dynamics/solver/velocity_ground_constraint.rs
+++ b/src/dynamics/solver/velocity_ground_constraint.rs
@@ -63,6 +63,7 @@ impl VelocityGroundConstraint {
         out_constraints: &mut Vec<AnyVelocityConstraint>,
         push: bool,
     ) {
+        let inv_dt = params.inv_dt();
         let mut rb1 = &bodies[manifold.data.body_pair.body1];
         let mut rb2 = &bodies[manifold.data.body_pair.body2];
         let flipped = !rb2.is_dynamic();
@@ -159,7 +160,7 @@ impl VelocityGroundConstraint {
                         rhs += manifold_point.restitution * rhs
                     }
 
-                    rhs += manifold_point.dist.max(0.0) * params.inv_dt();
+                    rhs += manifold_point.dist.max(0.0) * inv_dt;
 
                     let impulse = manifold_points[k].data.impulse * warmstart_coeff;
 
diff --git a/src/pipeline/physics_pipeline.rs b/src/pipeline/physics_pipeline.rs
index 718dd10..d59a534 100644
--- a/src/pipeline/physics_pipeline.rs
+++ b/src/pipeline/physics_pipeline.rs
@@ -154,7 +154,7 @@ impl PhysicsPipeline {
         self.counters.stages.update_time.start();
         bodies.foreach_active_dynamic_body_mut_internal(|_, b| {
             b.update_world_mass_properties();
-            b.integrate_accelerations(integration_parameters.dt(), *gravity)
+            b.integrate_accelerations(integration_parameters.dt, *gravity)
         });
         self.counters.stages.update_time.pause();
 
@@ -233,7 +233,7 @@ impl PhysicsPipeline {
                 rb.linvel = na::zero();
                 rb.angvel = na::zero();
             } else {
-                rb.update_predicted_position(integration_parameters.dt());
+                rb.update_predicted_position(integration_parameters.dt);
             }
 
             rb.update_colliders_positions(colliders);
@@ -330,6 +330,7 @@ mod test {
         );
     }
 
+    #[cfg(feature = "serde")]
     #[test]
     fn rigid_body_removal_snapshot_handle_determinism() {
         let mut colliders = ColliderSet::new();
diff --git a/src_testbed/box2d_backend.rs b/src_testbed/box2d_backend.rs
index 2d4ef29..29fd4fa 100644
--- a/src_testbed/box2d_backend.rs
+++ b/src_testbed/box2d_backend.rs
@@ -219,7 +219,7 @@ impl Box2dWorld {
 
         counters.step_started();
         self.world.step(
-            params.dt(),
+            params.dt,
             params.max_velocity_iterations as i32,
             params.max_position_iterations as i32,
         );
diff --git a/src_testbed/harness/mod.rs b/src_testbed/harness/mod.rs
index c95a722..413ef52 100644
--- a/src_testbed/harness/mod.rs
+++ b/src_testbed/harness/mod.rs
@@ -1,4 +1,8 @@
-use crate::physics::{PhysicsEvents, PhysicsState};
+use crate::{
+    physics::{PhysicsEvents, PhysicsState},
+    GraphicsManager,
+};
+use kiss3d::window::Window;
 use plugin::HarnessPlugin;
 use rapier::dynamics::{IntegrationParameters, JointSet, RigidBodySet};
 use rapier::geometry::{BroadPhase, ColliderSet, NarrowPhase};
@@ -7,24 +11,58 @@ use rapier::pipeline::{ChannelEventCollector, PhysicsPipeline, QueryPipeline};
 
 pub mod plugin;
 
-pub struct HarnessState {
+pub struct RunState {
     #[cfg(feature = "parallel")]
     pub thread_pool: rapier::rayon::ThreadPool,
+    #[cfg(feature = "parallel")]
+    pub num_threads: usize,
     pub timestep_id: usize,
+    pub time: f32,
+}
+
+impl RunState {
+    pub fn new() -> Self {
+        #[cfg(feature = "parallel")]
+        let num_threads = num_cpus::get_physical();
+
+        #[cfg(feature = "parallel")]
+        let thread_pool = rapier::rayon::ThreadPoolBuilder::new()
+            .num_threads(num_threads)
+            .build()
+            .unwrap();
+
+        Self {
+            #[cfg(feature = "parallel")]
+            thread_pool: thread_pool,
+            #[cfg(feature = "parallel")]
+            num_threads,
+            timestep_id: 0,
+            time: 0.0,
+        }
+    }
 }
 
 pub struct Harness {
-    physics: PhysicsState,
+    pub physics: PhysicsState,
     max_steps: usize,
     callbacks: Callbacks,
     plugins: Vec<Box<dyn HarnessPlugin>>,
-    time: f32,
     events: PhysicsEvents,
     event_handler: ChannelEventCollector,
-    pub state: HarnessState,
+    pub state: RunState,
 }
 
-type Callbacks = Vec<Box<dyn FnMut(&mut PhysicsState, &PhysicsEvents, &HarnessState, f32)>>;
+type Callbacks = Vec<
+    Box<
+        dyn FnMut(
+            Option<&mut Window>,
+            Option<&mut GraphicsManager>,
+            &mut PhysicsState,
+            &PhysicsEvents,
+            &RunState,
+        ),
+    >,
+>;
 
 #[allow(dead_code)]
 impl Harness {
@@ -46,18 +84,13 @@ impl Harness {
             intersection_events: proximity_channel.1,
         };
         let physics = PhysicsState::new();
-        let state = HarnessState {
-            #[cfg(feature = "parallel")]
-            thread_pool,
-            timestep_id: 0,
-        };
+        let state = RunState::new();
 
         Self {
             physics,
             max_steps: 1000,
             callbacks: Vec::new(),
             plugins: Vec::new(),
-            time: 0.0,
             events,
             event_handler,
             state,
@@ -101,7 +134,6 @@ impl Harness {
         self.physics.joints = joints;
         self.physics.broad_phase = BroadPhase::new();
         self.physics.narrow_phase = NarrowPhase::new();
-        self.time = 0.0;
         self.state.timestep_id = 0;
         self.physics.query_pipeline = QueryPipeline::new();
         self.physics.pipeline = PhysicsPipeline::new();
@@ -113,7 +145,13 @@ impl Harness {
     }
 
     pub fn add_callback<
-        F: FnMut(&mut PhysicsState, &PhysicsEvents, &HarnessState, f32) + 'static,
+        F: FnMut(
+                Option<&mut Window>,
+                Option<&mut GraphicsManager>,
+                &mut PhysicsState,
+                &PhysicsEvents,
+                &RunState,
+            ) + 'static,
     >(
         &mut self,
         callback: F,
@@ -122,6 +160,14 @@ impl Harness {
     }
 
     pub fn step(&mut self) {
+        self.step_with_graphics(None, None);
+    }
+
+    pub fn step_with_graphics(
+        &mut self,
+        window: Option<&mut Window>,
+        graphics: Option<&mut GraphicsManager>,
+    ) {
         #[cfg(feature = "parallel")]
         {
             let physics = &mut self.physics;
@@ -161,26 +207,44 @@ impl Harness {
             .update(&self.physics.bodies, &self.physics.colliders);
 
         for plugin in &mut self.plugins {
-            plugin.step(&mut self.physics)
+            plugin.step(&mut self.physics, &self.state)
         }
 
-        for f in &mut self.callbacks {
-            f(&mut self.physics, &self.events, &self.state, self.time)
+        // FIXME: This assumes either window & graphics are Some, or they are all None
+        // this is required as we cannot pass Option<&mut Window> & Option<&mut GraphicsManager directly in a loop
+        // there must be a better way of doing this?
+        match (window, graphics) {
+            (Some(window), Some(graphics)) => {
+                for f in &mut self.callbacks {
+                    f(
+                        Some(window),
+                        Some(graphics),
+                        &mut self.physics,
+                        &self.events,
+                        &self.state,
+                    );
+                }
+            }
+            _ => {
+                for f in &mut self.callbacks {
+                    f(None, None, &mut self.physics, &self.events, &self.state);
+                }
+            }
         }
 
         for plugin in &mut self.plugins {
-            plugin.run_callbacks(&mut self.physics, &self.events, &self.state, self.time)
+            plugin.run_callbacks(&mut self.physics, &self.events, &self.state)
         }
 
         self.events.poll_all();
 
-        self.time += self.physics.integration_parameters.dt();
+        self.state.time += self.physics.integration_parameters.dt;
+        self.state.timestep_id += 1;
     }
 
     pub fn run(&mut self) {
         for _ in 0..self.max_steps {
             self.step();
-            self.state.timestep_id += 1;
         }
     }
 }
diff --git a/src_testbed/harness/plugin.rs b/src_testbed/harness/plugin.rs
index 078219e..ac20945 100644
--- a/src_testbed/harness/plugin.rs
+++ b/src_testbed/harness/plugin.rs
@@ -1,4 +1,4 @@
-use crate::harness::HarnessState;
+use crate::harness::RunState;
 use crate::physics::PhysicsEvents;
 use crate::PhysicsState;
 
@@ -7,9 +7,8 @@ pub trait HarnessPlugin {
         &mut self,
         physics: &mut PhysicsState,
         events: &PhysicsEvents,
-        harness_state: &HarnessState,
-        t: f32,
+        harness_state: &RunState,
     );
-    fn step(&mut self, physics: &mut PhysicsState);
+    fn step(&mut self, physics: &mut PhysicsState, run_state: &RunState);
     fn profiling_string(&self) -> String;
 }
diff --git a/src_testbed/nphysics_backend.rs b/src_testbed/nphysics_backend.rs
index b2495bd..8b88e28 100644
--- a/src_testbed/nphysics_backend.rs
+++ b/src_testbed/nphysics_backend.rs
@@ -145,7 +145,7 @@ impl NPhysicsWorld {
             .max_velocity_iterations = params.max_velocity_iterations;
         self.mechanical_world
             .integration_parameters
-            .set_dt(params.dt());
+            .set_dt(params.dt);
         self.mechanical_world.integration_parameters.warmstart_coeff = params.warmstart_coeff;
 
         counters.step_started();
diff --git a/src_testbed/physx_backend.rs b/src_testbed/physx_backend.rs
index 837fff2..319736c 100644
--- a/src_testbed/physx_backend.rs
+++ b/src_testbed/physx_backend.rs
@@ -434,7 +434,7 @@ impl PhysxWorld {
             .as_mut()
             .unwrap()
             .step(
-                params.dt(),
+                params.dt,
                 None::<&mut physx_sys::PxBaseTask>,
                 Some(&mut scratch),
                 true,
diff --git a/src_testbed/plugin.rs b/src_testbed/plugin.rs
index 872cdf5..877e7f6 100644
--- a/src_testbed/plugin.rs
+++ b/src_testbed/plugin.rs
@@ -1,3 +1,4 @@
+use crate::harness::RunState;
 use crate::physics::PhysicsState;
 use kiss3d::window::Window;
 use na::Point3;
@@ -5,7 +6,12 @@ use na::Point3;
 pub trait TestbedPlugin {
     fn init_graphics(&mut self, window: &mut Window, gen_color: &mut dyn FnMut() -> Point3<f32>);
     fn clear_graphics(&mut self, window: &mut Window);
-    fn run_callbacks(&mut self, window: &mut Window, physics: &mut PhysicsState, t: f32);
+    fn run_callbacks(
+        &mut self,
+        window: &mut Window,
+        physics: &mut PhysicsState,
+        run_state: &RunState,
+    );
     fn step(&mut self, physics: &mut PhysicsState);
     fn draw(&mut self);
     fn profiling_string(&self) -> String;
diff --git a/src_testbed/testbed.rs b/src_testbed/testbed.rs
index 6acfede..ae73929 100644
--- a/src_testbed/testbed.rs
+++ b/src_testbed/testbed.rs
@@ -3,10 +3,10 @@ use std::mem;
 use std::path::Path;
 use std::rc::Rc;
 
-use crate::engine::GraphicsManager;
 use crate::physics::{PhysicsEvents, PhysicsSnapshot, PhysicsState};
 use crate::plugin::TestbedPlugin;
 use crate::ui::TestbedUi;
+use crate::{engine::GraphicsManager, harness::RunState};
 
 use kiss3d::camera::Camera;
 use kiss3d::event::Event;
@@ -21,7 +21,7 @@ use na::{self, Point2, Point3, Vector3};
 use rapier::dynamics::{
     ActivationStatus, IntegrationParameters, JointSet, RigidBodyHandle, RigidBodySet,
 };
-use rapier::geometry::{BroadPhase, ColliderHandle, ColliderSet, NarrowPhase};
+use rapier::geometry::{ColliderHandle, ColliderSet, NarrowPhase};
 #[cfg(feature = "dim3")]
 use rapier::geometry::{InteractionGroups, Ray};
 use rapier::math::{Isometry, Vector};
@@ -29,6 +29,7 @@ use rapier::pipeline::{ChannelEventCollector, PhysicsPipeline, QueryPipeline};
 
 #[cfg(all(feature = "dim2", feature = "other-backends"))]
 use crate::box2d_backend::Box2dWorld;
+use crate::harness::Harness;
 #[cfg(feature = "other-backends")]
 use crate::nphysics_backend::NPhysicsWorld;
 #[cfg(all(feature = "dim3", feature = "other-backends"))]
@@ -114,30 +115,22 @@ pub struct TestbedState {
     pub selected_example: usize,
     pub selected_backend: usize,
     pub physx_use_two_friction_directions: bool,
-    pub num_threads: usize,
     pub snapshot: Option<PhysicsSnapshot>,
-    #[cfg(feature = "parallel")]
-    pub thread_pool: rapier::rayon::ThreadPool,
-    pub timestep_id: usize,
 }
 
 pub struct Testbed {
     builders: Vec<(&'static str, fn(&mut Testbed))>,
-    physics: PhysicsState,
     graphics: GraphicsManager,
     nsteps: usize,
     camera_locked: bool, // Used so that the camera can remain the same before and after we change backend or press the restart button.
-    callbacks: Callbacks,
     plugins: Vec<Box<dyn TestbedPlugin>>,
-    time: f32,
     hide_counters: bool,
     //    persistant_contacts: HashMap<ContactId, bool>,
     font: Rc<Font>,
     cursor_pos: Point2<f32>,
-    events: PhysicsEvents,
-    event_handler: ChannelEventCollector,
     ui: Option<TestbedUi>,
     state: TestbedState,
+    harness: Harness,
     #[cfg(all(feature = "dim2", feature = "other-backends"))]
     box2d: Option<Box2dWorld>,
     #[cfg(all(feature = "dim3", feature = "other-backends"))]
@@ -146,9 +139,6 @@ pub struct Testbed {
     nphysics: Option<NPhysicsWorld>,
 }
 
-type Callbacks =
-    Vec<Box<dyn FnMut(&mut Window, &mut PhysicsState, &PhysicsEvents, &mut GraphicsManager, f32)>>;
-
 impl Testbed {
     pub fn new_empty() -> Testbed {
         let graphics = GraphicsManager::new();
@@ -166,17 +156,6 @@ impl Testbed {
         #[cfg(all(feature = "dim3", feature = "other-backends"))]
         backend_names.push("physx (two friction dir)");
 
-        #[cfg(feature = "parallel")]
-        let num_threads = num_cpus::get_physical();
-        #[cfg(not(feature = "parallel"))]
-        let num_threads = 1;
-
-        #[cfg(feature = "parallel")]
-        let thread_pool = rapier::rayon::ThreadPoolBuilder::new()
-            .num_threads(num_threads)
-            .build()
-            .unwrap();
-
         let state = TestbedState {
             running: RunMode::Running,
             draw_colls: false,
@@ -193,40 +172,25 @@ impl Testbed {
             backend_names,
             example_names: Vec::new(),
             selected_example: 0,
-            timestep_id: 0,
             selected_backend: RAPIER_BACKEND,
             physx_use_two_friction_directions: true,
-            num_threads,
-            #[cfg(feature = "parallel")]
-            thread_pool,
         };
 
-        let contact_channel = crossbeam::channel::unbounded();
-        let intersection_channel = crossbeam::channel::unbounded();
-        let event_handler = ChannelEventCollector::new(intersection_channel.0, contact_channel.0);
-        let events = PhysicsEvents {
-            contact_events: contact_channel.1,
-            intersection_events: intersection_channel.1,
-        };
-        let physics = PhysicsState::new();
+        let harness = Harness::new_empty();
 
         Testbed {
             builders: Vec::new(),
-            physics,
-            callbacks: Vec::new(),
             plugins: Vec::new(),
             graphics,
             nsteps: 1,
             camera_locked: false,
-            time: 0.0,
             hide_counters: true,
             //            persistant_contacts: HashMap::new(),
             font: Font::default(),
             cursor_pos: Point2::new(0.0f32, 0.0),
             ui,
-            event_handler,
-            events,
             state,
+            harness,
             #[cfg(all(feature = "dim2", feature = "other-backends"))]
             box2d: None,
             #[cfg(all(feature = "dim3", feature = "other-backends"))]
@@ -238,7 +202,7 @@ impl Testbed {
 
     pub fn new(bodies: RigidBodySet, colliders: ColliderSet, joints: JointSet) -> Self {
         let mut res = Self::new_empty();
-        res.set_world(bodies, colliders, joints);
+        res.harness.set_world(bodies, colliders, joints);
         res
     }
 
@@ -269,11 +233,15 @@ impl Testbed {
     }
 
     pub fn integration_parameters_mut(&mut self) -> &mut IntegrationParameters {
-        &mut self.physics.integration_parameters
+        &mut self.harness.physics.integration_parameters
     }
 
     pub fn physics_state_mut(&mut self) -> &mut PhysicsState {
-        &mut self.physics
+        &mut self.harness.physics
+    }
+
+    pub fn harness_mut(&mut self) -> &mut Harness {
+        &mut self.harness
     }
 
     pub fn set_world(&mut self, bodies: RigidBodySet, colliders: ColliderSet, joints: JointSet) {
@@ -289,30 +257,23 @@ impl Testbed {
     ) {
         println!("Num bodies: {}", bodies.len());
         println!("Num joints: {}", joints.len());
-        self.physics.gravity = gravity;
-        self.physics.bodies = bodies;
-        self.physics.colliders = colliders;
-        self.physics.joints = joints;
-        self.physics.broad_phase = BroadPhase::new();
-        self.physics.narrow_phase = NarrowPhase::new();
+        self.harness
+            .set_world_with_gravity(bodies, colliders, joints, gravity);
+
         self.state
             .action_flags
             .set(TestbedActionFlags::RESET_WORLD_GRAPHICS, true);
-        self.time = 0.0;
-        self.state.timestep_id = 0;
+
         self.state.highlighted_body = None;
-        self.physics.query_pipeline = QueryPipeline::new();
-        self.physics.pipeline = PhysicsPipeline::new();
-        self.physics.pipeline.counters.enable();
 
         #[cfg(all(feature = "dim2", feature = "other-backends"))]
         {
             if self.state.selected_backend == BOX2D_BACKEND {
                 self.box2d = Some(Box2dWorld::from_rapier(
-                    self.physics.gravity,
-                    &self.physics.bodies,
-                    &self.physics.colliders,
-                    &self.physics.joints,
+                    physics.gravity,
+                    &physics.bodies,
+                    &physics.colliders,
+                    &physics.joints,
                 ));
             }
         }
@@ -323,13 +284,13 @@ impl Testbed {
                 || self.state.selected_backend == PHYSX_BACKEND_TWO_FRICTION_DIR
             {
                 self.physx = Some(PhysxWorld::from_rapier(
-                    self.physics.gravity,
-                    &self.physics.integration_parameters,
-                    &self.physics.bodies,
-                    &self.physics.colliders,
-                    &self.physics.joints,
+                    physics.gravity,
+                    &physics.integration_parameters,
+                    &physics.bodies,
+                    &physics.colliders,
+                    &physics.joints,
                     self.state.selected_backend == PHYSX_BACKEND_TWO_FRICTION_DIR,
-                    self.state.num_threads,
+                    self.harness.state.num_threads,
                 ));
             }
         }
@@ -338,10 +299,10 @@ impl Testbed {
         {
             if self.state.selected_backend == NPHYSICS_BACKEND {
                 self.nphysics = Some(NPhysicsWorld::from_rapier(
-                    self.physics.gravity,
-                    &self.physics.bodies,
-                    &self.physics.colliders,
-                    &self.physics.joints,
+                    physics.gravity,
+                    &physics.bodies,
+                    &physics.colliders,
+                    &physics.joints,
                 ));
             }
         }
@@ -419,7 +380,6 @@ impl Testbed {
     }
 
     fn clear(&mut self, window: &mut Window) {
-        self.callbacks.clear();
         //        self.persistant_contacts.clear();
         //        self.state.grabbed_object = None;
         //        self.state.grabbed_object_constraint = None;
@@ -433,17 +393,23 @@ impl Testbed {
         self.plugins.clear();
     }
 
-    pub fn add_plugin(&mut self, plugin: impl TestbedPlugin + 'static) {
-        self.plugins.push(Box::new(plugin));
-    }
-
     pub fn add_callback<
-        F: FnMut(&mut Window, &mut PhysicsState, &PhysicsEvents, &mut GraphicsManager, f32) + 'static,
+        F: FnMut(
+                Option<&mut Window>,
+                Option<&mut GraphicsManager>,
+                &mut PhysicsState,
+                &PhysicsEvents,
+                &RunState,
+            ) + 'static,
     >(
         &mut self,
         callback: F,
     ) {
-        self.callbacks.push(Box::new(callback));
+        self.harness.add_callback(callback);
+    }
+
+    pub fn add_plugin(&mut self, plugin: impl TestbedPlugin + 'static) {
+        self.plugins.push(Box::new(plugin));
     }
 
     pub fn run(mut self) {
@@ -464,6 +430,7 @@ impl Testbed {
             }
         }
 
+        // TODO: move this to dedicated benchmarking code
         if benchmark_mode {
             use std::fs::File;
             use std::io::{BufWriter, Write};
@@ -484,11 +451,23 @@ impl Testbed {
                         && (backend_id == PHYSX_BACKEND_PATCH_FRICTION
                             || backend_id == PHYSX_BACKEND_TWO_FRICTION_DIR)
                     {
-                        self.physics.integration_parameters.max_velocity_iterations = 1;
-                        self.physics.integration_parameters.max_position_iterations = 4;
+                        self.harness
+                            .physics
+                            .integration_parameters
+                            .max_velocity_iterations = 1;
+                        self.harness
+                            .physics
+                            .integration_parameters
+                            .max_position_iterations = 4;
                     } else {
-                        self.physics.integration_parameters.max_velocity_iterations = 4;
-                        self.physics.integration_parameters.max_position_iterations = 1;
+                        self.harness
+                            .physics
+                            .integration_parameters
+                            .max_velocity_iterations = 4;
+                        self.harness
+                            .physics
+                            .integration_parameters
+                            .max_position_iterations = 1;
                     }
                     // Init world.
                     (builder.1)(&mut self);
@@ -496,57 +475,20 @@ impl Testbed {
                     let mut timings = Vec::new();
                     for k in 0..=NUM_ITERS {
                         {
-                            // FIXME: code duplicated from self.step()
                             if self.state.selected_backend == RAPIER_BACKEND {
-                                #[cfg(feature = "parallel")]
-                                {
-                                    let physics = &mut self.physics;
-                                    let event_handler = &self.event_handler;
-                                    self.state.thread_pool.install(|| {
-                                        physics.pipeline.step(
-                                            &physics.gravity,
-                                            &physics.integration_parameters,
-                                            &mut physics.broad_phase,
-                                            &mut physics.narrow_phase,
-                                            &mut physics.bodies,
-                                            &mut physics.colliders,
-                                            &mut physics.joints,
-                                            None,
-                                            None,
-                                            event_handler,
-                                        );
-                                    });
-                                }
-
-                                #[cfg(not(feature = "parallel"))]
-                                self.physics.pipeline.step(
-                                    &self.physics.gravity,
-                                    &self.physics.integration_parameters,
-                                    &mut self.physics.broad_phase,
-                                    &mut self.physics.narrow_phase,
-                                    &mut self.physics.bodies,
-                                    &mut self.physics.colliders,
-                                    &mut self.physics.joints,
-                                    None,
-                                    None,
-                                    &self.event_handler,
-                                );
-
-                                self.physics
-                                    .query_pipeline
-                                    .update(&self.physics.bodies, &self.physics.colliders);
+                                self.harness.step();
                             }
 
                             #[cfg(all(feature = "dim2", feature = "other-backends"))]
                             {
                                 if self.state.selected_backend == BOX2D_BACKEND {
                                     self.box2d.as_mut().unwrap().step(
-                                        &mut self.physics.pipeline.counters,
-                                        &self.physics.integration_parameters,
+                                        &mut self.harness.physics.pipeline.counters,
+                                        &physics.integration_parameters,
                                     );
                                     self.box2d.as_mut().unwrap().sync(
-                                        &mut self.physics.bodies,
-                                        &mut self.physics.colliders,
+                                        &mut self.harness.physics.bodies,
+                                        &mut self.harness.physics.colliders,
                                     );
                                 }
                             }
@@ -558,12 +500,12 @@ impl Testbed {
                                 {
                                     //                        println!("Step");
                                     self.physx.as_mut().unwrap().step(
-                                        &mut self.physics.pipeline.counters,
-                                        &self.physics.integration_parameters,
+                                        &mut self.harness.physics.pipeline.counters,
+                                        &physics.integration_parameters,
                                     );
                                     self.physx.as_mut().unwrap().sync(
-                                        &mut self.physics.bodies,
-                                        &mut self.physics.colliders,
+                                        &mut self.harness.physics.bodies,
+                                        &mut self.harness.physics.colliders,
                                     );
                                 }
                             }
@@ -572,12 +514,12 @@ impl Testbed {
                             {
                                 if self.state.selected_backend == NPHYSICS_BACKEND {
                                     self.nphysics.as_mut().unwrap().step(
-                                        &mut self.physics.pipeline.counters,
-                                        &self.physics.integration_parameters,
+                                        &mut self.harness.physics.pipeline.counters,
+                                        &physics.integration_parameters,
                                     );
                                     self.nphysics.as_mut().unwrap().sync(
-                                        &mut self.physics.bodies,
-                                        &mut self.physics.colliders,
+                                        &mut self.harness.physics.bodies,
+                                        &mut self.harness.physics.colliders,
                                     );
                                 }
                             }
@@ -585,7 +527,7 @@ impl Testbed {
 
                         // Skip the first update.
                         if k > 0 {
-                            timings.push(self.physics.pipeline.counters.step_time.time());
+                            timings.push(self.harness.physics.pipeline.counters.step_time.time());
                         }
                     }
                     results.push(timings);
@@ -640,6 +582,7 @@ impl Testbed {
             WindowEvent::Key(Key::C, Action::Release, _) => {
                 // Delete 1 collider of 10% of the remaining dynamic bodies.
                 let mut colliders: Vec<_> = self
+                    .harness
                     .physics
                     .bodies
                     .iter()
@@ -651,14 +594,17 @@ impl Testbed {
 
                 let num_to_delete = (colliders.len() / 10).max(1);
                 for to_delete in &colliders[..num_to_delete] {
-                    self.physics
-                        .colliders
-                        .remove(to_delete[0], &mut self.physics.bodies, true);
+                    self.harness.physics.colliders.remove(
+                        to_delete[0],
+                        &mut self.harness.physics.bodies,
+                        true,
+                    );
                 }
             }
             WindowEvent::Key(Key::D, Action::Release, _) => {
                 // Delete 10% of the remaining dynamic bodies.
                 let dynamic_bodies: Vec<_> = self
+                    .harness
                     .physics
                     .bodies
                     .iter()
@@ -667,21 +613,23 @@ impl Testbed {
                     .collect();
                 let num_to_delete = (dynamic_bodies.len() / 10).max(1);
                 for to_delete in &dynamic_bodies[..num_to_delete] {
-                    self.physics.bodies.remove(
+                    self.harness.physics.bodies.remove(
                         *to_delete,
-                        &mut self.physics.colliders,
-                        &mut self.physics.joints,
+                        &mut self.harness.physics.colliders,
+                        &mut self.harness.physics.joints,
                     );
                 }
             }
             WindowEvent::Key(Key::J, Action::Release, _) => {
                 // Delete 10% of the remaining joints.
-                let joints: Vec<_> = self.physics.joints.iter().map(|e| e.0).collect();
+                let joints: Vec<_> = self.harness.physics.joints.iter().map(|e| e.0).collect();
                 let num_to_delete = (joints.len() / 10).max(1);
                 for to_delete in &joints[..num_to_delete] {
-                    self.physics
-                        .joints
-                        .remove(*to_delete, &mut self.physics.bodies, true);
+                    self.harness.physics.joints.remove(
+                        *to_delete,
+                        &mut self.harness.physics.bodies,
+                        true,
+                    );
                 }
             }
             WindowEvent::CursorPos(x, y, _) => {
@@ -1028,8 +976,9 @@ impl Testbed {
             .camera()
             .unproject(&self.cursor_pos, &na::convert(size));
         let ray = Ray::new(pos, dir);
-        let hit = self.physics.query_pipeline.cast_ray(
-            &self.physics.colliders,
+        let physics = &self.harness.physics;
+        let hit = physics.query_pipeline.cast_ray(
+            &physics.colliders,
             &ray,
             f32::MAX,
             true,
@@ -1038,7 +987,7 @@ impl Testbed {
 
         if let Some((handle, _)) = hit {
             let collider = &self.physics.colliders[handle];
-            if self.physics.bodies[collider.parent()].is_dynamic() {
+            if physics.bodies[collider.parent()].is_dynamic() {
                 self.state.highlighted_body = Some(collider.parent());
                 for node in self.graphics.body_nodes_mut(collider.parent()).unwrap() {
                     node.select()
@@ -1077,8 +1026,9 @@ impl State for Testbed {
         if let Some(ui) = &mut self.ui {
             ui.update(
                 window,
-                &mut self.physics.integration_parameters,
+                &mut self.harness.physics.integration_parameters,
                 &mut self.state,
+                &mut self.harness.state,
             );
         }
 
@@ -1125,16 +1075,7 @@ impl State for Testbed {
                 self.clear(window);
 
                 if self.state.selected_example != prev_example {
-                    self.physics.integration_parameters = IntegrationParameters::default();
-                    if cfg!(feature = "dim3")
-                        && (self.state.selected_backend == PHYSX_BACKEND_PATCH_FRICTION
-                            || self.state.selected_backend == PHYSX_BACKEND_TWO_FRICTION_DIR)
-                    {
-                        std::mem::swap(
-                            &mut self.physics.integration_parameters.max_velocity_iterations,
-                            &mut self.physics.integration_parameters.max_position_iterations,
-                        )
-                    }
+                    self.harness.physics.integration_parameters = IntegrationParameters::default();
                 }
 
                 self.builders[self.state.selected_example].1(self);
@@ -1151,12 +1092,12 @@ impl State for Testbed {
                     .action_flags
                     .set(TestbedActionFlags::TAKE_SNAPSHOT, false);
                 self.state.snapshot = PhysicsSnapshot::new(
-                    self.state.timestep_id,
-                    &self.physics.broad_phase,
-                    &self.physics.narrow_phase,
-                    &self.physics.bodies,
-                    &self.physics.colliders,
-                    &self.physics.joints,
+                    self.harness.state.timestep_id,
+                    &self.harness.physics.broad_phase,
+                    &self.harness.physics.narrow_phase,
+                    &self.harness.physics.bodies,
+                    &self.harness.physics.colliders,
+                    &self.harness.physics.joints,
                 )
                 .ok();
 
@@ -1183,9 +1124,9 @@ impl State for Testbed {
                         }
 
                         self.set_world(w.3, w.4, w.5);
-                        self.physics.broad_phase = w.1;
-                        self.physics.narrow_phase = w.2;
-                        self.state.timestep_id = w.0;
+                        self.harness.physics.broad_phase = w.1;
+                        self.harness.physics.narrow_phase = w.2;
+                        self.harness.state.timestep_id = w.0;
                     }
                 }
             }
@@ -1198,12 +1139,12 @@ impl State for Testbed {
                 self.state
                     .action_flags
                     .set(TestbedActionFlags::RESET_WORLD_GRAPHICS, false);
-                for (handle, _) in self.physics.bodies.iter() {
+                for (handle, _) in self.harness.physics.bodies.iter() {
                     self.graphics.add(
                         window,
                         handle,
-                        &self.physics.bodies,
-                        &self.physics.colliders,
+                        &self.harness.physics.bodies,
+                        &self.harness.physics.colliders,
                     );
                 }
 
@@ -1218,7 +1159,7 @@ impl State for Testbed {
                     != self.state.flags.contains(TestbedStateFlags::WIREFRAME)
             {
                 self.graphics.toggle_wireframe_mode(
-                    &self.physics.colliders,
+                    &self.harness.physics.colliders,
                     self.state.flags.contains(TestbedStateFlags::WIREFRAME),
                 )
             }
@@ -1227,11 +1168,11 @@ impl State for Testbed {
                 != self.state.flags.contains(TestbedStateFlags::SLEEP)
             {
                 if self.state.flags.contains(TestbedStateFlags::SLEEP) {
-                    for (_, mut body) in self.physics.bodies.iter_mut() {
+                    for (_, mut body) in self.harness.physics.bodies.iter_mut() {
                         body.activation.threshold = ActivationStatus::default_threshold();
                     }
                 } else {
-                    for (_, mut body) in self.physics.bodies.iter_mut() {
+                    for (_, mut body) in self.harness.physics.bodies.iter_mut() {
                         body.wake_up(true);
                         body.activation.threshold = -1.0;
                     }
@@ -1244,7 +1185,10 @@ impl State for Testbed {
                 .contains(TestbedStateFlags::SUB_STEPPING)
                 != self.state.flags.contains(TestbedStateFlags::SUB_STEPPING)
             {
-                self.physics.integration_parameters.return_after_ccd_substep =
+                self.harness
+                    .physics
+                    .integration_parameters
+                    .return_after_ccd_substep =
                     self.state.flags.contains(TestbedStateFlags::SUB_STEPPING);
             }
 
@@ -1294,48 +1238,13 @@ impl State for Testbed {
 
         if self.state.running != RunMode::Stop {
             for _ in 0..self.nsteps {
-                self.state.timestep_id += 1;
                 if self.state.selected_backend == RAPIER_BACKEND {
-                    #[cfg(feature = "parallel")]
-                    {
-                        let physics = &mut self.physics;
-                        let event_handler = &self.event_handler;
-                        self.state.thread_pool.install(|| {
-                            physics.pipeline.step(
-                                &physics.gravity,
-                                &physics.integration_parameters,
-                                &mut physics.broad_phase,
-                                &mut physics.narrow_phase,
-                                &mut physics.bodies,
-                                &mut physics.colliders,
-                                &mut physics.joints,
-                                None,
-                                None,
-                                event_handler,
-                            );
-                        });
-                    }
-
-                    #[cfg(not(feature = "parallel"))]
-                    self.physics.pipeline.step(
-                        &self.physics.gravity,
-                        &self.physics.integration_parameters,
-                        &mut self.physics.broad_phase,
-                        &mut self.physics.narrow_phase,
-                        &mut self.physics.bodies,
-                        &mut self.physics.colliders,
-                        &mut self.physics.joints,
-                        None,
-                        None,
-                        &self.event_handler,
-                    );
-
-                    self.physics
-                        .query_pipeline
-                        .update(&self.physics.bodies, &self.physics.colliders);
+                    let graphics = &mut self.graphics;
+                    self.harness
+                        .step_with_graphics(Some(window), Some(graphics));
 
                     for plugin in &mut self.plugins {
-                        plugin.step(&mut self.physics)
+                        plugin.step(&mut self.harness.physics)
                     }
                 }
 
@@ -1343,13 +1252,13 @@ impl State for Testbed {
                 {
                     if self.state.selected_backend == BOX2D_BACKEND {
                         self.box2d.as_mut().unwrap().step(
-                            &mut self.physics.pipeline.counters,
-                            &self.physics.integration_parameters,
+                            &mut physics.pipeline.counters,
+                            &physics.integration_parameters,
                         );
                         self.box2d
                             .as_mut()
                             .unwrap()
-                            .sync(&mut self.physics.bodies, &mut self.physics.colliders);
+                            .sync(&mut physics.bodies, &mut physics.colliders);
                     }
                 }
 
@@ -1360,13 +1269,13 @@ impl State for Testbed {
                     {
                         //                        println!("Step");
                         self.physx.as_mut().unwrap().step(
-                            &mut self.physics.pipeline.counters,
-                            &self.physics.integration_parameters,
+                            &mut physics.pipeline.counters,
+                            &physics.integration_parameters,
                         );
                         self.physx
                             .as_mut()
                             .unwrap()
-                            .sync(&mut self.physics.bodies, &mut self.physics.colliders);
+                            .sync(&mut physics.bodies, &mut physics.colliders);
                     }
                 }
 
@@ -1374,32 +1283,20 @@ impl State for Testbed {
                 {
                     if self.state.selected_backend == NPHYSICS_BACKEND {
                         self.nphysics.as_mut().unwrap().step(
-                            &mut self.physics.pipeline.counters,
-                            &self.physics.integration_parameters,
+                            &mut physics.pipeline.counters,
+                            &physics.integration_parameters,
                         );
                         self.nphysics
                             .as_mut()
                             .unwrap()
-                            .sync(&mut self.physics.bodies, &mut self.physics.colliders);
+                            .sync(&mut physics.bodies, &mut physics.colliders);
                     }
                 }
 
-                for f in &mut self.callbacks {
-                    f(
-                        window,
-                        &mut self.physics,
-                        &self.events,
-                        &mut self.graphics,
-                        self.time,
-                    )
-                }
-
                 for plugin in &mut self.plugins {
-                    plugin.run_callbacks(window, &mut self.physics, self.time)
+                    plugin.run_callbacks(window, &mut self.harness.physics, &self.harness.state);
                 }
 
-                self.events.poll_all();
-
                 //                if true {
                 //                    // !self.hide_counters {
                 //                    #[cfg(not(feature = "log"))]
@@ -1407,20 +1304,21 @@ impl State for Testbed {
                 //                    #[cfg(feature = "log")]
                 //                    debug!("{}", self.world.counters);
                 //                }
-                self.time += self.physics.integration_parameters.dt();
             }
         }
 
         self.highlight_hovered_body(window);
+
+        let physics = &self.harness.physics;
         self.graphics
-            .draw(&self.physics.bodies, &self.physics.colliders, window);
+            .draw(&physics.bodies, &physics.colliders, window);
 
         for plugin in &mut self.plugins {
             plugin.draw();
         }
 
         if self.state.flags.contains(TestbedStateFlags::CONTACT_POINTS) {
-            draw_contacts(window, &self.physics.narrow_phase, &self.physics.colliders);
+            draw_contacts(window, &physics.narrow_phase, &physics.colliders);
         }
 
         if self.state.running == RunMode::Step {
@@ -1432,7 +1330,7 @@ impl State for Testbed {
         }
 
         let color = Point3::new(0.0, 0.0, 0.0);
-        let counters = self.physics.pipeline.counters;
+        let counters = physics.pipeline.counters;
         let mut profile = String::new();
 
         if self.state.flags.contains(TestbedStateFlags::PROFILE) {
@@ -1483,11 +1381,12 @@ CCD: {:.2}ms
 
         if self.state.flags.contains(TestbedStateFlags::DEBUG) {
             let t = instant::now();
-            let bf = bincode::serialize(&self.physics.broad_phase).unwrap();
-            let nf = bincode::serialize(&self.physics.narrow_phase).unwrap();
-            let bs = bincode::serialize(&self.physics.bodies).unwrap();
-            let cs = bincode::serialize(&self.physics.colliders).unwrap();
-            let js = bincode::serialize(&self.physics.joints).unwrap();
+            let physics = &self.harness.physics;
+            let bf = bincode::serialize(&physics.broad_phase).unwrap();
+            let nf = bincode::serialize(&physics.narrow_phase).unwrap();
+            let bs = bincode::serialize(&physics.bodies).unwrap();
+            let cs = bincode::serialize(&physics.colliders).unwrap();
+            let js = bincode::serialize(&physics.joints).unwrap();
             let serialization_time = instant::now() - t;
             let hash_bf = md5::compute(&bf);
             let hash_nf = md5::compute(&nf);
@@ -1505,7 +1404,7 @@ Hashes at frame: {}
 |_ Joints [{:.1}KB]: {:?}"#,
                 profile,
                 serialization_time,
-                self.state.timestep_id,
+                self.harness.state.timestep_id,
                 bf.len() as f32 / 1000.0,
                 hash_bf,
                 nf.len() as f32 / 1000.0,
diff --git a/src_testbed/ui.rs b/src_testbed/ui.rs
index f88db9d..1b9084c 100644
--- a/src_testbed/ui.rs
+++ b/src_testbed/ui.rs
@@ -2,6 +2,7 @@ use kiss3d::conrod::{self, Borderable, Colorable, Labelable, Positionable, Sizea
 use kiss3d::window::Window;
 use rapier::dynamics::IntegrationParameters;
 
+use crate::harness::RunState;
 use crate::testbed::{RunMode, TestbedActionFlags, TestbedState, TestbedStateFlags};
 
 const SIDEBAR_W: f64 = 200.0;
@@ -98,6 +99,7 @@ impl TestbedUi {
         window: &mut Window,
         integration_parameters: &mut IntegrationParameters,
         state: &mut TestbedState,
+        run_state: &mut RunState,
     ) {
         let ui_root = window.conrod_ui().window;
         let mut ui = window.conrod_ui_mut().set_widgets();
@@ -254,7 +256,7 @@ impl TestbedUi {
         let curr_vel_iters = integration_parameters.max_velocity_iterations;
         let curr_pos_iters = integration_parameters.max_position_iterations;
         #[cfg(feature = "parallel")]
-        let curr_num_threads = state.num_threads;
+        let curr_num_threads = run_state.num_threads;
         let curr_max_ccd_substeps = integration_parameters.max_ccd_substeps;
         let curr_min_island_size = integration_parameters.min_island_size;
         let curr_warmstart_coeff = integration_parameters.warmstart_coeff;
@@ -305,10 +307,10 @@ impl TestbedUi {
             .w_h(ELEMENT_W, ELEMENT_H)
             .set(self.ids.slider_num_threads, &mut ui)
             {
-                if state.num_threads != val as usize {
-                    state.num_threads = val as usize;
-                    state.thread_pool = rapier::rayon::ThreadPoolBuilder::new()
-                        .num_threads(state.num_threads)
+                if run_state.num_threads != val as usize {
+                    run_state.num_threads = val as usize;
+                    run_state.thread_pool = rapier::rayon::ThreadPoolBuilder::new()
+                        .num_threads(run_state.num_threads)
                         .build()
                         .unwrap();
                 }