From b8f6f4d82b952c3532a153237b98acc53e4a3bca Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 22 Mar 2025 23:07:08 +0200
Subject: [PATCH 01/13] Make dependencies `no_std` and use `alloc` more

---
 crates/avian2d/Cargo.toml                     | 62 +++++++++++++------
 crates/avian3d/Cargo.toml                     | 61 ++++++++++++------
 src/collision/collider/backend.rs             |  8 +--
 .../collider/collider_hierarchy/mod.rs        |  2 +-
 src/collision/collider/parry/mod.rs           |  2 +-
 src/collision/collider/parry/primitives2d.rs  |  7 +++
 src/collision/collider/parry/primitives3d.rs  |  1 +
 src/collision/diagnostics.rs                  |  1 +
 src/collision/mod.rs                          | 10 ++-
 src/collision/narrow_phase.rs                 |  2 +-
 src/diagnostics/mod.rs                        |  1 +
 src/diagnostics/ui.rs                         |  7 ++-
 .../rigid_body/mass_properties/mod.rs         |  2 +-
 src/dynamics/solver/contact/mod.rs            |  1 +
 src/dynamics/solver/diagnostics.rs            |  1 +
 src/dynamics/solver/schedule.rs               |  2 +-
 src/lib.rs                                    |  1 +
 src/prepare.rs                                |  2 +-
 src/schedule/mod.rs                           |  2 +-
 src/spatial_query/diagnostics.rs              |  4 +-
 20 files changed, 120 insertions(+), 59 deletions(-)

diff --git a/crates/avian2d/Cargo.toml b/crates/avian2d/Cargo.toml
index 7abf6f9d..afa07ee5 100644
--- a/crates/avian2d/Cargo.toml
+++ b/crates/avian2d/Cargo.toml
@@ -27,9 +27,9 @@ f64 = []
 
 debug-plugin = ["bevy/bevy_gizmos", "bevy/bevy_render"]
 simd = ["parry2d?/simd-stable", "parry2d-f64?/simd-stable"]
-parallel = ["parry2d?/parallel", "parry2d-f64?/parallel"]
+parallel = ["std", "parry2d?/parallel", "parry2d-f64?/parallel"]
 enhanced-determinism = [
-    "dep:libm",
+    "libm",
     "parry2d?/enhanced-determinism",
     "parry2d-f64?/enhanced-determinism",
     "bevy_math/libm",
@@ -60,6 +60,23 @@ bevy_diagnostic = []
 # Enables the `PhysicsDiagnosticsUiPlugin` for visualizing physics diagnostics data with a debug UI.
 diagnostic_ui = ["bevy_diagnostic", "bevy/bevy_ui"]
 
+# Enable the Rust standard library.
+std = [
+    "bevy/std",
+    "bevy_heavy/std",
+    "bevy_transform_interpolation/std",
+    "parry2d?/std",
+    "parry2d-f64?/std",
+]
+
+# Enable `libm` math operations for `no_std` environments and cross-platform determinism.
+libm = [
+    "dep:libm",
+    "bevy/libm",
+    "bevy_heavy/libm",
+    "bevy_transform_interpolation/libm",
+]
+
 [lib]
 name = "avian2d"
 path = "../../src/lib.rs"
@@ -68,24 +85,32 @@ bench = false
 
 [dependencies]
 avian_derive = { path = "../avian_derive", version = "0.2" }
-bevy = { version = "0.16.0-rc.1", default-features = false, features = [
-    "std",
-    "bevy_log",
+bevy = { version = "0.16.0-rc.1", default-features = false }
+bevy_math = { version = "0.16.0-rc.1", default-features = false }
+bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy", default-features = false, features = [
+    "2d",
+    "3d",
 ] }
-bevy_math = { version = "0.16.0-rc.1" }
-bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy" }
-bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation" }
+bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation", default-features = false }
 libm = { version = "0.2", optional = true }
-parry2d = { version = "0.17", optional = true }
-parry2d-f64 = { version = "0.17", optional = true }
-nalgebra = { version = "0.33", features = ["convert-glam029"], optional = true }
-serde = { version = "1", features = ["derive"], optional = true }
-derive_more = "1"
-indexmap = "2.0.0"
-arrayvec = "0.7"
-fxhash = "0.2.1"
-itertools = "0.13"
-bitflags = "2.5.0"
+parry2d = { version = "0.17", optional = true, default-features = false, features = [
+    "required-features",
+] }
+parry2d-f64 = { version = "0.17", optional = true, default-features = false, features = [
+    "required-features",
+] }
+nalgebra = { version = "0.33", default-features = false, features = [
+    "convert-glam029",
+], optional = true }
+serde = { version = "1", default-features = false, features = [
+    "derive",
+], optional = true }
+derive_more = { version = "1", default-features = false }
+log = { version = "0.4", default-features = false }
+indexmap = { version = "2.0.0", default-features = false }
+arrayvec = { version = "0.7", default-features = false }
+itertools = { version = "0.13", default-features = false }
+bitflags = { version = "2.5.0", default-features = false }
 
 [dev-dependencies]
 examples_common_2d = { path = "../examples_common_2d" }
@@ -94,7 +119,6 @@ bevy_math = { version = "0.16.0-rc.1", features = ["approx"] }
 bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy", features = [
     "approx",
 ] }
-glam = { version = "0.29", features = ["bytemuck"] }
 approx = "0.5"
 bytemuck = "1.19"
 criterion = { version = "0.5", features = ["html_reports"] }
diff --git a/crates/avian3d/Cargo.toml b/crates/avian3d/Cargo.toml
index e06d65f5..33cca14a 100644
--- a/crates/avian3d/Cargo.toml
+++ b/crates/avian3d/Cargo.toml
@@ -28,9 +28,9 @@ f64 = []
 
 debug-plugin = ["bevy/bevy_gizmos", "bevy/bevy_render"]
 simd = ["parry3d?/simd-stable", "parry3d-f64?/simd-stable"]
