Crate alice_physics 

ALICE-Physics: Deterministic 128-bit Fixed-Point Physics Engine

A high-precision physics engine designed for deterministic simulation across different platforms and hardware. Uses 128-bit fixed-point arithmetic to ensure bit-exact results regardless of CPU or compiler.

Features

• Deterministic: the Fix128 core (rigid bodies, constraints, joints, BVH, CCD) is bit-exact across all platforms — pure integer arithmetic. Grid / engineering modules on f32 / f64 are bit-exact via det_math (correctly-rounded software transcendental functions); see README “Determinism” for the per-module table.
• 128-bit Fixed-Point: I64F64 format with CORDIC trigonometry
• XPBD Solver: Extended Position Based Dynamics for stable constraints
• GJK/EPA: Robust collision detection for convex shapes
• Linear BVH: Morton code-based spatial acceleration (used for broad-phase and raycast)
• Rollback Support: State serialization for netcode

Feature Flags

Feature	Description
std (default)	Standard library support. Disable for no_std (requires alloc).
simd	SSE2 acceleration for Vec3Fix math ops (dot, add, sub). Results remain bit-exact. Solver hot paths use scalar arithmetic to guarantee cross-platform determinism.
parallel	Parallel constraint solving via Rayon with graph-colored batches.
neural	Deterministic neural controller integration (ALICE-ML).
python	PyO3 + NumPy zero-copy Python bindings.
replay	Replay recording/playback via ALICE-DB.
ffi	C FFI for Unity/UE5/game engine integration.
wasm	WebAssembly bindings via wasm-bindgen.
analytics	ALICE-Analytics simulation profiling (DDSketch, HyperLogLog).
gpu-solver-bridge	GpuSolverBridge trait for external GPU solver backends. No cost when off.
privacy-crypto	privacy re-exports alice-crypto’s differential-privacy primitives and adds KeyedRappor. Off by default; alice-crypto becomes a public dependency.

Example

use alice_physics::{PhysicsWorld, PhysicsConfig, RigidBody, Fix128, Vec3Fix};

// Create physics world
let config = PhysicsConfig::default();
let mut world = PhysicsWorld::new(config);

// Add a dynamic body
let body = RigidBody::new_dynamic(
    Vec3Fix::from_int(0, 10, 0),  // position
    Fix128::ONE,                   // mass = 1
);
let body_id = world.add_body(body);

// Step simulation (60 frames at 1/60 second)
let dt = Fix128::from_ratio(1, 60);
for _ in 0..60 {
    world.step(dt);
}

// Body should have fallen under gravity
let pos = world.bodies[body_id].position;
assert!(pos.y < Fix128::from_int(10), "Body fell under gravity");

Modules

Core

• math: Fixed-point math primitives (Fix128, Vec3Fix, QuatFix, Mat3Fix, CORDIC)
• collider: Collision shapes (Sphere, Capsule, ConvexHull, AABB) and GJK/EPA detection
• solver: XPBD physics solver, rigid body dynamics, constraint batching
• bvh: Linear BVH for broad-phase collision detection (Morton codes, stackless traversal)
• error: Unified physics error type (PhysicsError)

Collision Shapes

• box_collider: Oriented Bounding Box (OBB) with GJK support
• compound: Multi-shape compound collider with local transforms
• cone: Cone collider with GJK support (apex +Y, base -Y)
• convex_mesh_builder: Incremental convex hull builder from point sets
• cylinder: Cylinder collider with GJK support
• ellipsoid: Ellipsoid collider with three independent semi-axes
• plane_collider: Infinite plane collider (sphere/AABB intersection)
• sdf_collider: SDF-based collision shapes (distance field surfaces)
• spherical_terrain: Sphere-world ground as a radial height field, and central gravity
• torus: Torus collider with major/minor radii
• wedge: Wedge (triangular prism) collider with 6 vertices

Spatial Acceleration

• dynamic_bvh: Incremental AABB tree with O(log n) insert/remove/update
• spatial: Hash grid for neighbor queries (shared across fluid, cloth)
• contact_cache: Persistent contact manifold cache with HashMap O(1) lookup

Constraints & Dynamics

