diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 972372781..bcc00516e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -110,7 +110,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: test
-          args: --doc --all-features
+          args: --doc 
       - name: Get package names
         id: get-package-names
         run: |-
@@ -135,7 +135,7 @@ jobs:
         uses: actions-rs/cargo@v1
         with:
           command: doc
-          args: --no-deps ${{ steps.get-package-names.outputs.PACKAGE_NAMES }} --all-features ${{ steps.get-features-for-docs.outputs.FEATURES_FOR_DOCS }}
+          args: --no-deps ${{ steps.get-package-names.outputs.PACKAGE_NAMES }}
   docs-and-demos-ghpages:
     name: Update Docs and Demos in GitHub Pages
     runs-on: ubuntu-latest
@@ -176,7 +176,7 @@ jobs:
           GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
         run: |-
           set -ex
-          cargo doc --verbose ${{ steps.get-package-names.outputs.PACKAGE_NAMES }} --all-features ${{ steps.get-features-for-docs.outputs.FEATURES_FOR_DOCS }}
+          cargo doc --verbose ${{ steps.get-package-names.outputs.PACKAGE_NAMES }} 
           echo "<meta http-equiv=refresh content=0;url=bevy_tnua/index.html>" > target/doc/index.html
           for physics_backend in rapier xpbd; do
               cargo build \
diff --git a/Cargo.toml b/Cargo.toml
index 9463045c1..2f7432a9a 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -53,8 +53,11 @@ bevy = { version = "^0.13", default-features = false, features = [
     "x11",
     # "filesystem_watcher",
 ] }
-bevy_xpbd_3d = { version = "^0.4" }
+bevy_xpbd_3d = { version = "^0.4", features = ["3d","debug-plugin", "parallel", "async-collider", "parry-f32"] }
 bevy-tnua-xpbd3d = { path = "xpbd3d" }
 
 [package.metadata.docs.rs]
 all-features = true
+
+[features]
+f64 = ["bevy-tnua-physics-integration-layer/f64"]
\ No newline at end of file
diff --git a/demos/Cargo.toml b/demos/Cargo.toml
index 95c6e172b..1a3257484 100644
--- a/demos/Cargo.toml
+++ b/demos/Cargo.toml
@@ -11,11 +11,14 @@ exclude = [
 default = [
     # Comment this out when Bevy gets upgraded and bevy_egui lags behind
     "egui",
+    "bevy_xpbd_3d?/parry-f32",
+    "bevy_xpbd_2d?/parry-f32",
 ]
 egui = ["dep:bevy_egui", "dep:egui_plot"]
 rapier = []
 rapier2d = ["rapier", "dep:bevy_rapier2d", "dep:bevy-tnua-rapier2d"]
 rapier3d = ["rapier", "dep:bevy_rapier3d", "dep:bevy-tnua-rapier3d"]
+f64 = ["bevy_xpbd_3d?/parry-f64", "bevy_xpbd_2d?/parry-f64", "bevy-tnua-physics-integration-layer/f64", "bevy-tnua/f64"]
 
 xpbd = []
 xpbd2d = ["xpbd", "dep:bevy_xpbd_2d", "dep:bevy-tnua-xpbd2d"]
@@ -50,11 +53,13 @@ bevy-tnua-rapier2d = { path = "../rapier2d", optional = true }
 bevy_rapier3d = { version = "^0.25", features = ["debug-render-3d"], optional = true }
 bevy-tnua-rapier3d = { path = "../rapier3d", optional = true }
 
-bevy_xpbd_2d = { version = "^0.4", optional = true }
-bevy-tnua-xpbd2d = { path = "../xpbd2d", optional = true }
+bevy_xpbd_2d = {version = "^0.4", default-features = false, features = ["2d","debug-plugin", "parallel"], optional = true}
+bevy-tnua-xpbd2d = { path = "../xpbd2d", default-features = false, optional = true }
 
-bevy_xpbd_3d = { version = "^0.4", optional = true }
-bevy-tnua-xpbd3d = { path = "../xpbd3d", optional = true }
+bevy_xpbd_3d = {version = "^0.4", default-features = false, features = ["3d","debug-plugin", "parallel", "async-collider"], optional = true }
+bevy-tnua-xpbd3d = { path = "../xpbd3d", default-features = false, optional = true }
 
 bevy_egui = { version = "0.25", optional = true }
 egui_plot = { version = "0.26", optional = true }
+
+
diff --git a/demos/build.rs b/demos/build.rs
new file mode 100644
index 000000000..e85add04d
--- /dev/null
+++ b/demos/build.rs
@@ -0,0 +1,6 @@
+fn main() {
+    #[cfg(all(feature = "bevy_xpbd_2d/parry-f32", feature = "f64"))]
+    compile_error!(
+        "Default Feature (f32) and f64 are mutually exclusive and cannot be enabled together"
+    );
+}
diff --git a/demos/src/bin/platformer_2d.rs b/demos/src/bin/platformer_2d.rs
index b31db5be7..02f165e62 100644
--- a/demos/src/bin/platformer_2d.rs
+++ b/demos/src/bin/platformer_2d.rs
@@ -6,6 +6,7 @@ use bevy_tnua::control_helpers::{
     TnuaCrouchEnforcer, TnuaCrouchEnforcerPlugin, TnuaSimpleAirActionsCounter,
     TnuaSimpleFallThroughPlatformsHelper,
 };
+use bevy_tnua::math::{AsF32, Vector3};
 use bevy_tnua::prelude::*;
 use bevy_tnua::{TnuaGhostSensor, TnuaToggle};
 #[cfg(feature = "rapier2d")]
@@ -264,7 +265,7 @@ fn setup_player(mut commands: Commands) {
     });
 
     // `TnuaCrouchEnforcer` can be used to prevent the character from standing up when obstructed.
