Deterministic
Physics
A fixed step rigid body and soft body solver that produces bitwise identical results across machines. Safe to run as the server authority, safe to replay frame exact.
Why determinism is the product
Most game physics engines are stable but not deterministic. The moment you cross a machine boundary the simulations drift, which rules out rollback netcode, breaks replay files on patch day, and forces you to hand author every scripted sequence that needs to look the same twice.
Crowe Physics fixes the integrator at 480 Hz internally, pins floating point rounding at the compiler flag level, and exposes an explicit seed for any stochastic pass. Two servers in different data centers, two clients on different GPUs, and the solver produces the same bits. This is what unlocks the rollback transport, instant replay, and cheat detection that does not need heuristics.
The solver itself is an island based sequential impulse scheme with a warm started Gauss Seidel inner loop. Islands are discovered on the broad phase and solved in parallel on a work stealing job system. Constraint groups that touch each other merge and split across frames without a rebuild.
What the physics runtime covers
Rigid body dynamics
Sequential impulse solver with speculative contacts and continuous collision detection for fast moving bodies. Sleeping islands have zero runtime cost so a scene with a hundred thousand resting objects costs about what you pay for the broad phase sweep.
- Warm started impulse solver, 4 to 12 iterations
- Continuous collision for bullets and vehicles
- Sleep islands with zero idle cost
- Per material friction and restitution
Cloth, rope, and deformables
Position based dynamics for cloth and rope, finite element for volumetric deformation. The cloth solver ships with a tethering model that prevents the trench coat stretch problem at high velocity.
- Position based dynamics with XPBD stabilization
- Tetrahedral FEM for skin and muscle
- Two way coupling with rigid bodies
- Fracture with pre computed convex pieces
Articulated constraints
Hinges, sliders, ball joints, fixed joints, gears, and springs, all driven by target position, target velocity, or target force. Authored as chains so a humanoid rig or a tracked vehicle compiles to one solver island.
- Position, velocity, and force drives
- Angular and linear limits with soft zones
- Gear and rack constraint primitives
- Ragdoll with pose target blending
Spatial queries
Ray casts, sphere casts, overlap tests, and shape sweeps share the same acceleration structure the solver uses. Queries are thread safe and batched so AI and gameplay code does not contend with the physics step.
- Lock free query API
- Filter groups for gameplay layers
- Scene snapshot queries for AI tick
- Batch ray cast API for line of sight
Pinning determinism and stepping the world
The solver runs on its own clock. Gameplay sees a consistent view at render time:
// Pin the seed and time step so the simulation is deterministic
Physics.Deterministic = true;
Physics.Seed = 0xC0FFEE;
Physics.FixedStep = 1.0f / 480.0f; // 480 Hz internal
// Create a kinematic rigid body with a simple capsule shape
var body = Physics.CreateBody(new BodyDesc {
Shape = Shape.Capsule(radius: 0.4f, half: 0.9f),
Mass = 75.0f,
Drive = Drive.Kinematic,
Filter = CollisionLayer.Player
});
// Query the world from gameplay, lock free and thread safe
if (Physics.Raycast(origin, direction, 50.0f, out var hit, mask: CollisionLayer.World)) {
Debug.Log($"hit {hit.Body.Name} at {hit.Distance:F2}m");
}Cost profile at scale
Reference scene: 10,000 active rigid bodies, 2,000 cloth particles, 400 active constraints. Ryzen 9 7950X, single NUMA node.
Where the determinism matters
Rollback netcode
Fighting and sports titles running on the transport layer roll back eight frames and resimulate without visible drift. The solver is the reason this is possible.
Replay and esports
A replay is a seed, an initial state, and an input stream. Playback on any machine reproduces the match frame for frame, which removes the entire category of replay drift bugs.
Server side authority
Because clients and the server produce identical physics given the same inputs, the server can accept client predicted motion and only correct when it actually disagrees. Bandwidth drops sharply.
Adjacent reading
Networking
How the rollback transport and snapshot system consume deterministic simulation state.
Debugging Suite
Visualize solver islands, contact points, and constraint stress in the inline debugger.
Scripting reference
Full C# and C++ API for body creation, constraints, materials, and spatial queries.
Try the deterministic path
The SDK ships with a rollback netcode sample and a replay sample. Either will make the behavior concrete in ten minutes.