• joint: Joint constraints (Ball, Hinge, Fixed, Slider, Spring, D6, ConeTwist)
• joint_extra: Advanced joints (Pulley, Gear, Weld, Rack-and-Pinion, Mouse)
• motor: PD controllers and joint motors
• articulation: Articulated bodies (ragdolls, robotic arms, Featherstone)
• force: Custom force fields (wind, gravity, buoyancy, vortex, explosion, magnetic)
• sleeping: Sleep/wake and island management (Union-Find)
• filter: Collision filtering with layer/mask bitmasks (see filter::layers)
• material: Material pair table (friction, restitution, combine rules)

Queries

• raycast: Ray casting against spheres, AABBs, capsules, planes
• shape_raycast: World ray queries against the geometry bodies collide as (shapes, compounds, static colliders, SDF)
• sensors: Simulated lidar, contact sensor and IMU with deterministic Gaussian noise
• query: Shape cast (sphere, capsule) and overlap queries (sphere, AABB)
• ccd: Continuous collision detection (TOI, conservative advancement, speculative)

Soft Body & Simulation

• rope: XPBD distance chain rope and cable simulation
• cloth: XPBD triangle mesh cloth with self-collision
• fluid: Position-Based Fluids (PBF) with spatial hash grid
• deformable: FEM-XPBD deformable body simulation
• vehicle: Vehicle physics (wheel, suspension, engine, steering)
• vehicle_dynamics: Per-wheel vehicle dynamics (tyre models, wheel spin, brakes / ABS, road surfaces and weather, powertrain, scenario metrics and lossless replay)
• character: Kinematic capsule-based character controller (move-and-slide)
• world_character: PhysicsWorld::move_character, move-and-slide of a character against the world’s collided geometry
• trimesh: Triangle mesh collision with BVH acceleration (Moller-Trumbore)
• heightfield: Height field terrain collision (bilinear interpolation)
• cloth_fluid: Cloth-fluid coupling (drag, buoyancy, boundary repulsion)
• rope_attach: Rope attachment to rigid bodies with compliance and break force
• soft_body_cut: Plane-based cutting of deformable bodies and cloth
• particle: General-purpose particle system with emitters and force fields

2D Physics

• physics2d: Complete 2D engine (SAT collision, XPBD solver, joints)

Mesh & I/O Utilities

• mass_properties: Mass and inertia tensor computation for standard shapes
• collision_mesh_gen: Marching cubes SDF-to-mesh with simplification
• scene_io: Binary (.aphys) and JSON scene serialization (std)
• multi_world: Multiple independent physics worlds with body transfer

Visualization

• heatmap: Stress/temperature heatmap with viridis colormap
• flow_viz: Fluid flow arrows and streamline generation
• contact_viz: Contact force arrows and friction cone visualization

SDF Integration

• sdf_manifold: Multi-point contact manifold from SDF surfaces
• sdf_ccd: Sphere tracing continuous collision detection for SDF
• sdf_force: SDF-driven force fields (attract, repel, contain, flow)
• sdf_destruction: Real-time CSG boolean destruction (std)
• sdf_adaptive: Adaptive SDF evaluation with distance-based LOD (std)
• convex_decompose: Convex decomposition from SDF voxel grid (std)
• gpu_sdf: GPU compute shader interface for batch SDF evaluation (std)

SDF Simulation Modifiers (std)

• sim_field: 3D scalar/vector fields with trilinear interpolation and diffusion
• sim_modifier: Physics modifier chain for SDF surfaces
• thermal: Heat diffusion, melt, thermal expansion, freeze
• pressure: Contact-force deformation (crush, bulge, dent)
• erosion: Wind, water, chemical, ablation erosion
• fracture: Stress-driven crack propagation with CSG subtraction
• phase_change: Solid/liquid/gas transitions driven by temperature
• coupled_field: Deterministic Fix128 channel for sharing one field between physics

Game Systems

• animation_blend: Ragdoll animation blending with SLERP
• audio_physics: Physics-based audio parameter generation
• netcode: Deterministic simulation with frame input, checksum, rollback
• fluid_netcode: Deterministic fluid netcode with delta compression (std)
• interpolation: Substep interpolation with SLERP quaternion blending
• debug_render: Wireframe visualization API (bodies, contacts, joints, BVH)
• profiling: Per-stage timer and per-frame statistics