-    cmd.insert(TnuaCrouchEnforcer::new(0.5 * Vec3::Y, |cmd| {
+    cmd.insert(TnuaCrouchEnforcer::new(0.5 * Vector3::Y, |cmd| {
         // It needs a sensor shape because it needs to do a shapecast upwards. Without a sensor shape
         // it'd do a raycast.
         #[cfg(feature = "rapier2d")]
diff --git a/demos/src/bin/platformer_3d.rs b/demos/src/bin/platformer_3d.rs
index f1d1bcaa4..0d6027a22 100644
--- a/demos/src/bin/platformer_3d.rs
+++ b/demos/src/bin/platformer_3d.rs
@@ -6,6 +6,7 @@ use bevy_tnua::control_helpers::{
     TnuaCrouchEnforcer, TnuaCrouchEnforcerPlugin, TnuaSimpleAirActionsCounter,
     TnuaSimpleFallThroughPlatformsHelper,
 };
+use bevy_tnua::math::{AsF32, Vector3};
 use bevy_tnua::prelude::*;
 use bevy_tnua::{TnuaAnimatingState, TnuaGhostSensor, TnuaToggle};
 #[cfg(feature = "rapier3d")]
@@ -290,7 +291,7 @@ fn setup_player(mut commands: Commands, asset_server: Res<AssetServer>) {
     });
 
     // `TnuaCrouchEnforcer` can be used to prevent the character from standing up when obstructed.
-    cmd.insert(TnuaCrouchEnforcer::new(0.5 * Vec3::Y, |cmd| {
+    cmd.insert(TnuaCrouchEnforcer::new(0.5 * Vector3::Y, |cmd| {
         #[cfg(feature = "rapier3d")]
         cmd.insert(TnuaRapier3dSensorShape(rapier::Collider::cylinder(
             0.0, 0.5,
diff --git a/demos/src/bin/shooter_like.rs b/demos/src/bin/shooter_like.rs
index 48d8ba332..737bbd570 100644
--- a/demos/src/bin/shooter_like.rs
+++ b/demos/src/bin/shooter_like.rs
@@ -8,6 +8,7 @@ use bevy_tnua::control_helpers::{
     TnuaCrouchEnforcer, TnuaCrouchEnforcerPlugin, TnuaSimpleAirActionsCounter,
     TnuaSimpleFallThroughPlatformsHelper,
 };
+use bevy_tnua::math::{AdjustPrecision, AsF32, Float, Quaternion, Vector3};
 use bevy_tnua::prelude::*;
 use bevy_tnua::{TnuaAnimatingState, TnuaGhostSensor, TnuaToggle};
 #[cfg(feature = "rapier3d")]
@@ -144,7 +145,7 @@ fn setup_player(mut commands: Commands, asset_server: Res<AssetServer>) {
         speed: 20.0,
         walk: TnuaBuiltinWalk {
             float_height: 2.0,
-            turning_angvel: f32::INFINITY,
+            turning_angvel: Float::INFINITY,
             ..Default::default()
         },
         actions_in_air: 1,
@@ -297,7 +298,7 @@ fn setup_player(mut commands: Commands, asset_server: Res<AssetServer>) {
     });
 
     // `TnuaCrouchEnforcer` can be used to prevent the character from standing up when obstructed.
-    cmd.insert(TnuaCrouchEnforcer::new(0.5 * Vec3::Y, |cmd| {
+    cmd.insert(TnuaCrouchEnforcer::new(0.5 * Vector3::Y, |cmd| {
         #[cfg(feature = "rapier3d")]
         cmd.insert(TnuaRapier3dSensorShape(rapier::Collider::cylinder(
             0.0, 0.5,
@@ -365,7 +366,7 @@ fn apply_camera_controls(
         mouse_motion.clear();
         Vec2::ZERO
     };
-    let turning = Quat::from_rotation_y(-0.01 * total_delta.x);
+    let turning = Quaternion::from_rotation_y(-0.01 * total_delta.x.adjust_precision());
     let Ok((player_transform, mut forward_from_camera)) = player_character_query.get_single_mut()
     else {
         return;
@@ -373,8 +374,9 @@ fn apply_camera_controls(
     forward_from_camera.forward = turning.mul_vec3(forward_from_camera.forward);
 
     for mut camera in camera_query.iter_mut() {
-        camera.translation =
-            player_transform.translation() + -5.0 * forward_from_camera.forward + 1.0 * Vec3::Y;
-        camera.look_to(forward_from_camera.forward, Vec3::Y);
+        camera.translation = player_transform.translation()
+            + -5.0 * forward_from_camera.forward.f32()
+            + 1.0 * Vec3::Y;
+        camera.look_to(forward_from_camera.forward.f32(), Vec3::Y);
     }
 }
diff --git a/demos/src/character_animating_systems/platformer_animating_systems.rs b/demos/src/character_animating_systems/platformer_animating_systems.rs
index d81ed09e6..43b139726 100644
--- a/demos/src/character_animating_systems/platformer_animating_systems.rs
+++ b/demos/src/character_animating_systems/platformer_animating_systems.rs
@@ -1,5 +1,6 @@
 use bevy::prelude::*;
 use bevy_tnua::builtins::{TnuaBuiltinCrouch, TnuaBuiltinDash, TnuaBuiltinJumpState};
+use bevy_tnua::math::Float;
 use bevy_tnua::prelude::*;
 use bevy_tnua::{TnuaAnimatingState, TnuaAnimatingStateDirective};
 
@@ -8,14 +9,15 @@ use crate::util::animating::AnimationsHandler;
 #[derive(Debug)]
 pub enum AnimationState {
     Standing,
-    Running(f32),
+    Running(Float),
     Jumping,
     Falling,
     Crouching,
-    Crawling(f32),
+    Crawling(Float),
     Dashing,
 }
 
+#[allow(clippy::unnecessary_cast)]
 pub fn animate_platformer_character(
     mut animations_handlers_query: Query<(
         // `TnuaAnimatingState` is a helper for controlling the animations. The user system is
@@ -112,7 +114,7 @@ pub fn animate_platformer_character(
                 // animation (without necessarily replacing it). In this case - control the speed
                 // of the animation based on the speed of the movement.
                 AnimationState::Running(speed) | AnimationState::Crawling(speed) => {
-                    player.set_speed(*speed);
+                    player.set_speed(*speed as f32);
                 }
                 // Jumping and dashing can be chained, we want to start a new jump/dash animation
                 // when one jump/dash is chained to another.
@@ -142,7 +144,7 @@ pub fn animate_platformer_character(
                 AnimationState::Running(speed) => {
                     player
                         .start(handler.animations["Running"].clone_weak())
-                        .set_speed(*speed)
+                        .set_speed(*speed as f32)
                         .repeat();
                 }
                 AnimationState::Jumping => {
@@ -164,7 +166,7 @@ pub fn animate_platformer_character(
                 AnimationState::Crawling(speed) => {
                     player
                         .start(handler.animations["Crawling"].clone_weak())
-                        .set_speed(*speed)
+                        .set_speed(*speed as f32)
                         .repeat();
                 }
                 AnimationState::Dashing => {
diff --git a/demos/src/character_control_systems/platformer_control_systems.rs b/demos/src/character_control_systems/platformer_control_systems.rs
index 17655f88b..0f5b7c571 100644
--- a/demos/src/character_control_systems/platformer_control_systems.rs
+++ b/demos/src/character_control_systems/platformer_control_systems.rs
@@ -5,6 +5,7 @@ use bevy_tnua::builtins::{TnuaBuiltinCrouch, TnuaBuiltinCrouchState, TnuaBuiltin
 use bevy_tnua::control_helpers::{
     TnuaCrouchEnforcer, TnuaSimpleAirActionsCounter, TnuaSimpleFallThroughPlatformsHelper,
 };
+use bevy_tnua::math::{AdjustPrecision, AsF32, Float, Vector3};
 use bevy_tnua::prelude::*;
 use bevy_tnua::{TnuaGhostSensor, TnuaProximitySensor};
 
@@ -13,6 +14,7 @@ use crate::ui::tuning::UiTunable;
 use super::Dimensionality;
 
 #[allow(clippy::type_complexity)]
+#[allow(clippy::useless_conversion)]
 pub fn apply_platformer_controls(
     #[cfg(feature = "egui")] mut egui_context: EguiContexts,
     keyboard: Res<ButtonInput<KeyCode>>,
@@ -72,29 +74,30 @@ pub fn apply_platformer_controls(
     {
         // This part is just keyboard input processing. In a real game this would probably be done
         // with a third party plugin.
-        let mut direction = Vec3::ZERO;
+        let mut direction = Vector3::ZERO;
 
         if config.dimensionality == Dimensionality::Dim3 {
             if keyboard.any_pressed([KeyCode::ArrowUp, KeyCode::KeyW]) {
-                direction -= Vec3::Z;
+                direction -= Vector3::Z;
             }
             if keyboard.any_pressed([KeyCode::ArrowDown, KeyCode::KeyS]) {
-                direction += Vec3::Z;
+                direction += Vector3::Z;
             }
         }
         if keyboard.any_pressed([KeyCode::ArrowLeft, KeyCode::KeyA]) {
-            direction -= Vec3::X;
+            direction -= Vector3::X;
         }
         if keyboard.any_pressed([KeyCode::ArrowRight, KeyCode::KeyD]) {
-            direction += Vec3::X;
+            direction += Vector3::X;
         }
 
         direction = direction.clamp_length_max(1.0);
 
         if let Some(forward_from_camera) = forward_from_camera {
             direction = Transform::default()
-                .looking_to(forward_from_camera.forward, Vec3::Y)
-                .transform_point(direction);
+                .looking_to(forward_from_camera.forward.f32(), Vec3::Y)
+                .transform_point(direction.f32())
+                .adjust_precision();
         }
 
         let jump = match config.dimensionality {
@@ -291,7 +294,7 @@ pub fn apply_platformer_controls(
         // frame's input.
         controller.basis(TnuaBuiltinWalk {
             desired_velocity: if turn_in_place {
-                Vec3::ZERO
+                Vector3::ZERO
             } else {
                 direction * speed_factor * config.speed
             },
@@ -356,7 +359,7 @@ pub fn apply_platformer_controls(
                 } else {
                     // For shooters, we want to allow rotating mid-dash if the player moves the
                     // mouse.
-                    Vec3::ZERO
+                    Vector3::ZERO
                 },
                 allow_in_air: air_actions_counter.air_count_for(TnuaBuiltinDash::NAME)
                     <= config.actions_in_air,
@@ -369,14 +372,14 @@ pub fn apply_platformer_controls(
 #[derive(Component)]
 pub struct CharacterMotionConfigForPlatformerDemo {
     pub dimensionality: Dimensionality,
-    pub speed: f32,
+    pub speed: Float,
     pub walk: TnuaBuiltinWalk,
     pub actions_in_air: usize,
     pub jump: TnuaBuiltinJump,
     pub crouch: TnuaBuiltinCrouch,
-    pub dash_distance: f32,
+    pub dash_distance: Float,
     pub dash: TnuaBuiltinDash,
-    pub one_way_platforms_min_proximity: f32,
+    pub one_way_platforms_min_proximity: Float,
     pub falling_through: FallingThroughControlScheme,
 }
 
@@ -442,13 +445,13 @@ impl UiTunable for FallingThroughControlScheme {
 
 #[derive(Component)]
 pub struct ForwardFromCamera {
-    pub forward: Vec3,
+    pub forward: Vector3,
 }
 
 impl Default for ForwardFromCamera {
     fn default() -> Self {
         Self {
-            forward: Vec3::NEG_Z,
+            forward: Vector3::NEG_Z,
         }
     }
 }
diff --git a/demos/src/levels_setup/for_2d_platformer.rs b/demos/src/levels_setup/for_2d_platformer.rs
index 52b958886..03d3cf029 100644
--- a/demos/src/levels_setup/for_2d_platformer.rs
+++ b/demos/src/levels_setup/for_2d_platformer.rs
@@ -2,7 +2,10 @@ use bevy::prelude::*;
 
 #[cfg(feature = "rapier2d")]
 use bevy_rapier2d::{prelude as rapier, prelude::*};
-use bevy_tnua::TnuaGhostPlatform;
+use bevy_tnua::{
+    math::{AdjustPrecision, Vector2, Vector3},
+    TnuaGhostPlatform,
+};
 #[cfg(feature = "xpbd2d")]
 use bevy_xpbd_2d::{prelude as xpbd, prelude::*};
 
@@ -31,7 +34,7 @@ pub fn setup_level(mut commands: Commands, asset_server: Res<AssetServer>) {
     #[cfg(feature = "xpbd2d")]
     {
         cmd.insert(xpbd::RigidBody::Static);
-        cmd.insert(xpbd::Collider::halfspace(Vec2::Y));
+        cmd.insert(xpbd::Collider::halfspace(Vector2::Y));
     }
 
     for ([width, height], transform) in [
@@ -58,7 +61,10 @@ pub fn setup_level(mut commands: Commands, asset_server: Res<AssetServer>) {
         #[cfg(feature = "xpbd2d")]
         {
             cmd.insert(xpbd::RigidBody::Static);
-            cmd.insert(xpbd::Collider::rectangle(width, height));
+            cmd.insert(xpbd::Collider::rectangle(
+                width.adjust_precision(),
+                height.adjust_precision(),
+            ));
         }
     }
 
@@ -201,10 +207,10 @@ pub fn setup_level(mut commands: Commands, asset_server: Res<AssetServer>) {
         cmd.insert(MovingPlatform::new(
             4.0,
             &[
-                Vec3::new(-4.0, 6.0, 0.0),
-                Vec3::new(-8.0, 6.0, 0.0),
-                Vec3::new(-8.0, 10.0, 0.0),
-                Vec3::new(-4.0, 10.0, 0.0),
+                Vector3::new(-4.0, 6.0, 0.0),
+                Vector3::new(-8.0, 6.0, 0.0),
+                Vector3::new(-8.0, 10.0, 0.0),
+                Vector3::new(-4.0, 10.0, 0.0),
             ],
         ));
     }
diff --git a/demos/src/levels_setup/for_3d_platformer.rs b/demos/src/levels_setup/for_3d_platformer.rs
index a9a596ff1..3445a90fb 100644
--- a/demos/src/levels_setup/for_3d_platformer.rs
+++ b/demos/src/levels_setup/for_3d_platformer.rs
@@ -2,7 +2,7 @@ use bevy::prelude::*;
 
 #[cfg(feature = "rapier3d")]
 use bevy_rapier3d::{prelude as rapier, prelude::*};
-use bevy_tnua::TnuaGhostPlatform;
+use bevy_tnua::{math::Vector3, TnuaGhostPlatform};
 #[cfg(feature = "xpbd3d")]
 use bevy_xpbd_3d::{prelude as xpbd, prelude::*};
 
@@ -172,12 +172,12 @@ pub fn setup_level(
         cmd.insert(MovingPlatform::new(
             4.0,
             &[
-                Vec3::new(-4.0, 6.0, 0.0),
-                Vec3::new(-8.0, 6.0, 0.0),
-                Vec3::new(-8.0, 10.0, 0.0),
-                Vec3::new(-8.0, 10.0, -4.0),
-                Vec3::new(-4.0, 10.0, -4.0),
-                Vec3::new(-4.0, 10.0, 0.0),
+                Vector3::new(-4.0, 6.0, 0.0),
+                Vector3::new(-8.0, 6.0, 0.0),
+                Vector3::new(-8.0, 10.0, 0.0),
+                Vector3::new(-8.0, 10.0, -4.0),
+                Vector3::new(-4.0, 10.0, -4.0),
+                Vector3::new(-4.0, 10.0, 0.0),
             ],
         ));
     }
diff --git a/demos/src/moving_platform.rs b/demos/src/moving_platform.rs
index 80c64065d..6ba261451 100644
--- a/demos/src/moving_platform.rs
+++ b/demos/src/moving_platform.rs
@@ -1,4 +1,5 @@
 use bevy::prelude::*;
+use bevy_tnua::math::{AdjustPrecision, Float, Vector3};
 
 pub struct MovingPlatformPlugin;
 
@@ -8,7 +9,7 @@ impl Plugin for MovingPlatformPlugin {
         app.add_systems(
             Update,
             MovingPlatform::make_system(
-                |velocity: &mut bevy_rapier2d::prelude::Velocity, linvel: Vec3| {
+                |velocity: &mut bevy_rapier2d::prelude::Velocity, linvel: Vector3| {
                     velocity.linvel = linvel.truncate();
                 },
             ),
@@ -17,7 +18,7 @@ impl Plugin for MovingPlatformPlugin {
         app.add_systems(
             Update,
             MovingPlatform::make_system(
-                |velocity: &mut bevy_rapier3d::prelude::Velocity, linvel: Vec3| {
+                |velocity: &mut bevy_rapier3d::prelude::Velocity, linvel: Vector3| {
                     velocity.linvel = linvel;
                 },
             ),
@@ -26,7 +27,7 @@ impl Plugin for MovingPlatformPlugin {
         app.add_systems(
             Update,
             MovingPlatform::make_system(
-                |velocity: &mut bevy_xpbd_2d::prelude::LinearVelocity, linvel: Vec3| {
+                |velocity: &mut bevy_xpbd_2d::prelude::LinearVelocity, linvel: Vector3| {
                     velocity.0 = linvel.truncate();
                 },
             ),
@@ -35,7 +36,7 @@ impl Plugin for MovingPlatformPlugin {
         app.add_systems(
             Update,
             MovingPlatform::make_system(
-                |velocity: &mut bevy_xpbd_3d::prelude::LinearVelocity, linvel: Vec3| {
+                |velocity: &mut bevy_xpbd_3d::prelude::LinearVelocity, linvel: Vector3| {
                     velocity.0 = linvel;
                 },
             ),
@@ -46,12 +47,12 @@ impl Plugin for MovingPlatformPlugin {
 #[derive(Component)]
 pub struct MovingPlatform {
     pub current_leg: usize,
-    pub speed: f32,
-    pub locations: Vec<Vec3>,
+    pub speed: Float,
+    pub locations: Vec<Vector3>,
 }
 
 impl MovingPlatform {
-    pub fn new(speed: f32, locations: &[Vec3]) -> Self {
+    pub fn new(speed: Float, locations: &[Vector3]) -> Self {
         Self {
             current_leg: 0,
             speed,
@@ -60,19 +61,21 @@ impl MovingPlatform {
     }
 
     fn make_system<V: Component>(
-        mut updater: impl 'static + Send + Sync + FnMut(&mut V, Vec3),
+        mut updater: impl 'static + Send + Sync + FnMut(&mut V, Vector3),
     ) -> bevy::ecs::schedule::SystemConfigs {
         (move |time: Res<Time>,
                mut query: Query<(&mut MovingPlatform, &GlobalTransform, &mut V)>| {
             for (mut moving_platform, transform, mut velocity) in query.iter_mut() {
-                let current = transform.translation();
+                let current = transform.translation().adjust_precision();
                 let target = moving_platform.locations[moving_platform.current_leg];
                 let vec_to = target - current;
                 updater(
                     velocity.as_mut(),
                     vec_to.normalize_or_zero() * moving_platform.speed,
                 );
-                if vec_to.length() <= time.delta_seconds() * moving_platform.speed {
+                if vec_to.length()
+                    <= time.delta_seconds().adjust_precision() * moving_platform.speed
+                {
                     moving_platform.current_leg =
                         (moving_platform.current_leg + 1) % moving_platform.locations.len();
                 }
diff --git a/examples/example.rs b/examples/example.rs
index b0bd40a48..7b28c7d4d 100644
--- a/examples/example.rs
+++ b/examples/example.rs
@@ -5,6 +5,11 @@ use bevy_xpbd_3d::prelude::*;
 use bevy_tnua::prelude::*;
 use bevy_tnua_xpbd3d::*;
 
+#[cfg(all(feature = "bevy_xpbd_2d/parry-f32", feature = "f64"))]
+compile_error!(
+    "Default Feature (f32) and f64 are mutually exclusive and cannot be enabled together"
+);
+
 fn main() {
     App::new()
         .add_plugins((
diff --git a/physics-integration-layer/Cargo.toml b/physics-integration-layer/Cargo.toml
index 6e7f0e5d6..5095407c5 100644
--- a/physics-integration-layer/Cargo.toml
+++ b/physics-integration-layer/Cargo.toml
@@ -13,3 +13,6 @@ readme = "../README.md"
 
 [dependencies]
 bevy = { version = "^0.13", default-features = false }
+
+[features]
+f64 = []
diff --git a/physics-integration-layer/src/data_for_backends.rs b/physics-integration-layer/src/data_for_backends.rs
index d458becee..968f1b4dc 100644
--- a/physics-integration-layer/src/data_for_backends.rs
+++ b/physics-integration-layer/src/data_for_backends.rs
@@ -1,5 +1,6 @@
 use std::ops::{Add, AddAssign};
 
+use crate::math::{Float, Quaternion, Vector3};
 use bevy::prelude::*;
 
 /// Allows disabling Tnua for a specific entity.
@@ -35,23 +36,23 @@ pub enum TnuaToggle {
 /// [`TnuaPipelineStages::Sensors`](crate::TnuaPipelineStages::Sensors).
 #[derive(Component, Debug)]
 pub struct TnuaRigidBodyTracker {
-    pub translation: Vec3,
-    pub rotation: Quat,
-    pub velocity: Vec3,
+    pub translation: Vector3,
+    pub rotation: Quaternion,
+    pub velocity: Vector3,
     /// Angular velocity as the rotation axis multiplied by the rotation speed in radians per
-    /// second. Can be extracted from a quaternion using [`Quat::xyz`].
-    pub angvel: Vec3,
-    pub gravity: Vec3,
+    /// second. Can be extracted from a quaternion using [`Quaternion::xyz`].
+    pub angvel: Vector3,
+    pub gravity: Vector3,
 }
 
 impl Default for TnuaRigidBodyTracker {
     fn default() -> Self {
         Self {
-            translation: Vec3::ZERO,
-            rotation: Quat::IDENTITY,
-            velocity: Vec3::ZERO,
-            angvel: Vec3::ZERO,
-            gravity: Vec3::ZERO,
+            translation: Vector3::ZERO,
+            rotation: Quaternion::IDENTITY,
+            velocity: Vector3::ZERO,
+            angvel: Vector3::ZERO,
+            gravity: Vector3::ZERO,
         }
     }
 }
@@ -64,11 +65,11 @@ impl Default for TnuaRigidBodyTracker {
 #[derive(Component, Debug)]
 pub struct TnuaProximitySensor {
     /// The cast origin in the entity's coord system.
-    pub cast_origin: Vec3,
+    pub cast_origin: Vector3,
     /// The direction in world coord system (unmodified by the entity's transform)
     pub cast_direction: Direction3d,
     /// Tnua will update this field according to its need. The backend only needs to read it.
-    pub cast_range: f32,
+    pub cast_range: Float,
     pub output: Option<TnuaProximitySensorOutput>,
 
     /// Used to prevent collision with obstacles the character squeezed into sideways.
@@ -89,13 +90,13 @@ pub struct TnuaProximitySensor {
     ///
     /// Positive dot products should not happen (hitting the ceiling?), but it's trivial to
     /// consider them as invalid.
-    pub intersection_match_prevention_cutoff: f32,
+    pub intersection_match_prevention_cutoff: Float,
 }
 
 impl Default for TnuaProximitySensor {
     fn default() -> Self {
         Self {
-            cast_origin: Vec3::ZERO,
+            cast_origin: Vector3::ZERO,
             cast_direction: Direction3d::NEG_Y,
             cast_range: 0.0,
             output: None,
@@ -111,15 +112,15 @@ pub struct TnuaProximitySensorOutput {
     pub entity: Entity,
     /// The distance to the collider from [`cast_origin`](TnuaProximitySensor::cast_origin) along the
     /// [`cast_direction`](TnuaProximitySensor::cast_direction).
-    pub proximity: f32,
+    pub proximity: Float,
     /// The normal from the detected collider's surface where the ray hits.
     pub normal: Direction3d,
     /// The velocity of the detected entity,
-    pub entity_linvel: Vec3,
+    pub entity_linvel: Vector3,
     /// The angular velocity of the detected entity, given as the rotation axis multiplied by the
     /// rotation speed in radians per second. Can be extracted from a quaternion using
-    /// [`Quat::xyz`].
-    pub entity_angvel: Vec3,
+    /// [`Quaternion::xyz`].
+    pub entity_angvel: Vector3,
 }
 
 /// Represents a change to velocity (linear or angular)
@@ -129,34 +130,34 @@ pub struct TnuaVelChange {
     //
     // In Rapier, this is applied using `ExternalForce` so that the simulation will apply in
     // smoothly over time and won't be sensitive to frame rate.
-    pub acceleration: Vec3,
+    pub acceleration: Vector3,
     // The part of the velocity change that gets added to the velocity as-is.
     //
     // In Rapier, this is added directly to the `Velocity` component.
-    pub boost: Vec3,
+    pub boost: Vector3,
 }
 
 impl TnuaVelChange {
     pub const ZERO: Self = Self {
-        acceleration: Vec3::ZERO,
-        boost: Vec3::ZERO,
+        acceleration: Vector3::ZERO,
+        boost: Vector3::ZERO,
     };
 
-    pub fn acceleration(acceleration: Vec3) -> Self {
+    pub fn acceleration(acceleration: Vector3) -> Self {
         Self {
             acceleration,
-            boost: Vec3::ZERO,
+            boost: Vector3::ZERO,
         }
     }
 
-    pub fn boost(boost: Vec3) -> Self {
+    pub fn boost(boost: Vector3) -> Self {
         Self {
-            acceleration: Vec3::ZERO,
+            acceleration: Vector3::ZERO,
             boost,
         }
     }
 
-    pub fn cancel_on_axis(&mut self, axis: Vec3) {
+    pub fn cancel_on_axis(&mut self, axis: Vector3) {
         self.acceleration = self.acceleration.reject_from(axis);
         self.boost = self.boost.reject_from(axis);
     }
@@ -201,7 +202,7 @@ pub struct TnuaMotor {
 
     /// How much angular velocity to add to the rigid body in the current frame, given as the
     /// rotation axis multiplied by the rotation speed in radians per second. Can be extracted from
-    /// a quaternion using [`Quat::xyz`].
+    /// a quaternion using [`Quaternion::xyz`].
     pub ang: TnuaVelChange,
 }
 
diff --git a/physics-integration-layer/src/lib.rs b/physics-integration-layer/src/lib.rs
index 0ad2ae3c3..5225208c3 100644
--- a/physics-integration-layer/src/lib.rs
+++ b/physics-integration-layer/src/lib.rs
@@ -51,6 +51,7 @@
 use bevy::prelude::*;
 
 pub mod data_for_backends;
+pub mod math;
 pub mod subservient_sensors;
 
 /// Umbrella system set for [`TnuaPipelineStages`].
diff --git a/physics-integration-layer/src/math.rs b/physics-integration-layer/src/math.rs
new file mode 100644
index 000000000..58ea85470
--- /dev/null
+++ b/physics-integration-layer/src/math.rs
@@ -0,0 +1,154 @@
+#[cfg(feature = "f64")]
+pub type Float = f64;
+#[cfg(not(feature = "f64"))]
+pub type Float = f32;
+
+#[cfg(feature = "f64")]
+use bevy::math::{DQuat, DVec2, DVec3};
+use bevy::math::{Quat, Vec2, Vec3};
+
+#[cfg(feature = "f64")]
+pub type Vector3 = DVec3;
+#[cfg(not(feature = "f64"))]
+pub type Vector3 = Vec3;
+
+#[cfg(feature = "f64")]
+pub type Vector2 = DVec2;
+#[cfg(not(feature = "f64"))]
+pub type Vector2 = Vec2;
+
+#[cfg(feature = "f64")]
+pub type Quaternion = DQuat;
+#[cfg(not(feature = "f64"))]
+pub type Quaternion = Quat;
+
+// Taken from `bevy_xpbd` https://github.com/Jondolf/bevy_xpbd/blob/main/src/math/double.rs#L39
+/// Adjust the precision of the math construct to the precision chosen for compilation.
+pub trait AdjustPrecision {
+    /// A math construct type with the desired precision.
+    type Adjusted;
+    /// Adjusts the precision of [`self`] to [`Self::Adjusted`](#associatedtype.Adjusted).
+    fn adjust_precision(&self) -> Self::Adjusted;
+}
+
+impl AdjustPrecision for f32 {
+    type Adjusted = Float;
+    fn adjust_precision(&self) -> Self::Adjusted {
+        #[cfg(feature = "f64")]
+        return (*self).into();
+        #[cfg(not(feature = "f64"))]
+        return *self;
+    }
+}
+
+#[cfg(feature = "f64")]
+impl AdjustPrecision for f64 {
+    type Adjusted = Float;
+    fn adjust_precision(&self) -> Self::Adjusted {
+        #[cfg(feature = "f64")]
+        return *self;
+        #[cfg(not(feature = "f64"))]
+        return (*self).into();
+    }
+}
+
+impl AdjustPrecision for Vec3 {
+    type Adjusted = Vector3;
+    fn adjust_precision(&self) -> Self::Adjusted {
+        #[cfg(feature = "f64")]
+        return self.as_dvec3();
+        #[cfg(not(feature = "f64"))]
+        return *self;
+    }
+}
+
+#[cfg(feature = "f64")]
+impl AdjustPrecision for DVec3 {
+    type Adjusted = Vector3;
+    fn adjust_precision(&self) -> Self::Adjusted {
+        #[cfg(feature = "f64")]
+        return *self;
+        #[cfg(not(feature = "f64"))]
+        return self.as_vec3();
+    }
+}
+
+impl AdjustPrecision for Quat {
+    type Adjusted = Quaternion;
+    fn adjust_precision(&self) -> Self::Adjusted {
+        #[cfg(feature = "f64")]
+        return self.as_dquat();
+        #[cfg(not(feature = "f64"))]
+        return *self;
+    }
+}
+
+#[cfg(feature = "f64")]
+impl AdjustPrecision for DQuat {
+    type Adjusted = Quaternion;
+    fn adjust_precision(&self) -> Self::Adjusted {
+        #[cfg(feature = "f64")]
+        return *self;
+        #[cfg(not(feature = "f64"))]
+        return self.as_quat();
+    }
+}
+
+impl AdjustPrecision for Vec2 {
+    type Adjusted = Vector2;
+    fn adjust_precision(&self) -> Self::Adjusted {
+        #[cfg(feature = "f64")]
+        return self.as_dvec2();
+        #[cfg(not(feature = "f64"))]
+        return *self;
+    }
+}
+
+#[cfg(feature = "f64")]
+impl AdjustPrecision for DVec2 {
+    type Adjusted = Vector2;
+    fn adjust_precision(&self) -> Self::Adjusted {
+        #[cfg(feature = "f64")]
+        return *self;
+        #[cfg(not(feature = "f64"))]
+        return self.as_vec2();
+    }
+}
+
+/// Adjust the precision down to `f32` regardless of compilation.
+pub trait AsF32 {
+    /// The `f32` version of a math construct.
+    type F32;
+    /// Returns the `f32` version of this type.
+    fn f32(&self) -> Self::F32;
+}
+
+#[cfg(feature = "f64")]
+impl AsF32 for DVec3 {
+    type F32 = Vec3;
+    fn f32(&self) -> Self::F32 {
+        self.as_vec3()
+    }
+}
+
+impl AsF32 for Vec3 {
+    type F32 = Self;
+    fn f32(&self) -> Self::F32 {
+        *self
+    }
+}
+
+#[cfg(feature = "f64")]
+impl AsF32 for DVec2 {
+    type F32 = Vec2;
+    fn f32(&self) -> Self::F32 {
+        self.as_vec2()
+    }
+}
+
+impl AsF32 for Vec2 {
+    type F32 = Self;
+    fn f32(&self) -> Self::F32 {
+        *self
+    }
+}
diff --git a/src/animating_helper.rs b/src/animating_helper.rs
index 218ec9531..ea3d8d0f9 100644
--- a/src/animating_helper.rs
+++ b/src/animating_helper.rs
@@ -16,6 +16,7 @@ use bevy::prelude::*;
 /// # use bevy::prelude::*;
 /// # use bevy_tnua::prelude::*;
 /// # use bevy_tnua::{TnuaAnimatingState, TnuaAnimatingStateDirective};
+/// # use bevy_tnua::math::Float;
 /// # #[derive(Resource)]
 /// # struct AnimationClips {
 /// #     standing: Handle<AnimationClip>,
@@ -23,7 +24,7 @@ use bevy::prelude::*;
 /// # }
 /// enum AnimationState {
 ///     Standing,
-///     Running(f32),
+///     Running(Float),
 /// }
 ///
 /// fn animating_system(
diff --git a/src/basis_action_traits.rs b/src/basis_action_traits.rs
index df1be4439..669f7f605 100644
--- a/src/basis_action_traits.rs
+++ b/src/basis_action_traits.rs
@@ -1,5 +1,6 @@
 use bevy::prelude::*;
 use bevy::time::Stopwatch;
+use bevy_tnua_physics_integration_layer::math::{Float, Vector3};
 
 use std::any::Any;
 
@@ -8,7 +9,7 @@ use crate::{TnuaMotor, TnuaProximitySensor, TnuaRigidBodyTracker};
 /// Various data passed to [`TnuaBasis::apply`].
 pub struct TnuaBasisContext<'a> {
     /// The duration of the current frame.
-    pub frame_duration: f32,
+    pub frame_duration: Float,
 
     /// A sensor that collects data about the rigid body from the physics backend.
     pub tracker: &'a TnuaRigidBodyTracker,
@@ -62,7 +63,7 @@ pub trait TnuaBasis: 'static + Send + Sync {
 
     /// A value to configure the range of the ground proximity sensor according to the basis'
     /// needs.
-    fn proximity_sensor_cast_range(&self, state: &Self::State) -> f32;
+    fn proximity_sensor_cast_range(&self, state: &Self::State) -> Float;
 
     /// The direction the basis considers as "up".
     ///
@@ -72,17 +73,17 @@ pub trait TnuaBasis: 'static + Send + Sync {
     /// The displacement of the character from where the basis wants it to be.
     ///
     /// This is a query method, used by the action to determine what the basis thinks.
-    fn displacement(&self, state: &Self::State) -> Option<Vec3>;
+    fn displacement(&self, state: &Self::State) -> Option<Vector3>;
 
     /// The velocity of the character, relative the what the basis considers its frame of
     /// reference.
     ///
     /// This is a query method, used by the action to determine what the basis thinks.
-    fn effective_velocity(&self, state: &Self::State) -> Vec3;
+    fn effective_velocity(&self, state: &Self::State) -> Vector3;
 
     /// The vertical velocity the character requires to stay the same height if it wants to move in
     /// [`effective_velocity`](Self::effective_velocity).
-    fn vertical_velocity(&self, state: &Self::State) -> f32;
+    fn vertical_velocity(&self, state: &Self::State) -> Float;
 
     /// Nullify the fields of the basis that represent user input.
     fn neutralize(&mut self);
@@ -114,19 +115,19 @@ pub trait DynamicBasis: Send + Sync + Any + 'static {
     fn apply(&mut self, ctx: TnuaBasisContext, motor: &mut TnuaMotor);
 
     /// Dynamically invokes [`TnuaBasis::proximity_sensor_cast_range`].
-    fn proximity_sensor_cast_range(&self) -> f32;
+    fn proximity_sensor_cast_range(&self) -> Float;
 
     /// Dynamically invokes [`TnuaBasis::up_direction`].
     fn up_direction(&self) -> Direction3d;
 
     /// Dynamically invokes [`TnuaBasis::displacement`].
-    fn displacement(&self) -> Option<Vec3>;
+    fn displacement(&self) -> Option<Vector3>;
 
     /// Dynamically invokes [`TnuaBasis::effective_velocity`].
-    fn effective_velocity(&self) -> Vec3;
+    fn effective_velocity(&self) -> Vector3;
 
     /// Dynamically invokes [`TnuaBasis::vertical_velocity`].
-    fn vertical_velocity(&self) -> f32;
+    fn vertical_velocity(&self) -> Float;
 
     /// Dynamically invokes [`TnuaBasis::neutralize`].
     fn neutralize(&mut self);
@@ -165,7 +166,7 @@ impl<B: TnuaBasis> DynamicBasis for BoxableBasis<B> {
         self.input.apply(&mut self.state, ctx, motor);
     }
 
-    fn proximity_sensor_cast_range(&self) -> f32 {
+    fn proximity_sensor_cast_range(&self) -> Float {
         self.input.proximity_sensor_cast_range(&self.state)
     }
 
@@ -173,15 +174,15 @@ impl<B: TnuaBasis> DynamicBasis for BoxableBasis<B> {
         self.input.up_direction(&self.state)
     }
 
-    fn displacement(&self) -> Option<Vec3> {
+    fn displacement(&self) -> Option<Vector3> {
         self.input.displacement(&self.state)
     }
 
-    fn effective_velocity(&self) -> Vec3 {
+    fn effective_velocity(&self) -> Vector3 {
         self.input.effective_velocity(&self.state)
     }
 
-    fn vertical_velocity(&self) -> f32 {
+    fn vertical_velocity(&self) -> Float {
         self.input.vertical_velocity(&self.state)
     }
 
@@ -201,7 +202,7 @@ impl<B: TnuaBasis> DynamicBasis for BoxableBasis<B> {
 /// Various data passed to [`TnuaAction::apply`].
 pub struct TnuaActionContext<'a> {
     /// The duration of the current frame.
-    pub frame_duration: f32,
+    pub frame_duration: Float,
 
     /// A sensor that collects data about the rigid body from the physics backend.
     pub tracker: &'a TnuaRigidBodyTracker,
@@ -266,7 +267,10 @@ impl TnuaActionLifecycleStatus {
     /// Similar to [`directive_simple`](Self::directive_simple), but if some other action gets fed
     /// and this action is still being fed, reschedule this action once the other action finishes,
     /// as long as more time than `after_seconds` has passed.
-    pub fn directive_simple_reschedule(&self, after_seconds: f32) -> TnuaActionLifecycleDirective {
+    pub fn directive_simple_reschedule(
+        &self,
+        after_seconds: Float,
+    ) -> TnuaActionLifecycleDirective {
         match self {
             TnuaActionLifecycleStatus::Initiated => TnuaActionLifecycleDirective::StillActive,
             TnuaActionLifecycleStatus::CancelledFrom => TnuaActionLifecycleDirective::StillActive,
@@ -332,7 +336,7 @@ pub enum TnuaActionLifecycleDirective {
     /// run in the same frame, as long as the first is rescheduled (or [finished](Self::Finished))
     Reschedule {
         /// Only reschedule the action after this much time has passed.
-        after_seconds: f32,
+        after_seconds: Float,
     },
 }
 
@@ -406,7 +410,7 @@ pub trait TnuaAction: 'static + Send + Sync {
 
     /// A value to configure the range of the ground proximity sensor according to the action's
     /// needs.
-    fn proximity_sensor_cast_range(&self) -> f32 {
+    fn proximity_sensor_cast_range(&self) -> Float {
         0.0
     }
 
@@ -436,7 +440,7 @@ pub trait DynamicAction: Send + Sync + Any + 'static {
         lifecycle_status: TnuaActionLifecycleStatus,
         motor: &mut TnuaMotor,
     ) -> TnuaActionLifecycleDirective;
-    fn proximity_sensor_cast_range(&self) -> f32;
+    fn proximity_sensor_cast_range(&self) -> Float;
     fn initiation_decision(
         &self,
         ctx: TnuaActionContext,
@@ -478,7 +482,7 @@ impl<A: TnuaAction> DynamicAction for BoxableAction<A> {
             .apply(&mut self.state, ctx, lifecycle_status, motor)
     }
 
-    fn proximity_sensor_cast_range(&self) -> f32 {
+    fn proximity_sensor_cast_range(&self) -> Float {
         self.input.proximity_sensor_cast_range()
     }
 
diff --git a/src/builtins/crouch.rs b/src/builtins/crouch.rs
index fb75e3c74..2d7cac897 100644
--- a/src/builtins/crouch.rs
+++ b/src/builtins/crouch.rs
@@ -1,4 +1,5 @@
 use bevy::prelude::*;
+use bevy_tnua_physics_integration_layer::math::{AdjustPrecision, Float};
 
 use crate::basis_action_traits::{
     TnuaActionContext, TnuaActionInitiationDirective, TnuaActionLifecycleDirective,
@@ -29,7 +30,7 @@ pub struct TnuaBuiltinCrouch {
     /// This field should typically have a negative value. A positive value will cause the
     /// character to "crouch" upward - which may be an interesting gameplay action, but not
     /// what one would call a "crouch".
-    pub float_offset: f32,
+    pub float_offset: Float,
 
     /// A duration, in seconds, that it should take for the character to change its floating height
     /// to start or stop the crouch.
@@ -38,10 +39,10 @@ pub struct TnuaBuiltinCrouch {
     /// some distance for the
     /// [`spring_dampening`](crate::builtins::TnuaBuiltinWalk::spring_dampening) force to reduce
     /// its vertical velocity.
-    pub height_change_impulse_for_duration: f32,
+    pub height_change_impulse_for_duration: Float,
 
     /// The maximum impulse to apply when starting or stopping the crouch.
-    pub height_change_impulse_limit: f32,
+    pub height_change_impulse_limit: Float,
 
     /// If set to `true`, this action will not yield to other action who try to take control.
     ///
@@ -94,8 +95,9 @@ impl TnuaAction for TnuaBuiltinCrouch {
         let Some(sensor_output) = &ctx.proximity_sensor.output else {
             return TnuaActionLifecycleDirective::Reschedule { after_seconds: 0.0 };
         };
-        let spring_offset_up = walk_basis.float_height - sensor_output.proximity;
-        let spring_offset_down = spring_offset_up + self.float_offset;
+        let spring_offset_up = walk_basis.float_height - sensor_output.proximity.adjust_precision();
+        let spring_offset_down =
+            spring_offset_up.adjust_precision() + self.float_offset.adjust_precision();
 
         match lifecycle_status {
             TnuaActionLifecycleStatus::Initiated => {}
@@ -111,11 +113,11 @@ impl TnuaAction for TnuaBuiltinCrouch {
             }
         }
 
-        let spring_force_boost = |spring_offset: f32| -> f32 {
+        let spring_force_boost = |spring_offset: Float| -> Float {
             walk_basis.spring_force_boost(walk_state, &ctx.as_basis_context(), spring_offset)
         };
 
-        let impulse_or_spring_force_boost = |spring_offset: f32| -> f32 {
+        let impulse_or_spring_force_boost = |spring_offset: Float| -> Float {
             let spring_force_boost = spring_force_boost(spring_offset);
             let impulse_boost = self.impulse_boost(spring_offset);
             if spring_force_boost.abs() < impulse_boost.abs() {
@@ -125,9 +127,10 @@ impl TnuaAction for TnuaBuiltinCrouch {
             }
         };
 
-        let mut set_impulse = |impulse: f32| {
-            motor.lin.cancel_on_axis(*walk_basis.up);
-            motor.lin += TnuaVelChange::boost(impulse * *walk_basis.up);
+        let mut set_impulse = |impulse: Float| {
+            motor.lin.cancel_on_axis(walk_basis.up.adjust_precision());
+            motor.lin +=
+                TnuaVelChange::boost(impulse.adjust_precision() * walk_basis.up.adjust_precision());
         };
 
         match state {
@@ -165,7 +168,7 @@ impl TnuaAction for TnuaBuiltinCrouch {
 }
 
 impl TnuaBuiltinCrouch {
-    fn impulse_boost(&self, spring_offset: f32) -> f32 {
+    fn impulse_boost(&self, spring_offset: Float) -> Float {
         let velocity_to_get_to_new_float_height =
             spring_offset / self.height_change_impulse_for_duration;
         velocity_to_get_to_new_float_height.clamp(
@@ -187,7 +190,7 @@ pub enum TnuaBuiltinCrouchState {
 }
 
 impl TnuaCrouchEnforcedAction for TnuaBuiltinCrouch {
-    fn range_to_cast_up(&self, _state: &Self::State) -> f32 {
+    fn range_to_cast_up(&self, _state: &Self::State) -> Float {
         -self.float_offset
     }
 
diff --git a/src/builtins/dash.rs b/src/builtins/dash.rs
index ff5c6932c..b4d787bd1 100644
--- a/src/builtins/dash.rs
+++ b/src/builtins/dash.rs
@@ -1,4 +1,5 @@
 use bevy::prelude::*;
+use bevy_tnua_physics_integration_layer::math::{AdjustPrecision, Float, Vector3};
 
 use crate::util::ProjectionPlaneForRotation;
 use crate::{
@@ -14,43 +15,43 @@ pub struct TnuaBuiltinDash {
     /// This input parameter is cached when the action starts. This means that the control system
     /// does not have to make sure the direction reamins the same even if the player changes it
     /// mid-dash.
-    pub displacement: Vec3,
+    pub displacement: Vector3,
 
     /// Point the negative Z axis of the characetr model in that direction during the dash.
     ///
     /// This input parameter is cached when the action starts. This means that the control system
     /// does not have to make sure the direction reamins the same even if the player changes it
     /// mid-dash.
-    pub desired_forward: Vec3,
+    pub desired_forward: Vector3,
 
     /// Allow this action to start even if the character is not touching ground nor in coyote time.
     pub allow_in_air: bool,
 
     /// The speed the character will move in during the dash.
-    pub speed: f32,
+    pub speed: Float,
 
     /// After the dash, the character will brake until its speed is below that number.
-    pub brake_to_speed: f32,
+    pub brake_to_speed: Float,
 
     /// The maximum acceleration when starting the jump.
-    pub acceleration: f32,
+    pub acceleration: Float,
 
     /// The maximum acceleration when braking after the jump.
     ///
     /// Irrelevant if [`brake_to_speed`](Self::brake_to_speed) is set to infinity.
-    pub brake_acceleration: f32,
+    pub brake_acceleration: Float,
 
     /// A duration, in seconds, where a player can press a dash button before a dash becomes
     /// possible (typically when a character is still in the air and about the land) and the dash
     /// action would still get registered and be executed once the dash is possible.
-    pub input_buffer_time: f32,
+    pub input_buffer_time: Float,
 }
 
 impl Default for TnuaBuiltinDash {
     fn default() -> Self {
         Self {
-            displacement: Vec3::ZERO,
-            desired_forward: Vec3::ZERO,
+            displacement: Vector3::ZERO,
+            desired_forward: Vector3::ZERO,
             allow_in_air: false,
             speed: 80.0,
             brake_to_speed: 20.0,
@@ -71,12 +72,12 @@ impl TnuaAction for TnuaBuiltinDash {
         ctx: crate::TnuaActionContext,
         being_fed_for: &bevy::time::Stopwatch,
     ) -> crate::TnuaActionInitiationDirective {
-        if !self.displacement.is_finite() || self.displacement == Vec3::ZERO {
+        if !self.displacement.is_finite() || self.displacement == Vector3::ZERO {
             TnuaActionInitiationDirective::Reject
         } else if self.allow_in_air || !ctx.basis.is_airborne() {
             // Either not airborne, or air jumps are allowed
             TnuaActionInitiationDirective::Allow
-        } else if being_fed_for.elapsed().as_secs_f32() < self.input_buffer_time {
+        } else if (being_fed_for.elapsed().as_secs_f64() as Float) < self.input_buffer_time {
             TnuaActionInitiationDirective::Delay
         } else {
             TnuaActionInitiationDirective::Reject
@@ -95,14 +96,14 @@ impl TnuaAction for TnuaBuiltinDash {
             return match state {
                 TnuaBuiltinDashState::PreDash => {
                     // Probably unneeded because of the `initiation_decision`, but still
-                    if !self.displacement.is_finite() || self.displacement == Vec3::ZERO {
+                    if !self.displacement.is_finite() || self.displacement == Vector3::ZERO {
                         return TnuaActionLifecycleDirective::Finished;
                     }
                     *state = TnuaBuiltinDashState::During {
                         direction: self.displacement.normalize(),
                         destination: ctx.tracker.translation + self.displacement,
                         desired_forward: self.desired_forward,
-                        consider_blocked_if_speed_is_less_than: f32::NEG_INFINITY,
+                        consider_blocked_if_speed_is_less_than: Float::NEG_INFINITY,
                     };
                     continue;
                 }
@@ -141,14 +142,15 @@ impl TnuaAction for TnuaBuiltinDash {
                         let up = ctx.basis.up_direction();
                         let projection =
                             ProjectionPlaneForRotation::from_up_using_default_forward(up);
+                        let up = up.adjust_precision();
                         let current_forward = ctx.tracker.rotation.mul_vec3(projection.forward);
                         let rotation_along_up_axis = projection
                             .rotation_to_set_forward(current_forward, self.desired_forward);
                         let desired_angvel = rotation_along_up_axis / ctx.frame_duration;
-                        let existing_angvel = ctx.tracker.angvel.dot(*up);
+                        let existing_angvel = ctx.tracker.angvel.dot(up);
                         let torque_to_turn = desired_angvel - existing_angvel;
-                        motor.ang.cancel_on_axis(*up);
-                        motor.ang.boost += torque_to_turn * *up;
+                        motor.ang.cancel_on_axis(up);
+                        motor.ang.boost += torque_to_turn * up;
                     }
 
                     TnuaActionLifecycleDirective::StillActive
@@ -175,12 +177,12 @@ pub enum TnuaBuiltinDashState {
     #[default]
     PreDash,
     During {
-        direction: Vec3,
-        destination: Vec3,
-        desired_forward: Vec3,
-        consider_blocked_if_speed_is_less_than: f32,
+        direction: Vector3,
+        destination: Vector3,
+        desired_forward: Vector3,
+        consider_blocked_if_speed_is_less_than: Float,
     },
     Braking {
-        direction: Vec3,
+        direction: Vector3,
     },
 }
diff --git a/src/builtins/jump.rs b/src/builtins/jump.rs
index 136e0874f..8180645af 100644
--- a/src/builtins/jump.rs
+++ b/src/builtins/jump.rs
@@ -1,4 +1,5 @@
 use bevy::prelude::*;
+use bevy_tnua_physics_integration_layer::math::{AdjustPrecision, Float, Vector3};
 
 use crate::basis_action_traits::{
     TnuaAction, TnuaActionContext, TnuaActionInitiationDirective, TnuaActionLifecycleDirective,
@@ -28,7 +29,7 @@ pub struct TnuaBuiltinJump {
     /// center of the character at the top of the jump. It _does not_ mean the height from the
     /// ground. The float height is calculated by the inspecting the character's current position
     /// and the basis' [`displacement`](crate::TnuaBasis::displacement).
-    pub height: f32,
+    pub height: Float,
 
     /// Allow this action to start even if the character is not touching ground nor in coyote time.
     pub allow_in_air: bool,
@@ -39,7 +40,7 @@ pub struct TnuaBuiltinJump {
     /// slope. This may cause the jump to be too high, so this value is used to brake it.
     ///
     /// **NOTE**: This force will be added to the normal gravity.
-    pub upslope_extra_gravity: f32,
+    pub upslope_extra_gravity: Float,
 
     /// Extra gravity for fast takeoff.
     ///
@@ -47,23 +48,23 @@ pub struct TnuaBuiltinJump {
     /// vertical velocity reaches below [`takeoff_above_velocity`](Self::takeoff_above_velocity),
     /// and increase the initial jump boost in order to compensate. This will make the jump feel
     /// more snappy.
-    pub takeoff_extra_gravity: f32,
+    pub takeoff_extra_gravity: Float,
 
     /// The range of upward velocity during [`takeoff_extra_gravity`](Self::takeoff_extra_gravity)
     /// is applied.
     ///
-    /// To disable, set this to [`f32::INFINITY`] rather than zero.
-    pub takeoff_above_velocity: f32,
+    /// To disable, set this to [`Float::INFINITY`] rather than zero.
+    pub takeoff_above_velocity: Float,
 
     /// Extra gravity for falling down after reaching the top of the jump.
     ///
     /// **NOTE**: This force will be added to the normal gravity.
-    pub fall_extra_gravity: f32,
+    pub fall_extra_gravity: Float,
 
     /// Extra gravity for shortening a jump when the player releases the jump button.
     ///
     /// **NOTE**: This force will be added to the normal gravity.
-    pub shorten_extra_gravity: f32,
+    pub shorten_extra_gravity: Float,
 
     /// Used to decrease the time the character spends "floating" at the peak of the jump.
     ///
@@ -73,12 +74,12 @@ pub struct TnuaBuiltinJump {
     ///
     /// This extra gravity is taken into account when calculating the initial jump speed, so the
     /// character is still supposed to reach its full jump [`height`](Self::height).
-    pub peak_prevention_at_upward_velocity: f32,
+    pub peak_prevention_at_upward_velocity: Float,
 
     /// Extra gravity for decreasing the time the character spends at the peak of the jump.
     ///
     /// **NOTE**: This force will be added to the normal gravity.
-    pub peak_prevention_extra_gravity: f32,
+    pub peak_prevention_extra_gravity: Float,
 
     /// A duration, in seconds, after which the character would jump if the jump button was already
     /// pressed when the jump became available.
@@ -92,12 +93,12 @@ pub struct TnuaBuiltinJump {
     /// If the jump button is held but the jump input is still buffered (see
     /// [`input_buffer_time`](Self::input_buffer_time)), this setting will have no effect because
     /// the character will simply jump immediately.
-    pub reschedule_cooldown: Option<f32>,
+    pub reschedule_cooldown: Option<Float>,
 
     /// A duration, in seconds, where a player can press a jump button before a jump becomes
     /// possible (typically when a character is still in the air and about the land) and the jump
     /// action would still get registered and be executed once the jump is possible.
-    pub input_buffer_time: f32,
+    pub input_buffer_time: Float,
 }
 
 impl Default for TnuaBuiltinJump {
@@ -131,7 +132,7 @@ impl TnuaAction for TnuaBuiltinJump {
         if self.allow_in_air || !ctx.basis.is_airborne() {
             // Either not airborne, or air jumps are allowed
             TnuaActionInitiationDirective::Allow
-        } else if being_fed_for.elapsed().as_secs_f32() < self.input_buffer_time {
+        } else if (being_fed_for.elapsed().as_secs_f64() as Float) < self.input_buffer_time {
             TnuaActionInitiationDirective::Delay
         } else {
             TnuaActionInitiationDirective::Reject
@@ -145,18 +146,18 @@ impl TnuaAction for TnuaBuiltinJump {
         lifecycle_status: TnuaActionLifecycleStatus,
         motor: &mut crate::TnuaMotor,
     ) -> TnuaActionLifecycleDirective {
-        let up = ctx.basis.up_direction();
+        let up = ctx.basis.up_direction().adjust_precision();
 
         if lifecycle_status.just_started() {
             let mut calculator = SegmentedJumpInitialVelocityCalculator::new(self.height);
-            let gravity = ctx.tracker.gravity.dot(*-up);
+            let gravity = ctx.tracker.gravity.dot(-up);
             let kinetic_energy = calculator
                 .add_segment(
                     gravity + self.peak_prevention_extra_gravity,
                     self.peak_prevention_at_upward_velocity,
                 )
                 .add_segment(gravity, self.takeoff_above_velocity)
-                .add_segment(gravity + self.takeoff_extra_gravity, f32::INFINITY)
+                .add_segment(gravity + self.takeoff_extra_gravity, Float::INFINITY)
                 .kinetic_energy();
             *state = TnuaBuiltinJumpState::StartingJump {
                 desired_energy: kinetic_energy,
@@ -172,27 +173,27 @@ impl TnuaAction for TnuaBuiltinJump {
                 TnuaBuiltinJumpState::NoJump => panic!(),
                 TnuaBuiltinJumpState::StartingJump { desired_energy } => {
                     let extra_height = if let Some(displacement) = ctx.basis.displacement() {
-                        displacement.dot(*up)
+                        displacement.dot(up)
                     } else if !self.allow_in_air && ctx.basis.is_airborne() {
                         return self.directive_simple_or_reschedule(lifecycle_status);
                     } else {
                         // This means we are at Coyote time, so just jump from place.
                         0.0
                     };
-                    let gravity = ctx.tracker.gravity.dot(*-up);
+                    let gravity = ctx.tracker.gravity.dot(-up);
                     let energy_from_extra_height = extra_height * gravity;
                     let desired_kinetic_energy = *desired_energy - energy_from_extra_height;
                     let desired_upward_velocity = (2.0 * desired_kinetic_energy).sqrt();
 
                     let relative_velocity =
-                        effective_velocity.dot(*up) - ctx.basis.vertical_velocity().max(0.0);
+                        effective_velocity.dot(up) - ctx.basis.vertical_velocity().max(0.0);
 
-                    motor.lin.cancel_on_axis(*up);
-                    motor.lin.boost += (desired_upward_velocity - relative_velocity) * *up;
+                    motor.lin.cancel_on_axis(up);
+                    motor.lin.boost += (desired_upward_velocity - relative_velocity) * up;
                     if 0.0 <= extra_height {
                         *state = TnuaBuiltinJumpState::SlowDownTooFastSlopeJump {
                             desired_energy: *desired_energy,
-                            zero_potential_energy_at: ctx.tracker.translation - extra_height * *up,
+                            zero_potential_energy_at: ctx.tracker.translation - extra_height * up,
                         };
                     }
                     self.directive_simple_or_reschedule(lifecycle_status)
@@ -209,10 +210,10 @@ impl TnuaAction for TnuaBuiltinJump {
                         *state = TnuaBuiltinJumpState::StoppedMaintainingJump;
                         continue;
                     }
-                    let relative_velocity = effective_velocity.dot(*up);
+                    let relative_velocity = effective_velocity.dot(up);
                     let extra_height =
-                        (ctx.tracker.translation - *zero_potential_energy_at).dot(*up);
-                    let gravity = ctx.tracker.gravity.dot(*-up);
+                        (ctx.tracker.translation - *zero_potential_energy_at).dot(up);
+                    let gravity = ctx.tracker.gravity.dot(-up);
                     let energy_from_extra_height = extra_height * gravity;
                     let desired_kinetic_energy = *desired_energy - energy_from_extra_height;
                     let desired_upward_velocity = (2.0 * desired_kinetic_energy).sqrt();
@@ -224,22 +225,22 @@ impl TnuaAction for TnuaBuiltinJump {
                         if self.takeoff_above_velocity <= relative_velocity {
                             extra_gravity += self.takeoff_extra_gravity;
                         }
-                        motor.lin.cancel_on_axis(*up);
-                        motor.lin.acceleration = -extra_gravity * *up;
+                        motor.lin.cancel_on_axis(up);
+                        motor.lin.acceleration = -extra_gravity * up;
                         self.directive_simple_or_reschedule(lifecycle_status)
                     }
                 }
                 TnuaBuiltinJumpState::MaintainingJump => {
-                    let relevant_upward_velocity = effective_velocity.dot(*up);
+                    let relevant_upward_velocity = effective_velocity.dot(up);
                     if relevant_upward_velocity <= 0.0 {
                         *state = TnuaBuiltinJumpState::FallSection;
-                        motor.lin.cancel_on_axis(*up);
+                        motor.lin.cancel_on_axis(up);
                     } else {
-                        motor.lin.cancel_on_axis(*up);
+                        motor.lin.cancel_on_axis(up);
                         if relevant_upward_velocity < self.peak_prevention_at_upward_velocity {
-                            motor.lin.acceleration -= self.peak_prevention_extra_gravity * *up;
+                            motor.lin.acceleration -= self.peak_prevention_extra_gravity * up;
                         } else if self.takeoff_above_velocity <= relevant_upward_velocity {
-                            motor.lin.acceleration -= self.takeoff_extra_gravity * *up;
+                            motor.lin.acceleration -= self.takeoff_extra_gravity * up;
                         }
                     }
                     match lifecycle_status {
@@ -262,7 +263,7 @@ impl TnuaAction for TnuaBuiltinJump {
                         let landed = ctx
                             .basis
                             .displacement()
-                            .map_or(false, |displacement| displacement.dot(*up) <= 0.0);
+                            .map_or(false, |displacement| displacement.dot(up) <= 0.0);
                         if landed {
                             self.finish_or_reschedule()
                         } else {
@@ -278,8 +279,8 @@ impl TnuaAction for TnuaBuiltinJump {
                                 self.shorten_extra_gravity
                             };
 
-                            motor.lin.cancel_on_axis(*up);
-                            motor.lin.acceleration -= extra_gravity * *up;
+                            motor.lin.cancel_on_axis(up);
+                            motor.lin.acceleration -= extra_gravity * up;
                             TnuaActionLifecycleDirective::StillActive
                         }
                     }
@@ -288,14 +289,14 @@ impl TnuaAction for TnuaBuiltinJump {
                     let landed = ctx
                         .basis
                         .displacement()
-                        .map_or(false, |displacement| displacement.dot(*up) <= 0.0);
+                        .map_or(false, |displacement| displacement.dot(up) <= 0.0);
                     if landed
                         || matches!(lifecycle_status, TnuaActionLifecycleStatus::CancelledInto)
                     {
                         self.finish_or_reschedule()
                     } else {
-                        motor.lin.cancel_on_axis(*up);
-                        motor.lin.acceleration -= self.fall_extra_gravity * *up;
+                        motor.lin.cancel_on_axis(up);
+                        motor.lin.acceleration -= self.fall_extra_gravity * up;
                         TnuaActionLifecycleDirective::StillActive
                     }
                 }
@@ -340,11 +341,11 @@ pub enum TnuaBuiltinJumpState {
         /// * The mass is 1
         /// Calculating the desired velocity based on energy is easier than using the ballistic
         /// formulas.
-        desired_energy: f32,
+        desired_energy: Float,
     },
     SlowDownTooFastSlopeJump {
-        desired_energy: f32,
-        zero_potential_energy_at: Vec3,
+        desired_energy: Float,
+        zero_potential_energy_at: Vector3,
     },
     MaintainingJump,
     StoppedMaintainingJump,
diff --git a/src/builtins/walk.rs b/src/builtins/walk.rs
index c26b3d812..117b96cb4 100644
--- a/src/builtins/walk.rs
+++ b/src/builtins/walk.rs
@@ -1,6 +1,7 @@
 use std::time::Duration;
 
 use bevy::prelude::*;
+use bevy_tnua_physics_integration_layer::math::{AdjustPrecision, Float, Quaternion, Vector3};
 
 use crate::basis_action_traits::TnuaBasisContext;
 use crate::util::ProjectionPlaneForRotation;
@@ -16,19 +17,19 @@ use crate::{TnuaBasis, TnuaVelChange};
 ///   will not float. Set it to be higher than the distance from the center of the entity to the
 ///   bottom of the collider.
 /// * [`desired_velocity`](Self::desired_velocity) - while leaving this as as the default
-///   `Vec3::ZERO`, doing so would mean that the character will not move.
-/// * [`desired_forward`](Self::desired_forward) - leaving this is the default `Vec3::ZERO` will
+///   `Vector3::ZERO`, doing so would mean that the character will not move.
+/// * [`desired_forward`](Self::desired_forward) - leaving this is the default `Vector3::ZERO` will
 ///   mean that Tnua will not attempt to fix the character's rotation along the [up](Self::up)
 ///   axis.
 ///
 ///   This is fine if rotation along the up axis is locked (Rapier only supports locking cardinal
-///   axes, but [`up`](Self::up) defaults to `Vec3::Y` which fits the bill).
+///   axes, but [`up`](Self::up) defaults to `Vector3::Y` which fits the bill).
 ///
 ///   This is also fine for 2D games (or games with 3D graphics and 2D physics) played from side
 ///   view where the physics engine cannot rotate the character along the up axis.
 ///
 ///   But if the physics engine is free to rotate the character's rigid body along the up axis,
-///   leaving `desired_forward` as the default `Vec3::ZERO` may cause the character to spin
+///   leaving `desired_forward` as the default `Vector3::ZERO` may cause the character to spin
 ///   uncontrollably when it contacts other colliders. Unless, of course, some other mechanism
 ///   prevents that.
 #[derive(Clone)]
@@ -36,13 +37,13 @@ pub struct TnuaBuiltinWalk {
     /// The direction (in the world space) and speed to accelerate to.
     ///
     /// Tnua assumes that this vector is orthogonal to the [`up`](Self::up) vector.
-    pub desired_velocity: Vec3,
+    pub desired_velocity: Vector3,
 
     /// If non-zero, Tnua will rotate the character so that its negative Z will face in that
     /// direction.
     ///
     /// Tnua assumes that this vector is orthogonal to the [`up`](Self::up) vector.
-    pub desired_forward: Vec3,
+    pub desired_forward: Vector3,
 
     /// The height at which the character will float above ground at rest.
     ///
@@ -51,7 +52,7 @@ pub struct TnuaBuiltinWalk {
     ///
     /// To make a character crouch, instead of altering this field, prefer to use the
     /// [`TnuaBuiltinCrouch`](crate::builtins::TnuaBuiltinCrouch) action.
-    pub float_height: f32,
+    pub float_height: Float,
 
     /// Extra distance above the `float_height` where the spring is still in effect.
     ///
@@ -59,18 +60,18 @@ pub struct TnuaBuiltinWalk {
     /// [`float_height`](Self::float_height), the spring force will kick in and move it to the
     /// float height - even if that means pushing it down. If the character is above that distance
     /// above the `float_height`, Tnua will consider it to be in the air.
-    pub cling_distance: f32,
+    pub cling_distance: Float,
 
     /// The direction considered as upward.
     ///
-    /// Typically `Vec3::Y`.
+    /// Typically `Vector3::Y`.
     pub up: Direction3d,
 
     /// The force that pushes the character to the float height.
     ///
     /// The actual force applied is in direct linear relationship to the displacement from the
     /// `float_height`.
-    pub spring_strengh: f32,
+    pub spring_strengh: Float,
 
     /// A force that slows down the characters vertical spring motion.
     ///
@@ -79,22 +80,22 @@ pub struct TnuaBuiltinWalk {
     ///
     /// Note that as this approaches 2.0, the character starts to shake violently and eventually
     /// get launched upward at great speed.
-    pub spring_dampening: f32,
+    pub spring_dampening: Float,
 
     /// The acceleration for horizontal movement.
     ///
     /// Note that this is the acceleration for starting the horizontal motion and for reaching the
     /// top speed. When braking or changing direction the acceleration is greater, up to 2 times
     /// `acceleration` when doing a 180 turn.
-    pub acceleration: f32,
+    pub acceleration: Float,
 
     /// The acceleration for horizontal movement while in the air.
     ///
     /// Set to 0.0 to completely disable air movement.
-    pub air_acceleration: f32,
+    pub air_acceleration: Float,
 
     /// The time, in seconds, the character can still jump after losing their footing.
-    pub coyote_time: f32,
+    pub coyote_time: Float,
 
     /// Extra gravity for free fall (fall that's not initiated by a jump or some other action that
     /// provides its own fall gravity)
@@ -104,29 +105,29 @@ pub struct TnuaBuiltinWalk {
     /// **NOTE**: If the parameter set to this option is too low, the character may be able to run
     /// up a slope and "jump" potentially even higher than a regular jump, even without pressing
     /// the jump button.
-    pub free_fall_extra_gravity: f32,
+    pub free_fall_extra_gravity: Float,
 
     /// The maximum angular velocity used for keeping the character standing upright.
     ///
     /// NOTE: The character's rotation can also be locked to prevent it from being tilted, in which
     /// case this paramter is redundant and can be set to 0.0.
-    pub tilt_offset_angvel: f32,
+    pub tilt_offset_angvel: Float,
 
     /// The maximum angular acceleration used for reaching `tilt_offset_angvel`.
     ///
     /// NOTE: The character's rotation can also be locked to prevent it from being tilted, in which
     /// case this paramter is redundant and can be set to 0.0.
-    pub tilt_offset_angacl: f32,
+    pub tilt_offset_angacl: Float,
 
     /// The maximum angular velocity used for turning the character when the direction changes.
-    pub turning_angvel: f32,
+    pub turning_angvel: Float,
 }
 
 impl Default for TnuaBuiltinWalk {
     fn default() -> Self {
         Self {
-            desired_velocity: Vec3::ZERO,
-            desired_forward: Vec3::ZERO,
+            desired_velocity: Vector3::ZERO,
+            desired_forward: Vector3::ZERO,
             float_height: 0.0,
             cling_distance: 1.0,
             up: Direction3d::Y,
@@ -149,40 +150,41 @@ impl TnuaBasis for TnuaBuiltinWalk {
 
     fn apply(&self, state: &mut Self::State, ctx: TnuaBasisContext, motor: &mut crate::TnuaMotor) {
         if let Some(stopwatch) = &mut state.airborne_timer {
-            stopwatch.tick(Duration::from_secs_f32(ctx.frame_duration));
+            stopwatch.tick(Duration::from_secs_f64(ctx.frame_duration as f64));
         }
 
         let climb_vectors: Option<ClimbVectors>;
         let considered_in_air: bool;
-        let impulse_to_offset: Vec3;
+        let impulse_to_offset: Vector3;
 
         if let Some(sensor_output) = &ctx.proximity_sensor.output {
             state.effective_velocity = ctx.tracker.velocity - sensor_output.entity_linvel;
-            let sideways_unnormalized = sensor_output.normal.cross(*self.up);
-            if sideways_unnormalized == Vec3::ZERO {
+            let sideways_unnormalized = sensor_output.normal.cross(*self.up).adjust_precision();
+            if sideways_unnormalized == Vector3::ZERO {
                 climb_vectors = None;
             } else {
                 climb_vectors = Some(ClimbVectors {
                     direction: sideways_unnormalized
-                        .cross(*sensor_output.normal)
-                        .normalize_or_zero(),
-                    sideways: sideways_unnormalized.normalize_or_zero(),
+                        .cross(sensor_output.normal.adjust_precision())
+                        .normalize_or_zero()
+                        .adjust_precision(),
+                    sideways: sideways_unnormalized.normalize_or_zero().adjust_precision(),
                 });
             }
             considered_in_air = state.airborne_timer.is_some();
             if considered_in_air {
-                impulse_to_offset = Vec3::ZERO;
+                impulse_to_offset = Vector3::ZERO;
                 state.standing_on = None;
             } else {
                 if let Some(standing_on_state) = &state.standing_on {
                     if standing_on_state.entity != sensor_output.entity {
-                        impulse_to_offset = Vec3::ZERO;
+                        impulse_to_offset = Vector3::ZERO;
                     } else {
                         impulse_to_offset =
                             sensor_output.entity_linvel - standing_on_state.entity_linvel;
                     }
                 } else {
-                    impulse_to_offset = Vec3::ZERO;
+                    impulse_to_offset = Vector3::ZERO;
                 }
                 state.standing_on = Some(StandingOnState {
                     entity: sensor_output.entity,
@@ -193,12 +195,14 @@ impl TnuaBasis for TnuaBuiltinWalk {
             state.effective_velocity = ctx.tracker.velocity;
             climb_vectors = None;
             considered_in_air = true;
-            impulse_to_offset = Vec3::ZERO;
+            impulse_to_offset = Vector3::ZERO;
             state.standing_on = None;
         }
         state.effective_velocity += impulse_to_offset;
 
-        let velocity_on_plane = state.effective_velocity.reject_from(*self.up);
+        let velocity_on_plane = state
+            .effective_velocity
+            .reject_from(self.up.adjust_precision());
 
         let desired_boost = self.desired_velocity - velocity_on_plane;
 
@@ -215,7 +219,7 @@ impl TnuaBasis for TnuaBuiltinWalk {
         };
         let max_acceleration = direction_change_factor * relevant_acceleration_limit;
 
-        let walk_vel_change = if self.desired_velocity == Vec3::ZERO {
+        let walk_vel_change = if self.desired_velocity == Vector3::ZERO {
             // When stopping, prefer a boost to be able to reach a precise stop (see issue #39)
             let walk_boost = desired_boost.clamp_length_max(ctx.frame_duration * max_acceleration);
             let walk_boost = if let Some(climb_vectors) = &climb_vectors {
@@ -239,37 +243,43 @@ impl TnuaBasis for TnuaBuiltinWalk {
 
         state.vertical_velocity = if let Some(climb_vectors) = &climb_vectors {
             state.effective_velocity.dot(climb_vectors.direction)
-                * climb_vectors.direction.dot(*self.up)
+                * climb_vectors.direction.dot(self.up.adjust_precision())
         } else {
             0.0
         };
 
         let upward_impulse: TnuaVelChange = 'upward_impulse: {
             for _ in 0..2 {
+                #[allow(clippy::unnecessary_cast)]
                 match &mut state.airborne_timer {
                     None => {
                         if let Some(sensor_output) = &ctx.proximity_sensor.output {
                             // not doing the jump calculation here
-                            let spring_offset = self.float_height - sensor_output.proximity;
+                            let spring_offset =
+                                self.float_height - sensor_output.proximity.adjust_precision();
                             state.standing_offset = -spring_offset;
                             let boost = self.spring_force_boost(state, &ctx, spring_offset);
-                            break 'upward_impulse TnuaVelChange::boost(boost * *self.up);
+                            break 'upward_impulse TnuaVelChange::boost(
+                                boost * self.up.adjust_precision(),
+                            );
                         } else {
-                            state.airborne_timer =
-                                Some(Timer::from_seconds(self.coyote_time, TimerMode::Once));
+                            state.airborne_timer = Some(Timer::from_seconds(
+                                self.coyote_time as f32,
+                                TimerMode::Once,
+                            ));
                             continue;
                         }
                     }
                     Some(_) => {
                         if let Some(sensor_output) = &ctx.proximity_sensor.output {
-                            if sensor_output.proximity <= self.float_height {
+                            if sensor_output.proximity.adjust_precision() <= self.float_height {
                                 state.airborne_timer = None;
                                 continue;
                             }
                         }
                         if state.vertical_velocity <= 0.0 {
                             break 'upward_impulse TnuaVelChange::acceleration(
-                                -self.free_fall_extra_gravity * *self.up,
+                                -self.free_fall_extra_gravity * self.up.adjust_precision(),
                             );
                         } else {
                             break 'upward_impulse TnuaVelChange::ZERO;
@@ -285,14 +295,15 @@ impl TnuaBasis for TnuaBuiltinWalk {
             + motor.lin.boost
             + ctx.frame_duration * motor.lin.acceleration
             - impulse_to_offset;
-        state.running_velocity = new_velocity.reject_from(*self.up);
+        state.running_velocity = new_velocity.reject_from(self.up.adjust_precision());
 
         // Tilt
 
         let torque_to_fix_tilt = {
-            let tilted_up = ctx.tracker.rotation.mul_vec3(*self.up);
+            let tilted_up = ctx.tracker.rotation.mul_vec3(self.up.adjust_precision());
 
-            let rotation_required_to_fix_tilt = Quat::from_rotation_arc(tilted_up, *self.up);
+            let rotation_required_to_fix_tilt =
+                Quaternion::from_rotation_arc(tilted_up, self.up.adjust_precision());
 
             let desired_angvel = (rotation_required_to_fix_tilt.xyz() / ctx.frame_duration)
                 .clamp_length_max(self.tilt_offset_angvel);
@@ -314,19 +325,20 @@ impl TnuaBasis for TnuaBuiltinWalk {
         };
 
         // NOTE: This is the regular axis system so we used the configured up.
-        let existing_angvel = ctx.tracker.angvel.dot(*self.up);
+        let existing_angvel = ctx.tracker.angvel.dot(self.up.adjust_precision());
 
         // This is the torque. Should it be clamped by an acceleration? From experimenting with
         // this I think it's meaningless and only causes bugs.
         let torque_to_turn = desired_angvel - existing_angvel;
 
-        let existing_turn_torque = torque_to_fix_tilt.dot(*self.up);
+        let existing_turn_torque = torque_to_fix_tilt.dot(self.up.adjust_precision());
         let torque_to_turn = torque_to_turn - existing_turn_torque;
 
-        motor.ang = TnuaVelChange::boost(torque_to_fix_tilt + torque_to_turn * *self.up);
+        motor.ang =
+            TnuaVelChange::boost(torque_to_fix_tilt + torque_to_turn * self.up.adjust_precision());
     }
 
-    fn proximity_sensor_cast_range(&self, _state: &Self::State) -> f32 {
+    fn proximity_sensor_cast_range(&self, _state: &Self::State) -> Float {
         self.float_height + self.cling_distance
     }
 
@@ -334,24 +346,24 @@ impl TnuaBasis for TnuaBuiltinWalk {
         self.up
     }
 
-    fn displacement(&self, state: &Self::State) -> Option<Vec3> {
+    fn displacement(&self, state: &Self::State) -> Option<Vector3> {
         match state.airborne_timer {
-            None => Some(self.up * state.standing_offset),
+            None => Some(self.up.adjust_precision() * state.standing_offset),
             Some(_) => None,
         }
     }
 
-    fn effective_velocity(&self, state: &Self::State) -> Vec3 {
+    fn effective_velocity(&self, state: &Self::State) -> Vector3 {
         state.effective_velocity
     }
 
-    fn vertical_velocity(&self, state: &Self::State) -> f32 {
+    fn vertical_velocity(&self, state: &Self::State) -> Float {
         state.vertical_velocity
     }
 
     fn neutralize(&mut self) {
-        self.desired_velocity = Vec3::ZERO;
-        self.desired_forward = Vec3::ZERO;
+        self.desired_velocity = Vector3::ZERO;
+        self.desired_forward = Vector3::ZERO;
     }
 
     fn is_airborne(&self, state: &Self::State) -> bool {
@@ -383,16 +395,17 @@ impl TnuaBuiltinWalk {
         &self,
         state: &TnuaBuiltinWalkState,
         ctx: &TnuaBasisContext,
-        spring_offset: f32,
-    ) -> f32 {
-        let spring_force: f32 = spring_offset * self.spring_strengh;
+        spring_offset: Float,
+    ) -> Float {
+        let spring_force: Float = spring_offset * self.spring_strengh;
 
-        let relative_velocity = state.effective_velocity.dot(*self.up) - state.vertical_velocity;
+        let relative_velocity =
+            state.effective_velocity.dot(self.up.adjust_precision()) - state.vertical_velocity;
 
         let dampening_force = relative_velocity * self.spring_dampening / ctx.frame_duration;
         let spring_force = spring_force - dampening_force;
 
-        let gravity_compensation = -ctx.tracker.gravity.dot(*self.up);
+        let gravity_compensation = -ctx.tracker.gravity.dot(self.up.adjust_precision());
 
         ctx.frame_duration * (spring_force + gravity_compensation)
     }
@@ -401,24 +414,24 @@ impl TnuaBuiltinWalk {
 #[derive(Debug)]
 struct StandingOnState {
     entity: Entity,
-    entity_linvel: Vec3,
+    entity_linvel: Vector3,
 }
 
 #[derive(Default)]
 pub struct TnuaBuiltinWalkState {
     airborne_timer: Option<Timer>,
     /// The current vertical distance of the character from the distance its supposed to float at.
-    pub standing_offset: f32,
+    pub standing_offset: Float,
     standing_on: Option<StandingOnState>,
-    effective_velocity: Vec3,
-    vertical_velocity: f32,
+    effective_velocity: Vector3,
+    vertical_velocity: Float,
     /// The velocity, perpendicular to the [up](TnuaBuiltinWalk::up) axis, that the character is
     /// supposed to move at.
     ///
     /// If the character is standing on something else
     /// ([`standing_on_entity`](Self::standing_on_entity) returns `Some`) then the
     /// `running_velocity` will be relative to the velocity of that entity.
-    pub running_velocity: Vec3,
+    pub running_velocity: Vector3,
 }
 
 impl TnuaBuiltinWalkState {
@@ -429,12 +442,12 @@ impl TnuaBuiltinWalkState {
 }
 
 struct ClimbVectors {
-    direction: Vec3,
-    sideways: Vec3,
+    direction: Vector3,
+    sideways: Vector3,
 }
 
 impl ClimbVectors {
-    fn project(&self, vector: Vec3) -> Vec3 {
+    fn project(&self, vector: Vector3) -> Vector3 {
         let axis_direction = vector.dot(self.direction) * self.direction;
         let axis_sideways = vector.dot(self.sideways) * self.sideways;
         axis_direction + axis_sideways
diff --git a/src/control_helpers/crouch_enforcer.rs b/src/control_helpers/crouch_enforcer.rs
index 92bb98a80..407d9fed3 100644
--- a/src/control_helpers/crouch_enforcer.rs
+++ b/src/control_helpers/crouch_enforcer.rs
@@ -2,6 +2,7 @@ use std::any::Any;
 
 use bevy::ecs::system::EntityCommands;
 use bevy::prelude::*;
+use bevy_tnua_physics_integration_layer::math::{Float, Vector3};
 
 use crate::controller::TnuaController;
 use crate::subservient_sensors::TnuaSubservientSensor;
@@ -46,7 +47,7 @@ impl Plugin for TnuaCrouchEnforcerPlugin {
 #[derive(Component)]
 pub struct TnuaCrouchEnforcer {
     sensor_entity: Option<Entity>,
-    offset: Vec3,
+    offset: Vector3,
     modify_sensor: Box<dyn Send + Sync + Fn(&mut EntityCommands)>,
     enforced_action: Option<(Box<dyn DynamicCrouchEnforcedAction>, bool)>,
     currently_enforcing: bool,
@@ -65,7 +66,7 @@ impl TnuaCrouchEnforcer {
     ///   function has the opportunity to add things to the sensor entity - mostly cast-shape
     ///   components.
     pub fn new(
-        offset: Vec3,
+        offset: Vector3,
         modify_sensor: impl 'static + Send + Sync + Fn(&mut EntityCommands),
     ) -> Self {
         Self {
@@ -102,7 +103,7 @@ impl TnuaCrouchEnforcer {
 pub trait TnuaCrouchEnforcedAction: TnuaAction + Clone {
     /// The range, from the sensor's offset (as set by [`TnuaCrouchEnforcer::new`]), to check for a
     /// ceiling. If the sensor finds anything within that range - the crouch will be enforced.
-    fn range_to_cast_up(&self, state: &Self::State) -> f32;
+    fn range_to_cast_up(&self, state: &Self::State) -> Float;
 
     /// Modify the action so that it won't be cancellable by another action.
     fn prevent_cancellation(&mut self);
@@ -111,7 +112,7 @@ pub trait TnuaCrouchEnforcedAction: TnuaAction + Clone {
 trait DynamicCrouchEnforcedAction: Send + Sync {
     fn overwrite(&mut self, value: &dyn Any) -> Result<(), ()>;
     fn feed_to_controller(&mut self, controller: &mut TnuaController);
-    fn range_to_cast_up(&self, controller: &TnuaController) -> Option<f32>;
+    fn range_to_cast_up(&self, controller: &TnuaController) -> Option<Float>;
 }
 
 struct BoxableCrouchEnforcedAction<A: TnuaCrouchEnforcedAction>(A);
@@ -132,7 +133,7 @@ impl<A: TnuaCrouchEnforcedAction> DynamicCrouchEnforcedAction for BoxableCrouchE
         controller.action(action);
     }
 
-    fn range_to_cast_up(&self, controller: &TnuaController) -> Option<f32> {
+    fn range_to_cast_up(&self, controller: &TnuaController) -> Option<Float> {
         if let Some((action, state)) = controller.concrete_action::<A>() {
             Some(action.range_to_cast_up(state))
         } else {
@@ -149,7 +150,7 @@ fn update_crouch_enforcer(
     for (owner_entity, mut controller, mut crouch_enforcer) in query.iter_mut() {
         struct SetSensor {
             cast_direction: Direction3d,
-            cast_range: f32,
+            cast_range: Float,
         }
         let set_sensor: Option<SetSensor>;
         if let Some((enforced_action, fed_this_frame)) = crouch_enforcer.enforced_action.as_mut() {
diff --git a/src/control_helpers/simple_fall_through_platforms.rs b/src/control_helpers/simple_fall_through_platforms.rs
index 2892cf6d9..c1ad69156 100644
--- a/src/control_helpers/simple_fall_through_platforms.rs
+++ b/src/control_helpers/simple_fall_through_platforms.rs
@@ -1,5 +1,6 @@
 use bevy::prelude::*;
 use bevy::utils::HashSet;
+use bevy_tnua_physics_integration_layer::math::Float;
 
 use crate::{TnuaGhostSensor, TnuaProximitySensor};
 
@@ -29,7 +30,7 @@ impl TnuaSimpleFallThroughPlatformsHelper {
         &'a mut self,
         proximity_sensor: &'a mut TnuaProximitySensor,
         ghost_sensor: &'a TnuaGhostSensor,
-        min_proximity: f32,
+        min_proximity: Float,
     ) -> TnuaHandleForSimpleFallThroughPlatformsHelper<'a> {
         TnuaHandleForSimpleFallThroughPlatformsHelper {
             parent: self,
@@ -48,7 +49,7 @@ pub struct TnuaHandleForSimpleFallThroughPlatformsHelper<'a> {
     parent: &'a mut TnuaSimpleFallThroughPlatformsHelper,
     proximity_sensor: &'a mut TnuaProximitySensor,
     ghost_sensor: &'a TnuaGhostSensor,
-    min_proximity: f32,
+    min_proximity: Float,
 }
 
 impl TnuaHandleForSimpleFallThroughPlatformsHelper<'_> {
diff --git a/src/controller.rs b/src/controller.rs
index 92d322c7d..38721ad87 100644
--- a/src/controller.rs
+++ b/src/controller.rs
@@ -1,6 +1,7 @@
 use bevy::prelude::*;
 use bevy::time::Stopwatch;
 use bevy::utils::{Entry, HashMap};
+use bevy_tnua_physics_integration_layer::math::Float;
 
 use crate::basis_action_traits::{
     BoxableAction, BoxableBasis, DynamicAction, DynamicBasis, TnuaAction, TnuaActionContext,
@@ -352,7 +353,7 @@ fn apply_controller_system(
         Option<&TnuaToggle>,
     )>,
 ) {
-    let frame_duration = time.delta().as_secs_f32();
+    let frame_duration = time.delta().as_secs_f64() as Float;
     if frame_duration == 0.0 {
         return;
     }
@@ -448,10 +449,10 @@ fn apply_controller_system(
                 }
                 let reschedule_action =
                     |actions_being_fed: &mut HashMap<&'static str, FedEntry>,
-                     after_seconds: f32| {
+                     after_seconds: Float| {
                         if let Some(fed_entry) = actions_being_fed.get_mut(name) {
                             fed_entry.rescheduled_in =
-                                Some(Timer::from_seconds(after_seconds, TimerMode::Once));
+                                Some(Timer::from_seconds(after_seconds as f32, TimerMode::Once));
                         }
                     };
                 match directive {
diff --git a/src/lib.rs b/src/lib.rs
index d102a6dcd..5f7654e62 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -65,10 +65,11 @@
 //! ```no_run
 //! # use bevy::prelude::*;
 //! # use bevy_tnua::prelude::*;
+//! # use bevy_tnua::math::Vector3;
 //! # #[derive(Component)]
 //! # struct PlayerInputComponent;
 //! # impl PlayerInputComponent {
-//! # fn direction_vector(&self) -> Vec3 { Vec3::ZERO }
+//! # fn direction_vector(&self) -> Vector3 { Vector3::ZERO }
 //! # fn jump_pressed(&self) -> bool { false }
 //! # }
 //! fn player_control_system(mut query: Query<(
diff --git a/src/util.rs b/src/util.rs
index fbe6a2588..656a12c76 100644
--- a/src/util.rs
+++ b/src/util.rs
@@ -1,19 +1,22 @@
 use bevy::prelude::*;
+use bevy_tnua_physics_integration_layer::math::{
+    AdjustPrecision, Float, Quaternion, Vector2, Vector3,
+};
 
 pub struct SegmentedJumpInitialVelocityCalculator {
-    height: f32,
-    kinetic_energy: f32,
+    height: Float,
+    kinetic_energy: Float,
 }
 
 impl SegmentedJumpInitialVelocityCalculator {
-    pub fn new(total_height: f32) -> Self {
+    pub fn new(total_height: Float) -> Self {
         Self {
             height: total_height,
             kinetic_energy: 0.0,
         }
     }
 
-    pub fn add_segment(&mut self, gravity: f32, velocity_threshold: f32) -> &mut Self {
+    pub fn add_segment(&mut self, gravity: Float, velocity_threshold: Float) -> &mut Self {
         if self.height <= 0.0 {
             // No more height to jump
             return self;
@@ -40,34 +43,38 @@ impl SegmentedJumpInitialVelocityCalculator {
         self
     }
 
-    pub fn kinetic_energy(&self) -> f32 {
+    pub fn kinetic_energy(&self) -> Float {
         self.kinetic_energy
     }
 }
 
 pub struct ProjectionPlaneForRotation {
-    pub forward: Vec3,
-    pub sideways: Vec3,
+    pub forward: Vector3,
+    pub sideways: Vector3,
 }
 
 impl ProjectionPlaneForRotation {
-    pub fn from_up_and_fowrard(up: Direction3d, forward: Vec3) -> Self {
+    pub fn from_up_and_fowrard(up: Direction3d, forward: Vector3) -> Self {
         Self {
             forward,
-            sideways: up.cross(forward),
+            sideways: up.adjust_precision().cross(forward),
         }
     }
 
     pub fn from_up_using_default_forward(up: Direction3d) -> Self {
-        Self::from_up_and_fowrard(up, Vec3::NEG_Z)
+        Self::from_up_and_fowrard(up, Vector3::NEG_Z)
     }
 
-    pub fn project_and_normalize(&self, vector: Vec3) -> Vec2 {
-        Vec2::new(vector.dot(self.forward), vector.dot(self.sideways)).normalize_or_zero()
+    pub fn project_and_normalize(&self, vector: Vector3) -> Vector2 {
+        Vector2::new(vector.dot(self.forward), vector.dot(self.sideways)).normalize_or_zero()
     }
 
-    pub fn rotation_to_set_forward(&self, current_forward: Vec3, desired_forward: Vec3) -> f32 {
-        let rotation_to_set_forward = Quat::from_rotation_arc_2d(
+    pub fn rotation_to_set_forward(
+        &self,
+        current_forward: Vector3,
+        desired_forward: Vector3,
+    ) -> Float {
+        let rotation_to_set_forward = Quaternion::from_rotation_arc_2d(
             self.project_and_normalize(current_forward),
             self.project_and_normalize(desired_forward),
         );
diff --git a/xpbd2d/Cargo.toml b/xpbd2d/Cargo.toml
index e44b0e2da..33d937b4f 100644
--- a/xpbd2d/Cargo.toml
+++ b/xpbd2d/Cargo.toml
@@ -13,8 +13,12 @@ readme = "../README.md"
 
 [dependencies]
 bevy = { version = "^0.13", default-features = false }
-bevy_xpbd_2d = "^0.4"
+bevy_xpbd_2d = {version = "^0.4", default-features = false, features = ["2d","debug-plugin", "parallel"]}
 bevy-tnua-physics-integration-layer = { version = "^0.2", path = "../physics-integration-layer" }
 
 [package.metadata.docs.rs]
 all-features = true
+
+[features]
+default = [  "bevy_xpbd_2d/parry-f32" ]
+f64 = ["bevy_xpbd_2d/parry-f64",  "bevy-tnua-physics-integration-layer/f64" ]
\ No newline at end of file
diff --git a/xpbd2d/src/lib.rs b/xpbd2d/src/lib.rs
index f84052197..dcdd51e98 100644
--- a/xpbd2d/src/lib.rs
+++ b/xpbd2d/src/lib.rs
@@ -7,17 +7,16 @@
 //!   the characters controlled by Tnua, but also other things like the entity generated by
 //!   `TnuaCrouchEnforcer`, that can be affected with a closure.
 use bevy::prelude::*;
-use bevy_xpbd_2d::prelude::*;
-
-use bevy_tnua_physics_integration_layer::data_for_backends::TnuaGhostPlatform;
-use bevy_tnua_physics_integration_layer::data_for_backends::TnuaGhostSensor;
-use bevy_tnua_physics_integration_layer::data_for_backends::TnuaToggle;
 use bevy_tnua_physics_integration_layer::data_for_backends::{
-    TnuaMotor, TnuaProximitySensor, TnuaProximitySensorOutput, TnuaRigidBodyTracker,
+    TnuaGhostPlatform, TnuaGhostSensor, TnuaMotor, TnuaProximitySensor, TnuaProximitySensorOutput,
+    TnuaRigidBodyTracker, TnuaToggle,
 };
+use bevy_tnua_physics_integration_layer::math::*;
 use bevy_tnua_physics_integration_layer::subservient_sensors::TnuaSubservientSensor;
-use bevy_tnua_physics_integration_layer::TnuaPipelineStages;
-use bevy_tnua_physics_integration_layer::TnuaSystemSet;
+use bevy_xpbd_2d::math::{AdjustPrecision, AsF32};
+use bevy_xpbd_2d::prelude::*;
+
+use bevy_tnua_physics_integration_layer::*;
 
 /// Add this plugin to use bevy_xpbd_2d as a physics backend.
 ///
@@ -68,10 +67,10 @@ fn update_rigid_body_trackers_system(
         }
         let (_, rotation, translation) = transform.to_scale_rotation_translation();
         *tracker = TnuaRigidBodyTracker {
-            translation,
-            rotation,
+            translation: translation.adjust_precision(),
+            rotation: rotation.adjust_precision(),
             velocity: linaer_velocity.0.extend(0.0),
-            angvel: Vec3::new(0.0, 0.0, angular_velocity.0),
+            angvel: Vector3::new(0.0, 0.0, angular_velocity.0),
             gravity: gravity.0.extend(0.0),
         };
     }
@@ -113,7 +112,7 @@ fn update_proximity_sensors_system(
                 TnuaToggle::SenseOnly => {}
                 TnuaToggle::Enabled => {}
             }
-            let cast_origin = transform.transform_point(sensor.cast_origin);
+            let cast_origin = transform.transform_point(sensor.cast_origin.f32());
             let (_, owner_rotation, _) = transform.to_scale_rotation_translation();
             let cast_direction = owner_rotation * sensor.cast_direction;
             let cast_direction_2d = Direction2d::new(cast_direction.truncate())
@@ -121,8 +120,8 @@ fn update_proximity_sensors_system(
 
             struct CastResult {
                 entity: Entity,
-                proximity: f32,
-                intersection_point: Vec2,
+                proximity: Float,
+                intersection_point: Vector2,
                 // Use 3D and not 2D because converting a direction from 2D to 3D is more painful
                 // than it should be.
                 normal: Direction3d,
@@ -158,8 +157,9 @@ fn update_proximity_sensors_system(
                             } else {
                                 manifold.normal1
                             };
+                            #[allow(clippy::useless_conversion)]
                             if sensor.intersection_match_prevention_cutoff
-                                < manifold_normal.dot(cast_direction.truncate())
+                                < manifold_normal.dot(cast_direction.truncate().into())
                             {
                                 return true;
                             }
@@ -185,21 +185,21 @@ fn update_proximity_sensors_system(
                 if let Some((entity_transform, entity_linear_velocity, entity_angular_velocity)) =
                     entity_kinematic_data
                 {
-                    entity_angvel = Vec3::new(0.0, 0.0, entity_angular_velocity.0);
+                    entity_angvel = Vector3::new(0.0, 0.0, entity_angular_velocity.0);
                     entity_linvel = entity_linear_velocity.0.extend(0.0)
                         + if 0.0 < entity_angvel.length_squared() {
-                            let relative_point =
-                                intersection_point - entity_transform.translation().truncate();
+                            let relative_point = intersection_point
+                                - entity_transform.translation().truncate().adjust_precision();
                             // NOTE: no need to project relative_point on the
                             // rotation plane, it will not affect the cross
                             // product.
                             entity_angvel.cross(relative_point.extend(0.0))
                         } else {
-                            Vec3::ZERO
+                            Vector3::ZERO
                         };
                 } else {
-                    entity_angvel = Vec3::ZERO;
-                    entity_linvel = Vec3::ZERO;
+                    entity_angvel = Vector3::ZERO;
+                    entity_linvel = Vector3::ZERO;
                 }
                 let sensor_output = TnuaProximitySensorOutput {
                     entity,
@@ -234,25 +234,26 @@ fn update_proximity_sensors_system(
                 let (_, _, rotation_z) = owner_rotation.to_euler(EulerRot::XYZ);
                 spatial_query_pipeline.shape_hits_callback(
                     shape,
-                    cast_origin.truncate(),
-                    rotation_z,
+                    cast_origin.truncate().adjust_precision(),
+                    rotation_z.adjust_precision(),
                     cast_direction_2d,
                     sensor.cast_range,
                     true,
                     query_filter,
+                    #[allow(clippy::useless_conversion)]
                     |shape_hit_data| {
                         apply_cast(CastResult {
                             entity: shape_hit_data.entity,
                             proximity: shape_hit_data.time_of_impact,
                             intersection_point: shape_hit_data.point1,
-                            normal: Direction3d::new(shape_hit_data.normal1.extend(0.0))
+                            normal: Direction3d::new(shape_hit_data.normal1.extend(0.0).f32())
                                 .unwrap_or_else(|_| -cast_direction),
                         })
                     },
                 );
             } else {
                 spatial_query_pipeline.ray_hits_callback(
-                    cast_origin.truncate(),
+                    cast_origin.truncate().adjust_precision(),
                     cast_direction_2d,
                     sensor.cast_range,
                     true,
@@ -261,9 +262,10 @@ fn update_proximity_sensors_system(
                         apply_cast(CastResult {
                             entity: ray_hit_data.entity,
                             proximity: ray_hit_data.time_of_impact,
-                            intersection_point: cast_origin.truncate()
-                                + ray_hit_data.time_of_impact * *cast_direction_2d,
-                            normal: Direction3d::new(ray_hit_data.normal.extend(0.0))
+                            intersection_point: cast_origin.truncate().adjust_precision()
+                                + ray_hit_data.time_of_impact.adjust_precision()
+                                    * cast_direction_2d.adjust_precision(),
+                            normal: Direction3d::new(ray_hit_data.normal.extend(0.0).f32())
                                 .unwrap_or_else(|_| -cast_direction),
                         })
                     },
diff --git a/xpbd3d/Cargo.toml b/xpbd3d/Cargo.toml
index 80d3d5885..e71a93cdc 100644
--- a/xpbd3d/Cargo.toml
+++ b/xpbd3d/Cargo.toml
@@ -13,8 +13,12 @@ readme = "../README.md"
 
 [dependencies]
 bevy = { version = "^0.13", default-features = false }
-bevy_xpbd_3d = "^0.4"
+bevy_xpbd_3d = {version = "^0.4", default-features = false, features = ["3d","debug-plugin", "parallel", "async-collider"] }
 bevy-tnua-physics-integration-layer = { version = "^0.2", path = "../physics-integration-layer" }
 
 [package.metadata.docs.rs]
 all-features = true
+
+[features]
+default = [  "bevy_xpbd_3d/parry-f32" ]
+f64 = ["bevy_xpbd_3d/parry-f64", "bevy-tnua-physics-integration-layer/f64"]
diff --git a/xpbd3d/src/lib.rs b/xpbd3d/src/lib.rs
index 53e429138..abb7dca1c 100644
--- a/xpbd3d/src/lib.rs
+++ b/xpbd3d/src/lib.rs
@@ -7,6 +7,10 @@
 //!   the characters controlled by Tnua, but also other things like the entity generated by
 //!   `TnuaCrouchEnforcer`, that can be affected with a closure.
 use bevy::prelude::*;
+use bevy_tnua_physics_integration_layer::math::AdjustPrecision;
+use bevy_tnua_physics_integration_layer::math::AsF32;
+use bevy_tnua_physics_integration_layer::math::Float;
+use bevy_tnua_physics_integration_layer::math::Vector3;
 use bevy_xpbd_3d::prelude::*;
 
 use bevy_tnua_physics_integration_layer::data_for_backends::TnuaGhostPlatform;
@@ -68,11 +72,11 @@ fn update_rigid_body_trackers_system(
         }
         let (_, rotation, translation) = transform.to_scale_rotation_translation();
         *tracker = TnuaRigidBodyTracker {
-            translation,
-            rotation,
-            velocity: linaer_velocity.0,
-            angvel: angular_velocity.0,
-            gravity: gravity.0,
+            translation: translation.adjust_precision(),
+            rotation: rotation.adjust_precision(),
+            velocity: linaer_velocity.0.adjust_precision(),
+            angvel: angular_velocity.0.adjust_precision(),
+            gravity: gravity.0.adjust_precision(),
         };
     }
 }
@@ -113,14 +117,14 @@ fn update_proximity_sensors_system(
                 TnuaToggle::SenseOnly => {}
                 TnuaToggle::Enabled => {}
             }
-            let cast_origin = transform.transform_point(sensor.cast_origin);
+            let cast_origin = transform.transform_point(sensor.cast_origin.f32());
             let (_, owner_rotation, _) = transform.to_scale_rotation_translation();
             let cast_direction = owner_rotation * sensor.cast_direction;
 
             struct CastResult {
                 entity: Entity,
                 proximity: f32,
-                intersection_point: Vec3,
+                intersection_point: Vector3,
                 normal: Direction3d,
             }
 
@@ -150,12 +154,12 @@ fn update_proximity_sensors_system(
                     for manifold in contacts.manifolds.iter() {
                         if !manifold.contacts.is_empty() {
                             let manifold_normal = if same_order {
-                                manifold.normal2
+                                manifold.normal2.adjust_precision()
                             } else {
-                                manifold.normal1
+                                manifold.normal1.adjust_precision()
                             };
                             if sensor.intersection_match_prevention_cutoff
-                                < manifold_normal.dot(cast_direction.into())
+                                < manifold_normal.dot(cast_direction.adjust_precision())
                             {
                                 return true;
                             }
@@ -181,21 +185,21 @@ fn update_proximity_sensors_system(
                 if let Some((entity_transform, entity_linear_velocity, entity_angular_velocity)) =
                     entity_kinematic_data
                 {
-                    entity_angvel = entity_angular_velocity.0;
-                    entity_linvel = entity_linear_velocity.0
+                    entity_angvel = entity_angular_velocity.0.adjust_precision();
+                    entity_linvel = entity_linear_velocity.0.adjust_precision()
                         + if 0.0 < entity_angvel.length_squared() {
-                            let relative_point =
-                                intersection_point - entity_transform.translation();
+                            let relative_point = intersection_point
+                                - entity_transform.translation().adjust_precision();
                             // NOTE: no need to project relative_point on the
                             // rotation plane, it will not affect the cross
                             // product.
                             entity_angvel.cross(relative_point)
                         } else {
-                            Vec3::ZERO
+                            Vector3::ZERO
                         };
                 } else {
-                    entity_angvel = Vec3::ZERO;
-                    entity_linvel = Vec3::ZERO;
+                    entity_angvel = Vector3::ZERO;
+                    entity_linvel = Vector3::ZERO;
                 }
                 let sensor_output = TnuaProximitySensorOutput {
                     entity,