diff --git a/crates/bevy_xpbd_2d/examples/chain_2d.rs b/crates/bevy_xpbd_2d/examples/chain_2d.rs
index 36983669..83608a28 100644
--- a/crates/bevy_xpbd_2d/examples/chain_2d.rs
+++ b/crates/bevy_xpbd_2d/examples/chain_2d.rs
@@ -43,7 +43,7 @@ fn setup(
             FollowMouse,
             MaterialMesh2dBundle {
                 mesh: particle_mesh.clone(),
-                material: particle_material.clone_weak(),
+                material: particle_material.clone(),
                 ..default()
             },
         ))
@@ -57,7 +57,7 @@ fn setup(
                 MassPropertiesBundle::new_computed(&Collider::ball(particle_radius), 1.0),
                 MaterialMesh2dBundle {
                     mesh: particle_mesh.clone(),
-                    material: particle_material.clone_weak(),
+                    material: particle_material.clone(),
                     transform: Transform::from_xyz(
                         0.0,
                         i as f32 * (particle_radius as f32 * 2.0 + 1.0),
diff --git a/crates/bevy_xpbd_2d/examples/many_shapes.rs b/crates/bevy_xpbd_2d/examples/many_shapes.rs
index 14fe220a..c9b83ad3 100644
--- a/crates/bevy_xpbd_2d/examples/many_shapes.rs
+++ b/crates/bevy_xpbd_2d/examples/many_shapes.rs
@@ -136,21 +136,27 @@ fn setup(
 }
 
 fn movement(
+    time: Res<Time>,
     keyboard_input: Res<Input<KeyCode>>,
     mut marbles: Query<&mut LinearVelocity, With<Controllable>>,
 ) {
+    // Precision is adjusted so that the example works with
+    // both the `f32` and `f64` features. Otherwise you don't need this.
+    let delta_time = time.delta_seconds_f64().adjust_precision();
+
     for mut linear_velocity in &mut marbles {
-        if keyboard_input.pressed(KeyCode::Up) {
-            linear_velocity.y += 50.0;
+        if keyboard_input.any_pressed([KeyCode::W, KeyCode::Up]) {
+            // Use a higher acceleration for upwards movement to overcome gravity
+            linear_velocity.y += 2500.0 * delta_time;
         }
-        if keyboard_input.pressed(KeyCode::Down) {
-            linear_velocity.y -= 10.0;
+        if keyboard_input.any_pressed([KeyCode::S, KeyCode::Down]) {
+            linear_velocity.y -= 500.0 * delta_time;
         }
-        if keyboard_input.pressed(KeyCode::Left) {
-            linear_velocity.x -= 10.0;
+        if keyboard_input.any_pressed([KeyCode::A, KeyCode::Left]) {
+            linear_velocity.x -= 500.0 * delta_time;
         }
-        if keyboard_input.pressed(KeyCode::Right) {
-            linear_velocity.x += 10.0;
+        if keyboard_input.any_pressed([KeyCode::D, KeyCode::Right]) {
+            linear_velocity.x += 500.0 * delta_time;
         }
     }
 }
diff --git a/crates/bevy_xpbd_2d/examples/move_marbles.rs b/crates/bevy_xpbd_2d/examples/move_marbles.rs
index cecbd674..4fadfb0c 100644
--- a/crates/bevy_xpbd_2d/examples/move_marbles.rs
+++ b/crates/bevy_xpbd_2d/examples/move_marbles.rs
@@ -81,7 +81,7 @@ fn setup(
     let marble_material = materials.add(ColorMaterial::from(Color::rgb(0.2, 0.7, 0.9)));
 
     // Spawn stacks of marbles
-    for x in -21..21 {
+    for x in -20..20 {
         for y in -20..20 {
             commands.spawn((
                 MaterialMesh2dBundle {
@@ -103,21 +103,27 @@ fn setup(
 }
 
 fn movement(
+    time: Res<Time>,
     keyboard_input: Res<Input<KeyCode>>,
     mut marbles: Query<&mut LinearVelocity, With<Marble>>,
 ) {
+    // Precision is adjusted so that the example works with
+    // both the `f32` and `f64` features. Otherwise you don't need this.
+    let delta_time = time.delta_seconds_f64().adjust_precision();
+
     for mut linear_velocity in &mut marbles {
-        if keyboard_input.pressed(KeyCode::Up) {
-            linear_velocity.y += 50.0;
+        if keyboard_input.any_pressed([KeyCode::W, KeyCode::Up]) {
+            // Use a higher acceleration for upwards movement to overcome gravity
+            linear_velocity.y += 2500.0 * delta_time;
         }
-        if keyboard_input.pressed(KeyCode::Down) {
-            linear_velocity.y -= 10.0;
+        if keyboard_input.any_pressed([KeyCode::S, KeyCode::Down]) {
+            linear_velocity.y -= 500.0 * delta_time;
         }
-        if keyboard_input.pressed(KeyCode::Left) {
-            linear_velocity.x -= 10.0;
+        if keyboard_input.any_pressed([KeyCode::A, KeyCode::Left]) {
+            linear_velocity.x -= 500.0 * delta_time;
         }
-        if keyboard_input.pressed(KeyCode::Right) {
-            linear_velocity.x += 10.0;
+        if keyboard_input.any_pressed([KeyCode::D, KeyCode::Right]) {
+            linear_velocity.x += 500.0 * delta_time;
         }
     }
 }
diff --git a/crates/bevy_xpbd_2d/examples/one_way_platform_2d.rs b/crates/bevy_xpbd_2d/examples/one_way_platform_2d.rs
index f1376e4a..1988e112 100644
--- a/crates/bevy_xpbd_2d/examples/one_way_platform_2d.rs
+++ b/crates/bevy_xpbd_2d/examples/one_way_platform_2d.rs
@@ -23,6 +23,12 @@ fn main() {
 #[derive(Component)]
 struct Actor;
 
+#[derive(Component)]
+struct MovementSpeed(Scalar);
+
+#[derive(Component)]
+struct JumpImpulse(Scalar);
+
 #[derive(Clone, Eq, PartialEq, Debug, Default, Component)]
 pub struct OneWayPlatform(HashSet<Entity>);
 
@@ -136,20 +142,22 @@ fn setup(
         Collider::cuboid(actor_size.x, actor_size.y),
         Actor,
         PassThroughOneWayPlatform::ByNormal,
+        MovementSpeed(250.0),
+        JumpImpulse(450.0),
     ));
 }
 
 fn movement(
     keyboard_input: Res<Input<KeyCode>>,
-    mut actors: Query<&mut LinearVelocity, With<Actor>>,
+    mut actors: Query<(&mut LinearVelocity, &MovementSpeed, &JumpImpulse), With<Actor>>,
 ) {
-    for mut linear_velocity in &mut actors {
-        if keyboard_input.pressed(KeyCode::Left) {
-            linear_velocity.x -= 10.0;
-        }
-        if keyboard_input.pressed(KeyCode::Right) {
-            linear_velocity.x += 10.0;
-        }
+    for (mut linear_velocity, movement_speed, jump_impulse) in &mut actors {
+        let left = keyboard_input.any_pressed([KeyCode::A, KeyCode::Left]);
+        let right = keyboard_input.any_pressed([KeyCode::D, KeyCode::Right]);
+        let horizontal = right as i8 - left as i8;
+
+        // Move in input direction
+        linear_velocity.x = horizontal as Scalar * movement_speed.0;
 
         // Assume "mostly stopped" to mean "grounded".
         // You should use raycasting, shapecasting or sensor colliders
@@ -158,7 +166,7 @@ fn movement(
             && !keyboard_input.pressed(KeyCode::Down)
             && keyboard_input.just_pressed(KeyCode::Space)
         {
-            linear_velocity.y = 450.0;
+            linear_velocity.y = jump_impulse.0;
         }
     }
 }
diff --git a/crates/bevy_xpbd_3d/examples/basic_dynamic_character.rs b/crates/bevy_xpbd_3d/examples/basic_dynamic_character.rs
index 398e13eb..9b3d30b6 100644
--- a/crates/bevy_xpbd_3d/examples/basic_dynamic_character.rs
+++ b/crates/bevy_xpbd_3d/examples/basic_dynamic_character.rs
@@ -7,18 +7,69 @@
 //! For a kinematic character controller, see the `basic_kinematic_character` example.
 
 use bevy::prelude::*;
-use bevy_xpbd_3d::{math::*, prelude::*, PhysicsSchedule, PhysicsStepSet};
+use bevy_xpbd_3d::{math::*, prelude::*};
 
 fn main() {
     App::new()
         .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
         .add_systems(Startup, setup)
-        .add_systems(PhysicsSchedule, movement.before(PhysicsStepSet::BroadPhase))
+        .add_systems(Update, movement)
         .run();
 }
 
+/// The acceleration used for character movement.
 #[derive(Component)]
-struct Player;
+struct MovementAcceleration(Scalar);
+
+/// The damping factor used for slowing down movement.
+#[derive(Component)]
+struct MovementDampingFactor(Scalar);
+
+/// The strength of a jump.
+#[derive(Component)]
+struct JumpImpulse(Scalar);
+
+/// A bundle that contains the components needed for a basic
+/// dynamic character controller.
+#[derive(Bundle)]
+struct CharacterControllerBundle {
+    rigid_body: RigidBody,
+    collider: Collider,
+    ground_caster: ShapeCaster,
+    locked_axes: LockedAxes,
+    movement_acceleration: MovementAcceleration,
+    movement_damping: MovementDampingFactor,
+    jump_impulse: JumpImpulse,
+}
+
+impl CharacterControllerBundle {
+    fn new(
+        acceleration: Scalar,
+        damping: Scalar,
+        jump_impulse: Scalar,
+        collider: Collider,
+    ) -> Self {
+        // Create shape caster as a slightly smaller version of the collider
+        let mut caster_shape = collider.clone();
+        caster_shape.set_scale(Vector::ONE * 0.99, 10);
+
+        Self {
+            rigid_body: RigidBody::Dynamic,
+            locked_axes: LockedAxes::ROTATION_LOCKED,
+            collider,
+            ground_caster: ShapeCaster::new(
+                caster_shape,
+                Vector::ZERO,
+                Quaternion::default(),
+                Vector::NEG_Y,
+            )
+            .with_max_time_of_impact(0.2),
+            movement_acceleration: MovementAcceleration(acceleration),
+            movement_damping: MovementDampingFactor(damping),
+            jump_impulse: JumpImpulse(jump_impulse),
+        }
+    }
+}
 
 fn setup(
     mut commands: Commands,
@@ -44,25 +95,13 @@ fn setup(
                 ..default()
             })),
             material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
-            transform: Transform::from_xyz(0.0, 1.0, 0.0),
+            transform: Transform::from_xyz(0.0, 1.5, 0.0),
             ..default()
         },
-        RigidBody::Dynamic,
-        Collider::capsule(1.0, 0.4),
-        // Prevent the player from falling over
-        LockedAxes::new().lock_rotation_x().lock_rotation_z(),
-        // Cast the player shape downwards to detect when the player is grounded
-        ShapeCaster::new(
-            Collider::capsule(0.9, 0.35),
-            Vector::NEG_Y * 0.05,
-            Quaternion::default(),
-            Vector::NEG_Y,
-        )
-        .with_max_time_of_impact(0.2)
-        .with_max_hits(1),
-        Restitution::new(0.0).with_combine_rule(CoefficientCombine::Min),
+        CharacterControllerBundle::new(30.0, 0.9, 8.0, Collider::capsule(1.0, 0.4)),
+        Friction::ZERO.with_combine_rule(CoefficientCombine::Min),
+        Restitution::ZERO.with_combine_rule(CoefficientCombine::Min),
         GravityScale(2.0),
-        Player,
     ));
 
     // Light
@@ -84,31 +123,44 @@ fn setup(
 }
 
 fn movement(
+    time: Res<Time>,
     keyboard_input: Res<Input<KeyCode>>,
-    mut players: Query<(&mut LinearVelocity, &ShapeHits), With<Player>>,
+    mut controllers: Query<(
+        &MovementAcceleration,
+        &MovementDampingFactor,
+        &JumpImpulse,
+        &ShapeHits,
+        &mut LinearVelocity,
+    )>,
 ) {
-    for (mut linear_velocity, ground_hits) in &mut players {
-        // Directional movement
-        if keyboard_input.pressed(KeyCode::W) || keyboard_input.pressed(KeyCode::Up) {
-            linear_velocity.z -= 1.2;
-        }
-        if keyboard_input.pressed(KeyCode::S) || keyboard_input.pressed(KeyCode::Down) {
-            linear_velocity.z += 1.2;
-        }
-        if keyboard_input.pressed(KeyCode::A) || keyboard_input.pressed(KeyCode::Left) {
-            linear_velocity.x -= 1.2;
-        }
-        if keyboard_input.pressed(KeyCode::D) || keyboard_input.pressed(KeyCode::Right) {
-            linear_velocity.x += 1.2;
-        }
+    // Precision is adjusted so that the example works with
+    // both the `f32` and `f64` features. Otherwise you don't need this.
+    let delta_time = time.delta_seconds_f64().adjust_precision();
 
-        // Jump if space pressed and the player is close enough to the ground
+    for (movement_acceleration, damping_factor, jump_impulse, ground_hits, mut linear_velocity) in
+        &mut controllers
+    {
+        let up = keyboard_input.any_pressed([KeyCode::W, KeyCode::Up]);
+        let down = keyboard_input.any_pressed([KeyCode::S, KeyCode::Down]);
+        let left = keyboard_input.any_pressed([KeyCode::A, KeyCode::Left]);
+        let right = keyboard_input.any_pressed([KeyCode::D, KeyCode::Right]);
+
+        let horizontal = right as i8 - left as i8;
+        let vertical = down as i8 - up as i8;
+        let direction =
+            Vector::new(horizontal as Scalar, 0.0, vertical as Scalar).normalize_or_zero();
+
+        // Move in input direction
+        linear_velocity.x += direction.x * movement_acceleration.0 * delta_time;
+        linear_velocity.z += direction.z * movement_acceleration.0 * delta_time;
+
+        // Apply movement damping
+        linear_velocity.x *= damping_factor.0;
+        linear_velocity.z *= damping_factor.0;
+
+        // Jump if Space is pressed and the player is close enough to the ground
         if keyboard_input.just_pressed(KeyCode::Space) && !ground_hits.is_empty() {
-            linear_velocity.y += 8.0;
+            linear_velocity.y = jump_impulse.0;
         }
-
-        // Slow player down on the x and y axes
-        linear_velocity.x *= 0.8;
-        linear_velocity.z *= 0.8;
     }
 }
diff --git a/crates/bevy_xpbd_3d/examples/basic_kinematic_character.rs b/crates/bevy_xpbd_3d/examples/basic_kinematic_character.rs
index 2904ad6b..006281b8 100644
--- a/crates/bevy_xpbd_3d/examples/basic_kinematic_character.rs
+++ b/crates/bevy_xpbd_3d/examples/basic_kinematic_character.rs
@@ -9,15 +9,13 @@
 //! For a dynamic character controller, see the `basic_dynamic_character` example.
 
 use bevy::prelude::*;
-use bevy_xpbd_3d::{
-    math::*, prelude::*, PhysicsSchedule, PhysicsStepSet, SubstepSchedule, SubstepSet,
-};
+use bevy_xpbd_3d::{math::*, prelude::*, SubstepSchedule, SubstepSet};
 
 fn main() {
     App::new()
         .add_plugins((DefaultPlugins, PhysicsPlugins::default()))
         .add_systems(Startup, setup)
-        .add_systems(PhysicsSchedule, movement.before(PhysicsStepSet::BroadPhase))
+        .add_systems(Update, movement)
         .add_systems(
             // Run collision handling in substep schedule
             SubstepSchedule,
@@ -26,8 +24,64 @@ fn main() {
         .run();
 }
 
+/// The acceleration used for character movement.
 #[derive(Component)]
-struct Player;
+struct MovementAcceleration(Scalar);
+
+/// The damping factor used for slowing down movement.
+#[derive(Component)]
+struct MovementDampingFactor(Scalar);
+
+/// The strength of a jump.
+#[derive(Component)]
+struct JumpImpulse(Scalar);
+
+/// The gravitational acceleration used for a character controller.
+#[derive(Component)]
+struct ControllerGravity(Vector);
+
+/// A bundle that contains the components needed for a basic
+/// kinematic character controller.
+#[derive(Bundle)]
+struct CharacterControllerBundle {
+    rigid_body: RigidBody,
+    collider: Collider,
+    ground_caster: ShapeCaster,
+    movement_acceleration: MovementAcceleration,
+    movement_damping: MovementDampingFactor,
+    jump_impulse: JumpImpulse,
+    gravity: ControllerGravity,
+}
+
+impl CharacterControllerBundle {
+    fn new(
+        acceleration: Scalar,
+        damping: Scalar,
+        jump_impulse: Scalar,
+        gravity: Vector,
+        collider: Collider,
+    ) -> Self {
+        // Create shape caster as a slightly smaller version of the collider
+        let mut caster_shape = collider.clone();
+        caster_shape.set_scale(Vector::ONE * 0.99, 10);
+
+        Self {
+            rigid_body: RigidBody::Kinematic,
+            collider,
+            ground_caster: ShapeCaster::new(
+                caster_shape,
+                Vector::ZERO,
+                Quaternion::default(),
+                Vector::NEG_Y,
+            )
+            .with_max_time_of_impact(0.2),
+            movement_acceleration: MovementAcceleration(acceleration),
+            movement_damping: MovementDampingFactor(damping),
+            jump_impulse: JumpImpulse(jump_impulse),
+            gravity: ControllerGravity(gravity),
+        }
+    }
+}
 
 fn setup(
     mut commands: Commands,
@@ -53,21 +107,17 @@ fn setup(
                 ..default()
             })),
             material: materials.add(Color::rgb(0.8, 0.7, 0.6).into()),
-            transform: Transform::from_xyz(0.0, 1.0, 0.0),
+            transform: Transform::from_xyz(0.0, 1.5, 0.0),
             ..default()
         },
-        RigidBody::Kinematic,
-        Collider::capsule(1.0, 0.4),
-        // Cast the player shape downwards to detect when the player is grounded
-        ShapeCaster::new(
-            Collider::capsule(0.9, 0.35),
-            Vector::ZERO,
-            Quaternion::default(),
-            Vector::NEG_Y,
-        )
-        .with_max_time_of_impact(0.11)
-        .with_max_hits(1),
-        Player,
+        CharacterControllerBundle::new(
+            30.0,
+            0.9,
+            8.0,
+            // Two times the normal gravity
+            Vector::NEG_Y * 9.81 * 2.0,
+            Collider::capsule(1.0, 0.4),
+        ),
     ));
 
     // Light
@@ -89,40 +139,59 @@ fn setup(
 }
 
 fn movement(
+    time: Res<Time>,
     keyboard_input: Res<Input<KeyCode>>,
-    mut players: Query<(&mut LinearVelocity, &ShapeHits), With<Player>>,
+    mut controllers: Query<(
+        &MovementAcceleration,
+        &MovementDampingFactor,
+        &JumpImpulse,
+        &ControllerGravity,
+        &ShapeHits,
+        &mut LinearVelocity,
+    )>,
 ) {
-    for (mut linear_velocity, ground_hits) in &mut players {
+    // Precision is adjusted so that the example works with
+    // both the `f32` and `f64` features. Otherwise you don't need this.
+    let delta_time = time.delta_seconds_f64().adjust_precision();
+
+    for (
+        movement_acceleration,
+        damping_factor,
+        jump_impulse,
+        gravity,
+        ground_hits,
+        mut linear_velocity,
+    ) in &mut controllers
+    {
         // Reset vertical valocity if grounded, otherwise apply gravity
         if !ground_hits.is_empty() {
             linear_velocity.y = 0.0;
         } else {
-            linear_velocity.y -= 0.4;
+            linear_velocity.0 += gravity.0 * delta_time;
         }
 
-        // Directional movement
-        if keyboard_input.pressed(KeyCode::W) || keyboard_input.pressed(KeyCode::Up) {
-            linear_velocity.z -= 1.2;
-        }
-        if keyboard_input.pressed(KeyCode::A) || keyboard_input.pressed(KeyCode::Left) {
-            linear_velocity.x -= 1.2;
-        }
-        if keyboard_input.pressed(KeyCode::S) || keyboard_input.pressed(KeyCode::Down) {
-            linear_velocity.z += 1.2;
-        }
-        if keyboard_input.pressed(KeyCode::D) || keyboard_input.pressed(KeyCode::Right) {
-            linear_velocity.x += 1.2;
-        }
+        let up = keyboard_input.any_pressed([KeyCode::W, KeyCode::Up]);
+        let down = keyboard_input.any_pressed([KeyCode::S, KeyCode::Down]);
+        let left = keyboard_input.any_pressed([KeyCode::A, KeyCode::Left]);
+        let right = keyboard_input.any_pressed([KeyCode::D, KeyCode::Right]);
+
+        let horizontal = right as i8 - left as i8;
+        let vertical = down as i8 - up as i8;
+        let direction =
+            Vector::new(horizontal as Scalar, 0.0, vertical as Scalar).normalize_or_zero();
+
+        // Move in input direction
+        linear_velocity.x += direction.x * movement_acceleration.0 * delta_time;
+        linear_velocity.z += direction.z * movement_acceleration.0 * delta_time;
 
-        // Jump if space pressed and the player is close enough to the ground
+        // Apply movement damping
+        linear_velocity.x *= damping_factor.0;
+        linear_velocity.z *= damping_factor.0;
+
+        // Jump if Space is pressed and the player is close enough to the ground
         if keyboard_input.just_pressed(KeyCode::Space) && !ground_hits.is_empty() {
-            linear_velocity.y += 10.0;
+            linear_velocity.y = jump_impulse.0;
         }
-
-        // Slow player down
-        linear_velocity.x *= 0.8;
-        linear_velocity.y *= 0.98;
-        linear_velocity.z *= 0.8;
     }
 }
 
diff --git a/crates/bevy_xpbd_3d/examples/chain_3d.rs b/crates/bevy_xpbd_3d/examples/chain_3d.rs
index 5669ac60..79b5aec0 100644
--- a/crates/bevy_xpbd_3d/examples/chain_3d.rs
+++ b/crates/bevy_xpbd_3d/examples/chain_3d.rs
@@ -20,8 +20,9 @@ fn main() {
         .run();
 }
 
+/// The acceleration used for movement.
 #[derive(Component)]
-struct Controllable;
+struct MovementAcceleration(Scalar);
 
 fn setup(
     mut commands: Commands,
@@ -41,16 +42,26 @@ fn setup(
 
     // Spawn kinematic particle that can follow the mouse
     let mut previous_particle = commands
-        .spawn((particle_mesh.clone(), RigidBody::Kinematic, Controllable))
+        .spawn((
+            RigidBody::Kinematic,
+            MovementAcceleration(25.0),
+            PbrBundle {
+                mesh: particle_mesh.clone(),
+                material: particle_material.clone(),
+                ..default()
+            },
+        ))
         .id();
 
     // Spawn the rest of the particles, connecting each one to the previous one with joints
     for i in 1..particle_count {
         let current_particle = commands
             .spawn((
+                RigidBody::Dynamic,
+                MassPropertiesBundle::new_computed(&Collider::ball(particle_radius), 1.0),
                 PbrBundle {
-                    mesh: particle_mesh.clone_weak(),
-                    material: particle_material.clone_weak(),
+                    mesh: particle_mesh.clone(),
+                    material: particle_material.clone(),
                     transform: Transform::from_xyz(
                         0.0,
                         -i as f32 * particle_radius as f32 * 2.2,
@@ -58,8 +69,6 @@ fn setup(
                     ),
                     ..default()
                 },
-                RigidBody::Dynamic,
-                MassPropertiesBundle::new_computed(&Collider::ball(particle_radius), 1.0),
             ))
             .id();
 
@@ -81,22 +90,30 @@ fn setup(
 }
 
 fn movement(
+    time: Res<Time>,
     keyboard_input: Res<Input<KeyCode>>,
-    mut marbles: Query<&mut LinearVelocity, With<Controllable>>,
+    mut query: Query<(&MovementAcceleration, &mut LinearVelocity)>,
 ) {
-    for mut linear_velocity in &mut marbles {
-        if keyboard_input.pressed(KeyCode::Up) {
-            linear_velocity.z -= 0.75;
-        }
-        if keyboard_input.pressed(KeyCode::Down) {
-            linear_velocity.z += 0.75;
-        }
-        if keyboard_input.pressed(KeyCode::Left) {
-            linear_velocity.x -= 0.75;
-        }
-        if keyboard_input.pressed(KeyCode::Right) {
-            linear_velocity.x += 0.75;
-        }
+    // Precision is adjusted so that the example works with
+    // both the `f32` and `f64` features. Otherwise you don't need this.
+    let delta_time = time.delta_seconds_f64().adjust_precision();
+
+    for (movement_acceleration, mut linear_velocity) in &mut query {
+        let up = keyboard_input.any_pressed([KeyCode::W, KeyCode::Up]);
+        let down = keyboard_input.any_pressed([KeyCode::S, KeyCode::Down]);
+        let left = keyboard_input.any_pressed([KeyCode::A, KeyCode::Left]);
+        let right = keyboard_input.any_pressed([KeyCode::D, KeyCode::Right]);
+
+        let horizontal = right as i8 - left as i8;
+        let vertical = down as i8 - up as i8;
+        let direction =
+            Vector::new(horizontal as Scalar, 0.0, vertical as Scalar).normalize_or_zero();
+
+        // Move in input direction
+        linear_velocity.x += direction.x * movement_acceleration.0 * delta_time;
+        linear_velocity.z += direction.z * movement_acceleration.0 * delta_time;
+
+        // Slow down movement
         linear_velocity.0 *= 0.9;
     }
 }
@@ -122,7 +139,7 @@ fn ui(mut commands: Commands) {
             // text
             parent.spawn((
                 TextBundle::from_section(
-                    "Use Arrow Keys to Move The Chain",
+                    "Use Arrow Keys or WASD to Move The Chain",
                     TextStyle {
                         font_size: 20.0,
                         color: Color::WHITE,
diff --git a/crates/bevy_xpbd_3d/examples/cubes.rs b/crates/bevy_xpbd_3d/examples/cubes.rs
index 1dbccecc..808bd2b0 100644
--- a/crates/bevy_xpbd_3d/examples/cubes.rs
+++ b/crates/bevy_xpbd_3d/examples/cubes.rs
@@ -1,7 +1,7 @@
 #![allow(clippy::unnecessary_cast)]
 
 use bevy::prelude::*;
-use bevy_xpbd_3d::prelude::*;
+use bevy_xpbd_3d::{math::*, prelude::*};
 use examples_common_3d::XpbdExamplePlugin;
 
 fn main() {
@@ -14,8 +14,9 @@ fn main() {
         .run();
 }
 
+/// The acceleration used for movement.
 #[derive(Component)]
-struct Cube;
+struct MovementAcceleration(Scalar);
 
 fn setup(
     mut commands: Commands,
@@ -53,7 +54,7 @@ fn setup(
                     },
                     RigidBody::Dynamic,
                     Collider::cuboid(1.0, 1.0, 1.0),
-                    Cube,
+                    MovementAcceleration(10.0),
                 ));
             }
         }
@@ -79,21 +80,27 @@ fn setup(
 }
 
 fn movement(
+    time: Res<Time>,
     keyboard_input: Res<Input<KeyCode>>,
-    mut query: Query<&mut LinearVelocity, With<Cube>>,
+    mut query: Query<(&MovementAcceleration, &mut LinearVelocity)>,
 ) {
-    for mut lin_vel in &mut query {
-        if keyboard_input.pressed(KeyCode::Up) {
-            lin_vel.z -= 0.15;
-        }
-        if keyboard_input.pressed(KeyCode::Down) {
-            lin_vel.z += 0.15;
-        }
-        if keyboard_input.pressed(KeyCode::Left) {
-            lin_vel.x -= 0.15;
-        }
-        if keyboard_input.pressed(KeyCode::Right) {
-            lin_vel.x += 0.15;
-        }
+    // Precision is adjusted so that the example works with
+    // both the `f32` and `f64` features. Otherwise you don't need this.
+    let delta_time = time.delta_seconds_f64().adjust_precision();
+
+    for (movement_acceleration, mut linear_velocity) in &mut query {
+        let up = keyboard_input.any_pressed([KeyCode::W, KeyCode::Up]);
+        let down = keyboard_input.any_pressed([KeyCode::S, KeyCode::Down]);
+        let left = keyboard_input.any_pressed([KeyCode::A, KeyCode::Left]);
+        let right = keyboard_input.any_pressed([KeyCode::D, KeyCode::Right]);
+
+        let horizontal = right as i8 - left as i8;
+        let vertical = down as i8 - up as i8;
+        let direction =
+            Vector::new(horizontal as Scalar, 0.0, vertical as Scalar).normalize_or_zero();
+
+        // Move in input direction
+        linear_velocity.x += direction.x * movement_acceleration.0 * delta_time;
+        linear_velocity.z += direction.z * movement_acceleration.0 * delta_time;
     }
 }
diff --git a/crates/bevy_xpbd_3d/examples/custom_constraint.rs b/crates/bevy_xpbd_3d/examples/custom_constraint.rs
index e42a1ad5..3bd28583 100644
--- a/crates/bevy_xpbd_3d/examples/custom_constraint.rs
+++ b/crates/bevy_xpbd_3d/examples/custom_constraint.rs
@@ -104,8 +104,8 @@ fn setup(
     let static_cube = commands
         .spawn((
             PbrBundle {
-                mesh: cube_mesh.clone_weak(),
-                material: cube_material.clone_weak(),
+                mesh: cube_mesh.clone(),
+                material: cube_material.clone(),
                 ..default()
             },
             RigidBody::Static,
diff --git a/crates/bevy_xpbd_3d/examples/distance_joint_3d.rs b/crates/bevy_xpbd_3d/examples/distance_joint_3d.rs
index 23c5c700..f5d937e9 100644
--- a/crates/bevy_xpbd_3d/examples/distance_joint_3d.rs
+++ b/crates/bevy_xpbd_3d/examples/distance_joint_3d.rs
@@ -23,8 +23,8 @@ fn setup(
     let static_cube = commands
         .spawn((
             PbrBundle {
-                mesh: cube_mesh.clone_weak(),
-                material: cube_material.clone_weak(),
+                mesh: cube_mesh.clone(),
+                material: cube_material.clone(),
                 ..default()
             },
             RigidBody::Static,
diff --git a/crates/bevy_xpbd_3d/examples/fixed_joint_3d.rs b/crates/bevy_xpbd_3d/examples/fixed_joint_3d.rs
index fedf72cd..9952a3fb 100644
--- a/crates/bevy_xpbd_3d/examples/fixed_joint_3d.rs
+++ b/crates/bevy_xpbd_3d/examples/fixed_joint_3d.rs
@@ -24,8 +24,8 @@ fn setup(
     let anchor = commands
         .spawn((
             PbrBundle {
-                mesh: cube_mesh.clone_weak(),
-                material: cube_material.clone_weak(),
+                mesh: cube_mesh.clone(),
+                material: cube_material.clone(),
                 transform: Transform::from_xyz(3.0, 3.5, 0.0),
                 ..default()
             },
diff --git a/crates/bevy_xpbd_3d/examples/prismatic_joint_3d.rs b/crates/bevy_xpbd_3d/examples/prismatic_joint_3d.rs
index a50be3b2..2752b935 100644
--- a/crates/bevy_xpbd_3d/examples/prismatic_joint_3d.rs
+++ b/crates/bevy_xpbd_3d/examples/prismatic_joint_3d.rs
@@ -24,8 +24,8 @@ fn setup(
     let anchor = commands
         .spawn((
             PbrBundle {
-                mesh: cube_mesh.clone_weak(),
-                material: cube_material.clone_weak(),
+                mesh: cube_mesh.clone(),
+                material: cube_material.clone(),
                 ..default()
             },
             RigidBody::Kinematic,
diff --git a/crates/bevy_xpbd_3d/examples/revolute_joint_3d.rs b/crates/bevy_xpbd_3d/examples/revolute_joint_3d.rs
index 0bc6c1a4..1d313ec7 100644
--- a/crates/bevy_xpbd_3d/examples/revolute_joint_3d.rs
+++ b/crates/bevy_xpbd_3d/examples/revolute_joint_3d.rs
@@ -24,8 +24,8 @@ fn setup(
     let anchor = commands
         .spawn((
             PbrBundle {
-                mesh: cube_mesh.clone_weak(),
-                material: cube_material.clone_weak(),
+                mesh: cube_mesh.clone(),
+                material: cube_material.clone(),
                 ..default()
             },
             RigidBody::Kinematic,