Analytics & Privacy (std)

• sketch: Probabilistic sketches (HyperLogLog, DDSketch, Count-Min)
• anomaly: Streaming anomaly detection (MAD, EWMA, Z-score)
• privacy: Local differential privacy (Laplace, RAPPOR)
• pipeline: Lock-free metric aggregation pipeline

Utility

• rng: Deterministic pseudo-random number generator (PCG-XSH-RR)
• event: Contact and trigger event tracking

Feature-Gated

• neural: Deterministic neural controller (ALICE-ML, --features neural)
• ffi: C FFI for Unity/UE5 game engines (--features ffi)
• replay: Replay recording/playback (--features replay)
• db_bridge: Physics state persistence bridge (--features replay)
• analytics_bridge: Simulation profiling bridge (--features analytics)

Determinism

This engine guarantees bit-exact results by:

1. Using 128-bit fixed-point instead of IEEE 754 floating-point
2. CORDIC algorithm for trigonometry (no FPU instructions)
3. Fixed iteration counts in all algorithms
4. Deterministic sorting (stable sort with explicit comparators)

This makes it suitable for:

• Lockstep multiplayer games
• Rollback netcode
• Replay systems
• Distributed physics simulation

Re-exports

pub use animation_blend::AnimationBlender;

pub use animation_blend::AnimationClip;

pub use animation_blend::BlendMode;

pub use animation_blend::SkeletonPose;

pub use anomaly::AnomalyCallback;

pub use anomaly::AnomalyEvent;

pub use anomaly::CompositeDetector;

pub use anomaly::EwmaDetector;

pub use anomaly::MadDetector;

pub use anomaly::StreamingMedian;

pub use anomaly::ZScoreDetector;

pub use articulation::ArticulatedBody;

pub use articulation::FeatherstoneSolver;

pub use audio_physics::AudioConfig;

pub use audio_physics::AudioEvent;

pub use audio_physics::AudioGenerator;

pub use audio_physics::AudioMaterial;

pub use box_collider::OrientedBox;

pub use bvh::BvhNode;

pub use bvh::BvhPrimitive;

pub use bvh::LinearBvh;

pub use ccd::aabb_plane_toi;

pub use ccd::capsule_plane_toi;

pub use ccd::speculative_contact;

pub use ccd::sphere_capsule_toi;

pub use ccd::CcdConfig;

pub use character::CharacterConfig;

pub use character::CharacterController;

pub use character::MoveResult;

pub use character::PushImpulse;

pub use cloth::Cloth;

pub use cloth::ClothConfig;

pub use cloth_fluid::apply_cloth_boundary_to_fluid;

pub use cloth_fluid::apply_fluid_forces_to_cloth;

pub use cloth_fluid::ClothFluidCoupling;

pub use collider::Capsule;

pub use collider::CollisionResult;

pub use collider::ConvexHull;

pub use collider::ScaledShape;

pub use collider::Sphere;

pub use collider::Support;

pub use collider::AABB;

pub use collision_mesh_gen::compute_mesh_aabb;

pub use collision_mesh_gen::generate_collision_mesh;

pub use collision_mesh_gen::simplify_collision_mesh;

pub use collision_mesh_gen::CollisionMesh;

pub use collision_mesh_gen::CollisionMeshConfig;

pub use compound::CompoundShape;

pub use compound::ShapeRef;

pub use cone::Cone;

pub use contact_cache::BodyPairKey;

pub use contact_cache::ContactCache;

pub use contact_cache::ContactManifold;

pub use contact_viz::generate_contact_arrows;

pub use contact_viz::generate_friction_cones;

pub use contact_viz::ContactArrow;

pub use contact_viz::FrictionCone;

pub use convex_decompose::DecomposeConfig;

pub use convex_decompose::DecompositionResult;

pub use convex_mesh_builder::build_convex_hull;

pub use convex_mesh_builder::compute_centroid;

pub use cylinder::Cylinder;

pub use debug_render::debug_draw_world;

pub use debug_render::DebugColor;

pub use debug_render::DebugDrawData;

pub use debug_render::DebugDrawFlags;

pub use deformable::DeformableBody;

pub use deformable::DeformableConfig;

