Chaos Physics Performance

PhysX was deprecated as the default in UE 5.0 and is no longer shipped in UE5 unless the engine is rebuilt from source (per Epic forums on physics engine futures). Chaos is the default for everything: rigid body simulation, collision queries, cloth, geometry collections, vehicles. If you're shipping UE5, you're shipping Chaos.

Frame-time hits show up in two places:

• Game thread — PhysScene_ChaosTick in stat physics. Cost includes scene queries (line traces, overlaps, sweeps) and tick logic.
• Physics thread — the actual solver, when async physics tick is enabled. Or, when not, runs as part of the game-thread physics step.

Verify which is the bottleneck before tuning. stat physics shows the top-level time; stat Chaos drills into solver pipeline timings (advance, broadphase, narrowphase, constraints, integration).

Chaos is an iterative constraint solver. Each step: detect contacts (broadphase + narrowphase), build constraints, solve them iteratively, integrate forces, write back transforms. Most tunable cost is in the constraint solver.

Key CVars:

[/Script/Engine.PhysicsSettings]
; Override determinism. -1 = use config; 0 = disabled; 1 = enabled.
; Disabling can recover frame time when bit-exact replay isn't needed.
p.Chaos.Solver.Deterministic=1

; Joint solver tolerances. Tighten for accuracy; loosen for cost.
p.Chaos.Solver.Joint.PositionTolerance=0.025
p.Chaos.Solver.Joint.AngleTolerance=0.001

; SIMD code path; up to ~15% solver speedup when enabled.
p.Chaos.Solver.Joint.UseSimd=1

; Motion-Aware Collision Detection (replacement for PhysX CCD).
; Use UseMACD on individual fast bodies; ForceMACD globally if everything tunnels.
p.Chaos.Solver.UseMACD=0
p.Chaos.Solver.bChaosForceMACD=0

The solver iteration count is configured in the Chaos Solver Settings (Project Settings → Physics → Chaos Solver). Higher iteration counts = more accurate constraint solving = higher cost. Default values work for most projects; tune up only when joints visibly drift or stretch under load.

MACD (Motion-Aware Collision Detection) replaces PhysX's CCD for fast-moving bodies that would otherwise tunnel through thin geometry. It's opt-in per body (cheaper) or global force (sledgehammer). Use on bullets, fast vehicles, projectiles; not on everything.

Two ways to keep physics stable when frame time is variable. They are mutually exclusive — you pick one or the other, not both. ("Substepping Async" is deprecated; per the Epic forums.)

Substepping: when frame dt is too large, the physics tick is run multiple times per frame with smaller dt's. Bounds dt; preserves quality during frame drops. Configured in Project Settings:

• Max Substep Delta Time — typically 1/60 (0.01667) or 1/120 (0.00833).
• Max Substeps — typically 4. Below 1/(maxdt × maxsubsteps) FPS, the simulation slows below real-time.

Async Physics Tick: physics runs on its own thread at a fixed rate, decoupled from the render frame. Better latency consistency; required for predictive networked physics. Has non-trivial performance impact per Epic's own documentation. Use TSimCallbackObject for per-step work in async mode — it's cheaper than the standard async tick.

Decision tree:

• Single-player game with variable framerate: substepping. Simpler, no threading concerns.
• Networked physics with prediction/rewind: async tick (required for fixed-tick rewind/resim).
• Vehicles: do not use substepping with Chaos vehicles — there's a known glitch where vehicle controllers desync (per this Epic forums thread). Use async tick instead.

Geometry Collections are Chaos's destruction system — meshes that break apart into clusters of pieces under impact or applied force. The cost picture is dominated by two failure modes: too many simultaneous breaks and orphaned debris that never sleeps.

Per Epic's Chaos Destruction Optimization docs: "many clusters can break per frame, releasing a lot of new physics particles… desirable to control how many of those clusters can be broken and how many rigid bodies are released per frame."

Tuning:

