diff --git a/README.md b/README.md
index 04f6c149e..3c990d9f6 100644
--- a/README.md
+++ b/README.md
@@ -117,7 +117,7 @@ fn setup(
     commands.spawn((
         RigidBody::Dynamic,
         Collider::cuboid(1.0, 1.0, 1.0),
-        AngularVelocity(Vec3::new(2.5, 3.5, 1.5)),
+        Velocity::from_angular_xyz(2.5, 3.5, 1.5),
         Mesh3d(meshes.add(Cuboid::from_length(1.0))),
         MeshMaterial3d(materials.add(Color::srgb_u8(124, 144, 255))),
         Transform::from_xyz(0.0, 4.0, 0.0),
diff --git a/crates/avian2d/examples/ccd.rs b/crates/avian2d/examples/ccd.rs
index 6d6d73d76..f1e3a28e8 100644
--- a/crates/avian2d/examples/ccd.rs
+++ b/crates/avian2d/examples/ccd.rs
@@ -58,7 +58,7 @@ fn setup(mut commands: Commands) {
         },
         Transform::from_xyz(-200.0, -200.0, 0.0),
         RigidBody::Kinematic,
-        AngularVelocity(25.0),
+        Velocity::from_angular(25.0),
         Collider::rectangle(1.0, 400.0),
         // Enable swept CCD for this body. Considers both translational and rotational motion by default.
         // This could also be on the ball projectiles.
@@ -72,7 +72,7 @@ fn setup(mut commands: Commands) {
         },
         Transform::from_xyz(200.0, -200.0, 0.0),
         RigidBody::Kinematic,
-        AngularVelocity(-25.0),
+        Velocity::from_angular(-25.0),
         Collider::rectangle(1.0, 400.0),
         // Enable swept CCD for this body. Considers both translational and rotational motion by default.
         // This could also be on the ball projectiles.
@@ -140,7 +140,7 @@ fn spawn_balls(
         MeshMaterial2d(materials.add(Color::srgb(0.2, 0.7, 0.9))),
         Transform::from_xyz(0.0, 350.0, 0.0),
         RigidBody::Dynamic,
-        LinearVelocity(2000.0 * direction),
+        Velocity::from_linear(2000.0 * direction),
         Friction::ZERO.with_combine_rule(CoefficientCombine::Min),
         Collider::from(circle),
     ));
diff --git a/crates/avian2d/examples/custom_collider.rs b/crates/avian2d/examples/custom_collider.rs
index 89708bad8..2928a4f7b 100644
--- a/crates/avian2d/examples/custom_collider.rs
+++ b/crates/avian2d/examples/custom_collider.rs
@@ -206,7 +206,7 @@ fn setup(
                 ),
                 RigidBody::Dynamic,
                 CircleCollider::new(particle_radius.adjust_precision()),
-                LinearDamping(0.4),
+                Damping::from_linear(0.4),
             ));
         }
     }