pub use dynamic_bvh::DynamicAabbTree;

pub use ellipsoid::Ellipsoid;

pub use erosion::ErosionConfig;

pub use erosion::ErosionModifier;

pub use erosion::ErosionType;

pub use error::PhysicsError;

pub use event::ContactEvent;

pub use event::ContactEventType;

pub use event::EventCollector;

pub use event::JointBreakEvent;

pub use event::TriggerEvent;

pub use filter::layers;

pub use filter::CollisionFilter;

pub use flow_viz::generate_flow_arrows;

pub use flow_viz::generate_streamlines;

pub use flow_viz::FlowArrow;

pub use flow_viz::FlowVizConfig;

pub use flow_viz::Streamlines;

pub use fluid::Fluid;

pub use fluid::FluidConfig;

pub use fluid_netcode::FluidDelta;

pub use fluid_netcode::FluidSnapshot;

pub use force::apply_force_fields;

pub use force::ForceField;

pub use force::ForceFieldInstance;

pub use fracture::Crack;

pub use fracture::FractureConfig;

pub use fracture::FractureModifier;

pub use gpu_sdf::batch_size;

pub use gpu_sdf::GpuDispatchConfig;

pub use gpu_sdf::GpuSdfBatch;

pub use gpu_sdf::GpuSdfInstancedBatch;

pub use gpu_sdf::GpuSdfMultiDispatch;

pub use gpu_sdf::GpuSdfQuery;

pub use gpu_sdf::GpuSdfResult;

pub use heatmap::generate_stress_heatmap;

pub use heatmap::generate_temperature_heatmap;

pub use heatmap::heatmap_to_rgba;

pub use heatmap::Heatmap;

pub use heatmap::HeatmapConfig;

pub use heatmap::SliceAxis;

pub use heightfield::HeightField;

pub use interpolation::BodySnapshot;

pub use interpolation::InterpolationState;

pub use interpolation::WorldSnapshot;

pub use joint::solve_joints;

pub use joint::solve_joints_breakable;Deprecated

pub use joint::solve_joints_breaking_on_force;

pub use joint::solve_joints_with_reaction_forces;

pub use joint::BallJoint;

pub use joint::ConeTwistJoint;

pub use joint::D6Joint;

pub use joint::D6Motion;

pub use joint::FixedJoint;

pub use joint::HingeJoint;

pub use joint::Joint;

pub use joint::JointType;

pub use joint::SliderJoint;

pub use joint::SpringJoint;

pub use joint_extra::solve_extra_joints;

pub use joint_extra::ExtraJoint;

pub use joint_extra::GearJoint;

pub use joint_extra::MouseJoint;

pub use joint_extra::PulleyJoint;

pub use joint_extra::RackAndPinionJoint;

pub use joint_extra::WeldJoint;

pub use mass_properties::box_mass_properties;

pub use mass_properties::capsule_mass_properties;

pub use mass_properties::convex_hull_mass_properties;

pub use mass_properties::cylinder_mass_properties;

pub use mass_properties::sphere_mass_properties;

pub use mass_properties::translate_inertia;

pub use mass_properties::MassProperties;

pub use material::CombineRule;

pub use material::CombinedMaterial;

pub use material::MaterialId;

pub use material::MaterialTable;

pub use material::PhysicsMaterial;

pub use math::simd_width;

pub use math::Fix128;

pub use math::Mat3Fix;

pub use math::QuatFix;

pub use math::Vec3Fix;

pub use math::SIMD_WIDTH;

pub use motor::JointMotor;

pub use motor::MotorMode;

pub use motor::PdController;

pub use multi_world::MultiWorld;

pub use multi_world::Portal;

pub use netcode::DeterministicSimulation;

pub use netcode::FrameInput;

pub use netcode::InputApplicator;

pub use netcode::NetcodeConfig;

pub use netcode::SimulationChecksum;

pub use netcode::SimulationSnapshot;

pub use particle::LandingEvent;

pub use particle::LandingTarget;

pub use particle::Particle;

pub use particle::ParticleEmitter;

pub use particle::ParticleSystem;

pub use phase_change::Phase;

pub use phase_change::PhaseChangeConfig;

pub use phase_change::PhaseChangeModifier;