• Cluster hierarchies — build geometry collections with multiple cluster levels. Top level = single mesh; lower levels = progressively smaller pieces. The simulation only resolves down to the level needed by the damage.
• Damage Threshold Multiplier — per-cluster control over how much damage is required to break it. Tune so secondary debris breaks only on direct contact.
• Decay timers — debris pieces decay (fade out + remove from sim) after a configurable time. Mandatory for any destruction-heavy project; without it, debris accumulates indefinitely.
• Root Mesh Proxies (5.6+) — render the unfractured silhouette until break occurs. Eliminates per-piece draw cost pre-fracture.
• Cluster Trace/External Strain over fields — fracture authoring tools that allow precise control over what causes a piece to break.
• One-way interaction — an option that allows the destruction simulation to influence other physics objects but not the reverse, halving simulation work for some scenarios.

For more detail, see Epic's Chaos Destruction Optimizations tutorial.

The most common Chaos performance mistake is the same as PhysX's: "Use Complex Collision As Simple" on a tickrate-heavy actor. Every overlap, sweep, and physics tick walks the full triangle soup. We covered the fundamentals in Gotcha #1; this is the deeper version.

The collision shape selection ladder:

1. NoCollision — for purely decorative geometry. Free.
2. BlockAll / Custom presets with simple primitives — box, sphere, capsule. Cheapest active collision. Use for the vast majority of dynamic gameplay objects.
3. KDOP / Convex Decomposition — for irregular shapes that need accurate collision but not per-triangle precision.
4. Auto Convex Collision — semi-automated convex hulls for arbitrary shapes.
5. Use Complex Collision As Simple — the per-triangle path. Only when you genuinely need per-triangle accuracy and the actor doesn't tick frequently.

Epic's own Fortnite collision optimization tutorial (link) is the canonical reference for the rules.

Per-trace channel cost matters too. Each line trace tests against the channels its query mask covers; reducing channel breadth on high-frequency queries (AI vision, for example) is a meaningful saving.

Scene queries are line traces, sweeps, and overlap checks. They run on the game thread (or worker, with async traces). Their cost scales with the number of objects in range and the complexity of the collision representation.

Best practices:

• Prefer simple over complex traces. bTraceComplex=false uses simple collision; bTraceComplex=true uses the triangle-soup path. Complex traces are usually only needed for projectile hit detection on landscape or hero geometry.
• Cap the trace count per frame. If your AI does 20 line traces per tick and you have 50 AI, that's 1000 traces per frame — verify the cost in stat physics.
• Async traces — for non-time-critical queries (AI awareness, distant prop checks), use UWorld::AsyncLineTrace to schedule the trace on a worker. The result lands in a callback next frame.
• Multi-channel overlaps — expensive per channel. Combine queries when possible.
• Replace polling traces with events. Don't trace every frame to check if a door opened; have the door fire an event when it opens.

Cloth is a separate budget line and a frequent silent perf killer. A character with default Chaos Cloth assets, no LOD scaling, full self-collisions, and a dense sim mesh routinely consumes 1–3 ms per character on consumer CPUs (per Epic forums on Chaos Cloth heavy perf impact).

Low-budget cloth setup (per community guidance):

• Sub-300 simulation vertices. Authoring discipline; the cloth artist needs to deliberately keep sim mesh count down. Render mesh can be much higher poly.
• PBD-only constraints. Skip XPBD if standard PBD is sufficient.
• No self-collisions. Self-collision is the most expensive part of cloth sim. Disable unless visually critical.
• Quality Level Min LOD per platform. p.ClothAsset.MinLodQualityLevel caps cloth LOD by platform. Lower-tier platforms get aggressive cloth simplification.

p.ChaosCloth.UseTimeStepSmoothing=1 (default) smooths cloth dt to avoid jitter on dt spikes. Movie Render Pipeline disables it for deterministic captures.

Ragdolls have their own budget driven by body count and joint solver iterations. Per-character body count of ~15 (head, torso, four limb-segment pairs) is typical. Halving solver iterations on ragdoll-only physics asset configs can recover meaningful CPU.

Networked physics is one of the more delicate areas of Chaos. The basics:

• Server-authority by default. The server simulates physics; clients receive replicated transforms.
• Replication of physics state — expensive in bandwidth on many-body simulations. Replicating 100 destruction debris pieces independently is rarely the right call; replicate the spawn event and let each client simulate locally.
• UNetworkPhysicsComponent + Fixed-Tick mode are required for rewind/resim networking (server-authoritative client-prediction).
• PhysicsPredictionSettings in Project Settings — configure prediction window, snap thresholds, etc.
• Network Tick visualization mode (5.5+) — visualizes server vs client physics divergence.