@@ -214,21 +214,21 @@ fn setup(
 
 /// Pulls all particles towards the center.
 fn center_gravity(
-    mut particles: Query<(&Transform, &mut LinearVelocity), Without<CenterBody>>,
+    mut particles: Query<(&Transform, &mut Velocity), Without<CenterBody>>,
     time: Res<Time>,
 ) {
     let delta_seconds = time.delta_secs_f64().adjust_precision();
-    for (transform, mut lin_vel) in &mut particles {
+    for (transform, mut velocity) in &mut particles {
         let pos_delta = transform.translation.truncate().adjust_precision();
         let dir = -pos_delta.normalize_or_zero();
-        lin_vel.0 += 800.0 * delta_seconds * dir;
+        velocity.linear += 800.0 * delta_seconds * dir;
     }
 }
 
 /// Rotates the center body periodically clockwise and counterclockwise.
-fn rotate(mut query: Query<&mut AngularVelocity, With<CenterBody>>, time: Res<Time>) {
+fn rotate(mut query: Query<&mut Velocity, With<CenterBody>>, time: Res<Time>) {
     let sin = 3.0 * time.elapsed_secs_f64().adjust_precision().sin();
-    for mut ang_vel in &mut query {
-        ang_vel.0 = sin;
+    for mut velocity in &mut query {
+        velocity.angular = sin;
     }
 }
diff --git a/crates/avian2d/examples/dynamic_character_2d/plugin.rs b/crates/avian2d/examples/dynamic_character_2d/plugin.rs
index 7d8992be8..804f2185f 100644
--- a/crates/avian2d/examples/dynamic_character_2d/plugin.rs
+++ b/crates/avian2d/examples/dynamic_character_2d/plugin.rs
@@ -192,7 +192,7 @@ fn movement(
     mut controllers: Query<(
         &MovementAcceleration,
         &JumpImpulse,
-        &mut LinearVelocity,
+        &mut Velocity,
         Has<Grounded>,
     )>,
 ) {
@@ -201,16 +201,14 @@ fn movement(
     let delta_time = time.delta_secs_f64().adjust_precision();
 
     for event in movement_reader.read() {
-        for (movement_acceleration, jump_impulse, mut linear_velocity, is_grounded) in
-            &mut controllers
-        {
+        for (movement_acceleration, jump_impulse, mut velocity, is_grounded) in &mut controllers {
             match event {
                 MovementAction::Move(direction) => {
-                    linear_velocity.x += *direction * movement_acceleration.0 * delta_time;
+                    velocity.linear.x += *direction * movement_acceleration.0 * delta_time;
                 }
                 MovementAction::Jump => {
                     if is_grounded {
-                        linear_velocity.y = jump_impulse.0;
+                        velocity.linear.y = jump_impulse.0;
                     }
                 }
             }
@@ -221,14 +219,14 @@ fn movement(
 /// Slows down movement in the X direction.
 fn apply_movement_damping(
     time: Res<Time>,
-    mut query: Query<(&MovementDampingFactor, &mut LinearVelocity)>,
+    mut query: Query<(&MovementDampingFactor, &mut Velocity)>,
 ) {
     // 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_secs_f64().adjust_precision();
 
-    for (damping_factor, mut linear_velocity) in &mut query {
-        // We could use `LinearDamping`, but we don't want to dampen movement along the Y axis
-        linear_velocity.x *= 1.0 / (1.0 + damping_factor.0 * delta_time);
+    for (damping_factor, mut velocity) in &mut query {
+        // We could use `Damping`, but we don't want to dampen movement along the Y axis
+        velocity.linear.x *= 1.0 / (1.0 + damping_factor.0 * delta_time);
     }
 }
diff --git a/crates/avian2d/examples/fixed_joint_2d.rs b/crates/avian2d/examples/fixed_joint_2d.rs
index b55fa52bc..722117b8d 100644
--- a/crates/avian2d/examples/fixed_joint_2d.rs
+++ b/crates/avian2d/examples/fixed_joint_2d.rs
@@ -29,7 +29,7 @@ fn setup(mut commands: Commands) {
         .spawn((
             square_sprite.clone(),
             RigidBody::Kinematic,
-            AngularVelocity(1.5),
+            Velocity::from_angular(1.5),
         ))
         .id();
 
diff --git a/crates/avian2d/examples/kinematic_character_2d/plugin.rs b/crates/avian2d/examples/kinematic_character_2d/plugin.rs
index 214a0e5d9..d38c9d417 100644
--- a/crates/avian2d/examples/kinematic_character_2d/plugin.rs
+++ b/crates/avian2d/examples/kinematic_character_2d/plugin.rs
@@ -201,23 +201,19 @@ fn update_grounded(
 fn movement(
     time: Res<Time>,
     mut movement_reader: MessageReader<MovementAction>,
-    mut controllers: Query<(
-        &CharacterMovementSettings,
-        &mut LinearVelocity,
-        Has<Grounded>,
-    )>,
+    mut controllers: Query<(&CharacterMovementSettings, &mut Velocity, Has<Grounded>)>,
 ) {
     let delta_secs = time.delta_secs_f64().adjust_precision();
 
     for event in movement_reader.read() {
-        for (movement, mut linear_velocity, is_grounded) in &mut controllers {
+        for (movement, mut velocity, is_grounded) in &mut controllers {
             match event {
                 MovementAction::Move(direction) => {
-                    linear_velocity.x += *direction * movement.acceleration * delta_secs;
+                    velocity.linear.x += *direction * movement.acceleration * delta_secs;
                 }
                 MovementAction::Jump => {
                     if is_grounded {
-                        linear_velocity.y = movement.jump_impulse;
+                        velocity.linear.y = movement.jump_impulse;
                     }
                 }
             }
@@ -228,43 +224,43 @@ fn movement(
 /// Applies gravity to character controllers.
 fn apply_gravity(
     time: Res<Time>,
-    mut controllers: Query<(&CharacterMovementSettings, &mut LinearVelocity)>,
+    mut controllers: Query<(&CharacterMovementSettings, &mut Velocity)>,
 ) {
     let delta_secs = time.delta_secs_f64().adjust_precision();
 
-    for (movement, mut linear_velocity) in &mut controllers {
+    for (movement, mut velocity) in &mut controllers {
         let gravity_direction = movement.gravity.normalize_or_zero();
 
-        let velocity_along_gravity = linear_velocity.dot(gravity_direction);
+        let velocity_along_gravity = velocity.linear.dot(gravity_direction);
         if velocity_along_gravity > movement.terminal_velocity {
             // Don't apply more gravity if we're already at terminal velocity.
             continue;
         }
 
         // Calculate the new velocity after applying gravity.
-        let new_velocity = linear_velocity.0 + movement.gravity * delta_secs;
+        let new_velocity = velocity.linear + movement.gravity * delta_secs;
 
         // Don't exceed terminal velocity.
         let new_velocity_along_gravity = new_velocity.dot(gravity_direction);
         if new_velocity_along_gravity < movement.terminal_velocity {
-            linear_velocity.0 = new_velocity;
+            velocity.linear = new_velocity;
         } else {
-            linear_velocity.0 = gravity_direction * movement.terminal_velocity;
+            velocity.linear = gravity_direction * movement.terminal_velocity;
         }
     }
 }
 
 /// Slows down movement in the X axis.
 fn apply_movement_damping(
-    mut query: Query<(&CharacterMovementSettings, &mut LinearVelocity)>,
+    mut query: Query<(&CharacterMovementSettings, &mut Velocity)>,
     time: Res<Time>,
 ) {
     let delta_secs = time.delta_secs_f64().adjust_precision();
 
-    for (movement, mut linear_velocity) in &mut query {
-        // Approximate exponential decay. We could use `LinearDamping` for this,
+    for (movement, mut velocity) in &mut query {
+        // Approximate exponential decay. We could use `Damping` for this,
         // but we don't want to dampen movement along the Y axis.
-        linear_velocity.x *= 1.0 / (1.0 + delta_secs * movement.damping);
+        velocity.linear.x *= 1.0 / (1.0 + delta_secs * movement.damping);
     }
 }
 
@@ -280,7 +276,7 @@ fn move_and_slide(
             Option<&GroundDetection>,
             Option<&mut CharacterCollisions>,
             &mut Transform,
-            &mut LinearVelocity,
+            &mut Velocity,
             &Collider,
         ),
         With<CharacterController>,
@@ -288,7 +284,7 @@ fn move_and_slide(
     move_and_slide: MoveAndSlide,
     time: Res<Time>,
 ) {
-    for (entity, ground_detection, mut collisions, mut transform, mut lin_vel, collider) in
+    for (entity, ground_detection, mut collisions, mut transform, mut velocity, collider) in
         &mut query
     {
         let mut hit_ground_or_ceiling = false;
@@ -308,7 +304,7 @@ fn move_and_slide(
             collider,
             transform.translation.xy().adjust_precision(),
             Rotation::from(transform.rotation).as_radians(),
-            lin_vel.0,
+            velocity.linear,
             time.delta(),
             &MoveAndSlideConfig::default(),
             &SpatialQueryFilter::from_excluded_entities([entity]),
@@ -330,7 +326,7 @@ fn move_and_slide(
                 // Decompose the original input velocity into components relative to the hit normal and the up direction,
                 // to determine how much of the velocity is contributing to climbing, slipping, and unconstrained movement.
                 let [horizontal_component, vertical_component] =
-                    split_into_components(lin_vel.0, up);
+                    split_into_components(velocity.linear, up);
 
                 // Decompose the horizontal component and the current sliding velocity to determine
                 // whether the character is trying to climb or slip, and whether it is actually climbing or slipping.
@@ -394,9 +390,9 @@ fn move_and_slide(
         // and to prevent sticking to ceilings when jumping.
         if hit_ground_or_ceiling {
             let up = transform.up().xy().adjust_precision();
-            let velocity_along_up = lin_vel.dot(up);
+            let velocity_along_up = velocity.linear.dot(up);
             let new_velocity_along_up = projected_velocity.dot(up);
-            lin_vel.0 += (new_velocity_along_up - velocity_along_up) * up;
+            velocity.linear += (new_velocity_along_up - velocity_along_up) * up;
         }
     }
 }
@@ -451,7 +447,7 @@ fn apply_forces_to_dynamic_bodies(
             }
 
             let touch_dir = -collision.normal.adjust_precision();
-            let relative_velocity = collision.character_velocity - forces.linear_velocity();
+            let relative_velocity = collision.character_velocity - forces.velocity().linear;
             let touch_velocity = touch_dir.dot(relative_velocity) * touch_dir;
             let impulse = touch_velocity * mass;
 
diff --git a/crates/avian2d/examples/many_shapes.rs b/crates/avian2d/examples/many_shapes.rs
index 700947abb..4e7fc42d9 100644
--- a/crates/avian2d/examples/many_shapes.rs
+++ b/crates/avian2d/examples/many_shapes.rs
@@ -116,25 +116,25 @@ fn setup(
 fn movement(
     time: Res<Time>,
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut marbles: Query<&mut LinearVelocity, With<Controllable>>,
+    mut marbles: Query<&mut Velocity, 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_secs_f64().adjust_precision();
 
-    for mut linear_velocity in &mut marbles {
+    for mut velocity in &mut marbles {
         if keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]) {
             // Use a higher acceleration for upwards movement to overcome gravity
-            linear_velocity.y += 2500.0 * delta_time;
+            velocity.linear.y += 2500.0 * delta_time;
         }
         if keyboard_input.any_pressed([KeyCode::KeyS, KeyCode::ArrowDown]) {
-            linear_velocity.y -= 500.0 * delta_time;
+            velocity.linear.y -= 500.0 * delta_time;
         }
         if keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]) {
-            linear_velocity.x -= 500.0 * delta_time;
+            velocity.linear.x -= 500.0 * delta_time;
         }
         if keyboard_input.any_pressed([KeyCode::KeyD, KeyCode::ArrowRight]) {
-            linear_velocity.x += 500.0 * delta_time;
+            velocity.linear.x += 500.0 * delta_time;
         }
     }
 }
diff --git a/crates/avian2d/examples/move_and_slide_2d.rs b/crates/avian2d/examples/move_and_slide_2d.rs
index 23bfb7b3d..69e790eb0 100644
--- a/crates/avian2d/examples/move_and_slide_2d.rs
+++ b/crates/avian2d/examples/move_and_slide_2d.rs
@@ -189,11 +189,11 @@ fn setup(
 ///
 /// This only updates velocity. The actual movement is handled by the `run_move_and_slide` system.
 fn player_movement(
-    mut query: Query<&mut LinearVelocity, With<Player>>,
+    mut query: Query<&mut Velocity, With<Player>>,
     time: Res<Time>,
     input: Res<ButtonInput<KeyCode>>,
 ) {
-    for mut lin_vel in &mut query {
+    for mut velocity in &mut query {
         // Determine movement velocity from input
         let mut movement_velocity = Vec2::ZERO;
         if input.pressed(KeyCode::KeyW) {
@@ -215,12 +215,12 @@ fn player_movement(
         }
 
         // Add to current velocity
-        lin_vel.0 += movement_velocity.adjust_precision();
+        velocity.linear += movement_velocity.adjust_precision();
 
-        let current_speed = lin_vel.length();
+        let current_speed = velocity.linear.length();
         if current_speed > 0.0 {
             // Apply friction
-            lin_vel.0 = lin_vel.0 / current_speed
+            velocity.linear = velocity.linear / current_speed
                 * (current_speed - current_speed * 20.0 * time.delta_secs().adjust_precision())
                     .max(0.0)
         }
@@ -236,7 +236,7 @@ fn run_move_and_slide(
         (
             Entity,
             &mut Transform,
-            &mut LinearVelocity,
+            &mut Velocity,
             &mut TouchedEntities,
             &Collider,
         ),
@@ -246,7 +246,7 @@ fn run_move_and_slide(
     time: Res<Time>,
     mut gizmos: Gizmos,
 ) {
-    for (entity, mut transform, mut lin_vel, mut touched, collider) in &mut query {
+    for (entity, mut transform, mut velocity, mut touched, collider) in &mut query {
         touched.clear();
 
         // Perform move and slide
@@ -261,7 +261,7 @@ fn run_move_and_slide(
                 .to_euler(EulerRot::XYZ)
                 .2
                 .adjust_precision(),
-            lin_vel.0,
+            velocity.linear,
             time.delta(),
             &MoveAndSlideConfig::default(),
             &SpatialQueryFilter::from_excluded_entities([entity]),
@@ -286,20 +286,20 @@ fn run_move_and_slide(
 
         // Update transform and velocity
         transform.translation = position.extend(0.0).f32();
-        lin_vel.0 = projected_velocity;
+        velocity.linear = projected_velocity;
     }
 }
 
 fn update_debug_text(
     mut text: Single<&mut Text, With<DebugText>>,
-    player: Single<(&LinearVelocity, &TouchedEntities, &CollidingEntities), With<Player>>,
+    player: Single<(&Velocity, &TouchedEntities, &CollidingEntities), With<Player>>,
     names: Query<NameOrEntity>,
 ) {
-    let (lin_vel, touched, colliding_entities) = player.into_inner();
+    let (velocity, touched, colliding_entities) = player.into_inner();
     ***text = format!(
         "velocity: [{:.3}, {:.3}]\n{} intersections (goal is 0): {:#?}\n{} touched: {:#?}",
-        lin_vel.x,
-        lin_vel.y,
+        velocity.linear.x,
+        velocity.linear.y,
         colliding_entities.len(),
         names
             .iter_many(colliding_entities.iter())
diff --git a/crates/avian2d/examples/move_marbles.rs b/crates/avian2d/examples/move_marbles.rs
index a9a6d857c..386baab29 100644
--- a/crates/avian2d/examples/move_marbles.rs
+++ b/crates/avian2d/examples/move_marbles.rs
@@ -91,25 +91,25 @@ fn setup(
 fn movement(
     time: Res<Time>,
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut marbles: Query<&mut LinearVelocity, With<Marble>>,
+    mut marbles: Query<&mut Velocity, 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_secs_f64().adjust_precision();
 
-    for mut linear_velocity in &mut marbles {
+    for mut velocity in &mut marbles {
         if keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]) {
             // Use a higher acceleration for upwards movement to overcome gravity
-            linear_velocity.y += 2500.0 * delta_time;
+            velocity.linear.y += 2500.0 * delta_time;
         }
         if keyboard_input.any_pressed([KeyCode::KeyS, KeyCode::ArrowDown]) {
-            linear_velocity.y -= 500.0 * delta_time;
+            velocity.linear.y -= 500.0 * delta_time;
         }
         if keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]) {
-            linear_velocity.x -= 500.0 * delta_time;
+            velocity.linear.x -= 500.0 * delta_time;
         }
         if keyboard_input.any_pressed([KeyCode::KeyD, KeyCode::ArrowRight]) {
-            linear_velocity.x += 500.0 * delta_time;
+            velocity.linear.x += 500.0 * delta_time;
         }
     }
 }
diff --git a/crates/avian2d/examples/one_way_platform_2d.rs b/crates/avian2d/examples/one_way_platform_2d.rs
index 2cefe0109..f2a1eee0b 100644
--- a/crates/avian2d/examples/one_way_platform_2d.rs
+++ b/crates/avian2d/examples/one_way_platform_2d.rs
@@ -145,24 +145,24 @@ fn setup(
 
 fn movement(
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut actors: Query<(&mut LinearVelocity, &MovementSpeed, &JumpImpulse), With<Actor>>,
+    mut actors: Query<(&mut Velocity, &MovementSpeed, &JumpImpulse), With<Actor>>,
 ) {
-    for (mut linear_velocity, movement_speed, jump_impulse) in &mut actors {
+    for (mut velocity, movement_speed, jump_impulse) in &mut actors {
         let left = keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]);
         let right = keyboard_input.any_pressed([KeyCode::KeyD, KeyCode::ArrowRight]);
         let horizontal = right as i8 - left as i8;
 
         // Move in input direction
-        linear_velocity.x = horizontal as Scalar * movement_speed.0;
+        velocity.linear.x = horizontal as Scalar * movement_speed.0;
 
         // Assume "mostly stopped" to mean "grounded".
         // You should use raycasting, shapecasting or sensor colliders
         // for more robust ground detection.
-        if linear_velocity.y.abs() < 0.1
+        if velocity.linear.y.abs() < 0.1
             && !keyboard_input.pressed(KeyCode::ArrowDown)
             && keyboard_input.just_pressed(KeyCode::Space)
         {
-            linear_velocity.y = jump_impulse.0;
+            velocity.linear.y = jump_impulse.0;
         }
     }
 }
diff --git a/crates/avian2d/examples/prismatic_joint_2d.rs b/crates/avian2d/examples/prismatic_joint_2d.rs
index dcfa14f99..4008a5f46 100644
--- a/crates/avian2d/examples/prismatic_joint_2d.rs
+++ b/crates/avian2d/examples/prismatic_joint_2d.rs
@@ -29,7 +29,7 @@ fn setup(mut commands: Commands) {
         .spawn((
             square_sprite.clone(),
             RigidBody::Kinematic,
-            AngularVelocity(1.5),
+            Velocity::from_angular(1.5),
         ))
         .id();
 
diff --git a/crates/avian2d/examples/ray_caster.rs b/crates/avian2d/examples/ray_caster.rs
index 3afca6cd6..3b5bdf941 100644
--- a/crates/avian2d/examples/ray_caster.rs
+++ b/crates/avian2d/examples/ray_caster.rs
@@ -52,7 +52,7 @@ fn setup(
     // Spawn a rotating kinematic body with a ray caster
     commands.spawn((
         RigidBody::Kinematic,
-        AngularVelocity(0.2),
+        Velocity::from_angular(0.2),
         RayCaster::new(Vector::ZERO, Dir2::X),
     ));
 }
diff --git a/crates/avian2d/examples/revolute_joint_2d.rs b/crates/avian2d/examples/revolute_joint_2d.rs
index 8478b9df9..a5437a26c 100644
--- a/crates/avian2d/examples/revolute_joint_2d.rs
+++ b/crates/avian2d/examples/revolute_joint_2d.rs
@@ -29,7 +29,7 @@ fn setup(mut commands: Commands) {
         .spawn((
             square_sprite.clone(),
             RigidBody::Kinematic,
-            AngularVelocity(1.5),
+            Velocity::from_angular(1.5),
         ))
         .id();
 
diff --git a/crates/avian2d/examples/sensor.rs b/crates/avian2d/examples/sensor.rs
index e0a911dad..d31a31ae5 100644
--- a/crates/avian2d/examples/sensor.rs
+++ b/crates/avian2d/examples/sensor.rs
@@ -152,20 +152,20 @@ fn has_movement(mut reader: MessageReader<MovementAction>) -> bool {
 fn movement(
     time: Res<Time>,
     mut movement_reader: MessageReader<MovementAction>,
-    mut controllers: Query<(&mut LinearVelocity, &mut Position), With<Character>>,
+    mut controllers: Query<(&mut Velocity, &mut Position), With<Character>>,
 ) {
     let delta_time = time.delta_secs_f64().adjust_precision();
     for event in movement_reader.read() {
-        for (mut linear_velocity, mut position) in &mut controllers {
+        for (mut velocity, mut position) in &mut controllers {
             match event {
                 MovementAction::Stop => {
-                    linear_velocity.x = 0.0;
-                    linear_velocity.y = 0.0;
+                    velocity.linear.x = 0.0;
+                    velocity.linear.y = 0.0;
                 }
                 MovementAction::Velocity(direction) => {
                     let movement_acceleration = 2000.0;
-                    linear_velocity.x += direction.x * movement_acceleration * delta_time;
-                    linear_velocity.y += direction.y * movement_acceleration * delta_time;
+                    velocity.linear.x += direction.x * movement_acceleration * delta_time;
+                    velocity.linear.y += direction.y * movement_acceleration * delta_time;
                 }
                 MovementAction::Offset(direction) => {
                     let speed = 100.0;
@@ -179,28 +179,25 @@ fn movement(
 
 #[allow(clippy::type_complexity)]
 fn apply_movement_damping(
-    mut query: Query<
-        (&mut LinearVelocity, &mut AngularVelocity),
-        (With<Character>, Without<Sleeping>),
-    >,
+    mut query: Query<&mut Velocity, (With<Character>, Without<Sleeping>)>,
     time: Res<Time<Physics>>,
 ) {
     if time.is_paused() {
         return;
     }
     let damping_factor = 0.95;
-    for (mut linear_velocity, mut angular_velocity) in &mut query {
-        linear_velocity.x *= damping_factor;
-        if linear_velocity.x.abs() < 0.001 {
-            linear_velocity.x = 0.0;
+    for mut velocity in &mut query {
+        velocity.linear.x *= damping_factor;
+        if velocity.linear.x.abs() < 0.001 {
+            velocity.linear.x = 0.0;
         }
-        linear_velocity.y *= damping_factor;
-        if linear_velocity.y.abs() < 0.001 {
-            linear_velocity.y = 0.0;
+        velocity.linear.y *= damping_factor;
+        if velocity.linear.y.abs() < 0.001 {
+            velocity.linear.y = 0.0;
         }
-        angular_velocity.0 *= damping_factor;
-        if angular_velocity.0.abs() < 0.001 {
-            angular_velocity.0 = 0.0;
+        velocity.angular *= damping_factor;
+        if velocity.angular.abs() < 0.001 {
+            velocity.angular = 0.0;
         }
     }
 }
@@ -218,7 +215,7 @@ fn apply_pressure_plate_colour(
 }
 
 fn update_velocity_text(
-    character_query: Query<(&LinearVelocity, Has<Sleeping>), With<Character>>,
+    character_query: Query<(&Velocity, Has<Sleeping>), With<Character>>,
     pressure_plate_query: Query<Has<Sleeping>, With<PressurePlate>>,
     mut text_query: Query<&mut Text, With<CharacterVelocityText>>,
 ) -> Result {
@@ -227,7 +224,7 @@ fn update_velocity_text(
     {
         text_query.single_mut()?.0 = format!(
             "Velocity: {:.4}, {:.4}\nCharacter sleeping:{}\nPressure plate sleeping: {}",
-            velocity.x, velocity.y, character_sleeping, pressure_plate_sleeping
+            velocity.linear.x, velocity.linear.y, character_sleeping, pressure_plate_sleeping
         );
     }
     Ok(())
diff --git a/crates/avian2d/examples/tumbler.rs b/crates/avian2d/examples/tumbler.rs
index 95b1b9874..e7008708b 100644
--- a/crates/avian2d/examples/tumbler.rs
+++ b/crates/avian2d/examples/tumbler.rs
@@ -37,7 +37,7 @@ fn spawn_tumbler(
 
     commands.spawn((
         RigidBody::Kinematic,
-        AngularVelocity((25.0 as Scalar).to_radians()),
+        Velocity::from_angular((25.0 as Scalar).to_radians()),
         Transform::default(),
         Visibility::default(),
         children![
diff --git a/crates/avian3d/examples/cast_ray_predicate.rs b/crates/avian3d/examples/cast_ray_predicate.rs
index 09cff4625..235d35a69 100644
--- a/crates/avian3d/examples/cast_ray_predicate.rs
+++ b/crates/avian3d/examples/cast_ray_predicate.rs
@@ -101,13 +101,13 @@ fn setup(
 fn movement(
     time: Res<Time>,
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<(&MovementAcceleration, &mut LinearVelocity)>,
+    mut query: Query<(&MovementAcceleration, &mut Velocity)>,
 ) {
     // 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_secs_f64().adjust_precision();
 
-    for (movement_acceleration, mut linear_velocity) in &mut query {
+    for (movement_acceleration, mut velocity) in &mut query {
         let up = keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]);
         let down = keyboard_input.any_pressed([KeyCode::KeyS, KeyCode::ArrowDown]);
         let left = keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]);
@@ -120,8 +120,8 @@ fn movement(
 
         // Move in input direction
         if direction != Vector::ZERO {
-            linear_velocity.x += direction.x * movement_acceleration.0 * delta_time;
-            linear_velocity.z += direction.z * movement_acceleration.0 * delta_time;
+            velocity.linear.x += direction.x * movement_acceleration.0 * delta_time;
+            velocity.linear.z += direction.z * movement_acceleration.0 * delta_time;
         }
     }
 }
diff --git a/crates/avian3d/examples/chain_3d.rs b/crates/avian3d/examples/chain_3d.rs
index eb3c4a662..e5e3411f4 100644
--- a/crates/avian3d/examples/chain_3d.rs
+++ b/crates/avian3d/examples/chain_3d.rs
@@ -83,13 +83,13 @@ fn setup(
 fn movement(
     time: Res<Time>,
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<(&MovementAcceleration, &mut LinearVelocity)>,
+    mut query: Query<(&MovementAcceleration, &mut Velocity)>,
 ) {
     // 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_secs_f64().adjust_precision();
 
-    for (movement_acceleration, mut linear_velocity) in &mut query {
+    for (movement_acceleration, mut velocity) in &mut query {
         let up = keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]);
         let down = keyboard_input.any_pressed([KeyCode::KeyS, KeyCode::ArrowDown]);
         let left = keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]);
@@ -101,11 +101,11 @@ fn movement(
             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;
+        velocity.linear.x += direction.x * movement_acceleration.0 * delta_time;
+        velocity.linear.z += direction.z * movement_acceleration.0 * delta_time;
 
         // Slow down movement
-        linear_velocity.0 *= 0.9;
+        velocity.linear *= 0.9;
     }
 }
 
diff --git a/crates/avian3d/examples/cubes.rs b/crates/avian3d/examples/cubes.rs
index 4efcdb2f8..a71d2b7bd 100644
--- a/crates/avian3d/examples/cubes.rs
+++ b/crates/avian3d/examples/cubes.rs
@@ -76,13 +76,13 @@ fn setup(
 fn movement(
     time: Res<Time>,
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<(&MovementAcceleration, &mut LinearVelocity)>,
+    mut query: Query<(&MovementAcceleration, &mut Velocity)>,
 ) {
     // 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_secs_f64().adjust_precision();
 
-    for (movement_acceleration, mut linear_velocity) in &mut query {
+    for (movement_acceleration, mut velocity) in &mut query {
         let up = keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]);
         let down = keyboard_input.any_pressed([KeyCode::KeyS, KeyCode::ArrowDown]);
         let left = keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]);
@@ -95,8 +95,8 @@ fn movement(
 
         // Move in input direction
         if direction != Vector::ZERO {
-            linear_velocity.x += direction.x * movement_acceleration.0 * delta_time;
-            linear_velocity.z += direction.z * movement_acceleration.0 * delta_time;
+            velocity.linear.x += direction.x * movement_acceleration.0 * delta_time;
+            velocity.linear.z += direction.z * movement_acceleration.0 * delta_time;
         }
     }
 }
diff --git a/crates/avian3d/examples/custom_broad_phase.rs b/crates/avian3d/examples/custom_broad_phase.rs
index cece0a001..e86545918 100644
--- a/crates/avian3d/examples/custom_broad_phase.rs
+++ b/crates/avian3d/examples/custom_broad_phase.rs
@@ -1,4 +1,4 @@
-use avian3d::{dynamics::solver::joint_graph::JointGraph, math::*, prelude::*};
+use avian3d::{dynamics::solver::joint_graph::JointGraph, prelude::*};
 use bevy::prelude::*;
 use examples_common_3d::ExampleCommonPlugin;
 
@@ -37,7 +37,7 @@ fn setup(
         MeshMaterial3d(materials.add(Color::srgb(0.8, 0.7, 0.6))),
         Transform::from_xyz(0.0, 4.0, 0.0),
         RigidBody::Dynamic,
-        AngularVelocity(Vector::new(2.5, 3.4, 1.6)),
+        Velocity::from_angular_xyz(2.5, 3.4, 1.6),
         Collider::cuboid(1.0, 1.0, 1.0),
     ));
     // Light
diff --git a/crates/avian3d/examples/diagnostics.rs b/crates/avian3d/examples/diagnostics.rs
index e7d239c29..c6ecd994c 100644
--- a/crates/avian3d/examples/diagnostics.rs
+++ b/crates/avian3d/examples/diagnostics.rs
@@ -94,13 +94,13 @@ fn setup(
 fn movement(
     time: Res<Time>,
     keyboard_input: Res<ButtonInput<KeyCode>>,
-    mut query: Query<(&MovementAcceleration, &mut LinearVelocity)>,
+    mut query: Query<(&MovementAcceleration, &mut Velocity)>,
 ) {
     // 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_secs_f64().adjust_precision();
 
-    for (movement_acceleration, mut linear_velocity) in &mut query {
+    for (movement_acceleration, mut velocity) in &mut query {
         let up = keyboard_input.any_pressed([KeyCode::KeyW, KeyCode::ArrowUp]);
         let down = keyboard_input.any_pressed([KeyCode::KeyS, KeyCode::ArrowDown]);
         let left = keyboard_input.any_pressed([KeyCode::KeyA, KeyCode::ArrowLeft]);
@@ -113,8 +113,8 @@ fn movement(
 
         // Move in input direction
         if direction != Vector::ZERO {
-            linear_velocity.x += direction.x * movement_acceleration.0 * delta_time;
-            linear_velocity.z += direction.z * movement_acceleration.0 * delta_time;
+            velocity.linear.x += direction.x * movement_acceleration.0 * delta_time;
+            velocity.linear.z += direction.z * movement_acceleration.0 * delta_time;
         }
     }
 }
diff --git a/crates/avian3d/examples/dynamic_character_3d/plugin.rs b/crates/avian3d/examples/dynamic_character_3d/plugin.rs
index e618a4b61..82f144849 100644
--- a/crates/avian3d/examples/dynamic_character_3d/plugin.rs
+++ b/crates/avian3d/examples/dynamic_character_3d/plugin.rs
@@ -205,7 +205,7 @@ fn movement(
     mut controllers: Query<(
         &MovementAcceleration,
         &JumpImpulse,
-        &mut LinearVelocity,
+        &mut Velocity,
         Has<Grounded>,
     )>,
 ) {
@@ -214,17 +214,15 @@ fn movement(
     let delta_time = time.delta_secs_f64().adjust_precision();
 
     for event in movement_reader.read() {
-        for (movement_acceleration, jump_impulse, mut linear_velocity, is_grounded) in
-            &mut controllers
-        {
+        for (movement_acceleration, jump_impulse, mut velocity, is_grounded) in &mut controllers {
             match event {
                 MovementAction::Move(direction) => {
-                    linear_velocity.x += direction.x * movement_acceleration.0 * delta_time;
-                    linear_velocity.z -= direction.y * movement_acceleration.0 * delta_time;
+                    velocity.linear.x += direction.x * movement_acceleration.0 * delta_time;
+                    velocity.linear.z -= direction.y * movement_acceleration.0 * delta_time;
                 }
                 MovementAction::Jump => {
                     if is_grounded {
-                        linear_velocity.y = jump_impulse.0;
+                        velocity.linear.y = jump_impulse.0;
                     }
                 }
             }
@@ -233,10 +231,10 @@ fn movement(
 }
 
 /// Slows down movement in the XZ plane.
-fn apply_movement_damping(mut query: Query<(&MovementDampingFactor, &mut LinearVelocity)>) {
-    for (damping_factor, mut linear_velocity) in &mut query {
-        // We could use `LinearDamping`, but we don't want to dampen movement along the Y axis
-        linear_velocity.x *= damping_factor.0;
-        linear_velocity.z *= damping_factor.0;
+fn apply_movement_damping(mut query: Query<(&MovementDampingFactor, &mut Velocity)>) {
+    for (damping_factor, mut velocity) in &mut query {
+        // We could use `Damping`, but we don't want to dampen movement along the Y axis
+        velocity.linear.x *= damping_factor.0;
+        velocity.linear.z *= damping_factor.0;
     }
 }
diff --git a/crates/avian3d/examples/fixed_joint_3d.rs b/crates/avian3d/examples/fixed_joint_3d.rs
index c41bb7b5f..4985bdb51 100644
--- a/crates/avian3d/examples/fixed_joint_3d.rs
+++ b/crates/avian3d/examples/fixed_joint_3d.rs
@@ -29,7 +29,7 @@ fn setup(
             Mesh3d(cube_mesh.clone()),
             MeshMaterial3d(cube_material.clone()),
             RigidBody::Kinematic,
-            AngularVelocity(Vector::Z * 1.5),
+            Velocity::from_angular(Vector::Z * 1.5),
         ))
         .id();
 
diff --git a/crates/avian3d/examples/gyroscopic_motion.rs b/crates/avian3d/examples/gyroscopic_motion.rs
index 1e746f531..7d4af61ab 100644
--- a/crates/avian3d/examples/gyroscopic_motion.rs
+++ b/crates/avian3d/examples/gyroscopic_motion.rs
@@ -51,7 +51,7 @@ fn setup(
         Name::new("T-handle"),
         THandle,
         RigidBody::Dynamic,
-        AngularVelocity(Vector::Z * 10.0),
+        Velocity::from_angular(Vector::Z * 10.0),
         Transform::from_xyz(-4.0, 0.0, 0.0).with_rotation(Quat::from_rotation_y(FRAC_PI_2)),
         Collider::from(large_cylinder),
         Mesh3d(meshes.add(large_cylinder)),
@@ -72,7 +72,7 @@ fn setup(
         Racket,
         RigidBody::Dynamic,
         Transform::from_xyz(4.0, 0.0, 0.0).with_rotation(Quat::from_rotation_y(0.001)),
-        AngularVelocity(Vector::X * 10.0),
+        Velocity::from_angular(Vector::X * 10.0),
         Visibility::default(),
         children![
             (
@@ -111,14 +111,14 @@ fn setup(
 
 /// Logs the angular momentum of the racket to see how it changes over time.
 fn log_racket_angular_momentum(
-    query: Query<(&AngularVelocity, &GlobalTransform, &ComputedAngularInertia), With<Racket>>,
+    query: Query<(&Velocity, &GlobalTransform, &ComputedAngularInertia), With<Racket>>,
 ) {
-    for (angular_velocity, global_transform, inertia) in &query {
+    for (velocity, global_transform, inertia) in &query {
         // Compute the up-to-date inertia tensor in world space.
         let world_inertia = inertia.rotated(global_transform.rotation().adjust_precision());
 
         // Compute the angular momentum.
-        let angular_momentum = world_inertia.tensor() * angular_velocity.0;
+        let angular_momentum = world_inertia.tensor() * velocity.angular;
 
         // Gyroscopic torque should conserve angular momentum and kinetic energy,
         // assuming no external torques are applied.
diff --git a/crates/avian3d/examples/kinematic_character_3d/plugin.rs b/crates/avian3d/examples/kinematic_character_3d/plugin.rs
index 89010fa73..37478be59 100644
--- a/crates/avian3d/examples/kinematic_character_3d/plugin.rs
+++ b/crates/avian3d/examples/kinematic_character_3d/plugin.rs
@@ -211,24 +211,20 @@ fn update_grounded(
 fn movement(
     time: Res<Time>,
     mut movement_reader: MessageReader<MovementAction>,
-    mut controllers: Query<(
-        &CharacterMovementSettings,
-        &mut LinearVelocity,
-        Has<Grounded>,
-    )>,
+    mut controllers: Query<(&CharacterMovementSettings, &mut Velocity, Has<Grounded>)>,
 ) {
     let delta_secs = time.delta_secs_f64().adjust_precision();
 
     for event in movement_reader.read() {
-        for (movement, mut linear_velocity, is_grounded) in &mut controllers {
+        for (movement, mut velocity, is_grounded) in &mut controllers {
             match event {
                 MovementAction::Move(direction) => {
-                    linear_velocity.x += direction.x * movement.acceleration * delta_secs;
-                    linear_velocity.z -= direction.y * movement.acceleration * delta_secs;
+                    velocity.linear.x += direction.x * movement.acceleration * delta_secs;
+                    velocity.linear.z -= direction.y * movement.acceleration * delta_secs;
                 }
                 MovementAction::Jump => {
                     if is_grounded {
-                        linear_velocity.y = movement.jump_impulse;
+                        velocity.linear.y = movement.jump_impulse;
                     }
                 }
             }
@@ -239,44 +235,44 @@ fn movement(
 /// Applies gravity to character controllers.
 fn apply_gravity(
     time: Res<Time>,
-    mut controllers: Query<(&CharacterMovementSettings, &mut LinearVelocity)>,
+    mut controllers: Query<(&CharacterMovementSettings, &mut Velocity)>,
 ) {
     let delta_secs = time.delta_secs_f64().adjust_precision();
 
-    for (movement, mut linear_velocity) in &mut controllers {
+    for (movement, mut velocity) in &mut controllers {
         let gravity_direction = movement.gravity.normalize_or_zero();
 
-        let velocity_along_gravity = linear_velocity.dot(gravity_direction);
+        let velocity_along_gravity = velocity.linear.dot(gravity_direction);
         if velocity_along_gravity > movement.terminal_velocity {
             // Don't apply more gravity if we're already at terminal velocity.
             continue;
         }
 
         // Calculate the new velocity after applying gravity.
-        let new_velocity = linear_velocity.0 + movement.gravity * delta_secs;
+        let new_velocity = velocity.linear + movement.gravity * delta_secs;
 
         // Don't exceed terminal velocity.
         let new_velocity_along_gravity = new_velocity.dot(gravity_direction);
         if new_velocity_along_gravity < movement.terminal_velocity {
-            linear_velocity.0 = new_velocity;
+            velocity.linear = new_velocity;
         } else {
-            linear_velocity.0 = gravity_direction * movement.terminal_velocity;
+            velocity.linear = gravity_direction * movement.terminal_velocity;
         }
     }
 }
 
 /// Slows down movement in the XZ plane.
 fn apply_movement_damping(
-    mut query: Query<(&CharacterMovementSettings, &mut LinearVelocity)>,
+    mut query: Query<(&CharacterMovementSettings, &mut Velocity)>,
     time: Res<Time>,
 ) {
     let delta_secs = time.delta_secs_f64().adjust_precision();
 
-    for (movement, mut linear_velocity) in &mut query {
-        // Approximate exponential decay. We could use `LinearDamping` for this,
+    for (movement, mut velocity) in &mut query {
+        // Approximate exponential decay. We could use `Damping` for this,
         // but we don't want to dampen movement along the Y axis.
-        linear_velocity.x *= 1.0 / (1.0 + delta_secs * movement.damping);
-        linear_velocity.z *= 1.0 / (1.0 + delta_secs * movement.damping);
+        velocity.linear.x *= 1.0 / (1.0 + delta_secs * movement.damping);
+        velocity.linear.z *= 1.0 / (1.0 + delta_secs * movement.damping);
     }
 }
 
@@ -292,7 +288,7 @@ fn move_and_slide(
             Option<&GroundDetection>,
             Option<&mut CharacterCollisions>,
             &mut Transform,
-            &mut LinearVelocity,
+            &mut Velocity,
             &Collider,
         ),
         With<CharacterController>,
@@ -300,7 +296,7 @@ fn move_and_slide(
     move_and_slide: MoveAndSlide,
     time: Res<Time>,
 ) {
-    for (entity, ground_detection, mut collisions, mut transform, mut lin_vel, collider) in
+    for (entity, ground_detection, mut collisions, mut transform, mut velocity, collider) in
         &mut query
     {
         let mut hit_ground_or_ceiling = false;
@@ -320,7 +316,7 @@ fn move_and_slide(
             collider,
             transform.translation.adjust_precision(),
             transform.rotation.adjust_precision(),
-            lin_vel.0,
+            velocity.linear,
             time.delta(),
             &MoveAndSlideConfig::default(),
             &SpatialQueryFilter::from_excluded_entities([entity]),
@@ -342,7 +338,7 @@ fn move_and_slide(
                 // Decompose the original input velocity into components relative to the hit normal and the up direction,
                 // to determine how much of the velocity is contributing to climbing, slipping, and unconstrained movement.
                 let [horizontal_component, vertical_component] =
-                    split_into_components(lin_vel.0, up);
+                    split_into_components(velocity.linear, up);
 
                 // Decompose the horizontal component and the current sliding velocity to determine
                 // whether the character is trying to climb or slip, and whether it is actually climbing or slipping.
@@ -408,9 +404,9 @@ fn move_and_slide(
         // and to prevent sticking to ceilings when jumping.
         if hit_ground_or_ceiling {
             let up = up.adjust_precision();
-            let velocity_along_up = lin_vel.dot(up);
+            let velocity_along_up = velocity.linear.dot(up);
             let new_velocity_along_up = projected_velocity.dot(up);
-            lin_vel.0 += (new_velocity_along_up - velocity_along_up) * up;
+            velocity.linear += (new_velocity_along_up - velocity_along_up) * up;
         }
     }
 }
@@ -472,7 +468,7 @@ fn apply_forces_to_dynamic_bodies(
             }
 
             let touch_dir = -collision.normal.adjust_precision();
-            let relative_velocity = collision.character_velocity - forces.linear_velocity();
+            let relative_velocity = collision.character_velocity - forces.velocity().linear;
             let touch_velocity = touch_dir.dot(relative_velocity) * touch_dir;
             let impulse = touch_velocity * mass;
 
diff --git a/crates/avian3d/examples/move_and_slide_3d.rs b/crates/avian3d/examples/move_and_slide_3d.rs
index ae62777fd..02d5937cf 100644
--- a/crates/avian3d/examples/move_and_slide_3d.rs
+++ b/crates/avian3d/examples/move_and_slide_3d.rs
@@ -148,12 +148,12 @@ fn setup(
 ///
 /// This only updates velocity. The actual movement is handled by the `run_move_and_slide` system.
 fn player_movement(
-    mut query: Query<&mut LinearVelocity, With<Player>>,
+    mut query: Query<&mut Velocity, With<Player>>,
     camera: Single<&Transform, With<Camera>>,
     time: Res<Time>,
     input: Res<ButtonInput<KeyCode>>,
 ) {
-    for mut lin_vel in &mut query {
+    for mut velocity in &mut query {
         // Determine movement velocity from input
         let mut movement_velocity = Vec3::ZERO;
         if input.pressed(KeyCode::KeyW) {
@@ -182,12 +182,12 @@ fn player_movement(
         movement_velocity = camera.rotation * movement_velocity;
 
         // Add to current velocity
-        lin_vel.0 += movement_velocity.adjust_precision();
+        velocity.linear += movement_velocity.adjust_precision();
 
-        let current_speed = lin_vel.length();
+        let current_speed = velocity.linear.length();
         if current_speed > 0.0 {
             // Apply friction
-            lin_vel.0 = lin_vel.0 / current_speed
+            velocity.linear = velocity.linear / current_speed
                 * (current_speed - current_speed * 20.0 * time.delta_secs().adjust_precision())
                     .max(0.0)
         }
@@ -203,7 +203,7 @@ fn run_move_and_slide(
         (
             Entity,
             &mut Transform,
-            &mut LinearVelocity,
+            &mut Velocity,
             &mut TouchedEntities,
             &Collider,
         ),
@@ -213,7 +213,7 @@ fn run_move_and_slide(
     time: Res<Time>,
     mut gizmos: Gizmos,
 ) {
-    for (entity, mut transform, mut lin_vel, mut touched, collider) in &mut query {
+    for (entity, mut transform, mut velocity, mut touched, collider) in &mut query {
         touched.clear();
 
         // Perform move and slide
@@ -224,7 +224,7 @@ fn run_move_and_slide(
             collider,
             transform.translation.adjust_precision(),
             transform.rotation.adjust_precision(),
-            lin_vel.0,
+            velocity.linear,
             time.delta(),
             &MoveAndSlideConfig::default(),
             &SpatialQueryFilter::from_excluded_entities([entity]),
@@ -249,7 +249,7 @@ fn run_move_and_slide(
 
         // Update transform and velocity
         transform.translation = position.f32();
-        lin_vel.0 = projected_velocity;
+        velocity.linear = projected_velocity;
     }
 }
 
@@ -298,15 +298,15 @@ fn release_cursor(mut cursor: Single<&mut CursorOptions>) {
 
 fn update_debug_text(
     mut text: Single<&mut Text, With<DebugText>>,
-    player: Single<(&LinearVelocity, &TouchedEntities, &CollidingEntities), With<Player>>,
+    player: Single<(&Velocity, &TouchedEntities, &CollidingEntities), With<Player>>,
     names: Query<NameOrEntity>,
 ) {
-    let (lin_vel, touched, colliding_entities) = player.into_inner();
+    let (velocity, touched, colliding_entities) = player.into_inner();
     ***text = format!(
         "velocity: [{:.3}, {:.3}, {:.3}]\n{} intersections (goal is 0): {:#?}\n{} touched: {:#?}",
-        lin_vel.x,
-        lin_vel.y,
-        lin_vel.z,
+        velocity.linear.x,
+        velocity.linear.y,
+        velocity.linear.z,
         colliding_entities.len(),
         names
             .iter_many(colliding_entities.iter())
diff --git a/crates/avian3d/examples/picking.rs b/crates/avian3d/examples/picking.rs
index e89ca29ed..524ef676f 100644
--- a/crates/avian3d/examples/picking.rs
+++ b/crates/avian3d/examples/picking.rs
@@ -8,7 +8,7 @@
 
 use core::f32::consts::PI;
 
-use avian3d::{math::Vector, prelude::*};
+use avian3d::prelude::*;
 use bevy::{color::palettes::tailwind::*, picking::pointer::PointerInteraction, prelude::*};
 
 fn main() {
@@ -85,7 +85,7 @@ fn setup_scene(
                 MeshMaterial3d(white_matl.clone()),
                 RigidBody::Kinematic,
                 collider,
-                AngularVelocity(Vector::new(0.0, 0.5, 0.0)),
+                Velocity::from_angular_xyz(0.0, 0.5, 0.0),
                 Transform::from_xyz(
                     -SHAPES_X_EXTENT / 2. + i as f32 / (num_shapes - 1) as f32 * SHAPES_X_EXTENT,
                     2.0,
diff --git a/crates/avian3d/examples/prismatic_joint_3d.rs b/crates/avian3d/examples/prismatic_joint_3d.rs
index 0387b279b..6c0d56830 100644
--- a/crates/avian3d/examples/prismatic_joint_3d.rs
+++ b/crates/avian3d/examples/prismatic_joint_3d.rs
@@ -29,7 +29,7 @@ fn setup(
             Mesh3d(cube_mesh.clone()),
             MeshMaterial3d(cube_material.clone()),
             RigidBody::Kinematic,
-            AngularVelocity(Vector::Z * 1.5),
+            Velocity::from_angular(Vector::Z * 1.5),
         ))
         .id();
 
diff --git a/crates/avian3d/examples/revolute_joint_3d.rs b/crates/avian3d/examples/revolute_joint_3d.rs
index 4a570891d..ae95a03f8 100644
--- a/crates/avian3d/examples/revolute_joint_3d.rs
+++ b/crates/avian3d/examples/revolute_joint_3d.rs
@@ -29,7 +29,7 @@ fn setup(
             Mesh3d(cube_mesh.clone()),
             MeshMaterial3d(cube_material.clone()),
             RigidBody::Kinematic,
-            AngularVelocity(Vector::Z * 1.5),
+            Velocity::from_angular(Vector::Z * 1.5),
         ))
         .id();
 
diff --git a/migration-guides/0.6-to-main.md b/migration-guides/0.6-to-main.md
index 17649ef4d..4b884ac56 100644
--- a/migration-guides/0.6-to-main.md
+++ b/migration-guides/0.6-to-main.md
@@ -5,3 +5,127 @@ since the latest release. These guides are evolving and may not be polished yet.
 
 See [migration-guides/README.md](./README.md) and existing entries for information about Avian's
 migration guide process and what to put here.
+
+## `Velocity`, `MaxSpeed`, and `Damping`
+
+The `LinearVelocity`, `AngularVelocity`, `MaxLinearSpeed`, `MaxAngularSpeed`, `LinearDamping`,
+and `AngularDamping` components have been replaced with `Velocity`, `MaxSpeed`, and `Damping`
+respeoctively. The linear and angular components are now `linear` and `angular` properties.
+
+Constructing velocity:
+
+```rust
+// Before
+LinearVelocity(Vec3::new(x, y, z))
+
+// After (option 1)
+Velocity::from_linear(Vec3::new(x, y, z))
+
+// After (option 2)
+Velocity::from_linear_xyz(x, y, z)
+```
+
+```rust
+// Before
+(
+    LinearVelocity(Vec3::new(x, y, z)),
+    AngularVelocity(Vec3::new(x, y, z)),
+    // ...
+)
+
+// After (option 1)
+(
+    Velocity {
+        linear: Vec3::new(x, y, z),
+        angular: Vec3::new(x, y, z),
+    },
+    // ...
+)
+
+// After (option 2)
+(
+    Velocity::new(Vec3::new(x, y, z), Vec3::new(x, y, z)),
+    // ...
+)
+```
+
+Constructing damping or max speed (only damping is shown here):
+
+```rust
+// Before
+LinearDamping(0.6)
+
+// After
+Damping::from_linear(0.6)
+```
+
+```rust
+// Before
+(
+    LinearDamping(0.6),
+    AngularDamping(0.6),
+    // ...
+)
+
+// After (option 1)
+(
+    Damping {
+        linear: 0.6,
+        angular: 0.6,
+    }
+    // ...
+)
+
+// After (option 2)
+(
+    Damping::new(0.6, 0.6),
+    // ...
+)
+```
+
+Modifying velocity:
+
+```rust
+// Before
+fn accelerate_linear(mut query: Query<&mut LinearVelocity>, time: Res<Time>) {
+    let delta_secs = time.delta_secs();
+    for mut linear_velocity in &mut query {
+        // Accelerate
+        linear_velocity.x += 2.0 * delta_secs;
+        // Damping
+        linear_velocity.0 *= 1.0 / (1.0 + 0.6 * delta_secs)
+    }
+}
+
+// After
+fn accelerate_linear(mut query: Query<&mut Velocity>, time: Res<Time>) {
+    let delta_secs = time.delta_secs();
+    for mut velocity in &mut query {
+        // Accelerate
+        velocity.linear.x += 2.0 * delta_secs;
+        // Damping
+        velocity.linear *= 1.0 / (1.0 + 0.6 * delta_secs)
+    }
+}
+```
+
+The `Velocity` component also has an `at_point` helper, making it easier to compute point velocities:
+
+```rust
+// Before
+fn point_velocity(query: Query<(&LinearVelocity, &AngularVelocity)>) {
+    for (linear_velocity, angular_velocity) in &query {
+        // Compute the velocity at a point 1 unit to the right of the center of mass.
+        let point_velocity = linear_velocity.0 + angular_velocity.cross(Vec3::new(1.0, 0.0, 0.0));
+        println!("Velocity at point: {:?}", point_velocity);
+    }
+}
+
+fn point_velocity(query: Query<&Velocity>) {
+    for velocity in &query {
+        // Compute the velocity at a point 1 unit to the right of the center of mass.
+        let point_velocity = velocity.at_point(Vec3::new(1.0, 0.0, 0.0));
+        println!("Velocity at point: {:?}", point_velocity);
+    }
+}
+```
diff --git a/src/character_controller/move_and_slide.rs b/src/character_controller/move_and_slide.rs
index 190e3379f..896814411 100644
--- a/src/character_controller/move_and_slide.rs
+++ b/src/character_controller/move_and_slide.rs
@@ -266,10 +266,10 @@ pub struct MoveAndSlideOutput {
     /// For example, if the character is trying to move to the right, but there is a ramp in its path,
     /// the projected velocity will point up the ramp, with reduced magnitude.
     ///
-    /// It is useful to store this value or apply it to [`LinearVelocity`] and use it as the input velocity
+    /// It is useful to store this value or apply it to [`Velocity::linear`] and use it as the input velocity
     /// for the next frame's call to [`MoveAndSlide::move_and_slide`].
     ///
-    /// Note that if you apply this to [`LinearVelocity`], it is recommended to use [`CustomPositionIntegration`].
+    /// Note that if you apply this to [`Velocity::linear`], it is recommended to use [`CustomPositionIntegration`].
     /// This ways, the character's position is only updated via the move and slide algorithm,
     /// and not also by the physics integrator.
     pub projected_velocity: Vector,
diff --git a/src/collider_tree/update.rs b/src/collider_tree/update.rs
index cab44958a..a0b4bc279 100644
--- a/src/collider_tree/update.rs
+++ b/src/collider_tree/update.rs
@@ -655,8 +655,7 @@ fn update_solver_body_aabbs<C: AnyCollider>(
         (
             &Position,
             &ComputedCenterOfMass,
-            &LinearVelocity,
-            &AngularVelocity,
+            &Velocity,
             &RigidBodyColliders,
             Has<SweptCcd>,
         ),
@@ -711,7 +710,7 @@ fn update_solver_body_aabbs<C: AnyCollider>(
     let collider_query = colliders.p0();
 
     body_query.par_iter().for_each(
-        |(rb_pos, center_of_mass, lin_vel, ang_vel, body_colliders, has_swept_ccd)| {
+        |(rb_pos, center_of_mass, velocity, body_colliders, has_swept_ccd)| {
             for collider_entity in body_colliders.iter() {
                 let Ok((
                     collider,
@@ -749,24 +748,21 @@ fn update_solver_body_aabbs<C: AnyCollider>(
                     //       but because they are orbiting, the direction will change. We should take
                     //       into account the uniform circular motion.
                     let offset = pos.0 - rb_pos.0 - center_of_mass.0;
-                    #[cfg(feature = "2d")]
-                    let vel = lin_vel.0 + Vector::new(-ang_vel.0 * offset.y, ang_vel.0 * offset.x);
-                    #[cfg(feature = "3d")]
-                    let vel = lin_vel.0 + ang_vel.cross(offset);
-                    let movement = (vel * delta_secs)
+                    let point_vel = velocity.at_point(offset);
+                    let movement = (point_vel * delta_secs)
                         .clamp_length_max(speculative_margin.max(contact_tolerance));
 
                     // Current position and predicted position for next feame
                     #[cfg(feature = "2d")]
                     let (end_pos, end_rot) = (
                         pos.0 + movement,
-                        *rot * Rotation::radians(ang_vel.0 * delta_secs),
+                        *rot * Rotation::radians(velocity.angular * delta_secs),
                     );
 
                     #[cfg(feature = "3d")]
                     let (end_pos, end_rot) = (
                         pos.0 + movement,
-                        Rotation(Quaternion::from_scaled_axis(ang_vel.0 * delta_secs) * rot.0)
+                        Rotation(Quaternion::from_scaled_axis(velocity.angular * delta_secs) * rot.0)
                             .fast_renormalize(),
                     );
 
diff --git a/src/collision/collider/parry/contact_query.rs b/src/collision/collider/parry/contact_query.rs
index b48b8e704..8b9fb367d 100644
--- a/src/collision/collider/parry/contact_query.rs
+++ b/src/collision/collider/parry/contact_query.rs
@@ -571,28 +571,25 @@ pub fn time_of_impact(
     collider1: &Collider,
     position1: impl Into<Position>,
     rotation1: impl Into<Rotation>,
-    velocity1: impl Into<LinearVelocity>,
+    velocity1: Vector,
     collider2: &Collider,
     position2: impl Into<Position>,
     rotation2: impl Into<Rotation>,
-    velocity2: impl Into<LinearVelocity>,
+    velocity2: Vector,
     max_time_of_impact: Scalar,
 ) -> Result<Option<TimeOfImpact>, UnsupportedShape> {
     let rotation1: Rotation = rotation1.into();
     let rotation2: Rotation = rotation2.into();
 
-    let velocity1: LinearVelocity = velocity1.into();
-    let velocity2: LinearVelocity = velocity2.into();
-
     let isometry1 = make_pose(position1, rotation1);
     let isometry2 = make_pose(position2, rotation2);
 
     parry::query::cast_shapes(
         &isometry1,
-        velocity1.0,
+        velocity1,
         collider1.shape_scaled().0.as_ref(),
         &isometry2,
-        velocity2.0,
+        velocity2,
         collider2.shape_scaled().0.as_ref(),
         ShapeCastOptions {
             max_time_of_impact,
diff --git a/src/collision/narrow_phase/system_param.rs b/src/collision/narrow_phase/system_param.rs
index 6134e6f09..65af013a4 100644
--- a/src/collision/narrow_phase/system_param.rs
+++ b/src/collision/narrow_phase/system_param.rs
@@ -49,8 +49,7 @@ struct RigidBodyQuery {
     position: Read<Position>,
     rotation: Read<Rotation>,
     center_of_mass: Read<ComputedCenterOfMass>,
-    linear_velocity: Read<LinearVelocity>,
-    angular_velocity: Read<AngularVelocity>,
+    velocity: Read<Velocity>,
     // TODO: We should define these as purely collider components and not query for them here.
     friction: Option<Read<Friction>>,
     restitution: Option<Read<Restitution>>,
@@ -533,8 +532,7 @@ impl<C: AnyCollider> NarrowPhase<'_, '_, C> {
                     is_static1,
                     collider_offset1,
                     world_com1,
-                    mut lin_vel1,
-                    ang_vel1,
+                    mut vel1,
                     rb_friction1,
                     rb_collision_margin1,
                     rb_speculative_margin1,
@@ -545,8 +543,7 @@ impl<C: AnyCollider> NarrowPhase<'_, '_, C> {
                             body.rb.is_static(),
                             collider1.position.0 - body.position.0,
                             body.rotation * body.center_of_mass.0,
-                            body.linear_velocity.0,
-                            body.angular_velocity.0,
+                            *body.velocity,
                             body.friction,
                             body.collision_margin,
                             body.speculative_margin,
@@ -557,8 +554,7 @@ impl<C: AnyCollider> NarrowPhase<'_, '_, C> {
                     is_static2,
                     collider_offset2,
                     world_com2,
-                    mut lin_vel2,
-                    ang_vel2,
+                    mut vel2,
                     rb_friction2,
                     rb_collision_margin2,
                     rb_speculative_margin2,
@@ -569,8 +565,7 @@ impl<C: AnyCollider> NarrowPhase<'_, '_, C> {
                             body.rb.is_static(),
                             collider2.position.0 - body.position.0,
                             body.rotation * body.center_of_mass.0,
-                            body.linear_velocity.0,
-                            body.angular_velocity.0,
+                            *body.velocity,
                             body.friction,
                             body.collision_margin,
                             body.speculative_margin,
@@ -672,15 +667,19 @@ impl<C: AnyCollider> NarrowPhase<'_, '_, C> {
 
                     // Clamp velocities to the maximum speculative margins.
                     if speculative_margin1 < Scalar::MAX {
-                        lin_vel1 = lin_vel1.clamp_length_max(speculative_margin1 * inv_delta_secs);
+                        vel1.linear = vel1
+                            .linear
+                            .clamp_length_max(speculative_margin1 * inv_delta_secs);
                     }
                     if speculative_margin2 < Scalar::MAX {
-                        lin_vel2 = lin_vel2.clamp_length_max(speculative_margin2 * inv_delta_secs);
+                        vel2.linear = vel2
+                            .linear
+                            .clamp_length_max(speculative_margin2 * inv_delta_secs);
                     }
 
                     // Compute the effective margin based on how much the bodies
                     // are expected to move relative to each other.
-                    relative_linear_velocity = lin_vel2 - lin_vel1;
+                    relative_linear_velocity = vel2.linear - vel1.linear;
                     delta_secs * relative_linear_velocity.length()
                 };
 
@@ -742,12 +741,12 @@ impl<C: AnyCollider> NarrowPhase<'_, '_, C> {
                         // Compute the relative velocity along the contact normal.
                         #[cfg(feature = "2d")]
                         let relative_velocity = relative_linear_velocity
-                            + ang_vel2 * point.anchor2.perp()
-                            - ang_vel1 * point.anchor1.perp();
+                            + vel2.angular * point.anchor2.perp()
+                            - vel1.angular * point.anchor1.perp();
                         #[cfg(feature = "3d")]
                         let relative_velocity = relative_linear_velocity
-                            + ang_vel2.cross(point.anchor2)
-                            - ang_vel1.cross(point.anchor1);
+                            + vel2.angular.cross(point.anchor2)
+                            - vel1.angular.cross(point.anchor1);
                         let normal_speed = relative_velocity.dot(normal);
                         point.normal_speed = normal_speed;
 
diff --git a/src/dynamics/ccd/mod.rs b/src/dynamics/ccd/mod.rs
index 679c06c7d..a1f04db70 100644
--- a/src/dynamics/ccd/mod.rs
+++ b/src/dynamics/ccd/mod.rs
@@ -343,8 +343,14 @@ impl SpeculativeMargin {
 ///     commands.spawn((
 ///         RigidBody::Dynamic,
 ///         SweptCcd::default(),
-#[cfg_attr(feature = "2d", doc = "        LinearVelocity(Vec2::X * 100.0),")]
-#[cfg_attr(feature = "3d", doc = "        LinearVelocity(Vec3::X * 100.0),")]
+#[cfg_attr(
+    feature = "2d",
+    doc = "        Velocity::from_linear(Vec2::X * 100.0),"
+)]
+#[cfg_attr(
+    feature = "3d",
+    doc = "        Velocity::from_linear(Vec3::X * 100.0),"
+)]
 #[cfg_attr(feature = "2d", doc = "        Collider::circle(0.1),")]
 #[cfg_attr(feature = "3d", doc = "        Collider::sphere(0.1),")]
 ///         Transform::from_xyz(-10.0, 3.0, 0.0),
@@ -355,8 +361,14 @@ impl SpeculativeMargin {
 ///     commands.spawn((
 ///         RigidBody::Dynamic,
 ///         SweptCcd::LINEAR, // or `SweptCcd::new_with_mode(SweepMode::Linear)`
-#[cfg_attr(feature = "2d", doc = "        LinearVelocity(Vec2::X * 100.0),")]
-#[cfg_attr(feature = "3d", doc = "        LinearVelocity(Vec3::X * 100.0),")]
+#[cfg_attr(
+    feature = "2d",
+    doc = "        Velocity::from_linear(Vec2::X * 100.0),"
+)]
+#[cfg_attr(
+    feature = "3d",
+    doc = "        Velocity::from_linear(Vec3::X * 100.0),"
+)]
 #[cfg_attr(feature = "2d", doc = "        Collider::circle(0.1),")]
 #[cfg_attr(feature = "3d", doc = "        Collider::sphere(0.1),")]
 ///         Transform::from_xyz(-10.0, -3.0, 0.0),
@@ -368,8 +380,11 @@ impl SpeculativeMargin {
 ///     commands.spawn((
 ///         RigidBody::Dynamic,
 ///         LockedAxes::TRANSLATION_LOCKED,
-#[cfg_attr(feature = "2d", doc = "        AngularVelocity(100.0),")]
-#[cfg_attr(feature = "3d", doc = "        AngularVelocity(Vec3::Z * 100.0),")]
+#[cfg_attr(feature = "2d", doc = "        Velocity::from_angular(100.0),")]
+#[cfg_attr(
+    feature = "3d",
+    doc = "        Velocity::from_angular(Vec3::Z * 100.0),"
+)]
 #[cfg_attr(feature = "2d", doc = "        Collider::rectangle(0.2, 10.0),")]
 #[cfg_attr(feature = "3d", doc = "        Collider::cuboid(0.2, 10.0, 10.0),")]
 ///     ));
diff --git a/src/dynamics/integrator/mod.rs b/src/dynamics/integrator/mod.rs
index cb4d359ec..9151021e9 100644
--- a/src/dynamics/integrator/mod.rs
+++ b/src/dynamics/integrator/mod.rs
@@ -261,8 +261,7 @@ pub fn pre_process_velocity_increments(
     mut bodies: Query<(
         &RigidBody,
         &mut VelocityIntegrationData,
-        Option<&LinearDamping>,
-        Option<&AngularDamping>,
+        Option<&Damping>,
         Option<&GravityScale>,
         Option<&LockedAxes>,
     )>,
@@ -276,7 +275,7 @@ pub fn pre_process_velocity_increments(
 
     // TODO: Do we want to skip kinematic bodies here?
     bodies.par_iter_mut().for_each(
-        |(rb, mut integration, lin_damping, ang_damping, gravity_scale, locked_axes)| {
+        |(rb, mut integration, damping, gravity_scale, locked_axes)| {
             if !rb.is_dynamic() {
                 // Skip non-dynamic bodies.
                 return;
@@ -286,8 +285,8 @@ pub fn pre_process_velocity_increments(
 
             // Update the cached right-hand side of the velocity damping equation,
             // `1 / (1 + dt * c)`, where `c` is the damping coefficient.
-            let lin_damping = lin_damping.map_or(0.0, |damping| damping.0);
-            let ang_damping = ang_damping.map_or(0.0, |damping| damping.0);
+            let (lin_damping, ang_damping) =
+                damping.map_or((0.0, 0.0), |damping| (damping.linear, damping.angular));
             integration.update_linear_damping_rhs(lin_damping, delta_secs);
             integration.update_angular_damping_rhs(ang_damping, delta_secs);
 
@@ -463,35 +462,28 @@ pub fn solve_gyroscopic_torque(
 //       to do this in `integrate_velocities` rather than in a separate system.
 //       By doing this in a separate system, we're optimizing for the assumption
 //       that only some bodies have clamped velocities.
-/// Clamps the velocities of bodies to [`MaxLinearSpeed`] and [`MaxAngularSpeed`].
+/// Clamps the velocities of bodies to [`MaxSpeed`].
 fn clamp_velocities(
-    mut bodies: ParamSet<(
-        Query<(&mut SolverBody, &MaxLinearSpeed)>,
-        Query<(&mut SolverBody, &MaxAngularSpeed)>,
-    )>,
+    mut bodies: Query<(&mut SolverBody, &MaxSpeed)>,
     mut diagnostics: ResMut<SolverDiagnostics>,
 ) {
     let start = crate::utils::Instant::now();
 
-    // Clamp linear velocity.
-    bodies.p0().iter_mut().for_each(|(mut body, max_speed)| {
+    // Clamp velocity.
+    bodies.iter_mut().for_each(|(mut body, max_speed)| {
         let linear_speed_squared = body.linear_velocity.length_squared();
-        if linear_speed_squared > max_speed.0 * max_speed.0 {
-            body.linear_velocity *= max_speed.0 / linear_speed_squared.sqrt();
+        if linear_speed_squared > max_speed.linear * max_speed.linear {
+            body.linear_velocity *= max_speed.linear / linear_speed_squared.sqrt();
         }
-    });
-
-    // Clamp angular velocity.
-    bodies.p1().iter_mut().for_each(|(mut body, max_speed)| {
         #[cfg(feature = "2d")]
-        if body.angular_velocity.abs() > max_speed.0 {
-            body.angular_velocity = max_speed.copysign(body.angular_velocity);
+        if body.angular_velocity.abs() > max_speed.angular {
+            body.angular_velocity = max_speed.angular.copysign(body.angular_velocity);
         }
         #[cfg(feature = "3d")]
         {
             let angular_speed_squared = body.angular_velocity.length_squared();
-            if angular_speed_squared > max_speed.0 * max_speed.0 {
-                body.angular_velocity *= max_speed.0 / angular_speed_squared.sqrt();
+            if angular_speed_squared > max_speed.angular * max_speed.angular {
+                body.angular_velocity *= max_speed.angular / angular_speed_squared.sqrt();
             }
         }
     });
@@ -572,14 +564,14 @@ mod tests {
                 {
                     (
                         MassPropertiesBundle::from_shape(&Rectangle::from_length(1.0), 1.0),
-                        AngularVelocity(2.0),
+                        Velocity::from_angular(2.0),
                     )
                 },
                 #[cfg(feature = "3d")]
                 {
                     (
                         MassPropertiesBundle::from_shape(&Cuboid::from_length(1.0), 1.0),
-                        AngularVelocity(Vector::Z * 2.0),
+                        Velocity::from_angular(Vector::Z * 2.0),
                     )
                 },
             ))
@@ -602,8 +594,7 @@ mod tests {
         let entity_ref = app.world_mut().entity(body_entity);
         let position = entity_ref.get::<Position>().unwrap().0;
         let rotation = *entity_ref.get::<Rotation>().unwrap();
-        let linear_velocity = entity_ref.get::<LinearVelocity>().unwrap().0;
-        let angular_velocity = entity_ref.get::<AngularVelocity>().unwrap().0;
+        let velocity = entity_ref.get::<Velocity>().unwrap();
 
         // Euler methods have some precision issues, but this seems weirdly inaccurate.
         assert_relative_eq!(position, Vector::NEG_Y * 490.5, epsilon = 10.0);
@@ -621,10 +612,10 @@ mod tests {
             epsilon = 0.01
         );
 
-        assert_relative_eq!(linear_velocity, Vector::NEG_Y * 98.1, epsilon = 0.0001);
+        assert_relative_eq!(velocity.linear, Vector::NEG_Y * 98.1, epsilon = 0.0001);
         #[cfg(feature = "2d")]
-        assert_relative_eq!(angular_velocity, 2.0, epsilon = 0.00001);
+        assert_relative_eq!(velocity.angular, 2.0, epsilon = 0.00001);
         #[cfg(feature = "3d")]
-        assert_relative_eq!(angular_velocity, Vector::Z * 2.0, epsilon = 0.00001);
+        assert_relative_eq!(velocity.angular, Vector::Z * 2.0, epsilon = 0.00001);
     }
 }
diff --git a/src/dynamics/joints/tests.rs b/src/dynamics/joints/tests.rs
index 6aaaf03f0..5712b7244 100644
--- a/src/dynamics/joints/tests.rs
+++ b/src/dynamics/joints/tests.rs
@@ -83,19 +83,19 @@ fn revolute_motor_spins_body() {
     }
 
     let body_ref = app.world().entity(dynamic);
-    let angular_velocity = body_ref.get::<AngularVelocity>().unwrap();
+    let angular_velocity = body_ref.get::<Velocity>().unwrap().angular;
 
     #[cfg(feature = "2d")]
     {
         assert!(
-            angular_velocity.0.abs() > 1.0,
+            angular_velocity.abs() > 1.0,
             "Angular velocity should be significant"
         );
-        assert_relative_eq!(angular_velocity.0, 2.0, epsilon = 0.5);
+        assert_relative_eq!(angular_velocity, 2.0, epsilon = 0.5);
     }
     #[cfg(feature = "3d")]
     {
-        let speed = angular_velocity.0.length();
+        let speed = angular_velocity.length();
         assert!(speed > 1.0, "Angular velocity should be significant");
     }
 }
@@ -211,18 +211,18 @@ fn revolute_motor_respects_max_torque() {
     }
 
     let body_ref = app.world().entity(dynamic);
-    let angular_velocity = body_ref.get::<AngularVelocity>().unwrap();
+    let angular_velocity = body_ref.get::<Velocity>().unwrap().angular;
 
     #[cfg(feature = "2d")]
     {
         assert!(
-            angular_velocity.0.abs() < 5.0,
+            angular_velocity.abs() < 5.0,
             "Velocity should be limited by max torque"
         );
     }
     #[cfg(feature = "3d")]
     {
-        let speed = angular_velocity.0.length();
+        let speed = angular_velocity.length();
         assert!(speed < 5.0, "Velocity should be limited by max torque");
     }
 }
@@ -592,11 +592,11 @@ fn revolute_motor_force_based() {
     app.update();
 
     let body_ref = app.world().entity(dynamic);
-    let angular_velocity = body_ref.get::<AngularVelocity>().unwrap();
+    let angular_velocity = body_ref.get::<Velocity>().unwrap().angular;
     #[cfg(feature = "2d")]
-    let initial_speed = angular_velocity.0.abs();
+    let initial_speed = angular_velocity.abs();
     #[cfg(feature = "3d")]
-    let initial_speed = angular_velocity.0.length();
+    let initial_speed = angular_velocity.length();
 
     assert!(
         initial_speed.abs() < 0.001,
@@ -613,20 +613,20 @@ fn revolute_motor_force_based() {
     }
 
     let body_ref = app.world().entity(dynamic);
-    let angular_velocity = body_ref.get::<AngularVelocity>().unwrap();
+    let angular_velocity = body_ref.get::<Velocity>().unwrap().angular;
 
     // The body should have gained angular velocity.
     #[cfg(feature = "2d")]
     {
         assert!(
-            angular_velocity.0.abs() > 0.5,
+            angular_velocity.abs() > 0.5,
             "ForceBased motor should spin the body: {}",
-            angular_velocity.0
+            angular_velocity
         );
     }
     #[cfg(feature = "3d")]
     {
-        let speed = angular_velocity.0.length();
+        let speed = angular_velocity.length();
         assert!(
             speed > 0.5,
             "ForceBased motor should spin the body: {}",
diff --git a/src/dynamics/mod.rs b/src/dynamics/mod.rs
index 8a91ff256..48e764167 100644
--- a/src/dynamics/mod.rs
+++ b/src/dynamics/mod.rs
@@ -6,7 +6,7 @@
 //!
 //! Rigid body dynamics includes:
 //!
-//! - Motion of rigid bodies based on their [`LinearVelocity`] and [`AngularVelocity`].
+//! - Motion of rigid bodies based on their [`Velocity`].
 //! - Acceleration caused by external forces and [`Gravity`].
 //! - Collision response, preventing objects from overlapping each other,
 //!   considering properties such as [`Friction`] and [`Restitution`].
diff --git a/src/dynamics/rigid_body/forces/mod.rs b/src/dynamics/rigid_body/forces/mod.rs
index 907105a0d..a8c107256 100644
--- a/src/dynamics/rigid_body/forces/mod.rs
+++ b/src/dynamics/rigid_body/forces/mod.rs
@@ -162,9 +162,9 @@
 //!
 //! # Applying Forces vs. Modifying Velocity
 //!
-//! It is possible to achieve similar effects by directly modifying the [`LinearVelocity`]
-//! or [`AngularVelocity`] components instead of using the force APIs. For example, you could
-//! implement gravity by simply modifying the velocity of the rigid bodies in a system:
+//! It is possible to achieve similar effects by directly modifying the [`Velocity`]
+//! instead of using the force APIs. For example, you could implement gravity by simply
+//! modifying the velocity of the rigid bodies in a system:
 //!
 //! ```
 #![cfg_attr(feature = "2d", doc = "# use avian2d::prelude::*;")]
@@ -173,10 +173,10 @@
 //! #
 //! // In `FixedUpdate`
 //! # #[cfg(feature = "f32")]
-//! fn gravity(mut bodies: Query<&mut LinearVelocity>, time: Res<Time>) {
+//! fn gravity(mut bodies: Query<&mut Velocity>, time: Res<Time>) {
 //!     for mut velocity in &mut bodies {
 //!         // Apply a constant acceleration of 9.81 m/s² in the negative Y direction.
-//!         velocity.y -= 9.81 * time.delta_secs();
+//!         velocity.linear.y -= 9.81 * time.delta_secs();
 //!     }
 //! }
 //! ```
diff --git a/src/dynamics/rigid_body/forces/query_data.rs b/src/dynamics/rigid_body/forces/query_data.rs
index 72b28bee7..b9c962b58 100644
--- a/src/dynamics/rigid_body/forces/query_data.rs
+++ b/src/dynamics/rigid_body/forces/query_data.rs
@@ -107,8 +107,7 @@ use super::AccumulatedLocalAcceleration;
 pub struct Forces {
     position: Read<Position>,
     rotation: Read<Rotation>,
-    linear_velocity: Write<LinearVelocity>,
-    angular_velocity: Write<AngularVelocity>,
+    velocity: Write<Velocity>,
     mass: Read<ComputedMass>,
     angular_inertia: Read<ComputedAngularInertia>,
     center_of_mass: Read<ComputedCenterOfMass>,
@@ -133,8 +132,7 @@ impl ForcesItem<'_, '_> {
         ForcesItem {
             position: self.position,
             rotation: self.rotation,
-            linear_velocity: self.linear_velocity.reborrow(),
-            angular_velocity: self.angular_velocity.reborrow(),
+            velocity: self.velocity.reborrow(),
             mass: self.mass,
             angular_inertia: self.angular_inertia,
             center_of_mass: self.center_of_mass,
@@ -201,16 +199,10 @@ pub trait ReadRigidBodyForces: ReadRigidBodyForcesInternal {
         self.rot()
     }
 
-    /// Returns the [`LinearVelocity`] of the body in world space.
+    /// Returns the [`Velocity`] of the body in world space.
     #[inline]
-    fn linear_velocity(&self) -> Vector {
-        self.lin_vel()
-    }
-
-    /// Returns the [`AngularVelocity`] of the body in world space.
-    #[inline]
-    fn angular_velocity(&self) -> AngularVector {
-        self.ang_vel()
+    fn velocity(&self) -> &Velocity {
+        self.vel()
     }
 
     /// Returns the linear acceleration that the body has accumulated
@@ -268,14 +260,7 @@ pub trait ReadRigidBodyForces: ReadRigidBodyForcesInternal {
     #[doc(alias = "linear_velocity_at_point")]
     fn velocity_at_point(&self, world_point: Vector) -> Vector {
         let offset = world_point - self.global_center_of_mass();
-        #[cfg(feature = "2d")]
-        {
-            self.linear_velocity() + self.angular_velocity() * offset.perp()
-        }
-        #[cfg(feature = "3d")]
-        {
-            self.linear_velocity() + self.angular_velocity().cross(offset)
-        }
+        self.velocity().at_point(offset)
     }
 }
 
@@ -380,7 +365,7 @@ pub trait WriteRigidBodyForces: ReadRigidBodyForces + WriteRigidBodyForcesIntern
 
     /// Applies a linear impulse at the center of mass in world space. The unit is typically N⋅s or kg⋅m/s.
     ///
-    /// The impulse modifies the [`LinearVelocity`] of the body immediately.
+    /// The impulse modifies the [`Velocity::linear`] of the body immediately.
     ///
     /// By default, a non-zero impulse will wake up the body if it is sleeping. This can be prevented
     /// by first calling [`ForcesItem::non_waking`] to get a [`NonWakingForcesItem`].
@@ -391,7 +376,7 @@ pub trait WriteRigidBodyForces: ReadRigidBodyForces + WriteRigidBodyForcesIntern
                 .locked_axes()
                 .apply_to_vec(Vector::splat(self.inverse_mass()));
             let delta_vel = effective_inverse_mass * impulse;
-            *self.linear_velocity_mut() += delta_vel;
+            self.vel_mut().linear += delta_vel;
         }
     }
 
@@ -399,7 +384,7 @@ pub trait WriteRigidBodyForces: ReadRigidBodyForces + WriteRigidBodyForcesIntern
     ///
     /// If the point is not at the center of mass, the impulse will also generate an angular impulse.
     ///
-    /// The impulse modifies the [`LinearVelocity`] and [`AngularVelocity`] of the body immediately.
+    /// The impulse modifies the [`Velocity`] of the body immediately.
     ///
     /// By default, a non-zero impulse will wake up the body if it is sleeping. This can be prevented
     /// by first calling [`ForcesItem::non_waking`] to get a [`NonWakingForcesItem`].
@@ -424,7 +409,7 @@ pub trait WriteRigidBodyForces: ReadRigidBodyForces + WriteRigidBodyForcesIntern
 
     /// Applies a linear impulse in local space. The unit is typically N⋅s or kg⋅m/s.
     ///
-    /// The impulse modifies the [`LinearVelocity`] of the body immediately.
+    /// The impulse modifies the [`Velocity::linear`] of the body immediately.
     ///
     /// By default, a non-zero impulse will wake up the body if it is sleeping. This can be prevented
     /// by first calling [`ForcesItem::non_waking`] to get a [`NonWakingForcesItem`].
@@ -436,13 +421,13 @@ pub trait WriteRigidBodyForces: ReadRigidBodyForces + WriteRigidBodyForcesIntern
                 .locked_axes()
                 .apply_to_vec(Vector::splat(self.inverse_mass()));
             let delta_vel = effective_inverse_mass * world_impulse;
-            *self.linear_velocity_mut() += delta_vel;
+            self.vel_mut().linear += delta_vel;
         }
     }
 
     /// Applies an angular impulse in world space. The unit is typically N⋅m⋅s or kg⋅m²/s.
     ///
-    /// The impulse modifies the [`AngularVelocity`] of the body immediately.
+    /// The impulse modifies the [`Velocity::angular`] of the body immediately.
     ///
     /// By default, a non-zero impulse will wake up the body if it is sleeping. This can be prevented
     /// by first calling [`ForcesItem::non_waking`] to get a [`NonWakingForcesItem`].
@@ -451,13 +436,13 @@ pub trait WriteRigidBodyForces: ReadRigidBodyForces + WriteRigidBodyForcesIntern
         if impulse != AngularVector::ZERO && self.try_wake_up() {
             let effective_inverse_angular_inertia = self.effective_inverse_angular_inertia();
             let delta_vel = effective_inverse_angular_inertia * impulse;
-            *self.angular_velocity_mut() += delta_vel;
+            self.vel_mut().angular += delta_vel;
         }
     }
 
     /// Applies an angular impulse in local space. The unit is typically N⋅m⋅s or kg⋅m²/s.
     ///
-    /// The impulse modifies the [`AngularVelocity`] of the body immediately.
+    /// The impulse modifies the [`Velocity::angular`] of the body immediately.
     ///
     /// By default, a non-zero impulse will wake up the body if it is sleeping. This can be prevented
     /// by first calling [`ForcesItem::non_waking`] to get a [`NonWakingForcesItem`].
@@ -468,7 +453,7 @@ pub trait WriteRigidBodyForces: ReadRigidBodyForces + WriteRigidBodyForcesIntern
             let world_impulse = self.rot() * impulse;
             let effective_inverse_angular_inertia = self.effective_inverse_angular_inertia();
             let delta_vel = effective_inverse_angular_inertia * world_impulse;
-            *self.angular_velocity_mut() += delta_vel;
+            self.vel_mut().angular += delta_vel;
         }
     }
 
@@ -557,16 +542,10 @@ pub trait WriteRigidBodyForces: ReadRigidBodyForces + WriteRigidBodyForcesIntern
         }
     }
 
-    /// Returns a mutable reference to the [`LinearVelocity`] of the body in world space.
-    #[inline]
-    fn linear_velocity_mut(&mut self) -> &mut Vector {
-        self.lin_vel_mut()
-    }
-
-    /// Returns a mutable reference to the [`AngularVelocity`] of the body in world space.
+    /// Returns a mutable reference to the [`Velocity`] of the body in world space.
     #[inline]
-    fn angular_velocity_mut(&mut self) -> &mut AngularVector {
-        self.ang_vel_mut()
+    fn velocity_mut(&mut self) -> &mut Velocity {
+        self.vel_mut()
     }
 
     /// Resets the accumulated linear acceleration to zero.
@@ -591,8 +570,7 @@ pub trait WriteRigidBodyForces: ReadRigidBodyForces + WriteRigidBodyForcesIntern
 trait ReadRigidBodyForcesInternal {
     fn pos(&self) -> &Position;
     fn rot(&self) -> &Rotation;
-    fn lin_vel(&self) -> Vector;
-    fn ang_vel(&self) -> AngularVector;
+    fn vel(&self) -> &Velocity;
     fn global_center_of_mass(&self) -> Vector;
     fn locked_axes(&self) -> LockedAxes;
     fn integration_data(&self) -> &VelocityIntegrationData;
@@ -601,8 +579,7 @@ trait ReadRigidBodyForcesInternal {
 
 /// A trait to provide internal mutable getters and helpers for [`WriteRigidBodyForces`].
 trait WriteRigidBodyForcesInternal: ReadRigidBodyForcesInternal {
-    fn lin_vel_mut(&mut self) -> &mut Vector;
-    fn ang_vel_mut(&mut self) -> &mut AngularVector;
+    fn vel_mut(&mut self) -> &mut Velocity;
     fn inverse_mass(&self) -> Scalar;
     #[cfg(feature = "3d")]
     fn inverse_angular_inertia(&self) -> SymmetricTensor;
@@ -622,12 +599,8 @@ impl ReadRigidBodyForcesInternal for ForcesItem<'_, '_> {
         self.rotation
     }
     #[inline]
-    fn lin_vel(&self) -> Vector {
-        self.linear_velocity.0
-    }
-    #[inline]
-    fn ang_vel(&self) -> AngularVector {
-        self.angular_velocity.0
+    fn vel(&self) -> &Velocity {
+        &self.velocity
     }
     #[inline]
     fn global_center_of_mass(&self) -> Vector {
@@ -649,12 +622,8 @@ impl ReadRigidBodyForcesInternal for ForcesItem<'_, '_> {
 
 impl WriteRigidBodyForcesInternal for ForcesItem<'_, '_> {
     #[inline]
-    fn lin_vel_mut(&mut self) -> &mut Vector {
-        &mut self.linear_velocity.0
-    }
-    #[inline]
-    fn ang_vel_mut(&mut self) -> &mut AngularVector {
-        &mut self.angular_velocity.0
+    fn vel_mut(&mut self) -> &mut Velocity {
+        &mut self.velocity
     }
     #[inline]
     fn inverse_mass(&self) -> Scalar {
@@ -703,12 +672,8 @@ impl ReadRigidBodyForcesInternal for NonWakingForcesItem<'_, '_> {
         self.0.rot()
     }
     #[inline]
-    fn lin_vel(&self) -> Vector {
-        self.0.lin_vel()
-    }
-    #[inline]
-    fn ang_vel(&self) -> AngularVector {
-        self.0.ang_vel()
+    fn vel(&self) -> &Velocity {
+        self.0.vel()
     }
     #[inline]
     fn global_center_of_mass(&self) -> Vector {
@@ -738,12 +703,8 @@ impl ReadRigidBodyForcesInternal for ForcesReadOnlyItem<'_, '_> {
         self.rotation
     }
     #[inline]
-    fn lin_vel(&self) -> Vector {
-        self.linear_velocity.0
-    }
-    #[inline]
-    fn ang_vel(&self) -> AngularVector {
-        self.angular_velocity.0
+    fn vel(&self) -> &Velocity {
+        self.velocity
     }
     #[inline]
     fn global_center_of_mass(&self) -> Vector {
@@ -765,12 +726,8 @@ impl ReadRigidBodyForcesInternal for ForcesReadOnlyItem<'_, '_> {
 
 impl WriteRigidBodyForcesInternal for NonWakingForcesItem<'_, '_> {
     #[inline]
-    fn lin_vel_mut(&mut self) -> &mut Vector {
-        self.0.lin_vel_mut()
-    }
-    #[inline]
-    fn ang_vel_mut(&mut self) -> &mut AngularVector {
-        self.0.ang_vel_mut()
+    fn vel_mut(&mut self) -> &mut Velocity {
+        self.0.vel_mut()
     }
     #[inline]
     fn inverse_mass(&self) -> Scalar {
diff --git a/src/dynamics/rigid_body/mod.rs b/src/dynamics/rigid_body/mod.rs
index 1810fb785..8a9168ed1 100644
--- a/src/dynamics/rigid_body/mod.rs
+++ b/src/dynamics/rigid_body/mod.rs
@@ -7,12 +7,14 @@ pub mod sleeping;
 // Components
 mod locked_axes;
 mod physics_material;
+mod velocity;
 mod world_query;
 
 pub use locked_axes::LockedAxes;
 pub use physics_material::{
     CoefficientCombine, DefaultFriction, DefaultRestitution, Friction, Restitution,
 };
+pub use velocity::{Damping, MaxSpeed, Velocity};
 pub use world_query::*;
 
 #[cfg(feature = "2d")]
@@ -80,12 +82,10 @@ use derive_more::From;
 /// }
 /// ```
 ///
-/// However, moving a dynamic body by changing its position directly is similar
-/// to teleporting the body, which can result in unexpected behavior since the body can move
-/// inside walls.
+/// However, moving a dynamic body by changing its position directly is similar to teleporting
+/// the body, which can result in unexpected behavior since the body can move inside walls.
 ///
-/// You can instead change the velocity of a dynamic or kinematic body with the [`LinearVelocity`]
-/// and [`AngularVelocity`] components:
+/// You can instead change the velocity of a dynamic or kinematic body with the [`Velocity`] component:
 ///
 /// ```
 #[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
@@ -94,31 +94,29 @@ use derive_more::From;
 ///
 /// # #[cfg(feature = "f32")]
 /// fn accelerate_bodies(
-///     mut query: Query<(&mut LinearVelocity, &mut AngularVelocity)>,
+///     mut query: Query<&mut Velocity>,
 ///     time: Res<Time>,
 /// ) {
 ///     let delta_secs = time.delta_secs();
-///     for (mut linear_velocity, mut angular_velocity) in &mut query {
-///         linear_velocity.x += 2.0 * delta_secs;
-#[cfg_attr(
-    feature = "2d",
-    doc = "        angular_velocity.0 += 0.5 * delta_secs;"
-)]
+///     for mut velocity in &mut query {
+///         velocity.linear.x += 2.0 * delta_secs;
+#[cfg_attr(feature = "2d", doc = "        velocity.angular += 0.5 * delta_secs;")]
 #[cfg_attr(
     feature = "3d",
-    doc = "        angular_velocity.z += 0.5 * delta_secs;"
+    doc = "        velocity.angular.z += 0.5 * delta_secs;"
 )]
 ///     }
 /// }
+/// #
 /// # #[cfg(feature = "f64")]
 /// # fn main() {}
 /// ```
 ///
 /// For applying forces, impulses, and acceleration to dynamic bodies, see the [`forces`] module.
 ///
-/// Avian does not have a built-in character controller, so if you need one,
-/// you will need to implement it yourself or use a third party option.
-/// You can take a look at the [3D Examples] for implementations of basic kinematic and dynamic character controllers.
+/// Avian does not have a built-in character controller, so if you need one, you will need to
+/// implement it yourself or use a third party option. You can take a look at the [3D Examples]
+/// for implementations of basic kinematic and dynamic character controllers.
 ///
 /// [3D Examples]: https://github.com/avianphysics/avian/tree/081d2de15f526ada89bf642e3c3277c2c7784488/crates/avian3d/examples
 ///
@@ -250,7 +248,7 @@ use derive_more::From;
 ///
 /// - [Colliders](Collider)
 /// - [Gravity] and [gravity scale](GravityScale)
-/// - [Linear](LinearDamping) and [angular](AngularDamping) velocity damping
+/// - [Damping]
 /// - [Friction] and [restitution](Restitution) (bounciness)
 /// - [Lock translational and rotational axes](LockedAxes)
 /// - [Dominance]
@@ -269,8 +267,7 @@ use derive_more::From;
     //       and only dynamic bodies need mass and angular inertia.
     Position::PLACEHOLDER,
     Rotation::PLACEHOLDER,
-    LinearVelocity,
-    AngularVelocity,
+    Velocity,
     ComputedMass,
     ComputedAngularInertia,
     ComputedCenterOfMass,
@@ -379,178 +376,6 @@ pub(crate) type RigidBodyActiveFilter = (Without<RigidBodyDisabled>, Without<Sle
 #[reflect(Debug, Component, Default)]
 pub struct RigidBodyDisabled;
 
-/// The linear velocity of a [rigid body](RigidBody), typically in meters per second.
-///
-/// # Example
-///
-/// ```
-#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
-#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
-/// use bevy::prelude::*;
-///
-/// # #[cfg(feature = "f32")]
-/// fn accelerate_linear(mut query: Query<&mut LinearVelocity>, time: Res<Time>) {
-///     let delta_secs = time.delta_secs();
-///     for mut linear_velocity in &mut query {
-///         // Accelerate the entity towards +X at `2.0` units per second squared.
-///         linear_velocity.x += 2.0 * delta_secs;
-///     }
-/// }
-/// # #[cfg(feature = "f64")]
-/// # fn main() {}
-/// ```
-///
-/// # Related Components
-///
-/// - [`AngularVelocity`]: The angular velocity of a body.
-/// - [`LinearDamping`]: Reduces the linear velocity of a body over time, similar to air resistance.
-/// - [`MaxLinearSpeed`]: Clamps the linear velocity of a body.
-#[derive(Reflect, Clone, Copy, Component, Debug, Default, Deref, DerefMut, PartialEq, From)]
-#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
-#[reflect(Debug, Component, Default, PartialEq)]
-pub struct LinearVelocity(pub Vector);
-
-impl LinearVelocity {
-    /// Zero linear velocity.
-    pub const ZERO: LinearVelocity = LinearVelocity(Vector::ZERO);
-}
-
-/// The maximum linear speed of a [rigid body](RigidBody), clamping the [`LinearVelocity`],
-/// typically in meters per second.
-///
-/// This can be useful for limiting how fast bodies can move, and can help control behavior and prevent instability.
-///
-/// # Example
-///
-/// ```
-#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
-#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
-/// use bevy::prelude::*;
-///
-/// // Spawn a dynamic body with linear velocity clamped to `100.0` units per second.
-/// fn setup(mut commands: Commands) {
-///     commands.spawn((RigidBody::Dynamic, MaxLinearSpeed(100.0)));
-/// }
-/// ```
-#[derive(Reflect, Clone, Copy, Component, Debug, Deref, DerefMut, PartialEq, From)]
-#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
-#[reflect(Debug, Component, Default, PartialEq)]
-#[doc(alias = "MaxLinearVelocity")]
-pub struct MaxLinearSpeed(pub Scalar);
-
-impl Default for MaxLinearSpeed {
-    fn default() -> Self {
-        Self(Scalar::INFINITY)
-    }
-}
-
-/// The maximum angular speed of a [rigid body](RigidBody), clamping the [`AngularVelocity`],
-/// in radians per second.
-///
-/// This can be useful for limiting how fast bodies can rotate, and can help control behavior and prevent instability.
-///
-/// # Example
-///
-/// ```
-#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
-#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
-/// use bevy::prelude::*;
-///
-/// // Spawn a dynamic body with angular velocity clamped to `20.0` radians per second.
-/// fn setup(mut commands: Commands) {
-///     commands.spawn((RigidBody::Dynamic, MaxAngularSpeed(20.0)));
-/// }
-/// ```
-#[derive(Reflect, Clone, Copy, Component, Debug, Deref, DerefMut, PartialEq, From)]
-#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
-#[reflect(Debug, Component, Default, PartialEq)]
-#[doc(alias = "MaxAngularVelocity")]
-pub struct MaxAngularSpeed(pub Scalar);
-
-impl Default for MaxAngularSpeed {
-    fn default() -> Self {
-        Self(Scalar::INFINITY)
-    }
-}
-
-/// The angular velocity of a [rigid body](RigidBody) in radians per second.
-/// Positive values will result in counterclockwise rotation.
-///
-/// # Example
-///
-/// ```
-/// use avian2d::prelude::*;
-/// use bevy::prelude::*;
-///
-/// # #[cfg(feature = "f32")]
-/// fn accelerate_angular(mut query: Query<&mut AngularVelocity>, time: Res<Time>) {
-///     let delta_secs = time.delta_secs();
-///     for mut angular_velocity in &mut query {
-///         // Accelerate rotation counterclockwise at `0.5` radians per second squared.
-///         angular_velocity.0 += 0.5 * delta_secs;
-///     }
-/// }
-/// # #[cfg(feature = "f64")]
-/// # fn main() {}
-/// ```
-///
-/// # Related Components
-///
-/// - [`LinearVelocity`]: The linear velocity of a body.
-/// - [`AngularDamping`]: Reduces the angular velocity of a body over time, similar to air resistance.
-/// - [`MaxAngularSpeed`]: Clamps the angular velocity of a body.
-#[cfg(feature = "2d")]
-#[derive(Reflect, Clone, Copy, Deref, DerefMut, Component, Debug, Default, PartialEq, From)]
-#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
-#[reflect(Debug, Component, Default, PartialEq)]
-pub struct AngularVelocity(pub Scalar);
-
-/// The angular velocity of a [rigid body](RigidBody), represented as a rotation axis
-/// multiplied by the angular speed in radians per second.
-///
-/// # Example
-///
-/// ```
-/// use avian3d::prelude::*;
-/// use bevy::prelude::*;
-///
-/// # #[cfg(feature = "f32")]
-/// fn accelerate_angular(mut query: Query<&mut AngularVelocity>, time: Res<Time>) {
-///     let delta_secs = time.delta_secs();
-///     for mut angular_velocity in &mut query {
-///         // Accelerate rotation about the Z axis at `0.5` radians per second squared.
-///         angular_velocity.z += 0.5 * delta_secs;
-///     }
-/// }
-/// # #[cfg(feature = "f64")]
-/// # fn main() {}
-/// ```
-///
-/// # Related Components
-///
-/// - [`LinearVelocity`]: The linear velocity of a body.
-/// - [`AngularDamping`]: Reduces the angular velocity of a body over time, similar to air resistance.
-/// - [`MaxAngularSpeed`]: Clamps the angular velocity of a body.
-#[cfg(feature = "3d")]
-#[derive(Reflect, Clone, Copy, Component, Debug, Default, Deref, DerefMut, PartialEq, From)]
-#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
-#[reflect(Debug, Component, Default, PartialEq)]
-pub struct AngularVelocity(pub Vector);
-
-impl AngularVelocity {
-    /// Zero angular velocity.
-    #[cfg(feature = "2d")]
-    pub const ZERO: AngularVelocity = AngularVelocity(0.0);
-    /// Zero angular velocity.
-    #[cfg(feature = "3d")]
-    pub const ZERO: AngularVelocity = AngularVelocity(Vector::ZERO);
-}
-
 /// Controls how [gravity](Gravity) affects a specific [rigid body](RigidBody).
 ///
 /// A gravity scale of `0.0` will disable gravity, while `2.0` will double the gravity.
@@ -580,54 +405,6 @@ impl Default for GravityScale {
     }
 }
 
-/// Automatically slows down a dynamic [rigid body](RigidBody), decreasing its
-/// [linear velocity](LinearVelocity) each frame. This can be used to simulate air resistance.
-///
-/// The default linear damping coefficient is `0.0`, which corresponds to no damping.
-///
-/// # Example
-///
-/// ```
-#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
-#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
-/// use bevy::prelude::*;
-///
-/// fn setup(mut commands: Commands) {
-///     commands.spawn((RigidBody::Dynamic, LinearDamping(0.8)));
-/// }
-/// ```
-#[derive(
-    Component, Reflect, Debug, Clone, Copy, PartialEq, PartialOrd, Default, Deref, DerefMut, From,
-)]
-#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
-#[reflect(Debug, Component, Default, PartialEq)]
-pub struct LinearDamping(pub Scalar);
-
-/// Automatically slows down a dynamic [rigid body](RigidBody), decreasing its
-/// [angular velocity](AngularVelocity) each frame. This can be used to simulate air resistance.
-///
-/// The default angular damping coefficient is `0.0`, which corresponds to no damping.
-///
-/// # Example
-///
-/// ```
-#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
-#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
-/// use bevy::prelude::*;
-///
-/// fn setup(mut commands: Commands) {
-///     commands.spawn((RigidBody::Dynamic, AngularDamping(1.6)));
-/// }
-/// ```
-#[derive(
-    Component, Reflect, Debug, Clone, Copy, PartialEq, PartialOrd, Default, Deref, DerefMut, From,
-)]
-#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
-#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
-#[reflect(Debug, Component, Default, PartialEq)]
-pub struct AngularDamping(pub Scalar);
-
 /// **Dominance** allows [dynamic rigid bodies](RigidBody::Dynamic) to dominate
 /// each other during physical interactions.
 /// 
diff --git a/src/dynamics/rigid_body/physics_material.rs b/src/dynamics/rigid_body/physics_material.rs
index 4b0778203..2c058971e 100644
--- a/src/dynamics/rigid_body/physics_material.rs
+++ b/src/dynamics/rigid_body/physics_material.rs
@@ -278,7 +278,7 @@ impl From<Scalar> for Friction {
 /// Restitution is not guaranteed to be entirely accurate, especially for fast-moving bodies or when there are multiple contact points.
 ///
 /// - Even with a coefficient of 1, some kinetic energy can be lost over long periods of time for bouncing objects.
-///   This can be caused by [friction](Friction), [damping](LinearDamping), or simulation inaccuracies.
+///   This can be caused by [friction](Friction), [damping](Damping), or simulation inaccuracies.
 ///
 /// - Collisions can have more or less bounce than expected, especially when objects are moving very fast.
 ///   This is largely due to the the sequential solver and [speculative collision](dynamics::ccd#speculative-collision).
diff --git a/src/dynamics/rigid_body/sleeping.rs b/src/dynamics/rigid_body/sleeping.rs
index 564df036c..6d30c290b 100644
--- a/src/dynamics/rigid_body/sleeping.rs
+++ b/src/dynamics/rigid_body/sleeping.rs
@@ -11,8 +11,8 @@ use bevy::prelude::*;
 /// Simulating a large number of bodies can be expensive. To reduce CPU overhead, bodies that come to rest
 /// enter a low-cost "sleeping" state where they are not simulated until woken up again.
 ///
-/// To start sleeping, the [`LinearVelocity`] and [`AngularVelocity`] of a body must remain below the [`SleepThreshold`]
-/// for a time specified by the [`TimeToSleep`] resource. All bodies that are either directly or indirectly connected
+/// To start sleeping, the [`Velocity`] of a body must remain below the [`SleepThreshold`] for a time
+/// specified by the [`TimeToSleep`] resource. All bodies that are either directly or indirectly connected
 /// to the body through contacts or joints must also be allowed to sleep.
 ///
 /// A body is woken up when any of the following happens:
@@ -20,7 +20,7 @@ use bevy::prelude::*;
 /// - An awake body collides with a sleeping body.
 /// - A joint is created between an awake body and a sleeping body.
 /// - A joint or contact is removed from a sleeping body.
-/// - The [`Transform`], [`LinearVelocity`], or [`AngularVelocity`] of a sleeping body is modified.
+/// - The [`Transform`] or [`Velocity`] of a sleeping body is modified.
 /// - The [`RigidBody`] type of a body is changed.
 /// - A [constant force component](super::forces#constant-forces) of a sleeping body is modified.
 /// - A force, impulse, or acceleration is applied via [`Forces`], without using [`non_waking`].
@@ -33,8 +33,7 @@ use bevy::prelude::*;
 /// Sleeping can be disabled for an entity by adding the [`SleepingDisabled`] component.
 ///
 /// [`RigidBody`]: super::RigidBody
-/// [`LinearVelocity`]: super::LinearVelocity
-/// [`AngularVelocity`]: super::AngularVelocity
+/// [`Velocity`]: super::Velocity
 /// [`Forces`]: super::forces::Forces
 /// [`non_waking`]: super::forces::ForcesItem::non_waking
 /// [`Gravity`]: super::Gravity
@@ -69,14 +68,14 @@ pub struct Sleeping;
 #[reflect(Component, Debug, Default)]
 pub struct SleepingDisabled;
 
-/// A component for the maximum [`LinearVelocity`] and [`AngularVelocity`]
-/// for a body to be allowed to be [`Sleeping`].
+/// A component for the maximum [`Velocity`] that a [`RigidBody`] can have
+/// for it to be allowed to be [`Sleeping`].
 ///
 /// Setting a negative sleeping threshold disables sleeping entirely,
 /// similar to [`SleepingDisabled`].
 ///
-/// [`LinearVelocity`]: super::LinearVelocity
-/// [`AngularVelocity`]: super::AngularVelocity
+/// [`Velocity`]: super::Velocity
+/// [`RigidBody`]: super::RigidBody
 #[derive(Component, Clone, Copy, PartialEq, PartialOrd, Debug, Reflect)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
@@ -110,13 +109,12 @@ impl Default for SleepThreshold {
 }
 
 /// A component storing the time in seconds that a [`RigidBody`] has been resting
-/// with its [`LinearVelocity`] and [`AngularVelocity`] below the [`SleepThreshold`].
+/// with its [`Velocity`] below the [`SleepThreshold`].
 ///
 /// When this time exceeds the [`TimeToSleep`], the body is allowed to be [`Sleeping`].
 ///
 /// [`RigidBody`]: super::RigidBody
-/// [`LinearVelocity`]: super::LinearVelocity
-/// [`AngularVelocity`]: super::AngularVelocity
+/// [`Velocity`]: super::Velocity
 #[derive(Component, Clone, Copy, Debug, Default, PartialEq, Reflect)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
@@ -128,14 +126,12 @@ pub struct SleepTimer(pub f32);
 pub type TimeSleeping = SleepTimer;
 
 /// A resource that specifies the time in seconds that a [`RigidBody`] must rest
-/// with its [`LinearVelocity`] and [`AngularVelocity`] below the [`SleepThreshold`]
-/// before it is allowed to be [`Sleeping`].
+/// with its [`Velocity`] below the [`SleepThreshold`] before it is allowed to be [`Sleeping`].
 ///
 /// Default: `0.5`
 ///
 /// [`RigidBody`]: super::RigidBody
-/// [`LinearVelocity`]: super::LinearVelocity
-/// [`AngularVelocity`]: super::AngularVelocity
+/// [`Velocity`]: super::Velocity
 #[derive(Resource, Clone, Copy, Debug, PartialEq, PartialOrd, Reflect)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
 #[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
diff --git a/src/dynamics/rigid_body/velocity.rs b/src/dynamics/rigid_body/velocity.rs
new file mode 100644
index 000000000..123dbd492
--- /dev/null
+++ b/src/dynamics/rigid_body/velocity.rs
@@ -0,0 +1,440 @@
+use crate::prelude::*;
+use bevy::prelude::*;
+
+/// The velocity of a [rigid body](RigidBody), representing the speed and direction
+/// of movement in world space.
+///
+/// Velocity consists of:
+///
+/// - [`linear`](Velocity::linear) component representing the translational velocity
+///   of the body, typically in meters per second.
+/// - [`angular`](Velocity::angular) component representing the rotational velocity
+///   of the body in radians per second.
+///
+/// # Construction
+///
+/// The initial velocity of a dynamic body can be set by adding the [`Velocity`] component:
+///
+/// ```
+#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
+/// use bevy::prelude::*;
+///
+/// # #[cfg(feature = "f32")]
+/// fn setup(mut commands: Commands) {
+///     // Spawn a dynamic body with an initial velocity of `10.0` units per second towards +X,
+///     // and an angular velocity of `1.5` radians per second about the Z axis.
+///     commands.spawn((
+///         RigidBody::Dynamic,
+///         Velocity {
+#[cfg_attr(feature = "2d", doc = "            linear: Vec2::new(10.0, 0.0),")]
+#[cfg_attr(feature = "3d", doc = "            linear: Vec3::new(10.0, 0.0, 0.0),")]
+#[cfg_attr(feature = "2d", doc = "            angular: 1.5,")]
+#[cfg_attr(feature = "3d", doc = "            angular: Vec3::new(0.0, 0.0, 1.5),")]
+///         },
+///     ));
+/// }
+/// #
+/// # #[cfg(feature = "f64")]
+/// # fn main() {}
+/// ```
+///
+/// The [`Velocity`] component also provides constructor methods for convenience:
+///
+/// ```
+#[cfg_attr(feature = "2d", doc = "# use avian2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "# use avian3d::prelude::*;")]
+/// #
+/// # #[cfg(feature = "f32")]
+/// # const VELOCITIES: [Velocity; 4] = [
+/// // Velocity with linear and angular components
+/// Velocity::new(Vec3::new(10.0, 0.0, 0.0), Vec3::new(0.0, 0.0, 1.5)),
+///
+/// // Velocity with only the linear component
+/// Velocity::from_linear(Vec3::new(10.0, 0.0, 0.0)),
+/// Velocity::from_linear_xyz(10.0, 0.0, 0.0),
+///
+/// // Velocity with only the angular component
+/// Velocity::from_angular(Vec3::new(0.0, 0.0, 1.5)),
+/// Velocity::from_angular_xyz(0.0, 0.0, 1.5),
+/// # ];
+/// #
+/// # #[cfg(feature = "f64")]
+/// # fn main() {}
+/// ```
+///
+/// # Changing Velocity
+///
+/// Velocity can be modified at runtime to control the movement of bodies:
+///
+/// ```
+#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
+/// use bevy::prelude::*;
+///
+/// # #[cfg(feature = "f32")]
+/// fn accelerate_linear(mut query: Query<&mut Velocity>, time: Res<Time>) {
+///     let delta_secs = time.delta_secs();
+///     for mut velocity in &mut query {
+///         // Accelerate the entity towards +X at `2.0` units per second squared.
+///         velocity.linear.x += 2.0 * delta_secs;
+///     }
+/// }
+/// #
+/// # #[cfg(feature = "f64")]
+/// # fn main() {}
+/// ```
+///
+/// For controlling velocity and movement using forces, impulses, and acceleration,
+/// see the [`forces`] module.
+///
+/// # Point Velocity
+///
+/// The velocity at a specific point on the body can be computed using the [`Velocity::at_point`] method,
+/// which takes into account both the linear and angular components of the velocity. This is useful
+/// for determining the speed of a point on the body that is not at the center of mass.
+///
+/// ```
+#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
+/// use bevy::prelude::*;
+////
+/// # #[cfg(feature = "f32")]
+/// fn point_velocity(query: Query<&Velocity>) {
+///     for velocity in &query {
+///         // Compute the velocity at a point 1 unit to the right of the center of mass.
+#[cfg_attr(
+    feature = "2d",
+    doc = "         let point_velocity = velocity.at_point(Vec2::new(1.0, 0.0));"
+)]
+#[cfg_attr(
+    feature = "3d",
+    doc = "         let point_velocity = velocity.at_point(Vec3::new(1.0, 0.0, 0.0));"
+)]
+///         println!("Velocity at point: {:?}", point_velocity);
+///     }
+/// }
+/// #
+/// # #[cfg(feature = "f64")]
+/// # fn main() {}
+/// ```
+///
+/// # Related Components
+///
+/// - [`MaxSpeed`] for clamping the maximum linear and angular velocity of a body.
+/// - [`Damping`] for gradually slowing down a body's velocity over time.
+#[derive(Component, Clone, Copy, Debug, Default, PartialEq, Reflect)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
+#[reflect(Component, Debug, PartialEq)]
+pub struct Velocity {
+    /// The linear velocity, typically in meters per second.
+    ///
+    /// This represents the translational velocity of the body in world space.
+    pub linear: Vector,
+
+    /// The angular velocity in radians per second.
+    ///
+    /// This represents the rotational velocity of the body in world space.
+    pub angular: AngularVector,
+}
+
+impl Velocity {
+    /// Zero velocity.
+    pub const ZERO: Velocity = Velocity::new(Vector::ZERO, AngularVector::ZERO);
+
+    /// Creates a new [`Velocity`] with the given linear and angular components.
+    #[inline(always)]
+    pub const fn new(linear: Vector, angular: AngularVector) -> Self {
+        Self { linear, angular }
+    }
+
+    /// Creates a new [`Velocity`] with the given linear component and zero angular component.
+    #[inline(always)]
+    pub const fn from_linear(linear: Vector) -> Self {
+        Self {
+            linear,
+            angular: AngularVector::ZERO,
+        }
+    }
+
+    /// Creates a new [`Velocity`] with the given `x` and `y` values for the linear component
+    /// and zero angular component.
+    #[inline(always)]
+    #[cfg(feature = "2d")]
+    pub const fn from_linear_xy(x: Scalar, y: Scalar) -> Self {
+        Self {
+            linear: Vector::new(x, y),
+            angular: AngularVector::ZERO,
+        }
+    }
+
+    /// Creates a new [`Velocity`] with the given `x`, `y`, and `z` values for the linear component
+    /// and zero angular component.
+    #[inline(always)]
+    #[cfg(feature = "3d")]
+    pub const fn from_linear_xyz(x: Scalar, y: Scalar, z: Scalar) -> Self {
+        Self {
+            linear: Vector::new(x, y, z),
+            angular: AngularVector::ZERO,
+        }
+    }
+
+    /// Creates a new [`Velocity`] with the given angular component and zero linear component.
+    #[inline(always)]
+    pub const fn from_angular(angular: AngularVector) -> Self {
+        Self {
+            linear: Vector::ZERO,
+            angular,
+        }
+    }
+
+    /// Creates a new [`Velocity`] with the given `x`, `y`, and `z` values for the angular component
+    /// and zero linear component.
+    #[inline(always)]
+    #[cfg(feature = "3d")]
+    pub const fn from_angular_xyz(x: Scalar, y: Scalar, z: Scalar) -> Self {
+        Self {
+            linear: Vector::ZERO,
+            angular: AngularVector::new(x, y, z),
+        }
+    }
+
+    /// Computes the velocity at a given point relative to the center of mass.
+    #[inline]
+    pub fn at_point(&self, point: Vector) -> Vector {
+        #[cfg(feature = "2d")]
+        {
+            self.linear + self.angular * point.perp()
+        }
+        #[cfg(feature = "3d")]
+        {
+            self.linear + self.angular.cross(point)
+        }
+    }
+
+    /// Returns `true` if either the linear or angular component of the velocity is NaN.
+    #[inline]
+    pub fn is_nan(&self) -> bool {
+        self.linear.is_nan() || self.angular.is_nan()
+    }
+
+    /// Returns `true` if both the linear and angular components of the velocity
+    /// are neither infinite nor NaN.
+    #[inline]
+    pub fn is_finite(&self) -> bool {
+        self.linear.is_finite() && self.angular.is_finite()
+    }
+}
+
+/// The maximum movement speed of a [rigid body](RigidBody), clamping [`Velocity`],
+///
+/// This can be useful for limiting how fast bodies can move, and can help
+/// control behavior and prevent instability.
+///
+/// The default maximum speed is infinite, meaning that velocity is not clamped by default.
+///
+/// # Example
+///
+/// The maximum speed of a body can be set by adding the [`MaxSpeed`] component:
+///
+/// ```
+#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
+/// use bevy::prelude::*;
+///
+/// fn setup(mut commands: Commands) {
+///     // Spawn a dynamic body with linear velocity clamped to `100.0` units per second
+///     // and angular velocity clamped to `5.0` radians per second.
+///     commands.spawn((
+///         RigidBody::Dynamic,
+///         MaxSpeed {
+///             linear: 100.0,
+///             angular: 5.0,
+///         },
+///     ));
+/// }
+/// ```
+///
+/// The [`MaxSpeed`] component also provides constructor methods for convenience:
+///
+/// ```
+#[cfg_attr(feature = "2d", doc = "# use avian2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "# use avian3d::prelude::*;")]
+/// # use bevy::prelude::*;
+/// #
+/// # const MAX_SPEEDS: [MaxSpeed; 3] = [
+/// // Max speed with linear and angular components
+/// MaxSpeed::new(100.0, 5.0),
+///
+/// // Max speed with only the linear component
+/// MaxSpeed::from_linear(100.0),
+///
+/// // Max speed with only the angular component
+/// MaxSpeed::from_angular(5.0) ,
+/// # ];
+/// ```
+///
+/// # Related Components
+///
+/// - [`Velocity`] for the current speed and direction of movement of a body.
+/// - [`Damping`] for gradually slowing down a body's velocity over time.
+#[derive(Component, Clone, Copy, Debug, PartialEq, Reflect)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
+#[reflect(Component, Debug, Default, PartialEq)]
+#[doc(alias = "MaxVelocity")]
+pub struct MaxSpeed {
+    /// The maximum linear speed, clamping [`Velocity::linear`], typically in meters per second.
+    ///
+    /// Default: [`INFINITY`](Scalar::INFINITY)
+    pub linear: Scalar,
+
+    /// The maximum angular speed, clamping [`Velocity::angular`], in radians per second.
+    ///
+    /// Default: [`INFINITY`](Scalar::INFINITY)
+    pub angular: Scalar,
+}
+
+impl Default for MaxSpeed {
+    fn default() -> Self {
+        Self::new(Scalar::INFINITY, Scalar::INFINITY)
+    }
+}
+
+impl MaxSpeed {
+    /// Creates a new [`MaxSpeed`] with the given linear and angular components.
+    #[inline(always)]
+    pub const fn new(linear: Scalar, angular: Scalar) -> Self {
+        Self { linear, angular }
+    }
+
+    /// Creates a new [`MaxSpeed`] with the given linear component and infinite angular component.
+    #[inline(always)]
+    pub const fn from_linear(linear: Scalar) -> Self {
+        Self {
+            linear,
+            angular: Scalar::INFINITY,
+        }
+    }
+
+    /// Creates a new [`MaxSpeed`] with the given angular component and infinite linear component.
+    #[inline(always)]
+    pub const fn from_angular(angular: Scalar) -> Self {
+        Self {
+            linear: Scalar::INFINITY,
+            angular,
+        }
+    }
+}
+
+/// Damping coefficients to gradually slow down a dynamic [rigid body](RigidBody), decreasing its
+/// [`Velocity`] each time step.
+///
+/// This can be used for basic air resistance or other forms of drag, or to make bodies
+/// come to rest more quickly after movement.
+///
+/// The damping is implemented as a [Padé approximation] of [exponential decay],
+/// using the following formula:
+///
+/// ```text
+/// v(t + Δt) = v(t) / (1 + damping * Δt)
+/// ```
+///
+/// The default damping coefficients are `0.0`, which corresponds to no damping,
+/// meaning that the body will not slow down over time unless acted upon by other forces.
+///
+/// [Padé approximation]: https://en.wikipedia.org/wiki/Pad%C3%A9_approximant
+/// [exponential decay]: https://en.wikipedia.org/wiki/Exponential_decay
+///
+/// # Example
+///
+/// The damping coefficients of a body can be set by adding the [`Damping`] component:
+///
+/// ```
+#[cfg_attr(feature = "2d", doc = "use avian2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "use avian3d::prelude::*;")]
+/// use bevy::prelude::*;
+///
+/// fn setup(mut commands: Commands) {
+///     // Spawn a dynamic body with linear damping of `0.8` and angular damping of `1.6`.
+///     commands.spawn((
+///         RigidBody::Dynamic,
+///         Damping {
+///             linear: 0.8,
+///             angular: 1.6,
+///         },
+///     ));
+/// }
+/// ```
+///
+/// The [`Damping`] component also provides constructor methods for convenience:
+///
+/// ```
+#[cfg_attr(feature = "2d", doc = "# use avian2d::prelude::*;")]
+#[cfg_attr(feature = "3d", doc = "# use avian3d::prelude::*;")]
+/// # use bevy::prelude::*;
+/// #
+/// # const DAMPINGS: [Damping; 3] = [
+/// // Damping with linear and angular components
+/// Damping::new(0.8, 1.6),
+///
+/// // Damping with only the linear component
+/// Damping::from_linear(0.8),
+///
+/// // Damping with only the angular component
+/// Damping::from_angular(1.6),
+/// # ];
+/// ```
+///
+/// # Related Components
+///
+/// - [`Velocity`] for the current speed and direction of movement of a body.
+/// - [`MaxSpeed`] for clamping the maximum linear and angular velocity of a body.
+#[derive(Component, Clone, Copy, Debug, PartialEq, Reflect)]
+#[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
+#[cfg_attr(feature = "serialize", reflect(Serialize, Deserialize))]
+#[reflect(Component, Debug, Default, PartialEq)]
+pub struct Damping {
+    /// The linear damping coefficient, which gradually slows down the linear velocity of the body.
+    ///
+    /// Default: `0.0` (no damping)
+    pub linear: Scalar,
+
+    /// The angular damping coefficient, which gradually slows down the angular velocity of the body.
+    ///
+    /// Default: `0.0` (no damping)
+    pub angular: Scalar,
+}
+
+impl Default for Damping {
+    fn default() -> Self {
+        Self::new(0.0, 0.0)
+    }
+}
+
+impl Damping {
+    /// Creates a new [`Damping`] with the given linear and angular components.
+    #[inline(always)]
+    pub const fn new(linear: Scalar, angular: Scalar) -> Self {
+        Self { linear, angular }
+    }
+
+    /// Creates a new [`Damping`] with the given linear component and zero angular component.
+    #[inline(always)]
+    pub const fn from_linear(linear: Scalar) -> Self {
+        Self {
+            linear,
+            angular: 0.0,
+        }
+    }
+
+    /// Creates a new [`Damping`] with the given angular component and zero linear component.
+    #[inline(always)]
+    pub const fn from_angular(angular: Scalar) -> Self {
+        Self {
+            linear: 0.0,
+            angular,
+        }
+    }
+}
diff --git a/src/dynamics/rigid_body/world_query.rs b/src/dynamics/rigid_body/world_query.rs
index 9108ff37a..e5634b00f 100644
--- a/src/dynamics/rigid_body/world_query.rs
+++ b/src/dynamics/rigid_body/world_query.rs
@@ -14,8 +14,7 @@ pub struct RigidBodyQuery {
     pub rb: Ref<'static, RigidBody>,
     pub position: &'static mut Position,
     pub rotation: &'static mut Rotation,
-    pub linear_velocity: &'static mut LinearVelocity,
-    pub angular_velocity: &'static mut AngularVelocity,
+    pub velocity: &'static mut Velocity,
     pub mass: &'static mut ComputedMass,
     pub angular_inertia: &'static mut ComputedAngularInertia,
     pub center_of_mass: &'static mut ComputedCenterOfMass,
@@ -28,18 +27,6 @@ pub struct RigidBodyQuery {
 }
 
 impl RigidBodyQueryItem<'_, '_> {
-    /// Computes the velocity at the given `point` relative to the center of the body.
-    pub fn velocity_at_point(&self, point: Vector) -> Vector {
-        #[cfg(feature = "2d")]
-        {
-            self.linear_velocity.0 + self.angular_velocity.0 * point.perp()
-        }
-        #[cfg(feature = "3d")]
-        {
-            self.linear_velocity.0 + self.angular_velocity.cross(point)
-        }
-    }
-
     /// Computes the effective inverse mass, taking into account any translation locking.
     pub fn effective_inverse_mass(&self) -> Vector {
         if !self.rb.is_dynamic() {
@@ -96,18 +83,6 @@ impl RigidBodyQueryItem<'_, '_> {
 }
 
 impl RigidBodyQueryReadOnlyItem<'_, '_> {
-    /// Computes the velocity at the given `point` relative to the center of mass.
-    pub fn velocity_at_point(&self, point: Vector) -> Vector {
-        #[cfg(feature = "2d")]
-        {
-            self.linear_velocity.0 + self.angular_velocity.0 * point.perp()
-        }
-        #[cfg(feature = "3d")]
-        {
-            self.linear_velocity.0 + self.angular_velocity.cross(point)
-        }
-    }
-
     /// Returns the mass. If the rigid body is not dynamic, the returned mass is infinite.
     pub fn mass(&self) -> ComputedMass {
         if self.rb.is_dynamic() {
diff --git a/src/dynamics/solver/contact/mod.rs b/src/dynamics/solver/contact/mod.rs
index ced711f1f..9768b451f 100644
--- a/src/dynamics/solver/contact/mod.rs
+++ b/src/dynamics/solver/contact/mod.rs
@@ -157,8 +157,8 @@ impl ContactConstraint {
 
         let tangents = compute_tangent_directions(
             manifold.normal,
-            body1.linear_velocity.0,
-            body2.linear_velocity.0,
+            body1.velocity.linear,
+            body2.velocity.linear,
         );
 
         let mut points = Vec::with_capacity(manifold.points.len());
diff --git a/src/dynamics/solver/islands/sleeping.rs b/src/dynamics/solver/islands/sleeping.rs
index 9f4aaf097..d428b9b0c 100644
--- a/src/dynamics/solver/islands/sleeping.rs
+++ b/src/dynamics/solver/islands/sleeping.rs
@@ -567,8 +567,7 @@ fn wake_on_changed(
             (
                 Ref<Position>,
                 Ref<Rotation>,
-                Ref<LinearVelocity>,
-                Ref<AngularVelocity>,
+                Ref<Velocity>,
                 Ref<SleepTimer>,
                 &BodyIslandNode,
             ),
@@ -577,8 +576,7 @@ fn wake_on_changed(
                 Or<(
                     Changed<Position>,
                     Changed<Rotation>,
-                    Changed<LinearVelocity>,
-                    Changed<AngularVelocity>,
+                    Changed<Velocity>,
                     Changed<SleepTimer>,
                 )>,
             ),
@@ -593,11 +591,10 @@ fn wake_on_changed(
 ) {
     let this_run = system_tick.this_run();
 
-    for (pos, rot, lin_vel, ang_vel, sleep_timer, body_island) in &query.p0() {
+    for (pos, rot, vel, sleep_timer, body_island) in &query.p0() {
         if is_changed_after_tick(pos, last_physics_tick.0, this_run)
             || is_changed_after_tick(rot, last_physics_tick.0, this_run)
-            || is_changed_after_tick(lin_vel, last_physics_tick.0, this_run)
-            || is_changed_after_tick(ang_vel, last_physics_tick.0, this_run)
+            || is_changed_after_tick(vel, last_physics_tick.0, this_run)
             || is_changed_after_tick(sleep_timer, last_physics_tick.0, this_run)
         {
             awake_island_bit_vec.set_and_grow(body_island.island_id.0 as usize);
diff --git a/src/dynamics/solver/plugin.rs b/src/dynamics/solver/plugin.rs
index 65bd48ec8..18630888f 100644
--- a/src/dynamics/solver/plugin.rs
+++ b/src/dynamics/solver/plugin.rs
@@ -356,7 +356,7 @@ pub struct ContactConstraints(pub Vec<ContactConstraint>);
 #[derive(QueryData)]
 pub(super) struct BodyQuery {
     pub(super) rb: Read<RigidBody>,
-    pub(super) linear_velocity: Read<LinearVelocity>,
+    pub(super) velocity: Read<Velocity>,
     pub(super) inertia: Option<Read<SolverBodyInertia>>,
 }
 
diff --git a/src/dynamics/solver/solver_body/plugin.rs b/src/dynamics/solver/solver_body/plugin.rs
index c18a2e30d..5134f0d5c 100644
--- a/src/dynamics/solver/solver_body/plugin.rs
+++ b/src/dynamics/solver/solver_body/plugin.rs
@@ -4,21 +4,16 @@ use bevy::{
 };
 
 use super::{SolverBody, SolverBodyInertia};
-use crate::{
-    AngularVelocity, LinearVelocity, PhysicsSchedule, Position, RigidBody, RigidBodyActiveFilter,
-    RigidBodyDisabled, Rotation, Sleeping, SolverSystems, Vector,
-    dynamics::solver::{SolverDiagnostics, solver_body::SolverBodyFlags},
-    prelude::{
-        AppDiagnosticsExt, ComputedAngularInertia, ComputedCenterOfMass, ComputedMass, Dominance,
-        LockedAxes,
-    },
-};
 #[cfg(feature = "3d")]
 use crate::{
     MatExt,
     dynamics::integrator::{IntegrationSystems, integrate_positions},
     prelude::SubstepSchedule,
 };
+use crate::{
+    dynamics::solver::{SolverDiagnostics, solver_body::SolverBodyFlags},
+    prelude::*,
+};
 
 /// A plugin for managing solver bodies.
 ///
@@ -183,8 +178,7 @@ fn prepare_solver_bodies(
         &RigidBody,
         &mut SolverBody,
         &mut SolverBodyInertia,
-        &LinearVelocity,
-        &AngularVelocity,
+        &Velocity,
         &Rotation,
         &ComputedMass,
         &ComputedAngularInertia,
@@ -198,16 +192,15 @@ fn prepare_solver_bodies(
             rb,
             mut solver_body,
             mut inertial_properties,
-            linear_velocity,
-            angular_velocity,
+            velocity,
             rotation,
             mass,
             angular_inertia,
             locked_axes,
             dominance,
         )| {
-            solver_body.linear_velocity = linear_velocity.0;
-            solver_body.angular_velocity = angular_velocity.0;
+            solver_body.linear_velocity = velocity.linear;
+            solver_body.angular_velocity = velocity.angular;
             solver_body.delta_position = Vector::ZERO;
             solver_body.delta_rotation = Rotation::IDENTITY;
 
@@ -266,15 +259,15 @@ fn writeback_solver_bodies(
         &mut Position,
         &mut Rotation,
         &ComputedCenterOfMass,
-        &mut LinearVelocity,
-        &mut AngularVelocity,
+        &mut Velocity,
     )>,
     mut diagnostics: ResMut<SolverDiagnostics>,
 ) {
     let start = bevy::platform::time::Instant::now();
 
-    query.par_iter_mut().for_each(
-        |(solver_body, mut pos, mut rot, com, mut lin_vel, mut ang_vel)| {
+    query
+        .par_iter_mut()
+        .for_each(|(solver_body, mut pos, mut rot, com, mut vel)| {
             // Write back the position and rotation deltas,
             // rotating the body around its center of mass.
             let old_world_com = *rot * com.0;
@@ -283,10 +276,9 @@ fn writeback_solver_bodies(
             pos.0 += solver_body.delta_position + old_world_com - new_world_com;
 
             // Write back velocities.
-            lin_vel.0 = solver_body.linear_velocity;
-            ang_vel.0 = solver_body.angular_velocity;
-        },
-    );
+            vel.linear = solver_body.linear_velocity;
+            vel.angular = solver_body.angular_velocity;
+        });
 
     diagnostics.finalize += start.elapsed();
 }
diff --git a/src/dynamics/solver/xpbd/mod.rs b/src/dynamics/solver/xpbd/mod.rs
index 020b4a32a..32b2f530f 100644
--- a/src/dynamics/solver/xpbd/mod.rs
+++ b/src/dynamics/solver/xpbd/mod.rs
@@ -241,7 +241,7 @@
 //! ### Rigid body constraints
 //!
 //! Unlike particles, [rigid bodies](RigidBody) also have angular quantities like [rotation](Rotation),
-//! [angular velocity](AngularVelocity) and [angular inertia](AngularInertia). In addition, constraints can be applied at specific
+//! [angular velocity](Velocity::angular) and [angular inertia](AngularInertia). In addition, constraints can be applied at specific
 //! points in the body, like contact positions or joint attachment positions, which also affects the orientation.
 //!
 //! When the constraint is not applied at the center of mass, the inverse mass in the computation of `Δλ` must
diff --git a/src/interpolation.rs b/src/interpolation.rs
index 47884476d..375a05c38 100644
--- a/src/interpolation.rs
+++ b/src/interpolation.rs
@@ -305,14 +305,14 @@ struct PreviousLinearVelocity(Vector);
 
 /// The previous angular velocity of an entity indicating its rotation speed during the previous frame.
 #[derive(Component, Default, Deref, DerefMut)]
-struct PreviousAngularVelocity(AngularVelocity);
+struct PreviousAngularVelocity(AngularVector);
 
 #[derive(QueryData)]
 struct LinVelSource;
 
 impl VelocitySource for LinVelSource {
     type Previous = PreviousLinearVelocity;
-    type Current = LinearVelocity;
+    type Current = Velocity;
 
     fn previous(previous: &Self::Previous) -> Vec3 {
         #[cfg(feature = "2d")]
@@ -328,11 +328,11 @@ impl VelocitySource for LinVelSource {
     fn current(current: &Self::Current) -> Vec3 {
         #[cfg(feature = "2d")]
         {
-            current.0.f32().extend(0.0)
+            current.linear.f32().extend(0.0)
         }
         #[cfg(feature = "3d")]
         {
-            current.0.f32()
+            current.linear.f32()
         }
     }
 }
@@ -343,12 +343,12 @@ struct AngVelSource;
 #[allow(clippy::unnecessary_cast)]
 impl VelocitySource for AngVelSource {
     type Previous = PreviousAngularVelocity;
-    type Current = AngularVelocity;
+    type Current = Velocity;
 
     fn previous(previous: &Self::Previous) -> Vec3 {
         #[cfg(feature = "2d")]
         {
-            Vec3::Z * previous.0.0 as f32
+            Vec3::Z * previous.0 as f32
         }
         #[cfg(feature = "3d")]
         {
@@ -359,24 +359,24 @@ impl VelocitySource for AngVelSource {
     fn current(current: &Self::Current) -> Vec3 {
         #[cfg(feature = "2d")]
         {
-            Vec3::Z * current.0 as f32
+            Vec3::Z * current.angular as f32
         }
         #[cfg(feature = "3d")]
         {
-            current.0.f32()
+            current.angular.f32()
         }
     }
 }
 
 fn update_previous_velocity(
-    mut lin_vel_query: Query<(&LinearVelocity, &mut PreviousLinearVelocity)>,
-    mut ang_vel_query: Query<(&AngularVelocity, &mut PreviousAngularVelocity)>,
+    mut lin_vel_query: Query<(&Velocity, &mut PreviousLinearVelocity)>,
+    mut ang_vel_query: Query<(&Velocity, &mut PreviousAngularVelocity)>,
 ) {
-    for (lin_vel, mut prev_lin_vel) in &mut lin_vel_query {
-        prev_lin_vel.0 = lin_vel.0;
+    for (vel, mut prev_lin_vel) in &mut lin_vel_query {
+        prev_lin_vel.0 = vel.linear;
     }
 
-    for (ang_vel, mut prev_ang_vel) in &mut ang_vel_query {
-        prev_ang_vel.0 = *ang_vel;
+    for (vel, mut prev_ang_vel) in &mut ang_vel_query {
+        prev_ang_vel.0 = vel.angular;
     }
 }
diff --git a/src/lib.rs b/src/lib.rs
index 4abe69ff2..5bcf9c527 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -128,11 +128,11 @@
 //! - [Rigid body types](RigidBody#rigid-body-types)
 //! - [Creating rigid bodies](RigidBody#creation)
 //! - [Movement](RigidBody#movement)
-//!     - [Linear](LinearVelocity) and [angular](AngularVelocity) velocity
+//!     - [Velocity]
 //!     - [External forces, impulses, and acceleration](dynamics::rigid_body::forces)
 //! - [Gravity] and [gravity scale](GravityScale)
 //! - [Mass properties](dynamics::rigid_body::mass_properties)
-//! - [Linear](LinearDamping) and [angular](AngularDamping) velocity damping
+//! - [Damping]
 //! - [Lock translational and rotational axes](LockedAxes)
 //! - [Dominance]
 //! - [Continuous Collision Detection (CCD)](dynamics::ccd)
diff --git a/src/schedule/mod.rs b/src/schedule/mod.rs
index d56e13c8a..4b24e2da0 100644
--- a/src/schedule/mod.rs
+++ b/src/schedule/mod.rs
@@ -295,8 +295,7 @@ fn update_last_physics_tick(
 #[cfg(debug_assertions)]
 fn assert_components_finite(
     pos_query: Query<(Entity, Ref<Position>)>,
-    lin_vel_query: Query<(Entity, Ref<LinearVelocity>)>,
-    ang_vel_query: Query<(Entity, Ref<AngularVelocity>)>,
+    vel_query: Query<(Entity, Ref<Velocity>)>,
 ) {
     macro_rules! assert_finite {
         ($ent:expr, $val:ident, $ty:ty) => {
@@ -312,10 +311,7 @@ fn assert_components_finite(
     for (entity, position) in pos_query {
         assert_finite!(entity, position, Position);
     }
-    for (entity, velocity) in lin_vel_query {
-        assert_finite!(entity, velocity, LinearVelocity);
-    }
-    for (entity, velocity) in ang_vel_query {
-        assert_finite!(entity, velocity, AngularVelocity);
+    for (entity, velocity) in vel_query {
+        assert_finite!(entity, velocity, Velocity);
     }
 }
diff --git a/src/tests/mod.rs b/src/tests/mod.rs
index 2e6d6205b..2788cec91 100644
--- a/src/tests/mod.rs
+++ b/src/tests/mod.rs
@@ -110,7 +110,7 @@ fn body_with_velocity_moves() {
         commands.spawn((
             Transform::default(),
             RigidBody::Dynamic,
-            LinearVelocity(Vector::X),
+            Velocity::from_linear(Vector::X),
             #[cfg(feature = "2d")]
             MassPropertiesBundle::from_shape(&Circle::new(0.5), 1.0),
             #[cfg(feature = "3d")]