pub use physics2d::BodyType2D;

pub use physics2d::Contact2D;

pub use physics2d::Joint2D;

pub use physics2d::PhysicsConfig2D;

pub use physics2d::PhysicsWorld2D;

pub use physics2d::RigidBody2D;

pub use physics2d::Shape2D;

pub use physics2d::Vec2Fix;

pub use pipeline::MetricEvent;

pub use pipeline::MetricPipeline;

pub use pipeline::MetricRegistry;

pub use pipeline::MetricSnapshot;

pub use pipeline::MetricType;

pub use pipeline::RingBuffer;

pub use plane_collider::PlaneCollider;

pub use pressure::PressureConfig;

pub use pressure::PressureModifier;

pub use privacy::LaplaceNoise;Deprecated

pub use privacy::PrivacyBudget;

pub use privacy::PrivateAggregator;

pub use privacy::RandomizedResponse;Deprecated

pub use privacy::Rappor;Deprecated

pub use privacy::XorShift64;Deprecated

pub use profiling::PhysicsProfiler;

pub use profiling::ProfileEntry;

pub use profiling::StepStats;

pub use query::batch_raycast;

pub use query::batch_sphere_cast;

pub use query::capsule_cast;

pub use query::overlap_aabb;

pub use query::overlap_aabb_bvh;

pub use query::overlap_sphere;

pub use query::overlap_sphere_bvh;

pub use query::sphere_cast;

pub use query::BatchRayQuery;

pub use query::OverlapResult;

pub use query::ShapeCastHit;

pub use raycast::raycast_all_aabbs;

pub use raycast::raycast_all_spheres;

pub use raycast::raycast_any_aabbs;

pub use raycast::raycast_any_spheres;

pub use raycast::Ray;

pub use raycast::RayHit;

pub use rng::DeterministicRng;

pub use rope::Rope;

pub use rope::RopeConfig;

pub use rope_attach::solve_rope_attachments;

pub use rope_attach::RopeAttachment;

pub use scene_io::load_scene;

pub use scene_io::load_scene_json;

pub use scene_io::save_scene;

pub use scene_io::save_scene_json;

pub use scene_io::PhysicsScene;

pub use scene_io::SerializedBody;

pub use scene_io::SerializedJoint;

pub use sdf_adaptive::AdaptiveConfig;

pub use sdf_adaptive::AdaptiveSdfEvaluator;

pub use sdf_ccd::SdfCcdConfig;

pub use sdf_collider::ClosureSdf;

pub use sdf_collider::SdfCollider;

pub use sdf_collider::SdfContact;

pub use sdf_collider::SdfField;

pub use sdf_destruction::DestructibleSdf;

pub use sdf_destruction::DestructionShape;

pub use sdf_force::SdfForceField;

pub use sdf_force::SdfForceType;

pub use sdf_manifold::ManifoldConfig;

pub use sdf_manifold::SdfManifold;

pub use semantics::PHYSICS_SEMANTICS_ID;

pub use semantics::PHYSICS_SEMANTICS_PINS;

pub use shape::Shape;

pub use shape::ShapeError;

pub use sim_field::ScalarField3D;

pub use sim_field::VectorField3D;

pub use sim_modifier::ModifiedSdf;

pub use sim_modifier::PhysicsModifier;

pub use sim_modifier::SingleModifiedSdf;

pub use sketch::CountMinSketch;

pub use sketch::DDSketch;

pub use sketch::FnvHasher;

pub use sketch::HeavyHitters;

pub use sketch::HyperLogLog;

pub use sketch::Mergeable;

pub use sleeping::Island;

pub use sleeping::IslandManager;

pub use sleeping::SleepConfig;

pub use sleeping::SleepData;

pub use sleeping::SleepState;

pub use soft_body_cut::cut_cloth;

pub use soft_body_cut::cut_deformable;

pub use soft_body_cut::CutPlane;

pub use soft_body_cut::CutResult;

pub use solver::ContactModifier;

pub use solver::TgsCacheStats;

pub use solver::BodyType;

pub use solver::ContactConstraint;

pub use solver::DistanceConstraint;

pub use solver::LawCheck;

pub use solver::PhysicsConfig;

pub use solver::PhysicsWorld;