Reference: Epic's Networked Physics Overview and the more detailed Networked Physics docs.

The general principle: cheap synchronization (snapshots of important state) beats expensive prediction in most cases. Use prediction only where input latency genuinely matters — player vehicle, hero character physics — and accept simpler replication for everything else.

The standard kit:

• stat physics — top-level physics tick, cloth, scene-query timings.
• stat Chaos — Chaos solver pipeline timings (advance, broadphase, narrowphase, constraints, integration).
• stat SceneRendering / stat Game — confirm physics is actually the hot path before tuning.
• p.Chaos.DebugDraw.Enabled 1 + p.Chaos.Solver.DebugDrawShapes 1 — runtime collision visualization (red=static, blue=kinematic, yellow=active, gray=sleeping).
• p.Chaos.DebugDraw.MaxLines — default 20000; bump if debug-draw overflows on dense scenes.
• p.Chaos.Solver.DebugDraw.Cluster.Constraints 1 — visualize geometry-collection cluster constraints.

Chaos Visual Debugger (CVD). The major addition in 5.4 (Beta) and standalone-packagable in 5.5. Records a sim trace; replay later with full inspection of solver state. The 5.5 release moved on-the-fly geometry generation off the main thread, making CVD usable in production. Reference: Epic's CVD User Guide.

For deeper context, watch Epic's Debugging Chaos Physics Unreal Fest 2024 talk and A Tech Artist's Playbook for Chaos Performance.

Projects upgrading from UE4 to UE5 have to deal with the Chaos migration. The behavioral differences that bite most often:

• Friction model change. Chaos uses Static + Dynamic friction explicitly. Rolling/torque-driven movement that was tuned in UE4 PhysX will slide or stall on Chaos until friction values are re-tuned. Multiple migration threads document this; Artificial Life's UE5-vs-UE4 Part 2 is a good walkthrough.
• Mass and torque tuning need to be redone — Chaos integrates differently and PhysX-tuned values often need scaling up or down by a constant factor.
• Restitution differences. The way bounce energy is computed differs slightly; bouncy materials may bounce differently.
• Chaos Vehicles use ChaosVehicleMovementComponent, not the PhysX wheeled vehicle component. Code-side changes required.
• MACD replaces PhysX CCD. Same concept (continuous collision detection for fast bodies), different API and tuning.

Eternal Strands by Yellow Brick Games is a public reference: a four-year UE4 project ported to UE5/Chaos for telekinesis-driven gameplay, requiring dynamic per-context parameter retuning (per the postmortem at Creative Bloq). Plan for a chunk of physics re-tuning time when migrating; it will not be free.

Per-actor checklist when authoring physics-bearing content:

1. Collision complexity: NoCollision → Simple → Convex → Complex. Default is "use simple"; "complex as simple" only when justified.
2. Sleep thresholds — check the Physical Material's sleep thresholds. Set explicit values rather than relying on defaults; debris should sleep promptly when settled.
3. Simulate-on-spawn flag — only enable physics simulation when the actor needs it.
4. Network role — static replicated physics is rarely correct; choose between authoritative + simulated and snapshot replication deliberately.
5. LOD-driven cloth — p.ClothAsset.MinLodQualityLevel per platform; sim mesh under 300 vertices; no self-collisions unless visually critical.
6. Substepping vs async tick matches the project's networking choice and vehicle support.
7. MACD opt-in only on bodies that need it (bullets, fast vehicles).

PerfGuard can lock a baseline of stat Chaos solver totals plus key CVars (p.Chaos.Solver.Deterministic, p.ChaosCloth.UseTimeStepSmoothing, substepping vs async tick mode) and fail CI if a PR shifts physics-thread time, cloth time, or those CVars beyond a tolerance — catching silent regressions like "Use Complex Collision as Simple" toggled on or cloth MinLOD lowered.

• Animation Performance — the system Chaos most directly interacts with via cloth, ragdolls, and physics-driven animation.
• Gotcha #1: Complex Collision on Decorative Meshes — the field-guide version of section 5.
• Diagnosing CPU Regressions — physics tick is one of the most common CPU regression sources.