-parallel = ["parry3d?/parallel", "parry3d-f64?/parallel"]
+parallel = ["std", "parry3d?/parallel", "parry3d-f64?/parallel"]
 enhanced-determinism = [
-    "dep:libm",
+    "libm",
     "parry3d?/enhanced-determinism",
     "parry3d-f64?/enhanced-determinism",
     "bevy_math/libm",
@@ -62,6 +62,23 @@ bevy_diagnostic = []
 # Enables the `PhysicsDiagnosticsUiPlugin` for visualizing physics diagnostics data with a debug UI.
 diagnostic_ui = ["bevy_diagnostic", "bevy/bevy_ui"]
 
+# Enable the Rust standard library.
+std = [
+    "bevy/std",
+    "bevy_heavy/std",
+    "bevy_transform_interpolation/std",
+    "parry3d?/std",
+    "parry3d-f64?/std",
+]
+
+# Enable `libm` math operations for `no_std` environments and cross-platform determinism.
+libm = [
+    "dep:libm",
+    "bevy/libm",
+    "bevy_heavy/libm",
+    "bevy_transform_interpolation/libm",
+]
+
 [lib]
 name = "avian3d"
 path = "../../src/lib.rs"
@@ -70,24 +87,32 @@ bench = false
 
 [dependencies]
 avian_derive = { path = "../avian_derive", version = "0.2" }
-bevy = { version = "0.16.0-rc.1", default-features = false, features = [
-    "std",
-    "bevy_log",
+bevy = { version = "0.16.0-rc.1", default-features = false }
+bevy_math = { version = "0.16.0-rc.1", default-features = false }
+bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy", default-features = false, features = [
+    "2d",
+    "3d",
 ] }
-bevy_math = { version = "0.16.0-rc.1" }
-bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy" }
-bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation" }
+bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation", default-features = false }
 libm = { version = "0.2", optional = true }
-parry3d = { version = "0.17", optional = true }
-parry3d-f64 = { version = "0.17", optional = true }
-nalgebra = { version = "0.33", features = ["convert-glam029"], optional = true }
-serde = { version = "1", features = ["derive"], optional = true }
-derive_more = "1"
-indexmap = "2.0.0"
-arrayvec = "0.7"
-fxhash = "0.2.1"
-itertools = "0.13"
-bitflags = "2.5.0"
+parry3d = { version = "0.17", optional = true, default-features = false, features = [
+    "required-features",
+] }
+parry3d-f64 = { version = "0.17", optional = true, default-features = false, features = [
+    "required-features",
+] }
+nalgebra = { version = "0.33", default-features = false, features = [
+    "convert-glam029",
+], optional = true }
+serde = { version = "1", default-features = false, features = [
+    "derive",
+], optional = true }
+derive_more = { version = "1", default-features = false }
+log = { version = "0.4", default-features = false }
+indexmap = { version = "2.0.0", default-features = false }
+arrayvec = { version = "0.7", default-features = false }
+itertools = { version = "0.13", default-features = false }
+bitflags = { version = "2.5.0", default-features = false }
 
 [dev-dependencies]
 examples_common_3d = { path = "../examples_common_3d" }
diff --git a/src/collision/collider/backend.rs b/src/collision/collider/backend.rs
index c2f002b9..7aa9411e 100644
--- a/src/collision/collider/backend.rs
+++ b/src/collision/collider/backend.rs
@@ -309,7 +309,7 @@ fn init_collider_constructors(
     for (entity, existing_collider, name, constructor) in constructors.iter() {
         let name = pretty_name(name, entity);
         if existing_collider.is_some() {
-            warn!(
+            log::warn!(
                 "Tried to add a collider to entity {name} via {constructor:#?}, \
                 but that entity already holds a collider. Skipping.",
             );
@@ -339,7 +339,7 @@ fn init_collider_constructors(
         if let Some(collider) = collider {
             commands.entity(entity).insert(collider);
         } else {
-            error!(
+            log::error!(
                 "Tried to add a collider to entity {name} via {constructor:#?}, \
                 but the collider could not be generated. Skipping.",
             );
@@ -400,7 +400,7 @@ fn init_collider_constructor_hierarchies(
                     .cloned()
                     .unwrap_or_else(default_collider)
             } else if existing_collider.is_some() {
-                warn!("Tried to add a collider to entity {pretty_name} via {collider_constructor_hierarchy:#?}, \
+                log::warn!("Tried to add a collider to entity {pretty_name} via {collider_constructor_hierarchy:#?}, \
                         but that entity already holds a collider. Skipping. \
                         If this was intentional, add the name of the collider to overwrite to `ColliderConstructorHierarchy.config`.");
                 continue;
@@ -449,7 +449,7 @@ fn init_collider_constructor_hierarchies(
                         .unwrap_or(collider_constructor_hierarchy.default_density),
                 ));
             } else {
-                error!(
+                log::error!(
                         "Tried to add a collider to entity {pretty_name} via {collider_constructor_hierarchy:#?}, \
                         but the collider could not be generated. Skipping.",
                     );
diff --git a/src/collision/collider/collider_hierarchy/mod.rs b/src/collision/collider/collider_hierarchy/mod.rs
index 15caf958..1def147d 100644
--- a/src/collision/collider/collider_hierarchy/mod.rs
+++ b/src/collision/collider/collider_hierarchy/mod.rs
@@ -121,7 +121,7 @@ impl Relationship for ColliderOf {
                     .insert(RigidBodyColliders(vec![collider]));
             }
         } else {
-            warn!(
+            log::warn!(
                 "{}Tried to attach collider on entity {collider} to rigid body on entity {rigid_body}, but the rigid body does not exist.",
                 caller.map(|location| format!("{location}: ")).unwrap_or_default(),
             );
diff --git a/src/collision/collider/parry/mod.rs b/src/collision/collider/parry/mod.rs
index 4e73c5ae..40c9fb40 100644
--- a/src/collision/collider/parry/mod.rs
+++ b/src/collision/collider/parry/mod.rs
@@ -1,9 +1,9 @@
 #![allow(clippy::unnecessary_cast)]
 
 use crate::{make_isometry, prelude::*};
+use bevy::prelude::*;
 #[cfg(feature = "collider-from-mesh")]
 use bevy::render::mesh::{Indices, VertexAttributeValues};
-use bevy::{log, prelude::*};
 use collision::contact_query::UnsupportedShape;
 use itertools::Either;
 use parry::shape::{RoundShape, SharedShape, TypedShape};
diff --git a/src/collision/collider/parry/primitives2d.rs b/src/collision/collider/parry/primitives2d.rs
index 5324dd9b..9a55c424 100644
--- a/src/collision/collider/parry/primitives2d.rs
+++ b/src/collision/collider/parry/primitives2d.rs
@@ -1,6 +1,7 @@
 use crate::{math, AdjustPrecision, Scalar, Vector, FRAC_PI_2, PI, TAU};
 
 use super::{AsF32, Collider, IntoCollider};
+use alloc::boxed::Box;
 use bevy::prelude::{Deref, DerefMut};
 use bevy_math::{bounding::Bounded2d, prelude::*};
 use nalgebra::{Point2, UnitVector2, Vector2};
@@ -46,10 +47,12 @@ impl SupportMap for EllipseColliderShape {
 }
 
 impl Shape for EllipseColliderShape {
+    #[cfg(feature = "std")]
     fn clone_dyn(&self) -> Box<dyn Shape> {
         Box::new(*self)
     }
 
+    #[cfg(feature = "std")]
     fn scale_dyn(
         &self,
         scale: &parry::math::Vector<Scalar>,
@@ -99,6 +102,7 @@ impl Shape for EllipseColliderShape {
         )
     }
 
+    #[cfg(feature = "std")]
     fn clone_box(&self) -> Box<dyn Shape> {
         Box::new(*self)
     }
@@ -324,10 +328,12 @@ impl PolygonalFeatureMap for RegularPolygonColliderShape {
 }
 
 impl Shape for RegularPolygonColliderShape {
+    #[cfg(feature = "std")]
     fn clone_dyn(&self) -> Box<dyn Shape> {
         Box::new(*self)
     }
 
+    #[cfg(feature = "std")]
     fn scale_dyn(
         &self,
         scale: &parry::math::Vector<Scalar>,
@@ -377,6 +383,7 @@ impl Shape for RegularPolygonColliderShape {
         )
     }
 
+    #[cfg(feature = "std")]
     fn clone_box(&self) -> Box<dyn Shape> {
         Box::new(*self)
     }
diff --git a/src/collision/collider/parry/primitives3d.rs b/src/collision/collider/parry/primitives3d.rs
index 9917b686..f948808b 100644
--- a/src/collision/collider/parry/primitives3d.rs
+++ b/src/collision/collider/parry/primitives3d.rs
@@ -1,3 +1,4 @@
+use alloc::vec;
 use bevy_math::primitives::{
     BoxedPolyline3d, Capsule3d, Cone, Cuboid, Cylinder, Line3d, Plane3d, Polyline3d, Segment3d,
     Sphere,
diff --git a/src/collision/diagnostics.rs b/src/collision/diagnostics.rs
index 6e0d4a74..97b6390a 100644
--- a/src/collision/diagnostics.rs
+++ b/src/collision/diagnostics.rs
@@ -1,3 +1,4 @@
+use alloc::{vec, vec::Vec};
 use bevy::{
     diagnostic::DiagnosticPath,
     prelude::{ReflectResource, Resource},
diff --git a/src/collision/mod.rs b/src/collision/mod.rs
index 8c281a4e..34941a29 100644
--- a/src/collision/mod.rs
+++ b/src/collision/mod.rs
@@ -38,7 +38,7 @@ mod diagnostics;
 pub use diagnostics::CollisionDiagnostics;
 
 use crate::prelude::*;
-use bevy::prelude::*;
+use bevy::{platform_support::hash::FixedHasher, prelude::*};
 use indexmap::IndexMap;
 
 // TODO: Refactor this into a contact graph.
@@ -76,18 +76,16 @@ use indexmap::IndexMap;
 /// However, the public methods only use the current frame's collisions. To access the internal data structure,
 /// you can use [`get_internal`](Self::get_internal) or [`get_internal_mut`](Self::get_internal_mut).
 #[derive(Resource, Clone, Debug, Default, PartialEq)]
-pub struct Collisions(IndexMap<(Entity, Entity), Contacts, fxhash::FxBuildHasher>);
+pub struct Collisions(IndexMap<(Entity, Entity), Contacts, FixedHasher>);
 
 impl Collisions {
     /// Returns a reference to the internal `IndexMap`.
-    pub fn get_internal(&self) -> &IndexMap<(Entity, Entity), Contacts, fxhash::FxBuildHasher> {
+    pub fn get_internal(&self) -> &IndexMap<(Entity, Entity), Contacts, FixedHasher> {
         &self.0
     }
 
     /// Returns a mutable reference to the internal `IndexMap`.
-    pub fn get_internal_mut(
-        &mut self,
-    ) -> &mut IndexMap<(Entity, Entity), Contacts, fxhash::FxBuildHasher> {
+    pub fn get_internal_mut(&mut self) -> &mut IndexMap<(Entity, Entity), Contacts, FixedHasher> {
         &mut self.0
     }
 
diff --git a/src/collision/narrow_phase.rs b/src/collision/narrow_phase.rs
index 0efa662d..8d17562f 100644
--- a/src/collision/narrow_phase.rs
+++ b/src/collision/narrow_phase.rs
@@ -861,6 +861,6 @@ pub fn reset_collision_states(
 
 /// Runs the [`PostProcessCollisions`] schedule.
 fn run_post_process_collisions_schedule(world: &mut World) {
-    trace!("running PostProcessCollisions");
+    log::trace!("running PostProcessCollisions");
     world.run_schedule(PostProcessCollisions);
 }
diff --git a/src/diagnostics/mod.rs b/src/diagnostics/mod.rs
index dbed9ab2..dfa6e13e 100644
--- a/src/diagnostics/mod.rs
+++ b/src/diagnostics/mod.rs
@@ -76,6 +76,7 @@ pub(crate) use path_macro::impl_diagnostic_paths;
 pub use total::{PhysicsTotalDiagnostics, PhysicsTotalDiagnosticsPlugin};
 
 use crate::{schedule::PhysicsSchedule, PhysicsStepSet};
+use alloc::vec::Vec;
 use bevy::{
     app::{App, Plugin},
     diagnostic::{Diagnostic, DiagnosticPath, Diagnostics, RegisterDiagnostic},
diff --git a/src/diagnostics/ui.rs b/src/diagnostics/ui.rs
index caad1c8a..83aade2c 100644
--- a/src/diagnostics/ui.rs
+++ b/src/diagnostics/ui.rs
@@ -429,9 +429,10 @@ fn update_timers(
         };
 
         // Linearly interpolating between green and red, with `lower_bound` and `upper_bound`.
-        let t = (average as f32 - color_config.lower_bound)
-            / (color_config.upper_bound - color_config.lower_bound);
-        text_color.0 = Animatable::interpolate(&green, &red, t.min(1.0)).into();
+        let t = ((average as f32 - color_config.lower_bound)
+            / (color_config.upper_bound - color_config.lower_bound))
+            .min(1.0);
+        text_color.0 = (green * (1.0 - t) + red * t).into();
 
         // Make sure the node is visible.
         node.display = Display::Flex;
diff --git a/src/dynamics/rigid_body/mass_properties/mod.rs b/src/dynamics/rigid_body/mass_properties/mod.rs
index 4184b83a..e8c14e88 100644
--- a/src/dynamics/rigid_body/mass_properties/mod.rs
+++ b/src/dynamics/rigid_body/mass_properties/mod.rs
@@ -450,7 +450,7 @@ fn warn_missing_mass(
 
         // Warn about dynamic bodies with no mass or inertia
         if rb.is_dynamic() && !(is_mass_valid && is_inertia_valid) {
-            warn!(
+            log::warn!(
                 "Dynamic rigid body {:?} has no mass or inertia. This can cause NaN values. Consider adding a `MassPropertiesBundle` or a `Collider` with mass.",
                 entity
             );
diff --git a/src/dynamics/solver/contact/mod.rs b/src/dynamics/solver/contact/mod.rs
index 18263b42..dc7c5bf2 100644
--- a/src/dynamics/solver/contact/mod.rs
+++ b/src/dynamics/solver/contact/mod.rs
@@ -7,6 +7,7 @@ pub use normal_part::ContactNormalPart;
 pub use tangent_part::ContactTangentPart;
 
 use crate::{dynamics::solver::softness_parameters::SoftnessCoefficients, prelude::*};
+use alloc::vec::Vec;
 use bevy::{
     ecs::entity::{Entity, EntityMapper, MapEntities},
     reflect::Reflect,
diff --git a/src/dynamics/solver/diagnostics.rs b/src/dynamics/solver/diagnostics.rs
index b32f7f3e..ddefc458 100644
--- a/src/dynamics/solver/diagnostics.rs
+++ b/src/dynamics/solver/diagnostics.rs
@@ -1,3 +1,4 @@
+use alloc::{vec, vec::Vec};
 use bevy::{
     diagnostic::DiagnosticPath,
     prelude::{ReflectResource, Resource},
diff --git a/src/dynamics/solver/schedule.rs b/src/dynamics/solver/schedule.rs
index a63c08fb..7f800ddf 100644
--- a/src/dynamics/solver/schedule.rs
+++ b/src/dynamics/solver/schedule.rs
@@ -191,7 +191,7 @@ fn run_substep_schedule(world: &mut World) {
 
     let _ = world.try_schedule_scope(SubstepSchedule, |world, schedule| {
         for i in 0..substeps {
-            trace!("running SubstepSchedule: {i}");
+            log::trace!("running SubstepSchedule: {i}");
             *world.resource_mut::<Time>() = world.resource::<Time<Substeps>>().as_generic();
             schedule.run(world);
         }
diff --git a/src/lib.rs b/src/lib.rs
index 18efec06..9db19754 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -441,6 +441,7 @@
     rustdoc::invalid_rust_codeblocks
 )]
 #![warn(clippy::doc_markdown, missing_docs)]
+#![no_std]
 
 #[cfg(all(not(feature = "f32"), not(feature = "f64")))]
 compile_error!("either feature \"f32\" or \"f64\" must be enabled");
diff --git a/src/prepare.rs b/src/prepare.rs
index 500afe38..cedf4e51 100644
--- a/src/prepare.rs
+++ b/src/prepare.rs
@@ -358,7 +358,7 @@ mod tests {
                 position_to_transform,
                 transform_to_position,
             };
-            app.insert_resource(dbg!(config.clone()));
+            app.insert_resource(config.clone());
 
             // Spawn entities with `Position` and `Rotation`
             let (pos_0, rot_0) = {
diff --git a/src/schedule/mod.rs b/src/schedule/mod.rs
index 0811697c..42a5d566 100644
--- a/src/schedule/mod.rs
+++ b/src/schedule/mod.rs
@@ -264,7 +264,7 @@ fn run_physics_schedule(world: &mut World, mut is_first_run: Local<IsFirstRun>)
 
         // Advance the simulation.
         if !world.resource::<Time>().delta().is_zero() {
-            trace!("running PhysicsSchedule");
+            log::trace!("running PhysicsSchedule");
             schedule.run(world);
         }
 
diff --git a/src/spatial_query/diagnostics.rs b/src/spatial_query/diagnostics.rs
index 9f3f11de..e05a9a15 100644
--- a/src/spatial_query/diagnostics.rs
+++ b/src/spatial_query/diagnostics.rs
@@ -1,10 +1,10 @@
-use core::time::Duration;
-
+use alloc::{vec, vec::Vec};
 use bevy::{
     diagnostic::DiagnosticPath,
     prelude::{ReflectResource, Resource},
     reflect::Reflect,
 };
+use core::time::Duration;
 
 use crate::diagnostics::{impl_diagnostic_paths, PhysicsDiagnostics};
 

From 4ba965537d8b737e550000ac784c6fda9cc980df Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sat, 22 Mar 2025 23:56:01 +0200
Subject: [PATCH 02/13] Make math work with `no_std` and add method lints

---
 clippy.toml                                   |  76 +++
 crates/avian2d/Cargo.toml                     |   2 +
 crates/avian3d/Cargo.toml                     |   6 +-
 src/collision/collider/parry/mod.rs           |   4 +-
 src/collision/collider/parry/primitives2d.rs  |  15 +-
 src/collision/mod.rs                          |   4 +-
 src/collision/narrow_phase.rs                 |  10 -
 src/dynamics/ccd/mod.rs                       |   6 +-
 src/dynamics/integrator/mod.rs                |  12 +-
 src/dynamics/rigid_body/physics_material.rs   |   2 +-
 src/dynamics/sleeping/mod.rs                  |   8 +-
 src/dynamics/solver/contact/tangent_part.rs   |   4 +-
 src/dynamics/solver/joints/distance.rs        |   2 +-
 src/dynamics/solver/joints/mod.rs             |   2 +-
 .../solver/xpbd/angular_constraint.rs         |  14 +-
 src/dynamics/solver/xpbd/mod.rs               |   4 +-
 .../solver/xpbd/positional_constraint.rs      |   6 +-
 src/math/mod.rs                               |  13 +
 src/math/ops_f64.rs                           | 626 ++++++++++++++++++
 src/position.rs                               |  28 +-
 20 files changed, 771 insertions(+), 73 deletions(-)
 create mode 100644 clippy.toml
 create mode 100644 src/math/ops_f64.rs

diff --git a/clippy.toml b/clippy.toml
new file mode 100644
index 00000000..96b564c9
--- /dev/null
+++ b/clippy.toml
@@ -0,0 +1,76 @@
+disallowed-methods = [
+    # f32
+    { path = "f32::powi", reason = "use ops::FloatPow::squared, ops::FloatPow::cubed, or ops::powf instead for libm determinism" },
+    { path = "f32::log", reason = "use ops::ln, ops::log2, or ops::log10 instead for libm determinism" },
+    { path = "f32::abs_sub", reason = "deprecated and deeply confusing method" },
+    { path = "f32::powf", reason = "use ops::powf instead for libm determinism" },
+    { path = "f32::exp", reason = "use ops::exp instead for libm determinism" },
+    { path = "f32::exp2", reason = "use ops::exp2 instead for libm determinism" },
+    { path = "f32::ln", reason = "use ops::ln instead for libm determinism" },
+    { path = "f32::log2", reason = "use ops::log2 instead for libm determinism" },
+    { path = "f32::log10", reason = "use ops::log10 instead for libm determinism" },
+    { path = "f32::cbrt", reason = "use ops::cbrt instead for libm determinism" },
+    { path = "f32::hypot", reason = "use ops::hypot instead for libm determinism" },
+    { path = "f32::sin", reason = "use ops::sin instead for libm determinism" },
+    { path = "f32::cos", reason = "use ops::cos instead for libm determinism" },
+    { path = "f32::tan", reason = "use ops::tan instead for libm determinism" },
+    { path = "f32::asin", reason = "use ops::asin instead for libm determinism" },
+    { path = "f32::acos", reason = "use ops::acos instead for libm determinism" },
+    { path = "f32::atan", reason = "use ops::atan instead for libm determinism" },
+    { path = "f32::atan2", reason = "use ops::atan2 instead for libm determinism" },
+    { path = "f32::sin_cos", reason = "use ops::sin_cos instead for libm determinism" },
+    { path = "f32::exp_m1", reason = "use ops::exp_m1 instead for libm determinism" },
+    { path = "f32::ln_1p", reason = "use ops::ln_1p instead for libm determinism" },
+    { path = "f32::sinh", reason = "use ops::sinh instead for libm determinism" },
+    { path = "f32::cosh", reason = "use ops::cosh instead for libm determinism" },
+    { path = "f32::tanh", reason = "use ops::tanh instead for libm determinism" },
+    { path = "f32::asinh", reason = "use ops::asinh instead for libm determinism" },
+    { path = "f32::acosh", reason = "use ops::acosh instead for libm determinism" },
+    { path = "f32::atanh", reason = "use ops::atanh instead for libm determinism" },
+    # f64
+    { path = "f64::powi", reason = "use ops::FloatPow::squared, ops::FloatPow::cubed, or ops::powf instead for libm determinism" },
+    { path = "f64::log", reason = "use ops::ln, ops::log2, or ops::log10 instead for libm determinism" },
+    { path = "f64::abs_sub", reason = "deprecated and deeply confusing method" },
+    { path = "f64::powf", reason = "use ops::powf instead for libm determinism" },
+    { path = "f64::exp", reason = "use ops::exp instead for libm determinism" },
+    { path = "f64::exp2", reason = "use ops::exp2 instead for libm determinism" },
+    { path = "f64::ln", reason = "use ops::ln instead for libm determinism" },
+    { path = "f64::log2", reason = "use ops::log2 instead for libm determinism" },
+    { path = "f64::log10", reason = "use ops::log10 instead for libm determinism" },
+    { path = "f64::cbrt", reason = "use ops::cbrt instead for libm determinism" },
+    { path = "f64::hypot", reason = "use ops::hypot instead for libm determinism" },
+    { path = "f64::sin", reason = "use ops::sin instead for libm determinism" },
+    { path = "f64::cos", reason = "use ops::cos instead for libm determinism" },
+    { path = "f64::tan", reason = "use ops::tan instead for libm determinism" },
+    { path = "f64::asin", reason = "use ops::asin instead for libm determinism" },
+    { path = "f64::acos", reason = "use ops::acos instead for libm determinism" },
+    { path = "f64::atan", reason = "use ops::atan instead for libm determinism" },
+    { path = "f64::atan2", reason = "use ops::atan2 instead for libm determinism" },
+    { path = "f64::sin_cos", reason = "use ops::sin_cos instead for libm determinism" },
+    { path = "f64::exp_m1", reason = "use ops::exp_m1 instead for libm determinism" },
+    { path = "f64::ln_1p", reason = "use ops::ln_1p instead for libm determinism" },
+    { path = "f64::sinh", reason = "use ops::sinh instead for libm determinism" },
+    { path = "f64::cosh", reason = "use ops::cosh instead for libm determinism" },
+    { path = "f64::tanh", reason = "use ops::tanh instead for libm determinism" },
+    { path = "f64::asinh", reason = "use ops::asinh instead for libm determinism" },
+    { path = "f64::acosh", reason = "use ops::acosh instead for libm determinism" },
+    { path = "f64::atanh", reason = "use ops::atanh instead for libm determinism" },
+    # These methods have defined precision, but are only available from the standard library,
+    # not in core. Using these substitutes allows for no_std compatibility.
+    # f32
+    { path = "f32::rem_euclid", reason = "use ops::rem_euclid instead for no_std compatibility" },
+    { path = "f32::abs", reason = "use ops::abs instead for no_std compatibility" },
+    { path = "f32::sqrt", reason = "use ops::sqrt instead for no_std compatibility" },
+    { path = "f32::copysign", reason = "use ops::copysign instead for no_std compatibility" },
+    { path = "f32::round", reason = "use ops::round instead for no_std compatibility" },
+    { path = "f32::floor", reason = "use ops::floor instead for no_std compatibility" },
+    { path = "f32::fract", reason = "use ops::fract instead for no_std compatibility" },
+    # f64
+    { path = "f64::rem_euclid", reason = "use ops::rem_euclid instead for no_std compatibility" },
+    { path = "f64::abs", reason = "use ops::abs instead for no_std compatibility" },
+    { path = "f64::sqrt", reason = "use ops::sqrt instead for no_std compatibility" },
+    { path = "f64::copysign", reason = "use ops::copysign instead for no_std compatibility" },
+    { path = "f64::round", reason = "use ops::round instead for no_std compatibility" },
+    { path = "f64::floor", reason = "use ops::floor instead for no_std compatibility" },
+    { path = "f64::fract", reason = "use ops::fract instead for no_std compatibility" },
+]
diff --git a/crates/avian2d/Cargo.toml b/crates/avian2d/Cargo.toml
index afa07ee5..06b56386 100644
--- a/crates/avian2d/Cargo.toml
+++ b/crates/avian2d/Cargo.toml
@@ -13,6 +13,7 @@ categories = ["game-development", "science", "simulation"]
 
 [features]
 default = [
+    "std",
     "2d",
     "f32",
     "parry-f32",
@@ -90,6 +91,7 @@ bevy_math = { version = "0.16.0-rc.1", default-features = false }
 bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy", default-features = false, features = [
     "2d",
     "3d",
+    "bevy_reflect",
 ] }
 bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation", default-features = false }
 libm = { version = "0.2", optional = true }
diff --git a/crates/avian3d/Cargo.toml b/crates/avian3d/Cargo.toml
index 33cca14a..3eda2dfe 100644
--- a/crates/avian3d/Cargo.toml
+++ b/crates/avian3d/Cargo.toml
@@ -13,14 +13,15 @@ categories = ["game-development", "science", "simulation"]
 
 [features]
 default = [
+    "std",
     "3d",
     "f32",
     "parry-f32",
     "collider-from-mesh",
-    "bevy_scene",
-    "bevy_picking",
     "debug-plugin",
     "parallel",
+    "bevy_scene",
+    "bevy_picking",
 ]
 3d = []
 f32 = []
@@ -92,6 +93,7 @@ bevy_math = { version = "0.16.0-rc.1", default-features = false }
 bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy", default-features = false, features = [
     "2d",
     "3d",
+    "bevy_reflect",
 ] }
 bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation", default-features = false }
 libm = { version = "0.2", optional = true }
diff --git a/src/collision/collider/parry/mod.rs b/src/collision/collider/parry/mod.rs
index 40c9fb40..98a92586 100644
--- a/src/collision/collider/parry/mod.rs
+++ b/src/collision/collider/parry/mod.rs
@@ -1310,7 +1310,7 @@ fn scale_shape(
             #[cfg(feature = "2d")]
             {
                 if scale.x == scale.y {
-                    Ok(SharedShape::ball(b.radius * scale.x.abs()))
+                    Ok(SharedShape::ball(b.radius * ops::abs(scale.x)))
                 } else {
                     // A 2D circle becomes an ellipse when scaled non-uniformly.
                     Ok(SharedShape::new(EllipseColliderShape(Ellipse {
@@ -1472,7 +1472,7 @@ fn scale_shape(
                     if scale.x == scale.y {
                         return Ok(SharedShape::new(RegularPolygonColliderShape(
                             RegularPolygon::new(
-                                polygon.circumradius() * scale.x.abs() as f32,
+                                polygon.circumradius() * ops::abs(scale.x) as f32,
                                 polygon.sides,
                             ),
                         )));
diff --git a/src/collision/collider/parry/primitives2d.rs b/src/collision/collider/parry/primitives2d.rs
index 9a55c424..cab5c5bb 100644
--- a/src/collision/collider/parry/primitives2d.rs
+++ b/src/collision/collider/parry/primitives2d.rs
@@ -1,4 +1,7 @@
-use crate::{math, AdjustPrecision, Scalar, Vector, FRAC_PI_2, PI, TAU};
+use crate::{
+    math::{self, FloatPow},
+    AdjustPrecision, Scalar, Vector, FRAC_PI_2, PI, TAU,
+};
 
 use super::{AsF32, Collider, IntoCollider};
 use alloc::boxed::Box;
@@ -41,7 +44,7 @@ impl SupportMap for EllipseColliderShape {
     #[inline]
     fn local_support_point(&self, direction: &Vector2<Scalar>) -> Point2<Scalar> {
         let [a, b] = self.half_size.adjust_precision().to_array();
-        let denom = (direction.x.powi(2) * a * a + direction.y.powi(2) * b * b).sqrt();
+        let denom = ops::sqrt(direction.x.squared() * a * a + direction.y.squared() * b * b);
         Point2::new(a * a * direction.x / denom, b * b * direction.y / denom)
     }
 }
@@ -275,7 +278,7 @@ impl SupportMap for RegularPolygonColliderShape {
         };
 
         // How many rotations of `external_angle` correspond to the vertex closest to the support direction.
-        let n = (angle_from_top / external_angle).round() % self.sides as Scalar;
+        let n = ops::round(angle_from_top / external_angle) % self.sides as Scalar;
 
         // Rotate by an additional 90 degrees so that the first vertex is always at the top.
         let target_angle = n * external_angle + FRAC_PI_2;
@@ -304,7 +307,7 @@ impl PolygonalFeatureMap for RegularPolygonColliderShape {
 
         // How many rotations of `external_angle` correspond to the vertices.
         let n_unnormalized = angle_from_top / external_angle;
-        let n1 = n_unnormalized.floor() % self.sides as Scalar;
+        let n1 = ops::floor(n_unnormalized) % self.sides as Scalar;
         let n2 = n_unnormalized.ceil() % self.sides as Scalar;
 
         // Rotate by an additional 90 degrees so that the first vertex is always at the top.
@@ -393,8 +396,8 @@ impl Shape for RegularPolygonColliderShape {
         let mass = volume * density;
 
         let half_external_angle = PI / self.sides as Scalar;
-        let angular_inertia = mass * self.circumradius().adjust_precision().powi(2) / 6.0
-            * (1.0 + 2.0 * half_external_angle.cos().powi(2));
+        let angular_inertia = mass * self.circumradius().adjust_precision().squared() / 6.0
+            * (1.0 + 2.0 * ops::cos(half_external_angle).squared());
 
         MassProperties::new(Point2::origin(), mass, angular_inertia)
     }
diff --git a/src/collision/mod.rs b/src/collision/mod.rs
index 34941a29..9a453128 100644
--- a/src/collision/mod.rs
+++ b/src/collision/mod.rs
@@ -295,7 +295,7 @@ impl Contacts {
 
         for manifold in &self.manifolds {
             let impulse = manifold.max_normal_impulse();
-            if impulse.abs() > magnitude.abs() {
+            if ops::abs(impulse) > ops::abs(magnitude) {
                 magnitude = impulse;
                 normal = manifold.normal;
             }
@@ -448,7 +448,7 @@ impl ContactManifold {
         distance_threshold: Scalar,
     ) {
         // The squared maximum distance for two contact points to be considered matching.
-        let distance_threshold_squared = distance_threshold.powi(2);
+        let distance_threshold_squared = distance_threshold.squared();
 
         for contact in self.points.iter_mut() {
             for previous_contact in previous_contacts.iter() {
diff --git a/src/collision/narrow_phase.rs b/src/collision/narrow_phase.rs
index 8d17562f..9a974a80 100644
--- a/src/collision/narrow_phase.rs
+++ b/src/collision/narrow_phase.rs
@@ -370,7 +370,6 @@ fn generate_constraints<C: AnyCollider>(
 /// and generates [`ContactConstraints`] for the contacts.
 #[derive(SystemParam)]
 pub struct NarrowPhase<'w, 's, C: AnyCollider> {
-    parallel_commands: ParallelCommands<'w, 's>,
     collider_query: Query<'w, 's, ColliderQuery<C>, Without<ColliderDisabled>>,
     body_query: Query<
         'w,
@@ -776,15 +775,6 @@ impl<C: AnyCollider> NarrowPhase<'_, '_, C> {
             return;
         }
 
-        // When an active body collides with a sleeping body, wake up the sleeping body.
-        self.parallel_commands.command_scope(|mut commands| {
-            if body1.is_sleeping {
-                commands.queue(WakeUpBody(body1.entity));
-            } else if body2.is_sleeping {
-                commands.queue(WakeUpBody(body2.entity));
-            }
-        });
-
         let contact_softness = if !body1.rb.is_dynamic() || !body2.rb.is_dynamic() {
             contact_softness.non_dynamic
         } else {
diff --git a/src/dynamics/ccd/mod.rs b/src/dynamics/ccd/mod.rs
index 901e132c..76f4ae4d 100644
--- a/src/dynamics/ccd/mod.rs
+++ b/src/dynamics/ccd/mod.rs
@@ -579,15 +579,15 @@ fn solve_swept_ccd(
 
                 #[cfg(feature = "2d")]
                 let ang_vel_below_threshold =
-                    (ang_vel1.0 - ang_vel2).abs() < ccd1.angular_threshold;
+                    ops::abs(ang_vel1.0 - ang_vel2) < ccd1.angular_threshold;
                 #[cfg(feature = "3d")]
                 let ang_vel_below_threshold =
-                    (ang_vel1.0 - ang_vel2).length_squared() < ccd1.angular_threshold.powi(2);
+                    (ang_vel1.0 - ang_vel2).length_squared() < ccd1.angular_threshold.squared();
 
                 // If both the relative linear and relative angular velocity
                 // are below the defined thresholds, skip this body.
                 if ang_vel_below_threshold
-                    && (lin_vel1.0 - lin_vel2).length_squared() < ccd1.linear_threshold.powi(2)
+                    && (lin_vel1.0 - lin_vel2).length_squared() < ccd1.linear_threshold.squared()
                 {
                     continue;
                 }
diff --git a/src/dynamics/integrator/mod.rs b/src/dynamics/integrator/mod.rs
index 3d81ebf3..aaee3c40 100644
--- a/src/dynamics/integrator/mod.rs
+++ b/src/dynamics/integrator/mod.rs
@@ -233,20 +233,20 @@ fn integrate_velocities(
         // Clamp velocities
         if let Some(max_linear_speed) = body.max_linear_speed {
             let linear_speed_squared = body.lin_vel.0.length_squared();
-            if linear_speed_squared > max_linear_speed.0.powi(2) {
-                body.lin_vel.0 *= max_linear_speed.0 / linear_speed_squared.sqrt();
+            if linear_speed_squared > max_linear_speed.0.squared() {
+                body.lin_vel.0 *= max_linear_speed.0 / ops::sqrt(linear_speed_squared);
             }
         }
         if let Some(max_angular_speed) = body.max_angular_speed {
             #[cfg(feature = "2d")]
-            if body.ang_vel.abs() > max_angular_speed.0 {
-                body.ang_vel.0 = max_angular_speed.copysign(body.ang_vel.0);
+            if ops::abs(body.ang_vel.0) > max_angular_speed.0 {
+                body.ang_vel.0 = ops::copysign(max_angular_speed.0, body.ang_vel.0);
             }
             #[cfg(feature = "3d")]
             {
                 let angular_speed_squared = body.ang_vel.0.length_squared();
-                if angular_speed_squared > max_angular_speed.0.powi(2) {
-                    body.ang_vel.0 *= max_angular_speed.0 / angular_speed_squared.sqrt();
+                if angular_speed_squared > max_angular_speed.0.squared() {
+                    body.ang_vel.0 *= max_angular_speed.0 / ops::sqrt(angular_speed_squared);
                 }
             }
         }
diff --git a/src/dynamics/rigid_body/physics_material.rs b/src/dynamics/rigid_body/physics_material.rs
index 4b077820..277c6ec5 100644
--- a/src/dynamics/rigid_body/physics_material.rs
+++ b/src/dynamics/rigid_body/physics_material.rs
@@ -28,7 +28,7 @@ impl CoefficientCombine {
     pub fn mix(&self, a: Scalar, b: Scalar) -> Scalar {
         match self {
             CoefficientCombine::Average => (a + b) * 0.5,
-            CoefficientCombine::GeometricMean => (a * b).sqrt(),
+            CoefficientCombine::GeometricMean => ops::sqrt(a * b),
             CoefficientCombine::Min => a.min(b),
             CoefficientCombine::Multiply => a * b,
             CoefficientCombine::Max => a.max(b),
diff --git a/src/dynamics/sleeping/mod.rs b/src/dynamics/sleeping/mod.rs
index a56b7728..6c429f03 100644
--- a/src/dynamics/sleeping/mod.rs
+++ b/src/dynamics/sleeping/mod.rs
@@ -149,7 +149,7 @@ pub fn mark_sleeping_bodies(
     length_unit: Res<PhysicsLengthUnit>,
     time: Res<Time>,
 ) {
-    let length_unit_sq = length_unit.powi(2);
+    let length_unit_sq = length_unit.squared();
     let delta_secs = time.delta_seconds_adjusted();
 
     for (entity, rb, mut lin_vel, mut ang_vel, mut time_sleeping) in &mut query {
@@ -177,14 +177,14 @@ pub fn mark_sleeping_bodies(
         let lin_vel_sq = lin_vel.length_squared();
 
         #[cfg(feature = "2d")]
-        let ang_vel_sq = ang_vel.0.powi(2);
+        let ang_vel_sq = ang_vel.0.squared();
         #[cfg(feature = "3d")]
         let ang_vel_sq = ang_vel.0.dot(ang_vel.0);
 
         // Negative thresholds indicate that sleeping is disabled.
         let lin_sleeping_threshold_sq =
-            length_unit_sq * sleep_threshold.linear * sleep_threshold.linear.abs();
-        let ang_sleeping_threshold_sq = sleep_threshold.angular * sleep_threshold.angular.abs();
+            length_unit_sq * sleep_threshold.linear * ops::abs(sleep_threshold.linear);
+        let ang_sleeping_threshold_sq = sleep_threshold.angular * ops::abs(sleep_threshold.angular);
 
         // If linear and angular velocity are below the sleeping threshold,
         // add delta time to the time sleeping, i.e. the time that the body has remained still.
diff --git a/src/dynamics/solver/contact/tangent_part.rs b/src/dynamics/solver/contact/tangent_part.rs
index 10aeb105..7489c795 100644
--- a/src/dynamics/solver/contact/tangent_part.rs
+++ b/src/dynamics/solver/contact/tangent_part.rs
@@ -208,8 +208,8 @@ impl ContactTangentPart {
             // Solve the two tangent directions simultaneously.
             // Based on Rapier's two-body constraint.
             // https://github.com/dimforge/rapier/blob/af1ac9baa26b1199ae2728e91adf5345bcd1c693/src/dynamics/solver/contact_constraint/two_body_constraint_element.rs#L127-L133
-            let t11 = tangent_speed1.powi(2);
-            let t22 = tangent_speed2.powi(2);
+            let t11 = tangent_speed1.squared();
+            let t22 = tangent_speed2.squared();
             let t12 = tangent_speed1 * tangent_speed2;
             let inv = t11 * self.effective_inverse_mass[0]
                 + t22 * self.effective_inverse_mass[1]
diff --git a/src/dynamics/solver/joints/distance.rs b/src/dynamics/solver/joints/distance.rs
index e937ea1d..ee9ffa01 100644
--- a/src/dynamics/solver/joints/distance.rs
+++ b/src/dynamics/solver/joints/distance.rs
@@ -144,7 +144,7 @@ impl DistanceJoint {
         );
 
         // Avoid division by zero and unnecessary computation
-        if distance.abs() < Scalar::EPSILON {
+        if ops::abs(distance) < Scalar::EPSILON {
             return Vector::ZERO;
         }
 
diff --git a/src/dynamics/solver/joints/mod.rs b/src/dynamics/solver/joints/mod.rs
index b3ca329b..be95602d 100644
--- a/src/dynamics/solver/joints/mod.rs
+++ b/src/dynamics/solver/joints/mod.rs
@@ -300,7 +300,7 @@ impl AngleLimit {
         // [limit_axis, axis1, axis2] = [n, n1, n2] in XPBD rigid body paper.
 
         // Angle between axis1 and axis2 with respect to limit_axis.
-        let mut phi = axis1.cross(axis2).dot(limit_axis).asin();
+        let mut phi = ops::asin(axis1.cross(axis2).dot(limit_axis));
 
         // `asin` returns the angle in the [-pi/2, pi/2] range.
         // This is correct if the angle between n1 and n2 is acute,
diff --git a/src/dynamics/solver/xpbd/angular_constraint.rs b/src/dynamics/solver/xpbd/angular_constraint.rs
index 74fdceaf..c8dab797 100644
--- a/src/dynamics/solver/xpbd/angular_constraint.rs
+++ b/src/dynamics/solver/xpbd/angular_constraint.rs
@@ -14,7 +14,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         body2: &mut RigidBodyQueryItem,
         delta_lagrange: Scalar,
     ) -> Scalar {
-        if delta_lagrange.abs() <= Scalar::EPSILON {
+        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return 0.0;
         }
 
@@ -60,7 +60,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         delta_lagrange: Scalar,
         axis: Vector,
     ) -> Vector {
-        if delta_lagrange.abs() <= Scalar::EPSILON {
+        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return Vector::ZERO;
         }
 
@@ -116,7 +116,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         compliance: Scalar,
         dt: Scalar,
     ) -> Torque {
-        if angle.abs() <= Scalar::EPSILON {
+        if ops::abs(angle) <= Scalar::EPSILON {
             return Torque::ZERO;
         }
 
@@ -185,7 +185,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         delta_lagrange: Scalar,
         axis: Vector3,
     ) -> Scalar {
-        if delta_lagrange.abs() <= Scalar::EPSILON {
+        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return 0.0;
         }
 
@@ -220,7 +220,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         delta_lagrange: Scalar,
         axis: Vector,
     ) -> Vector {
-        if delta_lagrange.abs() <= Scalar::EPSILON {
+        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return Vector::ZERO;
         }
 
@@ -296,13 +296,13 @@ pub trait AngularConstraint: XpbdConstraint<2> {
     #[cfg(feature = "2d")]
     fn compute_torque(&self, lagrange: Scalar, dt: Scalar) -> Torque {
         // Eq (17)
-        lagrange / dt.powi(2)
+        lagrange / dt.squared()
     }
 
     /// Computes the torque acting along the constraint using the equation `tau = lambda * n / h^2`
     #[cfg(feature = "3d")]
     fn compute_torque(&self, lagrange: Scalar, axis: Vector, dt: Scalar) -> Torque {
         // Eq (17)
-        lagrange * axis / dt.powi(2)
+        lagrange * axis / dt.squared()
     }
 }
diff --git a/src/dynamics/solver/xpbd/mod.rs b/src/dynamics/solver/xpbd/mod.rs
index 3acdba89..c16c71de 100644
--- a/src/dynamics/solver/xpbd/mod.rs
+++ b/src/dynamics/solver/xpbd/mod.rs
@@ -287,7 +287,7 @@ pub trait XpbdConstraint<const ENTITY_COUNT: usize>: MapEntities {
         }
 
         // tilde_a = a/h^2
-        let tilde_compliance = compliance / dt.powi(2);
+        let tilde_compliance = compliance / dt.squared();
 
         (-c - tilde_compliance * lagrange) / (w_sum + tilde_compliance)
     }
@@ -317,7 +317,7 @@ pub trait XpbdConstraint<const ENTITY_COUNT: usize>: MapEntities {
         }
 
         // tilde_a = a/h^2
-        let tilde_compliance = compliance / dt.powi(2);
+        let tilde_compliance = compliance / dt.squared();
 
         (-c - tilde_compliance * lagrange) / (w_sum + tilde_compliance)
     }
diff --git a/src/dynamics/solver/xpbd/positional_constraint.rs b/src/dynamics/solver/xpbd/positional_constraint.rs
index acb66fec..675c970a 100644
--- a/src/dynamics/solver/xpbd/positional_constraint.rs
+++ b/src/dynamics/solver/xpbd/positional_constraint.rs
@@ -17,7 +17,7 @@ pub trait PositionConstraint: XpbdConstraint<2> {
         r1: Vector,
         r2: Vector,
     ) -> Vector {
-        if delta_lagrange.abs() <= Scalar::EPSILON {
+        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return Vector::ZERO;
         }
 
@@ -92,7 +92,7 @@ pub trait PositionConstraint: XpbdConstraint<2> {
         n: Vector,
     ) -> Scalar {
         if body.rb.is_dynamic() {
-            body.mass.inverse() + body.angular_inertia.inverse() * r.perp_dot(n).powi(2)
+            body.mass.inverse() + body.angular_inertia.inverse() * r.perp_dot(n).squared()
         } else {
             // Static and kinematic bodies are a special case, where 0.0 can be thought of as infinite mass.
             0.0
@@ -138,6 +138,6 @@ pub trait PositionConstraint: XpbdConstraint<2> {
 
     /// Computes the force acting along the constraint using the equation f = lambda * n / h^2
     fn compute_force(&self, lagrange: Scalar, direction: Vector, dt: Scalar) -> Vector {
-        lagrange * direction / dt.powi(2)
+        lagrange * direction / dt.squared()
     }
 }
diff --git a/src/math/mod.rs b/src/math/mod.rs
index 1ca5b261..66dd820c 100644
--- a/src/math/mod.rs
+++ b/src/math/mod.rs
@@ -12,6 +12,19 @@ mod double;
 #[cfg(feature = "f64")]
 pub use double::*;
 
+#[cfg(feature = "f64")]
+mod ops_f64;
+
+#[cfg(feature = "f32")]
+pub use bevy_math::ops;
+#[cfg(feature = "f64")]
+pub use ops_f64 as ops;
+
+#[cfg(feature = "f32")]
+pub(crate) use bevy_math::ops::FloatPow;
+#[cfg(feature = "f64")]
+pub(crate) use ops_f64::FloatPow;
+
 use bevy_math::{prelude::*, *};
 
 /// The active dimension.
diff --git a/src/math/ops_f64.rs b/src/math/ops_f64.rs
new file mode 100644
index 00000000..cf2600bf
--- /dev/null
+++ b/src/math/ops_f64.rs
@@ -0,0 +1,626 @@
+//! This mod re-exports the correct versions of floating-point operations with
+//! unspecified precision in the standard library depending on whether the `libm`
+//! crate feature is enabled.
+//!
+//! All the functions here are named according to their versions in the standard
+//! library.
+//!
+//! It also provides `no_std` compatible alternatives to certain floating-point
+//! operations which are not provided in the [`core`] library.
+
+// Note: There are some Rust methods with unspecified precision without a `libm`
+// equivalent:
+// - `f64::powi` (integer powers)
+// - `f64::log` (logarithm with specified base)
+// - `f64::abs_sub` (actually unsure if `libm` has this, but don't use it regardless)
+//
+// Additionally, the following nightly API functions are not presently integrated
+// into this, but they would be candidates once standardized:
+// - `f64::gamma`
+// - `f64::ln_gamma`
+
+#[cfg(not(feature = "libm"))]
+#[expect(
+    clippy::disallowed_methods,
+    reason = "Many of the disallowed methods are disallowed to force code to use the feature-conditional re-exports from this module, but this module itself is exempt from that rule."
+)]
+mod std_ops {
+
+    /// Raises a number to a floating point power.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn powf(x: f64, y: f64) -> f64 {
+        f64::powf(x, y)
+    }
+
+    /// Returns `e^(self)`, (the exponential function).
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn exp(x: f64) -> f64 {
+        f64::exp(x)
+    }
+
+    /// Returns `2^(self)`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn exp2(x: f64) -> f64 {
+        f64::exp2(x)
+    }
+
+    /// Returns the natural logarithm of the number.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn ln(x: f64) -> f64 {
+        f64::ln(x)
+    }
+
+    /// Returns the base 2 logarithm of the number.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn log2(x: f64) -> f64 {
+        f64::log2(x)
+    }
+
+    /// Returns the base 10 logarithm of the number.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn log10(x: f64) -> f64 {
+        f64::log10(x)
+    }
+
+    /// Returns the cube root of a number.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn cbrt(x: f64) -> f64 {
+        f64::cbrt(x)
+    }
+
+    /// Compute the distance between the origin and a point `(x, y)` on the Euclidean plane.
+    /// Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length `x.abs()` and `y.abs()`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn hypot(x: f64, y: f64) -> f64 {
+        f64::hypot(x, y)
+    }
+
+    /// Computes the sine of a number (in radians).
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn sin(x: f64) -> f64 {
+        f64::sin(x)
+    }
+
+    /// Computes the cosine of a number (in radians).
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn cos(x: f64) -> f64 {
+        f64::cos(x)
+    }
+
+    /// Computes the tangent of a number (in radians).
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn tan(x: f64) -> f64 {
+        f64::tan(x)
+    }
+
+    /// Computes the arcsine of a number. Return value is in radians in
+    /// the range [-pi/2, pi/2] or NaN if the number is outside the range
+    /// [-1, 1].
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn asin(x: f64) -> f64 {
+        f64::asin(x)
+    }
+
+    /// Computes the arccosine of a number. Return value is in radians in
+    /// the range [0, pi] or NaN if the number is outside the range
+    /// [-1, 1].
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn acos(x: f64) -> f64 {
+        f64::acos(x)
+    }
+
+    /// Computes the arctangent of a number. Return value is in radians in the
+    /// range [-pi/2, pi/2];
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn atan(x: f64) -> f64 {
+        f64::atan(x)
+    }
+
+    /// Computes the four-quadrant arctangent of `y` and `x` in radians.
+    ///
+    /// * `x = 0`, `y = 0`: `0`
+    /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
+    /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
+    /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn atan2(y: f64, x: f64) -> f64 {
+        f64::atan2(y, x)
+    }
+
+    /// Simultaneously computes the sine and cosine of the number, `x`. Returns
+    /// `(sin(x), cos(x))`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn sin_cos(x: f64) -> (f64, f64) {
+        f64::sin_cos(x)
+    }
+
+    /// Returns `e^(self) - 1` in a way that is accurate even if the
+    /// number is close to zero.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn exp_m1(x: f64) -> f64 {
+        f64::exp_m1(x)
+    }
+
+    /// Returns `ln(1+n)` (natural logarithm) more accurately than if
+    /// the operations were performed separately.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn ln_1p(x: f64) -> f64 {
+        f64::ln_1p(x)
+    }
+
+    /// Hyperbolic sine function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn sinh(x: f64) -> f64 {
+        f64::sinh(x)
+    }
+
+    /// Hyperbolic cosine function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn cosh(x: f64) -> f64 {
+        f64::cosh(x)
+    }
+
+    /// Hyperbolic tangent function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn tanh(x: f64) -> f64 {
+        f64::tanh(x)
+    }
+
+    /// Inverse hyperbolic sine function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn asinh(x: f64) -> f64 {
+        f64::asinh(x)
+    }
+
+    /// Inverse hyperbolic cosine function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn acosh(x: f64) -> f64 {
+        f64::acosh(x)
+    }
+
+    /// Inverse hyperbolic tangent function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn atanh(x: f64) -> f64 {
+        f64::atanh(x)
+    }
+}
+
+#[cfg(feature = "libm")]
+mod libm_ops {
+
+    /// Raises a number to a floating point power.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn powf(x: f64, y: f64) -> f64 {
+        libm::pow(x, y)
+    }
+
+    /// Returns `e^(self)`, (the exponential function).
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn exp(x: f64) -> f64 {
+        libm::exp(x)
+    }
+
+    /// Returns `2^(self)`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn exp2(x: f64) -> f64 {
+        libm::exp2(x)
+    }
+
+    /// Returns the natural logarithm of the number.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn ln(x: f64) -> f64 {
+        // This isn't documented in `libm` but this is actually the base e logarithm.
+        libm::log(x)
+    }
+
+    /// Returns the base 2 logarithm of the number.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn log2(x: f64) -> f64 {
+        libm::log2(x)
+    }
+
+    /// Returns the base 10 logarithm of the number.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn log10(x: f64) -> f64 {
+        libm::log10(x)
+    }
+
+    /// Returns the cube root of a number.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn cbrt(x: f64) -> f64 {
+        libm::cbrt(x)
+    }
+
+    /// Compute the distance between the origin and a point `(x, y)` on the Euclidean plane.
+    ///
+    /// Equivalently, compute the length of the hypotenuse of a right-angle triangle with other sides having length `x.abs()` and `y.abs()`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn hypot(x: f64, y: f64) -> f64 {
+        libm::hypot(x, y)
+    }
+
+    /// Computes the sine of a number (in radians).
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn sin(x: f64) -> f64 {
+        libm::sin(x)
+    }
+
+    /// Computes the cosine of a number (in radians).
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn cos(x: f64) -> f64 {
+        libm::cos(x)
+    }
+
+    /// Computes the tangent of a number (in radians).
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn tan(x: f64) -> f64 {
+        libm::tan(x)
+    }
+
+    /// Computes the arcsine of a number. Return value is in radians in
+    /// the range [-pi/2, pi/2] or NaN if the number is outside the range
+    /// [-1, 1].
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn asin(x: f64) -> f64 {
+        libm::asin(x)
+    }
+
+    /// Computes the arccosine of a number. Return value is in radians in
+    /// Hyperbolic tangent function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    /// the range [0, pi] or NaN if the number is outside the range
+    /// [-1, 1].
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn acos(x: f64) -> f64 {
+        libm::acos(x)
+    }
+
+    /// Computes the arctangent of a number. Return value is in radians in the
+    /// range [-pi/2, pi/2];
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn atan(x: f64) -> f64 {
+        libm::atan(x)
+    }
+
+    /// Computes the four-quadrant arctangent of `y` and `x` in radians.
+    ///
+    /// * `x = 0`, `y = 0`: `0`
+    /// * `x >= 0`: `arctan(y/x)` -> `[-pi/2, pi/2]`
+    /// * `y >= 0`: `arctan(y/x) + pi` -> `(pi/2, pi]`
+    /// * `y < 0`: `arctan(y/x) - pi` -> `(-pi, -pi/2)`
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn atan2(y: f64, x: f64) -> f64 {
+        libm::atan2(y, x)
+    }
+
+    /// Simultaneously computes the sine and cosine of the number, `x`. Returns
+    /// `(sin(x), cos(x))`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn sin_cos(x: f64) -> (f64, f64) {
+        libm::sincos(x)
+    }
+
+    /// Returns `e^(self) - 1` in a way that is accurate even if the
+    /// number is close to zero.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn exp_m1(x: f64) -> f64 {
+        libm::expm1(x)
+    }
+
+    /// Returns `ln(1+n)` (natural logarithm) more accurately than if
+    /// the operations were performed separately.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn ln_1p(x: f64) -> f64 {
+        libm::log1p(x)
+    }
+
+    /// Hyperbolic sine function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn sinh(x: f64) -> f64 {
+        libm::sinh(x)
+    }
+
+    /// Hyperbolic cosine function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn cosh(x: f64) -> f64 {
+        libm::cosh(x)
+    }
+
+    /// Hyperbolic tangent function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn tanh(x: f64) -> f64 {
+        libm::tanh(x)
+    }
+
+    /// Inverse hyperbolic sine function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn asinh(x: f64) -> f64 {
+        libm::asinh(x)
+    }
+
+    /// Inverse hyperbolic cosine function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn acosh(x: f64) -> f64 {
+        libm::acosh(x)
+    }
+
+    /// Inverse hyperbolic tangent function.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn atanh(x: f64) -> f64 {
+        libm::atanh(x)
+    }
+}
+
+#[cfg(all(feature = "libm", not(feature = "std")))]
+mod libm_ops_for_no_std {
+    //! Provides standardized names for [`f64`] operations which may not be
+    //! supported on `no_std` platforms.
+    //! On `no_std` platforms, this forwards to the implementations provided
+    //! by [`libm`].
+
+    /// Calculates the least nonnegative remainder of `self (mod rhs)`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn rem_euclid(x: f64, y: f64) -> f64 {
+        let result = libm::remainder(x, y);
+
+        // libm::remainderf has a range of -y/2 to +y/2
+        if result < 0. {
+            result + y
+        } else {
+            result
+        }
+    }
+
+    /// Computes the absolute value of x.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn abs(x: f64) -> f64 {
+        libm::fabs(x)
+    }
+
+    /// Returns the square root of a number.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn sqrt(x: f64) -> f64 {
+        libm::sqrt(x)
+    }
+
+    /// Returns a number composed of the magnitude of `x` and the sign of `y`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn copysign(x: f64, y: f64) -> f64 {
+        libm::copysign(x, y)
+    }
+
+    /// Returns the nearest integer to `x`. If a value is half-way between two integers, round away from `0.0`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn round(x: f64) -> f64 {
+        libm::round(x)
+    }
+
+    /// Returns the largest integer less than or equal to `x`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn floor(x: f64) -> f64 {
+        libm::floor(x)
+    }
+
+    /// Returns the fractional part of `x`.
+    ///
+    /// This function always returns the precise result.
+    #[inline(always)]
+    pub fn fract(x: f64) -> f64 {
+        libm::modf(x).0
+    }
+}
+
+#[cfg(feature = "std")]
+#[expect(
+    clippy::disallowed_methods,
+    reason = "Many of the disallowed methods are disallowed to force code to use the feature-conditional re-exports from this module, but this module itself is exempt from that rule."
+)]
+mod std_ops_for_no_std {
+    //! Provides standardized names for [`f64`] operations which may not be
+    //! supported on `no_std` platforms.
+    //! On `std` platforms, this forwards directly to the implementations provided
+    //! by [`std`].
+
+    /// Calculates the least nonnegative remainder of `x (mod y)`.
+    ///
+    /// The result of this operation is guaranteed to be the rounded infinite-precision result.
+    #[inline(always)]
+    pub fn rem_euclid(x: f64, y: f64) -> f64 {
+        f64::rem_euclid(x, y)
+    }
+
+    /// Computes the absolute value of x.
+    ///
+    /// This function always returns the precise result.
+    #[inline(always)]
+    pub fn abs(x: f64) -> f64 {
+        f64::abs(x)
+    }
+
+    /// Returns the square root of a number.
+    ///
+    /// The result of this operation is guaranteed to be the rounded infinite-precision result.
+    /// It is specified by IEEE 754 as `squareRoot` and guaranteed not to change.
+    #[inline(always)]
+    pub fn sqrt(x: f64) -> f64 {
+        f64::sqrt(x)
+    }
+
+    /// Returns a number composed of the magnitude of `x` and the sign of `y`.
+    ///
+    /// Equal to `x` if the sign of `x` and `y` are the same, otherwise equal to `-x`. If `x` is a
+    /// `NaN`, then a `NaN` with the sign bit of `y` is returned. Note, however, that conserving the
+    /// sign bit on `NaN` across arithmetical operations is not generally guaranteed.
+    #[inline(always)]
+    pub fn copysign(x: f64, y: f64) -> f64 {
+        f64::copysign(x, y)
+    }
+
+    /// Returns the nearest integer to `x`. If a value is half-way between two integers, round away from `0.0`.
+    ///
+    /// This function always returns the precise result.
+    #[inline(always)]
+    pub fn round(x: f64) -> f64 {
+        f64::round(x)
+    }
+
+    /// Returns the largest integer less than or equal to `x`.
+    ///
+    /// This function always returns the precise result.
+    #[inline(always)]
+    pub fn floor(x: f64) -> f64 {
+        f64::floor(x)
+    }
+
+    /// Returns the fractional part of `x`.
+    ///
+    /// This function always returns the precise result.
+    #[inline(always)]
+    pub fn fract(x: f64) -> f64 {
+        f64::fract(x)
+    }
+}
+
+#[cfg(feature = "libm")]
+pub use libm_ops::*;
+
+#[cfg(not(feature = "libm"))]
+pub use std_ops::*;
+
+#[cfg(feature = "std")]
+pub use std_ops_for_no_std::*;
+
+#[cfg(all(feature = "libm", not(feature = "std")))]
+pub use libm_ops_for_no_std::*;
+
+#[cfg(all(not(feature = "libm"), not(feature = "std")))]
+compile_error!("Either the `libm` feature or the `std` feature must be enabled.");
+
+/// This extension trait covers shortfall in determinacy from the lack of a `libm` counterpart
+/// to `f64::powi`. Use this for the common small exponents.
+pub trait FloatPow {
+    /// Squares the f64
+    fn squared(self) -> Self;
+    /// Cubes the f64
+    fn cubed(self) -> Self;
+}
+
+impl FloatPow for f64 {
+    #[inline]
+    fn squared(self) -> Self {
+        self * self
+    }
+    #[inline]
+    fn cubed(self) -> Self {
+        self * self * self
+    }
+}
diff --git a/src/position.rs b/src/position.rs
index eb26b1fd..31fa7463 100644
--- a/src/position.rs
+++ b/src/position.rs
@@ -212,14 +212,7 @@ impl Rotation {
     /// Creates a [`Rotation`] from a counterclockwise angle in radians.
     #[inline]
     pub fn radians(radians: Scalar) -> Self {
-        #[cfg(feature = "enhanced-determinism")]
-        let (sin, cos) = (
-            libm::sin(radians as f64) as Scalar,
-            libm::cos(radians as f64) as Scalar,
-        );
-        #[cfg(not(feature = "enhanced-determinism"))]
-        let (sin, cos) = radians.sin_cos();
-
+        let (sin, cos) = ops::sin_cos(radians);
         Self::from_sin_cos(sin, cos)
     }
 
@@ -261,14 +254,7 @@ impl Rotation {
     /// Returns the rotation in radians in the `(-pi, pi]` range.
     #[inline]
     pub fn as_radians(self) -> Scalar {
-        #[cfg(feature = "enhanced-determinism")]
-        {
-            libm::atan2(self.sin as f64, self.cos as f64) as Scalar
-        }
-        #[cfg(not(feature = "enhanced-determinism"))]
-        {
-            Scalar::atan2(self.sin, self.cos)
-        }
+        ops::atan2(self.sin, self.cos)
     }
 
     /// Returns the rotation in degrees in the `(-180, 180]` range.
@@ -392,7 +378,7 @@ impl Rotation {
         // The allowed length is 1 +/- 1e-4, so the largest allowed
         // squared length is (1 + 1e-4)^2 = 1.00020001, which makes
         // the threshold for the squared length approximately 2e-4.
-        (self.length_squared() - 1.0).abs() <= 2e-4
+        ops::abs(self.length_squared() - 1.0) <= 2e-4
     }
 
     /// Returns `true` if the rotation is near [`Rotation::IDENTITY`].
@@ -400,7 +386,7 @@ impl Rotation {
     pub fn is_near_identity(self) -> bool {
         // Same as `Quat::is_near_identity`, but using sine and cosine
         let threshold_angle_sin = 0.000_049_692_047; // let threshold_angle = 0.002_847_144_6;
-        self.cos > 0.0 && self.sin.abs() < threshold_angle_sin
+        self.cos > 0.0 && ops::abs(self.sin) < threshold_angle_sin
     }
 
     /// Returns the angle in radians needed to make `self` and `other` coincide.
@@ -429,7 +415,7 @@ impl Rotation {
         let (sin, cos) = (self.sin + radians * self.cos, self.cos - radians * self.sin);
         let magnitude_squared = sin * sin + cos * cos;
         let magnitude_recip = if magnitude_squared > 0.0 {
-            magnitude_squared.sqrt().recip()
+            ops::sqrt(magnitude_squared).recip()
         } else {
             0.0
         };
@@ -908,8 +894,8 @@ impl From<Rotation> for Scalar {
 #[cfg(feature = "2d")]
 impl From<Rotation> for Quaternion {
     fn from(rot: Rotation) -> Self {
-        let z = rot.sin.signum() * ((1.0 - rot.cos) / 2.0).abs().sqrt();
-        let w = ((1.0 + rot.cos) / 2.0).abs().sqrt();
+        let z = rot.sin.signum() * ops::sqrt(ops::abs((1.0 - rot.cos) / 2.0));
+        let w = ops::sqrt(ops::abs((1.0 + rot.cos) / 2.0));
         Quaternion::from_xyzw(0.0, 0.0, z, w)
     }
 }

From 6a7b217b720c47acc4647045073adbe0ed705633 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sun, 23 Mar 2025 04:36:55 +0200
Subject: [PATCH 03/13] Add feature-dependent `ceil`

---
 clippy.toml                                  |  2 ++
 src/collision/collider/parry/primitives2d.rs |  2 +-
 src/math/mod.rs                              | 26 +++++++++++++++++++-
 src/math/ops_f64.rs                          | 16 ++++++++++++
 4 files changed, 44 insertions(+), 2 deletions(-)

diff --git a/clippy.toml b/clippy.toml
index 96b564c9..c0c68ade 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -64,6 +64,7 @@ disallowed-methods = [
     { path = "f32::copysign", reason = "use ops::copysign instead for no_std compatibility" },
     { path = "f32::round", reason = "use ops::round instead for no_std compatibility" },
     { path = "f32::floor", reason = "use ops::floor instead for no_std compatibility" },
+    { path = "f32::ceil", reason = "use ops::ceil instead for no_std compatibility" },
     { path = "f32::fract", reason = "use ops::fract instead for no_std compatibility" },
     # f64
     { path = "f64::rem_euclid", reason = "use ops::rem_euclid instead for no_std compatibility" },
@@ -72,5 +73,6 @@ disallowed-methods = [
     { path = "f64::copysign", reason = "use ops::copysign instead for no_std compatibility" },
     { path = "f64::round", reason = "use ops::round instead for no_std compatibility" },
     { path = "f64::floor", reason = "use ops::floor instead for no_std compatibility" },
+    { path = "f64::ceil", reason = "use ops::ceil instead for no_std compatibility" },
     { path = "f64::fract", reason = "use ops::fract instead for no_std compatibility" },
 ]
diff --git a/src/collision/collider/parry/primitives2d.rs b/src/collision/collider/parry/primitives2d.rs
index cab5c5bb..fa75412a 100644
--- a/src/collision/collider/parry/primitives2d.rs
+++ b/src/collision/collider/parry/primitives2d.rs
@@ -308,7 +308,7 @@ impl PolygonalFeatureMap for RegularPolygonColliderShape {
         // How many rotations of `external_angle` correspond to the vertices.
         let n_unnormalized = angle_from_top / external_angle;
         let n1 = ops::floor(n_unnormalized) % self.sides as Scalar;
-        let n2 = n_unnormalized.ceil() % self.sides as Scalar;
+        let n2 = math::ceil(n_unnormalized) % self.sides as Scalar;
 
         // Rotate by an additional 90 degrees so that the first vertex is always at the top.
         let target_angle1 = n1 * external_angle + FRAC_PI_2;
diff --git a/src/math/mod.rs b/src/math/mod.rs
index 66dd820c..8deccd34 100644
--- a/src/math/mod.rs
+++ b/src/math/mod.rs
@@ -21,10 +21,34 @@ pub use bevy_math::ops;
 pub use ops_f64 as ops;
 
 #[cfg(feature = "f32")]
-pub(crate) use bevy_math::ops::FloatPow;
+pub(crate) use ops::FloatPow;
 #[cfg(feature = "f64")]
 pub(crate) use ops_f64::FloatPow;
 
+// bevy_math doesn't have these yet.
+
+/// Returns the smallest integer greater than or equal to `x`.
+///
+/// Precision is specified when the `libm` feature is enabled.
+#[inline(always)]
+#[cfg(all(feature = "f32", feature = "libm", not(feature = "std")))]
+pub fn ceil(x: f32) -> f32 {
+    libm::ceilf(x)
+}
+
+/// Returns the smallest integer greater than or equal to `x`.
+///     
+/// Precision is specified when the `std` feature is enabled.
+#[inline(always)]
+#[cfg(all(feature = "f32", feature = "std"))]
+pub fn ceil(x: f32) -> f32 {
+    #[allow(clippy::disallowed_methods)]
+    x.ceil()
+}
+
+#[cfg(feature = "f64")]
+pub use ops_f64::ceil;
+
 use bevy_math::{prelude::*, *};
 
 /// The active dimension.
diff --git a/src/math/ops_f64.rs b/src/math/ops_f64.rs
index cf2600bf..e9ba820f 100644
--- a/src/math/ops_f64.rs
+++ b/src/math/ops_f64.rs
@@ -510,6 +510,14 @@ mod libm_ops_for_no_std {
         libm::floor(x)
     }
 
+    /// Returns the smallest integer greater than or equal to `x`.
+    ///
+    /// Precision is specified when the `libm` feature is enabled.
+    #[inline(always)]
+    pub fn ceil(x: f64) -> f64 {
+        libm::ceil(x)
+    }
+
     /// Returns the fractional part of `x`.
     ///
     /// This function always returns the precise result.
@@ -581,6 +589,14 @@ mod std_ops_for_no_std {
         f64::floor(x)
     }
 
+    /// Returns the smallest integer greater than or equal to `x`.
+    ///
+    /// This function always returns the precise result.
+    #[inline(always)]
+    pub fn ceil(x: f64) -> f64 {
+        f64::ceil(x)
+    }
+
     /// Returns the fractional part of `x`.
     ///
     /// This function always returns the precise result.

From ccd338b82265e3dc454d6627a7256a3118ff6134 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Sun, 23 Mar 2025 04:37:13 +0200
Subject: [PATCH 04/13] Patch Parry and Nalgebra to work with `no_std`

---
 Cargo.toml                                   |  7 +++++++
 crates/avian2d/Cargo.toml                    |  6 ++++--
 crates/avian3d/Cargo.toml                    |  6 ++++--
 src/collision/collider/parry/mod.rs          | 11 ++++++++---
 src/collision/collider/parry/primitives2d.rs |  4 ----
 5 files changed, 23 insertions(+), 11 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index 375766db..c34b9437 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -9,3 +9,10 @@ std_instead_of_core = "warn"
 
 [profile.dev]
 opt-level = 1 # Use slightly better optimization, so examples work
+
+[patch.crates-io]
+parry2d = { git = "https://github.com/Jondolf/barry", branch = "no-std" }
+parry2d-f64 = { git = "https://github.com/Jondolf/barry", branch = "no-std" }
+parry3d = { git = "https://github.com/Jondolf/barry", branch = "no-std" }
+parry3d-f64 = { git = "https://github.com/Jondolf/barry", branch = "no-std" }
+nalgebra = { git = "https://github.com/Jondolf/nalgebra", branch = "glam-no-default-features" }
diff --git a/crates/avian2d/Cargo.toml b/crates/avian2d/Cargo.toml
index 06b56386..f6dec7cb 100644
--- a/crates/avian2d/Cargo.toml
+++ b/crates/avian2d/Cargo.toml
@@ -95,11 +95,13 @@ bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy", default-features =
 ] }
 bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation", default-features = false }
 libm = { version = "0.2", optional = true }
-parry2d = { version = "0.17", optional = true, default-features = false, features = [
+parry2d = { version = "0.18", optional = true, default-features = false, features = [
     "required-features",
+    "alloc",
 ] }
-parry2d-f64 = { version = "0.17", optional = true, default-features = false, features = [
+parry2d-f64 = { version = "0.18", optional = true, default-features = false, features = [
     "required-features",
+    "alloc",
 ] }
 nalgebra = { version = "0.33", default-features = false, features = [
     "convert-glam029",
diff --git a/crates/avian3d/Cargo.toml b/crates/avian3d/Cargo.toml
index 3eda2dfe..e957eaf9 100644
--- a/crates/avian3d/Cargo.toml
+++ b/crates/avian3d/Cargo.toml
@@ -97,11 +97,13 @@ bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy", default-features =
 ] }
 bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation", default-features = false }
 libm = { version = "0.2", optional = true }
-parry3d = { version = "0.17", optional = true, default-features = false, features = [
+parry3d = { version = "0.18", optional = true, default-features = false, features = [
     "required-features",
+    "alloc",
 ] }
-parry3d-f64 = { version = "0.17", optional = true, default-features = false, features = [
+parry3d-f64 = { version = "0.18", optional = true, default-features = false, features = [
     "required-features",
+    "alloc",
 ] }
 nalgebra = { version = "0.33", default-features = false, features = [
     "convert-glam029",
diff --git a/src/collision/collider/parry/mod.rs b/src/collision/collider/parry/mod.rs
index 98a92586..caf68cff 100644
--- a/src/collision/collider/parry/mod.rs
+++ b/src/collision/collider/parry/mod.rs
@@ -852,7 +852,7 @@ impl Collider {
     /// For thin shapes like triangle meshes, it can help improve collision stability and performance.
     pub fn trimesh(vertices: Vec<Vector>, indices: Vec<[u32; 3]>) -> Self {
         let vertices = vertices.into_iter().map(|v| v.into()).collect();
-        SharedShape::trimesh(vertices, indices).into()
+        SharedShape::trimesh(vertices, indices).unwrap().into()
     }
 
     /// Creates a collider with a triangle mesh shape defined by its vertex and index buffers
@@ -868,7 +868,9 @@ impl Collider {
         flags: TrimeshFlags,
     ) -> Self {
         let vertices = vertices.into_iter().map(|v| v.into()).collect();
-        SharedShape::trimesh_with_flags(vertices, indices, flags.into()).into()
+        SharedShape::trimesh_with_flags(vertices, indices, flags.into())
+            .unwrap()
+            .into()
     }
 
     /// Creates a collider shape with a compound shape obtained from the decomposition of a given polyline
@@ -996,6 +998,7 @@ impl Collider {
                 indices,
                 TrimeshFlags::MERGE_DUPLICATE_VERTICES.into(),
             )
+            .unwrap()
             .into()
         })
     }
@@ -1025,7 +1028,9 @@ impl Collider {
     #[cfg(feature = "collider-from-mesh")]
     pub fn trimesh_from_mesh_with_config(mesh: &Mesh, flags: TrimeshFlags) -> Option<Self> {
         extract_mesh_vertices_indices(mesh).map(|(vertices, indices)| {
-            SharedShape::trimesh_with_flags(vertices, indices, flags.into()).into()
+            SharedShape::trimesh_with_flags(vertices, indices, flags.into())
+                .unwrap()
+                .into()
         })
     }
 
diff --git a/src/collision/collider/parry/primitives2d.rs b/src/collision/collider/parry/primitives2d.rs
index fa75412a..7a00642e 100644
--- a/src/collision/collider/parry/primitives2d.rs
+++ b/src/collision/collider/parry/primitives2d.rs
@@ -50,12 +50,10 @@ impl SupportMap for EllipseColliderShape {
 }
 
 impl Shape for EllipseColliderShape {
-    #[cfg(feature = "std")]
     fn clone_dyn(&self) -> Box<dyn Shape> {
         Box::new(*self)
     }
 
-    #[cfg(feature = "std")]
     fn scale_dyn(
         &self,
         scale: &parry::math::Vector<Scalar>,
@@ -331,12 +329,10 @@ impl PolygonalFeatureMap for RegularPolygonColliderShape {
 }
 
 impl Shape for RegularPolygonColliderShape {
-    #[cfg(feature = "std")]
     fn clone_dyn(&self) -> Box<dyn Shape> {
         Box::new(*self)
     }
 
-    #[cfg(feature = "std")]
     fn scale_dyn(
         &self,
         scale: &parry::math::Vector<Scalar>,

From 24804f36615b14ea4442fbaa0d9ee2b4e0f0c07f Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Thu, 17 Apr 2025 11:43:37 +0300
Subject: [PATCH 05/13] Update `data_structures` to be `no_std` compatible

---
 crates/avian2d/Cargo.toml                   |  1 +
 crates/avian3d/Cargo.toml                   |  1 +
 src/data_structures/bit_vec.rs              |  2 ++
 src/data_structures/graph.rs                |  1 +
 src/data_structures/sparse_secondary_map.rs | 21 +++++++++++----------
 5 files changed, 16 insertions(+), 10 deletions(-)

diff --git a/crates/avian2d/Cargo.toml b/crates/avian2d/Cargo.toml
index a3f01bd9..22663438 100644
--- a/crates/avian2d/Cargo.toml
+++ b/crates/avian2d/Cargo.toml
@@ -116,6 +116,7 @@ serde = { version = "1", default-features = false, features = [
 derive_more = { version = "1", default-features = false }
 log = { version = "0.4", default-features = false }
 arrayvec = { version = "0.7", default-features = false }
+hashbrown = { version = "0.15", default-features = false }
 itertools = { version = "0.13", default-features = false }
 bitflags = { version = "2.5.0", default-features = false }
 thread_local = { version = "1.1", optional = true, default-features = false }
diff --git a/crates/avian3d/Cargo.toml b/crates/avian3d/Cargo.toml
index b1483aa2..0a9139b5 100644
--- a/crates/avian3d/Cargo.toml
+++ b/crates/avian3d/Cargo.toml
@@ -117,6 +117,7 @@ serde = { version = "1", default-features = false, features = [
 ], optional = true }
 derive_more = { version = "1", default-features = false }
 log = { version = "0.4", default-features = false }
+hashbrown = { version = "0.15", default-features = false }
 itertools = { version = "0.13", default-features = false }
 bitflags = { version = "2.5.0", default-features = false }
 thread_local = { version = "1.1", optional = true, default-features = false }
diff --git a/src/data_structures/bit_vec.rs b/src/data_structures/bit_vec.rs
index 1bb9ca41..8a75f3bf 100644
--- a/src/data_structures/bit_vec.rs
+++ b/src/data_structures/bit_vec.rs
@@ -5,6 +5,8 @@
 use core::ops::BitOrAssign;
 use core::slice;
 
+use alloc::{vec, vec::Vec};
+
 /// A dynamically sized compact bit vector with a fixed block size of 64 bits.
 #[derive(Clone, Debug, Default)]
 #[cfg_attr(feature = "serialize", derive(serde::Serialize, serde::Deserialize))]
diff --git a/src/data_structures/graph.rs b/src/data_structures/graph.rs
index bd1dc779..fd9f45bb 100644
--- a/src/data_structures/graph.rs
+++ b/src/data_structures/graph.rs
@@ -7,6 +7,7 @@
 use core::cmp::max;
 use core::ops::{Index, IndexMut};
 
+use alloc::vec::Vec;
 use derive_more::derive::From;
 
 /// A node identifier for a graph structure.
diff --git a/src/data_structures/sparse_secondary_map.rs b/src/data_structures/sparse_secondary_map.rs
index 27597b9c..d2c10d6b 100644
--- a/src/data_structures/sparse_secondary_map.rs
+++ b/src/data_structures/sparse_secondary_map.rs
@@ -9,11 +9,12 @@
 //!
 //! [`slotmap::SparseSecondaryMap`]: https://docs.rs/slotmap/1.0.7/slotmap/struct.SparseSecondaryMap.html
 
-use alloc::collections::TryReserveError;
-use bevy::platform::hash::RandomState;
-use core::mem::MaybeUninit;
-use std::collections::hash_map::{self, HashMap};
-use std::hash;
+use bevy::platform::{
+    collections::{hash_map::Entry, HashMap},
+    hash::FixedHasher,
+};
+use core::{hash::BuildHasher, mem::MaybeUninit};
+use hashbrown::TryReserveError;
 
 use bevy::ecs::entity::Entity;
 
@@ -26,11 +27,11 @@ struct Slot<T> {
 /// Sparse secondary map for associating data with previously stored entities
 /// in a generational arena.
 #[derive(Debug, Clone)]
-pub struct SparseSecondaryEntityMap<V, S: hash::BuildHasher = RandomState> {
+pub struct SparseSecondaryEntityMap<V, S: BuildHasher = FixedHasher> {
     slots: HashMap<u32, Slot<V>, S>,
 }
 
-impl<V> SparseSecondaryEntityMap<V, hash_map::RandomState> {
+impl<V> SparseSecondaryEntityMap<V, FixedHasher> {
     /// Constructs a new, empty [`SparseSecondaryEntityMap`].
     #[inline]
     pub fn new() -> Self {
@@ -56,7 +57,7 @@ fn is_older_generation(a: u32, b: u32) -> bool {
     diff >= (1 << 31)
 }
 
-impl<V, S: hash::BuildHasher> SparseSecondaryEntityMap<V, S> {
+impl<V, S: BuildHasher> SparseSecondaryEntityMap<V, S> {
     /// Creates an empty [`SparseSecondaryEntityMap`] which will use the given hash
     /// builder to hash keys.
     ///
@@ -164,7 +165,7 @@ impl<V, S: hash::BuildHasher> SparseSecondaryEntityMap<V, S> {
     /// the entity was not previously removed.
     #[inline]
     pub fn remove(&mut self, entity: Entity) -> Option<V> {
-        if let hash_map::Entry::Occupied(entry) = self.slots.entry(entity.index()) {
+        if let Entry::Occupied(entry) = self.slots.entry(entity.index()) {
             if entry.get().generation == entity.generation() {
                 return Some(entry.remove_entry().1.value);
             }
@@ -317,7 +318,7 @@ impl<V, S: hash::BuildHasher> SparseSecondaryEntityMap<V, S> {
 
 impl<V, S> Default for SparseSecondaryEntityMap<V, S>
 where
-    S: hash::BuildHasher + Default,
+    S: BuildHasher + Default,
 {
     fn default() -> Self {
         Self::with_hasher(Default::default())

From 1f166cb8d52dfd3b7f475932334bba4a0e9237a5 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Thu, 17 Apr 2025 11:44:00 +0300
Subject: [PATCH 06/13] Fix minor `no_std` problems

---
 src/collision/collider/parry/mod.rs | 2 +-
 src/collision/contact_types/mod.rs  | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/src/collision/collider/parry/mod.rs b/src/collision/collider/parry/mod.rs
index 8d4b0bb7..7d33acc2 100644
--- a/src/collision/collider/parry/mod.rs
+++ b/src/collision/collider/parry/mod.rs
@@ -11,9 +11,9 @@ mod primitives3d;
 pub use primitives2d::{EllipseColliderShape, RegularPolygonColliderShape};
 
 use crate::{make_isometry, prelude::*};
+use bevy::prelude::*;
 #[cfg(feature = "collider-from-mesh")]
 use bevy::render::mesh::{Indices, VertexAttributeValues};
-use bevy::{log, prelude::*};
 use contact_query::UnsupportedShape;
 use itertools::Either;
 use parry::shape::{RoundShape, SharedShape, TypedShape};
diff --git a/src/collision/contact_types/mod.rs b/src/collision/contact_types/mod.rs
index ee02a815..e2862c68 100644
--- a/src/collision/contact_types/mod.rs
+++ b/src/collision/contact_types/mod.rs
@@ -109,7 +109,7 @@ impl ContactPair {
 
         for manifold in &self.manifolds {
             let impulse = manifold.max_normal_impulse();
-            if impulse.abs() > magnitude.abs() {
+            if ops::abs(impulse) > ops::abs(magnitude) {
                 magnitude = impulse;
                 normal = manifold.normal;
             }
@@ -282,7 +282,7 @@ impl ContactManifold {
         distance_threshold: Scalar,
     ) {
         // The squared maximum distance for two contact points to be considered matching.
-        let distance_threshold_squared = distance_threshold.powi(2);
+        let distance_threshold_squared = distance_threshold.squared();
 
         for contact in self.points.iter_mut() {
             for previous_contact in previous_contacts.iter() {

From 7d3e1ab5f2c2c327e49fec0186a6ae98b4bae505 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Thu, 17 Apr 2025 11:46:49 +0300
Subject: [PATCH 07/13] Check `no_std` compatibility in CI

---
 .github/workflows/ci.yml | 118 ++++++++++++++++++++++-----------------
 1 file changed, 68 insertions(+), 50 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 5d246083..1ba8622a 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,60 +1,78 @@
 name: CI
 
 on:
-    push:
-        branches:
-            - main
-    pull_request:
+  push:
+    branches:
+      - main
+  pull_request:
 
 env:
-    CARGO_TERM_COLOR: always
+  CARGO_TERM_COLOR: always
 
 jobs:
-    check:
-        name: Check
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v4
-            - uses: dtolnay/rust-toolchain@stable
-            - uses: Swatinem/rust-cache@v2
-            - name: Run cargo check
-              run: cargo check
+  check:
+    name: Check
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Run cargo check
+        run: cargo check
 
-    docs:
-        name: Check Documentation
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v4
-            - uses: dtolnay/rust-toolchain@stable
-            - uses: Swatinem/rust-cache@v2
-            - name: Run cargo doc
-              run: cargo doc --workspace --no-deps --document-private-items --keep-going
-              env:
-                  RUSTDOCFLAGS: "-D warnings"
+  check-compiles-no-std:
+    runs-on: ubuntu-latest
+    strategy:
+      fail-fast: false
+      matrix:
+        target:
+          - "x86_64-unknown-none"
+          - "wasm32v1-none"
+          - "thumbv6m-none-eabi"
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+        with:
+          targets: ${{ matrix.target }}
+      - uses: Swatinem/rust-cache@v2
+      - name: Run cargo check
+        run: cargo check --no-default-features --features libm --target ${{ matrix.target }}
 
-    test:
-        name: Test Suite
-        strategy:
-            matrix:
-                # TODO: Add ubuntu-latest back. It had CI storage issues, so it's left out for now.
-                os: [windows-latest, macos-latest]
-        runs-on: ${{ matrix.os }}
-        timeout-minutes: 60
-        steps:
-            - uses: actions/checkout@v4
-            - uses: dtolnay/rust-toolchain@stable
-            - uses: Swatinem/rust-cache@v2
-            - name: Run cargo test
-              run: cargo test --no-default-features --features enhanced-determinism,collider-from-mesh,serialize,debug-plugin,avian2d/2d,avian3d/3d,avian2d/f64,avian3d/f64,default-collider,parry-f64,bevy_scene,bevy_picking,diagnostic_ui
+  docs:
+    name: Check Documentation
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Run cargo doc
+        run: cargo doc --workspace --no-deps --document-private-items --keep-going
+        env:
+          RUSTDOCFLAGS: "-D warnings"
 
-    lints:
-        name: Lints
-        runs-on: ubuntu-latest
-        steps:
-            - uses: actions/checkout@v4
-            - uses: dtolnay/rust-toolchain@stable
-            - uses: Swatinem/rust-cache@v2
-            - name: Run cargo fmt
-              run: cargo fmt --all -- --check
-            - name: Run cargo clippy
-              run: cargo clippy -- -D warnings
+  test:
+    name: Test Suite
+    strategy:
+      matrix:
+        # TODO: Add ubuntu-latest back. It had CI storage issues, so it's left out for now.
+        os: [windows-latest, macos-latest]
+    runs-on: ${{ matrix.os }}
+    timeout-minutes: 60
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Run cargo test
+        run: cargo test --no-default-features --features enhanced-determinism,collider-from-mesh,serialize,debug-plugin,avian2d/2d,avian3d/3d,avian2d/f64,avian3d/f64,default-collider,parry-f64,bevy_scene,bevy_picking,diagnostic_ui
+
+  lints:
+    name: Lints
+    runs-on: ubuntu-latest
+    steps:
+      - uses: actions/checkout@v4
+      - uses: dtolnay/rust-toolchain@stable
+      - uses: Swatinem/rust-cache@v2
+      - name: Run cargo fmt
+        run: cargo fmt --all -- --check
+      - name: Run cargo clippy
+        run: cargo clippy -- -D warnings

From d9047f6fb7e00eeede930358942caa84c8e07d4a Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Thu, 17 Apr 2025 12:01:42 +0300
Subject: [PATCH 08/13] Clean up attribute order

---
 crates/avian2d/Cargo.toml | 2 +-
 crates/avian3d/Cargo.toml | 3 ++-
 2 files changed, 3 insertions(+), 2 deletions(-)

diff --git a/crates/avian2d/Cargo.toml b/crates/avian2d/Cargo.toml
index 22663438..ec67793d 100644
--- a/crates/avian2d/Cargo.toml
+++ b/crates/avian2d/Cargo.toml
@@ -119,7 +119,7 @@ arrayvec = { version = "0.7", default-features = false }
 hashbrown = { version = "0.15", default-features = false }
 itertools = { version = "0.13", default-features = false }
 bitflags = { version = "2.5.0", default-features = false }
-thread_local = { version = "1.1", optional = true, default-features = false }
+thread_local = { version = "1.1", default-features = false, optional = true }
 
 [dev-dependencies]
 examples_common_2d = { path = "../examples_common_2d" }
diff --git a/crates/avian3d/Cargo.toml b/crates/avian3d/Cargo.toml
index 0a9139b5..188e960e 100644
--- a/crates/avian3d/Cargo.toml
+++ b/crates/avian3d/Cargo.toml
@@ -80,6 +80,7 @@ std = [
 libm = [
     "dep:libm",
     "bevy/libm",
+    "bevy_math/libm",
     "bevy_heavy/libm",
     "bevy_transform_interpolation/libm",
 ]
@@ -120,7 +121,7 @@ log = { version = "0.4", default-features = false }
 hashbrown = { version = "0.15", default-features = false }
 itertools = { version = "0.13", default-features = false }
 bitflags = { version = "2.5.0", default-features = false }
-thread_local = { version = "1.1", optional = true, default-features = false }
+thread_local = { version = "1.1", default-features = false, optional = true }
 
 [dev-dependencies]
 examples_common_3d = { path = "../examples_common_3d" }

From 9f60fd01307624777c2b240f8efdb2fa004c4a1a Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Thu, 17 Apr 2025 14:23:41 +0300
Subject: [PATCH 09/13] Add `ParallelCommands` wrapper to allow using the same
 API on `no_std` platforms

---
 src/lib.rs   |  2 ++
 src/utils.rs | 18 ++++++++++++++++++
 2 files changed, 20 insertions(+)

diff --git a/src/lib.rs b/src/lib.rs
index b71ae2d3..25763d02 100644
--- a/src/lib.rs
+++ b/src/lib.rs
@@ -520,6 +520,8 @@ pub mod prelude {
     };
     #[cfg(feature = "default-collider")]
     pub(crate) use crate::position::RotationValue;
+    #[cfg(not(feature = "std"))]
+    pub(crate) use crate::utils::ParallelCommands;
     pub use crate::{
         collision::prelude::*,
         dynamics::{self, ccd::SpeculativeMargin, prelude::*},
diff --git a/src/utils.rs b/src/utils.rs
index d7b2364d..5aed5bdd 100644
--- a/src/utils.rs
+++ b/src/utils.rs
@@ -2,6 +2,8 @@
 
 use crate::prelude::*;
 
+#[cfg(not(feature = "std"))]
+use bevy::ecs::system::{Commands, SystemParam};
 pub(crate) use bevy::platform::time::Instant;
 
 /// Computes translation of `Position` based on center of mass rotation and translation
@@ -14,6 +16,22 @@ pub(crate) fn get_pos_translation(
     com_translation.0 + (previous_rotation * center_of_mass.0) - (rotation * center_of_mass.0)
 }
 
+/// A wrapper around [`Commands`] to allow using the `ParallelCommands` API
+/// in both `std` and `no_std` environments.
+#[cfg(not(feature = "std"))]
+#[derive(SystemParam)]
+pub(crate) struct ParallelCommands<'w, 's> {
+    commands: Commands<'w, 's>,
+}
+
+#[cfg(not(feature = "std"))]
+impl ParallelCommands<'_, '_> {
+    /// Provides access to [`Commands`].
+    pub fn command_scope<R>(&mut self, f: impl FnOnce(Commands) -> R) -> R {
+        f(self.commands.reborrow())
+    }
+}
+
 /// A helper macro for iterating over a slice in parallel or serially
 /// based on the `parallel` feature.
 ///

From 840942aaf7b53f84e1af74f24b5f48bd4b39c222 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Thu, 17 Apr 2025 14:24:03 +0300
Subject: [PATCH 10/13] Fix usage without Parry

---
 src/collision/mod.rs              | 14 +++++++++-----
 src/collision/narrow_phase/mod.rs |  2 +-
 2 files changed, 10 insertions(+), 6 deletions(-)

diff --git a/src/collision/mod.rs b/src/collision/mod.rs
index 9dea5cfa..4a91ca62 100644
--- a/src/collision/mod.rs
+++ b/src/collision/mod.rs
@@ -93,11 +93,15 @@ pub mod prelude {
     pub use super::collider::{
         collider_hierarchy::{ColliderHierarchyPlugin, ColliderOf, RigidBodyColliders},
         collider_transform::{ColliderTransform, ColliderTransformPlugin},
-        AabbContext, AnyCollider, Collider, ColliderAabb, ColliderBackendPlugin,
-        ColliderConstructor, ColliderConstructorHierarchy, ColliderDisabled, ColliderMarker,
-        CollidingEntities, CollisionLayers, CollisionMargin, ContactManifoldContext, FillMode,
-        IntoCollider, LayerMask, PhysicsLayer, ScalableCollider, Sensor, SimpleCollider,
-        TrimeshFlags, VhacdParameters,
+        AabbContext, AnyCollider, ColliderAabb, ColliderBackendPlugin, ColliderDisabled,
+        ColliderMarker, CollidingEntities, CollisionLayers, CollisionMargin,
+        ContactManifoldContext, IntoCollider, LayerMask, PhysicsLayer, ScalableCollider, Sensor,
+        SimpleCollider,
+    };
+    #[cfg(feature = "default-collider")]
+    pub use super::collider::{
+        Collider, ColliderConstructor, ColliderConstructorHierarchy, FillMode, TrimeshFlags,
+        VhacdParameters,
     };
     pub use super::collision_events::{CollisionEnded, CollisionEventsEnabled, CollisionStarted};
     pub use super::contact_types::{
diff --git a/src/collision/narrow_phase/mod.rs b/src/collision/narrow_phase/mod.rs
index f6c03bc5..38fbb83c 100644
--- a/src/collision/narrow_phase/mod.rs
+++ b/src/collision/narrow_phase/mod.rs
@@ -123,7 +123,7 @@ where
         // Remove collision pairs when colliders are disabled or removed.
         app.add_observer(remove_collider_on::<OnAdd, Disabled>);
         app.add_observer(remove_collider_on::<OnAdd, ColliderDisabled>);
-        app.add_observer(remove_collider_on::<OnRemove, Collider>);
+        app.add_observer(remove_collider_on::<OnRemove, C>);
 
         // Perform narrow phase collision detection.
         app.add_systems(

From e1565af9c4d35af42c7b5928eab371459986c694 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Thu, 17 Apr 2025 15:46:20 +0300
Subject: [PATCH 11/13] Update deps

---
 Cargo.toml                | 4 ----
 crates/avian2d/Cargo.toml | 4 ++--
 crates/avian3d/Cargo.toml | 4 ++--
 3 files changed, 4 insertions(+), 8 deletions(-)

diff --git a/Cargo.toml b/Cargo.toml
index c34b9437..008884bd 100644
--- a/Cargo.toml
+++ b/Cargo.toml
@@ -11,8 +11,4 @@ std_instead_of_core = "warn"
 opt-level = 1 # Use slightly better optimization, so examples work
 
 [patch.crates-io]
-parry2d = { git = "https://github.com/Jondolf/barry", branch = "no-std" }
-parry2d-f64 = { git = "https://github.com/Jondolf/barry", branch = "no-std" }
-parry3d = { git = "https://github.com/Jondolf/barry", branch = "no-std" }
-parry3d-f64 = { git = "https://github.com/Jondolf/barry", branch = "no-std" }
 nalgebra = { git = "https://github.com/Jondolf/nalgebra", branch = "glam-no-default-features" }
diff --git a/crates/avian2d/Cargo.toml b/crates/avian2d/Cargo.toml
index ec67793d..e7e8bc41 100644
--- a/crates/avian2d/Cargo.toml
+++ b/crates/avian2d/Cargo.toml
@@ -99,11 +99,11 @@ bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy", default-features =
 ] }
 bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation", default-features = false }
 libm = { version = "0.2", optional = true }
-parry2d = { version = "0.18", optional = true, default-features = false, features = [
+parry2d = { version = "0.19", optional = true, default-features = false, features = [
     "required-features",
     "alloc",
 ] }
-parry2d-f64 = { version = "0.18", optional = true, default-features = false, features = [
+parry2d-f64 = { version = "0.19", optional = true, default-features = false, features = [
     "required-features",
     "alloc",
 ] }
diff --git a/crates/avian3d/Cargo.toml b/crates/avian3d/Cargo.toml
index 188e960e..b7403a3b 100644
--- a/crates/avian3d/Cargo.toml
+++ b/crates/avian3d/Cargo.toml
@@ -102,11 +102,11 @@ bevy_heavy = { git = "https://github.com/Jondolf/bevy_heavy", default-features =
 ] }
 bevy_transform_interpolation = { git = "https://github.com/Jondolf/bevy_transform_interpolation", default-features = false }
 libm = { version = "0.2", optional = true }
-parry3d = { version = "0.18", optional = true, default-features = false, features = [
+parry3d = { version = "0.19", optional = true, default-features = false, features = [
     "required-features",
     "alloc",
 ] }
-parry3d-f64 = { version = "0.18", optional = true, default-features = false, features = [
+parry3d-f64 = { version = "0.19", optional = true, default-features = false, features = [
     "required-features",
     "alloc",
 ] }

From b3f3575c7e0bd280b2eb7a57b314a9145f79d1a3 Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Thu, 17 Apr 2025 15:46:32 +0300
Subject: [PATCH 12/13] Fix CI check

---
 .github/workflows/ci.yml | 5 ++++-
 1 file changed, 4 insertions(+), 1 deletion(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 1ba8622a..fcf6f88c 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -29,6 +29,9 @@ jobs:
           - "x86_64-unknown-none"
           - "wasm32v1-none"
           - "thumbv6m-none-eabi"
+        dimensions:
+          - "2d"
+          - "3d"
     steps:
       - uses: actions/checkout@v4
       - uses: dtolnay/rust-toolchain@stable
@@ -36,7 +39,7 @@ jobs:
           targets: ${{ matrix.target }}
       - uses: Swatinem/rust-cache@v2
       - name: Run cargo check
-        run: cargo check --no-default-features --features libm --target ${{ matrix.target }}
+        run: cargo check -p avian${{ matrix.dimensions }} --no-default-features --features "${{ matrix.dimensions }} f32 parry-f32 libm" --target ${{ matrix.target }}
 
   docs:
     name: Check Documentation

From 289944a6a566cfd389de60aa6174563dd4018b1a Mon Sep 17 00:00:00 2001
From: Joona Aalto <jondolf.dev@gmail.com>
Date: Thu, 17 Apr 2025 18:08:59 +0300
Subject: [PATCH 13/13] Fix CI and math ops

---
 .github/workflows/ci.yml                      |   2 +-
 clippy.toml                                   | 136 +++++++++---------
 src/collision/collider/parry/mod.rs           |   4 +-
 src/collision/collider/parry/primitives2d.rs  |  12 +-
 src/collision/contact_types/mod.rs            |   2 +-
 src/dynamics/ccd/mod.rs                       |   2 +-
 src/dynamics/integrator/mod.rs                |   8 +-
 src/dynamics/rigid_body/physics_material.rs   |   2 +-
 src/dynamics/sleeping/mod.rs                  |   5 +-
 src/dynamics/solver/joints/distance.rs        |   2 +-
 src/dynamics/solver/joints/mod.rs             |   2 +-
 .../solver/xpbd/angular_constraint.rs         |  10 +-
 .../solver/xpbd/positional_constraint.rs      |   2 +-
 src/math/mod.rs                               |  35 +----
 src/position.rs                               |  14 +-
 15 files changed, 106 insertions(+), 132 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index fcf6f88c..4a732429 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -66,7 +66,7 @@ jobs:
       - uses: dtolnay/rust-toolchain@stable
       - uses: Swatinem/rust-cache@v2
       - name: Run cargo test
-        run: cargo test --no-default-features --features enhanced-determinism,collider-from-mesh,serialize,debug-plugin,avian2d/2d,avian3d/3d,avian2d/f64,avian3d/f64,default-collider,parry-f64,bevy_scene,bevy_picking,diagnostic_ui
+        run: cargo test --no-default-features --features std,enhanced-determinism,collider-from-mesh,serialize,debug-plugin,avian2d/2d,avian3d/3d,avian2d/f64,avian3d/f64,default-collider,parry-f64,bevy_scene,bevy_picking,diagnostic_ui
 
   lints:
     name: Lints
diff --git a/clippy.toml b/clippy.toml
index c0c68ade..ddc8bf45 100644
--- a/clippy.toml
+++ b/clippy.toml
@@ -1,78 +1,78 @@
 disallowed-methods = [
     # f32
-    { path = "f32::powi", reason = "use ops::FloatPow::squared, ops::FloatPow::cubed, or ops::powf instead for libm determinism" },
-    { path = "f32::log", reason = "use ops::ln, ops::log2, or ops::log10 instead for libm determinism" },
+    { path = "f32::powi", reason = "use math_ops::FloatPow::squared, math_ops::FloatPow::cubed, or math_ops::powf instead for libm determinism" },
+    { path = "f32::log", reason = "use math_ops::ln, math_ops::log2, or math_ops::log10 instead for libm determinism" },
     { path = "f32::abs_sub", reason = "deprecated and deeply confusing method" },
-    { path = "f32::powf", reason = "use ops::powf instead for libm determinism" },
-    { path = "f32::exp", reason = "use ops::exp instead for libm determinism" },
-    { path = "f32::exp2", reason = "use ops::exp2 instead for libm determinism" },
-    { path = "f32::ln", reason = "use ops::ln instead for libm determinism" },
-    { path = "f32::log2", reason = "use ops::log2 instead for libm determinism" },
-    { path = "f32::log10", reason = "use ops::log10 instead for libm determinism" },
-    { path = "f32::cbrt", reason = "use ops::cbrt instead for libm determinism" },
-    { path = "f32::hypot", reason = "use ops::hypot instead for libm determinism" },
-    { path = "f32::sin", reason = "use ops::sin instead for libm determinism" },
-    { path = "f32::cos", reason = "use ops::cos instead for libm determinism" },
-    { path = "f32::tan", reason = "use ops::tan instead for libm determinism" },
-    { path = "f32::asin", reason = "use ops::asin instead for libm determinism" },
-    { path = "f32::acos", reason = "use ops::acos instead for libm determinism" },
-    { path = "f32::atan", reason = "use ops::atan instead for libm determinism" },
-    { path = "f32::atan2", reason = "use ops::atan2 instead for libm determinism" },
-    { path = "f32::sin_cos", reason = "use ops::sin_cos instead for libm determinism" },
-    { path = "f32::exp_m1", reason = "use ops::exp_m1 instead for libm determinism" },
-    { path = "f32::ln_1p", reason = "use ops::ln_1p instead for libm determinism" },
-    { path = "f32::sinh", reason = "use ops::sinh instead for libm determinism" },
-    { path = "f32::cosh", reason = "use ops::cosh instead for libm determinism" },
-    { path = "f32::tanh", reason = "use ops::tanh instead for libm determinism" },
-    { path = "f32::asinh", reason = "use ops::asinh instead for libm determinism" },
-    { path = "f32::acosh", reason = "use ops::acosh instead for libm determinism" },
-    { path = "f32::atanh", reason = "use ops::atanh instead for libm determinism" },
+    { path = "f32::powf", reason = "use math_ops::powf instead for libm determinism" },
+    { path = "f32::exp", reason = "use math_ops::exp instead for libm determinism" },
+    { path = "f32::exp2", reason = "use math_ops::exp2 instead for libm determinism" },
+    { path = "f32::ln", reason = "use math_ops::ln instead for libm determinism" },
+    { path = "f32::log2", reason = "use math_ops::log2 instead for libm determinism" },
+    { path = "f32::log10", reason = "use math_ops::log10 instead for libm determinism" },
+    { path = "f32::cbrt", reason = "use math_ops::cbrt instead for libm determinism" },
+    { path = "f32::hypot", reason = "use math_ops::hypot instead for libm determinism" },
+    { path = "f32::sin", reason = "use math_ops::sin instead for libm determinism" },
+    { path = "f32::cos", reason = "use math_ops::cos instead for libm determinism" },
+    { path = "f32::tan", reason = "use math_ops::tan instead for libm determinism" },
+    { path = "f32::asin", reason = "use math_ops::asin instead for libm determinism" },
+    { path = "f32::acos", reason = "use math_ops::acos instead for libm determinism" },
+    { path = "f32::atan", reason = "use math_ops::atan instead for libm determinism" },
+    { path = "f32::atan2", reason = "use math_ops::atan2 instead for libm determinism" },
+    { path = "f32::sin_cos", reason = "use math_ops::sin_cos instead for libm determinism" },
+    { path = "f32::exp_m1", reason = "use math_ops::exp_m1 instead for libm determinism" },
+    { path = "f32::ln_1p", reason = "use math_ops::ln_1p instead for libm determinism" },
+    { path = "f32::sinh", reason = "use math_ops::sinh instead for libm determinism" },
+    { path = "f32::cosh", reason = "use math_ops::cosh instead for libm determinism" },
+    { path = "f32::tanh", reason = "use math_ops::tanh instead for libm determinism" },
+    { path = "f32::asinh", reason = "use math_ops::asinh instead for libm determinism" },
+    { path = "f32::acosh", reason = "use math_ops::acosh instead for libm determinism" },
+    { path = "f32::atanh", reason = "use math_ops::atanh instead for libm determinism" },
     # f64
-    { path = "f64::powi", reason = "use ops::FloatPow::squared, ops::FloatPow::cubed, or ops::powf instead for libm determinism" },
-    { path = "f64::log", reason = "use ops::ln, ops::log2, or ops::log10 instead for libm determinism" },
+    { path = "f64::powi", reason = "use math_ops::FloatPow::squared, math_ops::FloatPow::cubed, or math_ops::powf instead for libm determinism" },
+    { path = "f64::log", reason = "use math_ops::ln, math_ops::log2, or math_ops::log10 instead for libm determinism" },
     { path = "f64::abs_sub", reason = "deprecated and deeply confusing method" },
-    { path = "f64::powf", reason = "use ops::powf instead for libm determinism" },
-    { path = "f64::exp", reason = "use ops::exp instead for libm determinism" },
-    { path = "f64::exp2", reason = "use ops::exp2 instead for libm determinism" },
-    { path = "f64::ln", reason = "use ops::ln instead for libm determinism" },
-    { path = "f64::log2", reason = "use ops::log2 instead for libm determinism" },
-    { path = "f64::log10", reason = "use ops::log10 instead for libm determinism" },
-    { path = "f64::cbrt", reason = "use ops::cbrt instead for libm determinism" },
-    { path = "f64::hypot", reason = "use ops::hypot instead for libm determinism" },
-    { path = "f64::sin", reason = "use ops::sin instead for libm determinism" },
-    { path = "f64::cos", reason = "use ops::cos instead for libm determinism" },
-    { path = "f64::tan", reason = "use ops::tan instead for libm determinism" },
-    { path = "f64::asin", reason = "use ops::asin instead for libm determinism" },
-    { path = "f64::acos", reason = "use ops::acos instead for libm determinism" },
-    { path = "f64::atan", reason = "use ops::atan instead for libm determinism" },
-    { path = "f64::atan2", reason = "use ops::atan2 instead for libm determinism" },
-    { path = "f64::sin_cos", reason = "use ops::sin_cos instead for libm determinism" },
-    { path = "f64::exp_m1", reason = "use ops::exp_m1 instead for libm determinism" },
-    { path = "f64::ln_1p", reason = "use ops::ln_1p instead for libm determinism" },
-    { path = "f64::sinh", reason = "use ops::sinh instead for libm determinism" },
-    { path = "f64::cosh", reason = "use ops::cosh instead for libm determinism" },
-    { path = "f64::tanh", reason = "use ops::tanh instead for libm determinism" },
-    { path = "f64::asinh", reason = "use ops::asinh instead for libm determinism" },
-    { path = "f64::acosh", reason = "use ops::acosh instead for libm determinism" },
-    { path = "f64::atanh", reason = "use ops::atanh instead for libm determinism" },
+    { path = "f64::powf", reason = "use math_ops::powf instead for libm determinism" },
+    { path = "f64::exp", reason = "use math_ops::exp instead for libm determinism" },
+    { path = "f64::exp2", reason = "use math_ops::exp2 instead for libm determinism" },
+    { path = "f64::ln", reason = "use math_ops::ln instead for libm determinism" },
+    { path = "f64::log2", reason = "use math_ops::log2 instead for libm determinism" },
+    { path = "f64::log10", reason = "use math_ops::log10 instead for libm determinism" },
+    { path = "f64::cbrt", reason = "use math_ops::cbrt instead for libm determinism" },
+    { path = "f64::hypot", reason = "use math_ops::hypot instead for libm determinism" },
+    { path = "f64::sin", reason = "use math_ops::sin instead for libm determinism" },
+    { path = "f64::cos", reason = "use math_ops::cos instead for libm determinism" },
+    { path = "f64::tan", reason = "use math_ops::tan instead for libm determinism" },
+    { path = "f64::asin", reason = "use math_ops::asin instead for libm determinism" },
+    { path = "f64::acos", reason = "use math_ops::acos instead for libm determinism" },
+    { path = "f64::atan", reason = "use math_ops::atan instead for libm determinism" },
+    { path = "f64::atan2", reason = "use math_ops::atan2 instead for libm determinism" },
+    { path = "f64::sin_cos", reason = "use math_ops::sin_cos instead for libm determinism" },
+    { path = "f64::exp_m1", reason = "use math_ops::exp_m1 instead for libm determinism" },
+    { path = "f64::ln_1p", reason = "use math_ops::ln_1p instead for libm determinism" },
+    { path = "f64::sinh", reason = "use math_ops::sinh instead for libm determinism" },
+    { path = "f64::cosh", reason = "use math_ops::cosh instead for libm determinism" },
+    { path = "f64::tanh", reason = "use math_ops::tanh instead for libm determinism" },
+    { path = "f64::asinh", reason = "use math_ops::asinh instead for libm determinism" },
+    { path = "f64::acosh", reason = "use math_ops::acosh instead for libm determinism" },
+    { path = "f64::atanh", reason = "use math_ops::atanh instead for libm determinism" },
     # These methods have defined precision, but are only available from the standard library,
     # not in core. Using these substitutes allows for no_std compatibility.
     # f32
-    { path = "f32::rem_euclid", reason = "use ops::rem_euclid instead for no_std compatibility" },
-    { path = "f32::abs", reason = "use ops::abs instead for no_std compatibility" },
-    { path = "f32::sqrt", reason = "use ops::sqrt instead for no_std compatibility" },
-    { path = "f32::copysign", reason = "use ops::copysign instead for no_std compatibility" },
-    { path = "f32::round", reason = "use ops::round instead for no_std compatibility" },
-    { path = "f32::floor", reason = "use ops::floor instead for no_std compatibility" },
-    { path = "f32::ceil", reason = "use ops::ceil instead for no_std compatibility" },
-    { path = "f32::fract", reason = "use ops::fract instead for no_std compatibility" },
+    { path = "f32::rem_euclid", reason = "use math_ops::rem_euclid instead for no_std compatibility" },
+    { path = "f32::abs", reason = "use math_ops::abs instead for no_std compatibility" },
+    { path = "f32::sqrt", reason = "use math_ops::sqrt instead for no_std compatibility" },
+    { path = "f32::copysign", reason = "use math_ops::copysign instead for no_std compatibility" },
+    { path = "f32::round", reason = "use math_ops::round instead for no_std compatibility" },
+    { path = "f32::floor", reason = "use math_ops::floor instead for no_std compatibility" },
+    { path = "f32::ceil", reason = "use math_ops::ceil instead for no_std compatibility" },
+    { path = "f32::fract", reason = "use math_ops::fract instead for no_std compatibility" },
     # f64
-    { path = "f64::rem_euclid", reason = "use ops::rem_euclid instead for no_std compatibility" },
-    { path = "f64::abs", reason = "use ops::abs instead for no_std compatibility" },
-    { path = "f64::sqrt", reason = "use ops::sqrt instead for no_std compatibility" },
-    { path = "f64::copysign", reason = "use ops::copysign instead for no_std compatibility" },
-    { path = "f64::round", reason = "use ops::round instead for no_std compatibility" },
-    { path = "f64::floor", reason = "use ops::floor instead for no_std compatibility" },
-    { path = "f64::ceil", reason = "use ops::ceil instead for no_std compatibility" },
-    { path = "f64::fract", reason = "use ops::fract instead for no_std compatibility" },
+    { path = "f64::rem_euclid", reason = "use math_ops::rem_euclid instead for no_std compatibility" },
+    { path = "f64::abs", reason = "use math_ops::abs instead for no_std compatibility" },
+    { path = "f64::sqrt", reason = "use math_ops::sqrt instead for no_std compatibility" },
+    { path = "f64::copysign", reason = "use math_ops::copysign instead for no_std compatibility" },
+    { path = "f64::round", reason = "use math_ops::round instead for no_std compatibility" },
+    { path = "f64::floor", reason = "use math_ops::floor instead for no_std compatibility" },
+    { path = "f64::ceil", reason = "use math_ops::ceil instead for no_std compatibility" },
+    { path = "f64::fract", reason = "use math_ops::fract instead for no_std compatibility" },
 ]
diff --git a/src/collision/collider/parry/mod.rs b/src/collision/collider/parry/mod.rs
index 7d33acc2..9cd32347 100644
--- a/src/collision/collider/parry/mod.rs
+++ b/src/collision/collider/parry/mod.rs
@@ -1326,7 +1326,7 @@ fn scale_shape(
             #[cfg(feature = "2d")]
             {
                 if scale.x == scale.y {
-                    Ok(SharedShape::ball(b.radius * ops::abs(scale.x)))
+                    Ok(SharedShape::ball(b.radius * math_ops::abs(scale.x)))
                 } else {
                     // A 2D circle becomes an ellipse when scaled non-uniformly.
                     Ok(SharedShape::new(EllipseColliderShape(Ellipse {
@@ -1488,7 +1488,7 @@ fn scale_shape(
                     if scale.x == scale.y {
                         return Ok(SharedShape::new(RegularPolygonColliderShape(
                             RegularPolygon::new(
-                                polygon.circumradius() * ops::abs(scale.x) as f32,
+                                polygon.circumradius() * math_ops::abs(scale.x) as f32,
                                 polygon.sides,
                             ),
                         )));
diff --git a/src/collision/collider/parry/primitives2d.rs b/src/collision/collider/parry/primitives2d.rs
index 7a00642e..f3e9fa7e 100644
--- a/src/collision/collider/parry/primitives2d.rs
+++ b/src/collision/collider/parry/primitives2d.rs
@@ -1,5 +1,5 @@
 use crate::{
-    math::{self, FloatPow},
+    math::{self, math_ops, FloatPow},
     AdjustPrecision, Scalar, Vector, FRAC_PI_2, PI, TAU,
 };
 
@@ -44,7 +44,7 @@ impl SupportMap for EllipseColliderShape {
     #[inline]
     fn local_support_point(&self, direction: &Vector2<Scalar>) -> Point2<Scalar> {
         let [a, b] = self.half_size.adjust_precision().to_array();
-        let denom = ops::sqrt(direction.x.squared() * a * a + direction.y.squared() * b * b);
+        let denom = math_ops::sqrt(direction.x.squared() * a * a + direction.y.squared() * b * b);
         Point2::new(a * a * direction.x / denom, b * b * direction.y / denom)
     }
 }
@@ -276,7 +276,7 @@ impl SupportMap for RegularPolygonColliderShape {
         };
 
         // How many rotations of `external_angle` correspond to the vertex closest to the support direction.
-        let n = ops::round(angle_from_top / external_angle) % self.sides as Scalar;
+        let n = math_ops::round(angle_from_top / external_angle) % self.sides as Scalar;
 
         // Rotate by an additional 90 degrees so that the first vertex is always at the top.
         let target_angle = n * external_angle + FRAC_PI_2;
@@ -305,8 +305,8 @@ impl PolygonalFeatureMap for RegularPolygonColliderShape {
 
         // How many rotations of `external_angle` correspond to the vertices.
         let n_unnormalized = angle_from_top / external_angle;
-        let n1 = ops::floor(n_unnormalized) % self.sides as Scalar;
-        let n2 = math::ceil(n_unnormalized) % self.sides as Scalar;
+        let n1 = math_ops::floor(n_unnormalized) % self.sides as Scalar;
+        let n2 = math_ops::ceil(n_unnormalized) % self.sides as Scalar;
 
         // Rotate by an additional 90 degrees so that the first vertex is always at the top.
         let target_angle1 = n1 * external_angle + FRAC_PI_2;
@@ -393,7 +393,7 @@ impl Shape for RegularPolygonColliderShape {
 
         let half_external_angle = PI / self.sides as Scalar;
         let angular_inertia = mass * self.circumradius().adjust_precision().squared() / 6.0
-            * (1.0 + 2.0 * ops::cos(half_external_angle).squared());
+            * (1.0 + 2.0 * math_ops::cos(half_external_angle).squared());
 
         MassProperties::new(Point2::origin(), mass, angular_inertia)
     }
diff --git a/src/collision/contact_types/mod.rs b/src/collision/contact_types/mod.rs
index e2862c68..501239b7 100644
--- a/src/collision/contact_types/mod.rs
+++ b/src/collision/contact_types/mod.rs
@@ -109,7 +109,7 @@ impl ContactPair {
 
         for manifold in &self.manifolds {
             let impulse = manifold.max_normal_impulse();
-            if ops::abs(impulse) > ops::abs(magnitude) {
+            if math_ops::abs(impulse) > math_ops::abs(magnitude) {
                 magnitude = impulse;
                 normal = manifold.normal;
             }
diff --git a/src/dynamics/ccd/mod.rs b/src/dynamics/ccd/mod.rs
index 870b1166..2d76edb7 100644
--- a/src/dynamics/ccd/mod.rs
+++ b/src/dynamics/ccd/mod.rs
@@ -580,7 +580,7 @@ fn solve_swept_ccd(
 
                 #[cfg(feature = "2d")]
                 let ang_vel_below_threshold =
-                    ops::abs(ang_vel1.0 - ang_vel2) < ccd1.angular_threshold;
+                    math_ops::abs(ang_vel1.0 - ang_vel2) < ccd1.angular_threshold;
                 #[cfg(feature = "3d")]
                 let ang_vel_below_threshold =
                     (ang_vel1.0 - ang_vel2).length_squared() < ccd1.angular_threshold.squared();
diff --git a/src/dynamics/integrator/mod.rs b/src/dynamics/integrator/mod.rs
index 2274c6ae..0cc6a74a 100644
--- a/src/dynamics/integrator/mod.rs
+++ b/src/dynamics/integrator/mod.rs
@@ -234,19 +234,19 @@ fn integrate_velocities(
         if let Some(max_linear_speed) = body.max_linear_speed {
             let linear_speed_squared = body.lin_vel.0.length_squared();
             if linear_speed_squared > max_linear_speed.0.squared() {
-                body.lin_vel.0 *= max_linear_speed.0 / ops::sqrt(linear_speed_squared);
+                body.lin_vel.0 *= max_linear_speed.0 / math_ops::sqrt(linear_speed_squared);
             }
         }
         if let Some(max_angular_speed) = body.max_angular_speed {
             #[cfg(feature = "2d")]
-            if ops::abs(body.ang_vel.0) > max_angular_speed.0 {
-                body.ang_vel.0 = ops::copysign(max_angular_speed.0, body.ang_vel.0);
+            if math_ops::abs(body.ang_vel.0) > max_angular_speed.0 {
+                body.ang_vel.0 = math_ops::copysign(max_angular_speed.0, body.ang_vel.0);
             }
             #[cfg(feature = "3d")]
             {
                 let angular_speed_squared = body.ang_vel.0.length_squared();
                 if angular_speed_squared > max_angular_speed.0.squared() {
-                    body.ang_vel.0 *= max_angular_speed.0 / ops::sqrt(angular_speed_squared);
+                    body.ang_vel.0 *= max_angular_speed.0 / math_ops::sqrt(angular_speed_squared);
                 }
             }
         }
diff --git a/src/dynamics/rigid_body/physics_material.rs b/src/dynamics/rigid_body/physics_material.rs
index 277c6ec5..64705c88 100644
--- a/src/dynamics/rigid_body/physics_material.rs
+++ b/src/dynamics/rigid_body/physics_material.rs
@@ -28,7 +28,7 @@ impl CoefficientCombine {
     pub fn mix(&self, a: Scalar, b: Scalar) -> Scalar {
         match self {
             CoefficientCombine::Average => (a + b) * 0.5,
-            CoefficientCombine::GeometricMean => ops::sqrt(a * b),
+            CoefficientCombine::GeometricMean => math_ops::sqrt(a * b),
             CoefficientCombine::Min => a.min(b),
             CoefficientCombine::Multiply => a * b,
             CoefficientCombine::Max => a.max(b),
diff --git a/src/dynamics/sleeping/mod.rs b/src/dynamics/sleeping/mod.rs
index d579097f..b87a5ee2 100644
--- a/src/dynamics/sleeping/mod.rs
+++ b/src/dynamics/sleeping/mod.rs
@@ -180,8 +180,9 @@ pub fn mark_sleeping_bodies(
 
         // Negative thresholds indicate that sleeping is disabled.
         let lin_sleeping_threshold_sq =
-            length_unit_sq * sleep_threshold.linear * ops::abs(sleep_threshold.linear);
-        let ang_sleeping_threshold_sq = sleep_threshold.angular * ops::abs(sleep_threshold.angular);
+            length_unit_sq * sleep_threshold.linear * math_ops::abs(sleep_threshold.linear);
+        let ang_sleeping_threshold_sq =
+            sleep_threshold.angular * math_ops::abs(sleep_threshold.angular);
 
         // If linear and angular velocity are below the sleeping threshold,
         // add delta time to the time sleeping, i.e. the time that the body has remained still.
diff --git a/src/dynamics/solver/joints/distance.rs b/src/dynamics/solver/joints/distance.rs
index ee9ffa01..d1f81930 100644
--- a/src/dynamics/solver/joints/distance.rs
+++ b/src/dynamics/solver/joints/distance.rs
@@ -144,7 +144,7 @@ impl DistanceJoint {
         );
 
         // Avoid division by zero and unnecessary computation
-        if ops::abs(distance) < Scalar::EPSILON {
+        if math_ops::abs(distance) < Scalar::EPSILON {
             return Vector::ZERO;
         }
 
diff --git a/src/dynamics/solver/joints/mod.rs b/src/dynamics/solver/joints/mod.rs
index be95602d..079d436e 100644
--- a/src/dynamics/solver/joints/mod.rs
+++ b/src/dynamics/solver/joints/mod.rs
@@ -300,7 +300,7 @@ impl AngleLimit {
         // [limit_axis, axis1, axis2] = [n, n1, n2] in XPBD rigid body paper.
 
         // Angle between axis1 and axis2 with respect to limit_axis.
-        let mut phi = ops::asin(axis1.cross(axis2).dot(limit_axis));
+        let mut phi = math_ops::asin(axis1.cross(axis2).dot(limit_axis));
 
         // `asin` returns the angle in the [-pi/2, pi/2] range.
         // This is correct if the angle between n1 and n2 is acute,
diff --git a/src/dynamics/solver/xpbd/angular_constraint.rs b/src/dynamics/solver/xpbd/angular_constraint.rs
index c8dab797..37cff143 100644
--- a/src/dynamics/solver/xpbd/angular_constraint.rs
+++ b/src/dynamics/solver/xpbd/angular_constraint.rs
@@ -14,7 +14,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         body2: &mut RigidBodyQueryItem,
         delta_lagrange: Scalar,
     ) -> Scalar {
-        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
+        if math_ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return 0.0;
         }
 
@@ -60,7 +60,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         delta_lagrange: Scalar,
         axis: Vector,
     ) -> Vector {
-        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
+        if math_ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return Vector::ZERO;
         }
 
@@ -116,7 +116,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         compliance: Scalar,
         dt: Scalar,
     ) -> Torque {
-        if ops::abs(angle) <= Scalar::EPSILON {
+        if math_ops::abs(angle) <= Scalar::EPSILON {
             return Torque::ZERO;
         }
 
@@ -185,7 +185,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         delta_lagrange: Scalar,
         axis: Vector3,
     ) -> Scalar {
-        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
+        if math_ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return 0.0;
         }
 
@@ -220,7 +220,7 @@ pub trait AngularConstraint: XpbdConstraint<2> {
         delta_lagrange: Scalar,
         axis: Vector,
     ) -> Vector {
-        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
+        if math_ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return Vector::ZERO;
         }
 
diff --git a/src/dynamics/solver/xpbd/positional_constraint.rs b/src/dynamics/solver/xpbd/positional_constraint.rs
index 675c970a..005a3450 100644
--- a/src/dynamics/solver/xpbd/positional_constraint.rs
+++ b/src/dynamics/solver/xpbd/positional_constraint.rs
@@ -17,7 +17,7 @@ pub trait PositionConstraint: XpbdConstraint<2> {
         r1: Vector,
         r2: Vector,
     ) -> Vector {
-        if ops::abs(delta_lagrange) <= Scalar::EPSILON {
+        if math_ops::abs(delta_lagrange) <= Scalar::EPSILON {
             return Vector::ZERO;
         }
 
diff --git a/src/math/mod.rs b/src/math/mod.rs
index 8deccd34..9ef9668a 100644
--- a/src/math/mod.rs
+++ b/src/math/mod.rs
@@ -13,41 +13,14 @@ mod double;
 pub use double::*;
 
 #[cfg(feature = "f64")]
-mod ops_f64;
+pub mod ops_f64;
 
 #[cfg(feature = "f32")]
-pub use bevy_math::ops;
+pub use bevy_math::ops as math_ops;
 #[cfg(feature = "f64")]
-pub use ops_f64 as ops;
+pub use ops_f64 as math_ops;
 
-#[cfg(feature = "f32")]
-pub(crate) use ops::FloatPow;
-#[cfg(feature = "f64")]
-pub(crate) use ops_f64::FloatPow;
-
-// bevy_math doesn't have these yet.
-
-/// Returns the smallest integer greater than or equal to `x`.
-///
-/// Precision is specified when the `libm` feature is enabled.
-#[inline(always)]
-#[cfg(all(feature = "f32", feature = "libm", not(feature = "std")))]
-pub fn ceil(x: f32) -> f32 {
-    libm::ceilf(x)
-}
-
-/// Returns the smallest integer greater than or equal to `x`.
-///     
-/// Precision is specified when the `std` feature is enabled.
-#[inline(always)]
-#[cfg(all(feature = "f32", feature = "std"))]
-pub fn ceil(x: f32) -> f32 {
-    #[allow(clippy::disallowed_methods)]
-    x.ceil()
-}
-
-#[cfg(feature = "f64")]
-pub use ops_f64::ceil;
+pub(crate) use math_ops::FloatPow;
 
 use bevy_math::{prelude::*, *};
 
diff --git a/src/position.rs b/src/position.rs
index 31fa7463..cc90d75a 100644
--- a/src/position.rs
+++ b/src/position.rs
@@ -212,7 +212,7 @@ impl Rotation {
     /// Creates a [`Rotation`] from a counterclockwise angle in radians.
     #[inline]
     pub fn radians(radians: Scalar) -> Self {
-        let (sin, cos) = ops::sin_cos(radians);
+        let (sin, cos) = math_ops::sin_cos(radians);
         Self::from_sin_cos(sin, cos)
     }
 
@@ -254,7 +254,7 @@ impl Rotation {
     /// Returns the rotation in radians in the `(-pi, pi]` range.
     #[inline]
     pub fn as_radians(self) -> Scalar {
-        ops::atan2(self.sin, self.cos)
+        math_ops::atan2(self.sin, self.cos)
     }
 
     /// Returns the rotation in degrees in the `(-180, 180]` range.
@@ -378,7 +378,7 @@ impl Rotation {
         // The allowed length is 1 +/- 1e-4, so the largest allowed
         // squared length is (1 + 1e-4)^2 = 1.00020001, which makes
         // the threshold for the squared length approximately 2e-4.
-        ops::abs(self.length_squared() - 1.0) <= 2e-4
+        math_ops::abs(self.length_squared() - 1.0) <= 2e-4
     }
 
     /// Returns `true` if the rotation is near [`Rotation::IDENTITY`].
@@ -386,7 +386,7 @@ impl Rotation {
     pub fn is_near_identity(self) -> bool {
         // Same as `Quat::is_near_identity`, but using sine and cosine
         let threshold_angle_sin = 0.000_049_692_047; // let threshold_angle = 0.002_847_144_6;
-        self.cos > 0.0 && ops::abs(self.sin) < threshold_angle_sin
+        self.cos > 0.0 && math_ops::abs(self.sin) < threshold_angle_sin
     }
 
     /// Returns the angle in radians needed to make `self` and `other` coincide.
@@ -415,7 +415,7 @@ impl Rotation {
         let (sin, cos) = (self.sin + radians * self.cos, self.cos - radians * self.sin);
         let magnitude_squared = sin * sin + cos * cos;
         let magnitude_recip = if magnitude_squared > 0.0 {
-            ops::sqrt(magnitude_squared).recip()
+            math_ops::sqrt(magnitude_squared).recip()
         } else {
             0.0
         };
@@ -894,8 +894,8 @@ impl From<Rotation> for Scalar {
 #[cfg(feature = "2d")]
 impl From<Rotation> for Quaternion {
     fn from(rot: Rotation) -> Self {
-        let z = rot.sin.signum() * ops::sqrt(ops::abs((1.0 - rot.cos) / 2.0));
-        let w = ops::sqrt(ops::abs((1.0 + rot.cos) / 2.0));
+        let z = rot.sin.signum() * math_ops::sqrt(math_ops::abs((1.0 - rot.cos) / 2.0));
+        let w = math_ops::sqrt(math_ops::abs((1.0 + rot.cos) / 2.0));
         Quaternion::from_xyzw(0.0, 0.0, z, w)
     }
 }