pub use solver::RigidBody;

pub use solver::SolverBackend;

pub use solver::StageWork;

pub use solver::WorldCcdConfig;

pub use solver::WorldSnapshotError;

pub use spatial::SpatialGrid;

pub use thermal::HeatSource;

pub use thermal::ThermalConfig;

pub use thermal::ThermalModifier;

pub use torus::Torus;

pub use trimesh::TriMesh;

pub use trimesh::Triangle;

pub use vehicle::Vehicle;

pub use vehicle::VehicleConfig;

pub use wedge::Wedge;

Modules

acoustic_wave

1-D acoustic wave equation solver.

aeroelasticity

Vortex-induced vibration (VIV) of an elastically-mounted circular cylinder.

animation_blend

Ragdoll Animation Blending

anisotropic

Anisotropic Material Behaviour for FDM & Fiber-Reinforced Composites

anisotropic_friction

Direction-dependent friction for tyres, skis, and ice-blade contacts.

anomaly

Streaming Anomaly Detection

articulation

Articulated Bodies (Multi-Joint Chains)

atmosphere

U.S. Standard Atmosphere 1976 (ISA) for the lower two layers.

audio_physics

Audio-Physics Integration

beam_stress

Beam Stress Analysis for 3D Print Safety

bimaterial

Bimaterial Interface Stress Analysis (Multi-Filament / Composite Bonding)

box_collider

Oriented Box (OBB) Collider

bridging

Bridging Distance Analysis for Support-Free Overhangs

buckling

Column and Shell Buckling Analysis

buoyancy_zone

BuoyancyZone — 3-D fluid volume that applies buoyancy + drag to immersed rigid bodies.

bvh

Linear Bounding Volume Hierarchy (LBVH) - Stackless Edition

ccd

Continuous Collision Detection (CCD)

cfd_solver

Integrated CFD Solver

character

Character Controller

character_state

Locomotion state machine for kinematic character controllers.

cloth

Cloth / Shell Simulation (XPBD Triangle Mesh)

cloth_fluid

Cloth-Fluid Coupling

collider

Collision Detection using GJK and EPA

collision_mesh_gen

Collision Mesh Generation from Signed Distance Fields

compound

Compound Shape

compressible

Compressible Fluid Dynamics — Ideal Gas + Shock Relations

cone

Cone Collider

contact_cache

Contact Manifold Cache with Warm Starting

contact_viz

Contact Force Visualization

convex_decompose

Convex Decomposition from SDF

convex_mesh_builder

Convex Hull Builder

coupled_field

Deterministic coupling channel between physics subsystems.

coupled_iteration

Sub-iteration monitoring for partitioned (staggered) multiphysics coupling.

coupling_medium

A homogeneous medium that exchanges momentum with rigid bodies through a linear drag, as a Participant of the world’s substep loop.

creep_longterm

Long-Term Creep Prediction (Findley + Time-Temperature Superposition)

crowd_force

Social force model of pedestrian motion (Helbing–Molnár 1995, Helbing–Farkas–Vicsek 2000).

cubic_elastic_fem

Small-strain linear elastic FEM on twenty-node cubic tetrahedra (P3).

cylinder

Cylinder Collider

damping_rayleigh

Rayleigh (Proportional) Damping Model

debug_render

Debug Visualization API

deformable

Deformable Body Simulation (FEM-XPBD)

det_math

Deterministic f32 / f64 transcendentals (cross-platform bit-exact).

dynamic_bvh

Dynamic AABB Tree (Incremental BVH)

dynamic_fem

Transient small-strain FEM on P1 tetrahedra: a mass matrix and a Newmark-β time integrator.

electromagnetic

Lorentz-force electromagnetics for charged rigid bodies.

ellipsoid

Ellipsoid Collider

erosion

Erosion Simulation Modifier

error

Physics Error Types

euler_fv

One-dimensional compressible Euler equations, finite-volume method.

eulerian_grid

Eulerian Fluid Grid (MAC + FLIP/PIC)

event

Physics Event System

fatigue

Fatigue Life Prediction (S-N Curve + Miner’s Rule)

ffi

C Foreign Function Interface for ALICE-Physics

filament_db

3D Printing Material & Sheet Metal Property Database

fillet_stress

Stress Concentration Factors (Peterson / Neuber)

filter

Collision Filtering (Layer/Mask System)

flow_viz

Fluid Flow Visualization

fluid

Position-Based Fluids (PBF)

fluid_netcode

Deterministic Fluid Netcode

force

Custom Force Fields and Gravity

fracture

Fracture Simulation Modifier

fsi_advanced

Advanced Fluid-Structure Interaction (Deformable / Articulation Coupling) Phase G3 of the ALICE-Physics completeness project. Extends the existing cloth_fluid two-way coupling module to work with deformable solids (deformable.rs) and articulated bodies (articulation.rs).

gpu_bridge

GPU solver bridge trait for external offload backends.

gpu_sdf

GPU-Accelerated SDF Evaluation (Compute Shader Interface)

heatmap

Stress and Temperature Heatmap Visualization

heightfield

Height Field Collision

hyperelastic

Nonlinear Hyperelastic Constitutive Models (Rubber / TPU / Silicone)

ik_physics_bridge

Bridge between an inverse-kinematics (IK) target chain and the physics rigid-body world.

interface_capture

Sharp Interface Capturing (Level Set FSM + PLIC VOF Reconstruction)

interpolation

Substep Interpolation Output

joint

Joint System for Rigid Body Connections

joint_extra

Extended Joint Types for Mechanical Linkages

kepler

Two-body problem: Kepler’s equation, classical orbital elements and the closed-form laws of an elliptic orbit.

kinematic_loop

Position-based kinematic loop closure constraint.

laminate

Classical Laminate Theory (CLT) for Stacked-Ply Composites

laminate_failure

Composite laminate failure criteria for orthotropic plies.

law_id

Content identifier of the law a PhysicsWorld is configured with: PhysicsWorld::law_id.

layer_adhesion

FDM Layer Adhesion Analysis (Print-Direction × Load-Direction Matrix)

lift_drag

Lift and drag of a wing surface attached to a rigid body.

linear_elastic_fem

Small-strain linear elastic FEM on tetrahedra (P1), producing a Cauchy stress tensor per element from an sdf_fem_mesh::SdfTetMesh.

linear_solver

General Krylov solvers on Fix128: GMRES(m) and BiCGStab, with Jacobi / block Jacobi preconditioning and mandatory block equilibration for coupled systems.

mass_properties

Mass Property Computation from Geometry

material

Material System with Pair-wise Combine Rules

math

Deterministic Fixed-Point Mathematics - SIMD Optimized Edition

math_util

Deterministic Numerical Utilities (Fix128 Transcendentals & Solvers)

maxwell_fdtd

Maxwell field solver on a Yee (FDTD) lattice, in normalised units.

metric

The metric a distance is measured in, in fixed point.

modal

Modal Analysis — Natural Frequency of Beams / Plates / Springs

molecular_dynamics

Molecular dynamics of point particles under a pair potential: velocity Verlet integration, a periodic cell list and the NVE observables.

motor

Motors and PD Controllers

multi_world

Multiple Independent Physics Worlds

multiphase

Multi-Phase Flow (VOF + Level Set)

nbody

N-body gravity: direct-sum mutual attraction and a symplectic integrator.

netcode

Deterministic Netcode Foundation

netcode_prediction

Client-side prediction primitives with server reconciliation.

non_newtonian

Non-Newtonian Fluid Constitutive Models

pair_potential

Pair potentials between point particles: Lennard-Jones 12-6, Morse, Coulomb and screened Coulomb (Yukawa), with cutoff / shift and the Lorentz–Berthelot mixing rule.

particle

General-Purpose Particle System

phase_change

Phase Change Simulation Modifier

physics2d

2D Physics Subsystem — Deterministic XPBD with 128-bit Fixed-Point Arithmetic

piezoelectric

Piezoelectric element with bidirectional force ↔ voltage coupling.

pipeline

Lock-Free Metric Aggregation Pipeline

plane_collider

Infinite Plane Collider

plastic

Elastoplastic Deformation with von Mises Yield & Creep Prediction

prelude

Prelude module for convenient imports

pressure

Pressure Simulation Modifier

prestressed

Prestressed / Pretensioned Joint & Cable Analysis

print_orientation

Print Orientation Optimization for Load-Aligned Strength

print_pipeline_solver

3D Print Full Safety Pipeline

privacy

Local Differential Privacy (LDP) Mechanisms

profiling

Physics Profiling API

quadratic_elastic_fem

Small-strain linear elastic FEM on ten-node quadratic tetrahedra (P2).

query

Shape Cast and Overlap Queries

ragdoll

RagdollBuilder — humanoid ragdoll preset.

raycast

Raycasting and Shape Casting

rng

Deterministic Random Number Generator

rolling_contact

Hertzian rolling-contact stress + Basquin-style fatigue life.

rope

Rope / Cable Simulation (XPBD Distance Chain)

rope_attach

Rope Attachment to Rigid Bodies

rotor

Rotor and propeller thrust, torque and ideal hover power.

scene_io

Scene Serialization and Deserialization

sdf_adaptive

Adaptive SDF Resolution

sdf_ccd

SDF Sphere Tracing CCD (Continuous Collision Detection)

sdf_character

SDF-swept kinematic character controller.

sdf_collider

SDF (Signed Distance Field) Collision Detection

sdf_destruction

SDF Boolean Destruction System

sdf_fem_mesh

Cartesian tetrahedral mesh generation from a signed distance field.

sdf_force

SDF-Driven Force Fields

sdf_manifold

SDF Contact Manifold Generation

sdf_sph

Minimal SPH particle fluid with SDF boundary repulsion.

sdf_wind_field

SDF-driven wind field: wind vector is a function of the local SDF distance to obstacles.

semantics

Content hash of the stepping semantics: PHYSICS_SEMANTICS_ID.

sensors

Simulated sensors over a PhysicsWorld: a scanning range finder (lidar), a contact sensor and an inertial measurement unit (IMU), each with optional deterministic Gaussian noise.

shape

Solid shapes with mass properties, and the bodies built from them.

shape_raycast

Ray queries against the geometry a PhysicsWorld actually collides with.

sim_field

3D Simulation Field Infrastructure

sim_modifier

Simulation Modifier Core System

sketch

Probabilistic Sketch Data Structures

sleeping

Sleeping and Island Management

smoke_fire

Combustion, Smoke and Fire (Arrhenius + Soot + Buoyancy)

soft_body_cut

Soft Body Cutting (Topology Change)

solver

XPBD (Extended Position Based Dynamics) Solver - Batched Edition

spatial

Spatial Hash Grid

spherical_terrain

Building blocks for a world whose ground is a sphere: a radial height field, and gravity that points at the centre.

static_collider

Immovable collision surfaces for a PhysicsWorld.

structural_solver

Structural (Solid Mechanics) Time-Stepping Solver

support_volume

Support Structure Volume Estimation for 3D Printing

surface_tension_csf

Continuum Surface Force (CSF) for Surface Tension

thermal

Thermal Simulation Modifier

thermal_stress

Thermal Stress in Constrained Parts

thin_wall

Thin-Wall Detection for 3D Print Safety

torus

Torus Collider

transient_thermal

Transient thermal conduction with temperature-dependent material properties.

trimesh

Triangle Mesh Collision

turbulence

Turbulence Closure Models — Smagorinsky LES + k-ε + k-ω

vehicle

Vehicle Physics

vehicle_dynamics

Vehicle dynamics: per-wheel contact forces, wheel spin, brake torque, ABS, tyre models, road surfaces and weather, powertrain.

vibration_wall

Thin-Wall Vibration & Printer Resonance Risk

warp_risk

Warp Risk Analysis for 3D Printed Parts (Cooling Shrinkage → Curl / Peel)

wave_ship

Ocean Waves + Ship Dynamics (JONSWAP + Froude-Krylov)

wedge

Wedge (Triangular Prism) Collider

wind_zone

WindZone — bounded aerodynamic force field applied to rigid bodies and cloth / hair particles.

world_character

Move-and-slide of a CharacterController against the geometry a PhysicsWorld collides with.

world_participant

The contract a law signs to take part in crate::solver::PhysicsWorld’s substep loop: Participant and the small types around it.

world_shape_query

Swept and overlap queries against the geometry a PhysicsWorld actually collides with.