physics-tuning

Physics tuning

Most "bad physics" is not a bug in the engine — it's a mismatch between the fixed-timestep simulation and the variable-rate render loop, or untuned mass/drag/CCD/layer settings. This skill covers the engine-neutral knobs that make physics stable and responsive; pair it with godot-physics or unity-physics for the concrete APIs.

When to use

• Use when motion jitters, objects pass through walls (tunneling), stacks

explode, or movement feels floaty/sticky/laggy.

• Use to decide what goes in the fixed (physics) step vs the render frame, and

how to interpolate between them.

• Use to tune gravity, mass, drag, restitution, solver iterations, sleeping, and

collision layers/masks.

When not to use: for an engine's exact physics nodes/components and collision callbacks, use `godot-physics` or `unity-physics`. For movement decisions* (when to jump, AI steering) use input-systems and game-ai. For platformer jump-feel specifics like coyote time/jump buffering, that's input/ controller territory — see input-systems and the platformer genre.

Core workflow

1. Run physics on a fixed timestep. Simulate at a constant rate (e.g. 50–60

Hz). A fixed dt makes the simulation deterministic-ish and stable; a variable dt makes integration and collisions inconsistent.

1. Put physics work in the physics callback, not the render frame. Apply

forces/velocities and read collisions in the fixed step (FixedUpdate / _physics_process), using that step's dt.

1. Interpolate rendering between physics ticks. The render frame rate ≠ the

physics rate, so smoothly interpolate transforms toward the latest physics state, or enable the engine's Rigidbody interpolation, to remove visible stutter.

1. Tune the body, not the scene. Set mass for relative weight, drag for

damping, gravity scale per object, and restitution/friction via materials.

1. Stop tunneling with CCD on small/fast bodies; cap maximum velocity.
2. Stabilize stacks/joints with more solver iterations, sane mass ratios, and

sleeping for resting bodies.

1. Verify by feel and stress test. Play at low and high frame rates; throw

fast objects at thin walls; stack and shove bodies. Report what you observed.

Patterns

1. Fixed timestep for simulation, render interpolation for smoothness

# Physics callback: runs at the FIXED rate. Use its dt for all integration.
func _physics_process(dt):                  # Unity: void FixedUpdate()
    velocity += gravity * dt                # integrate with the FIXED dt
    move_and_slide()                        # engine resolves collisions this step
    _prev_pos = _curr_pos; _curr_pos = global_position   # record for interpolation

# Render frame: runs as fast as the display. Interpolate between physics states.
func _process(_frame_dt):                   # Unity: void Update()
    var alpha = Engine.get_physics_interpolation_fraction()  # 0..1 within the tick
    visual.global_position = _prev_pos.lerp(_curr_pos, alpha)
# RIGHT: integrate in the fixed step, render via interpolation.
# WRONG: applying forces in _process/Update with frame dt — speed and collisions
# then depend on frame rate and jitter under load.

Most engines offer this for you: Godot's project setting physics/common/physics_interpolation (off by default; it interpolates every node, 2D and 3D) and Unity's Rigidbody.interpolation = Interpolate. Prefer the built-in before hand-rolling, and never do both on the same node.

2. Stop tunneling: CCD + a speed cap

# Fast, small bodies skip past thin colliders between ticks. Two fixes:
body.continuous_cd = true            # RigidBody3D bool (RigidBody2D: CCD_MODE_* enum)
# Unity: rb.collisionDetectionMode = CollisionDetectionMode.ContinuousSpeculative (cheap, covers
# dynamic bodies too) or ContinuousDynamic (fast vs fast); plain Continuous sweeps vs static only.
# Cap velocity so a single step can't move more than ~one collider thickness.
const MAX_SPEED := 40.0
if velocity.length() > MAX_SPEED:
    velocity = velocity.normalized() * MAX_SPEED
# Rule of thumb: max_distance_per_step (= speed / physics_hz) should be < the
# thinnest wall. Raise physics_hz or enable CCD when that fails.

3. Body tuning: mass, drag, gravity scale, material

# Mass is RELATIVE weight in collisions; it does NOT change fall speed (gravity
# accelerates all masses equally). Use drag and gravity_scale to shape feel.
body.mass = 2.0                      # heavier pushes lighter in collisions
body.linear_damp = 0.5               # air drag: higher = stops sooner (Unity 6: linearDamping, was drag)
body.gravity_scale = 1.5             # per-object gravity multiplier (Unity: Rigidbody2D.gravityScale)
# Bounce/slide come from the physics material, not code:
material.bounce = 0.2                # restitution 0..1 (Unity: PhysicsMaterial.bounciness)
material.friction = 0.8              # surface grip
body.physics_material_override = material

4. Collision layers and masks (who collides with whom)

# A body is ON its layer(s) and SCANS the layers in its mask. Both directions of a
# pair must be configured for them to interact.
player.collision_layer = LAYER_PLAYER
player.collision_mask  = LAYER_WORLD | LAYER_ENEMY     # player detects world+enemies
pickup.collision_layer = LAYER_PICKUP
pickup.collision_mask  = LAYER_PLAYER                  # pickup only reacts to player
# Unity equivalent: assign GameObject layers and edit the Physics collision matrix
# (or Physics.IgnoreLayerCollision). Keep a named layer constant table, not magic numbers.

Pitfalls

• Applying forces/movement in the render frame (Update/_process) makes

behavior frame-rate dependent — faster PCs run faster, and collisions get flaky. Do simulation in the fixed step.

• Visible jitter even with a fixed step usually means no render

interpolation: the physics rate and display rate beat against each other. Enable interpolation.

• Tunneling through thin walls: discrete collision misses fast movers. Enable

CCD, cap speed, thicken walls, or raise the physics rate.

• Expecting heavier objects to fall faster. Gravity is acceleration; mass

affects collision response, not fall speed. Use gravity_scale/drag for feel.

• Exploding stacks / jittery joints: mass ratios too extreme, or too few

solver iterations. Keep mass ratios modest and raise iteration counts.

• Bodies that never rest burn CPU and twitch. Enable sleeping and a sensible

sleep threshold for resting objects.

• One-directional layer setup: A's mask includes B but B's mask excludes A.

Detection/collision can need both sides; verify the full matrix.

• Huge `dt` spikes (load hitches, breakpoints) blow up integration. Clamp the

max physics step / substep count so a stall doesn't launch everything (Godot physics/common/max_physics_steps_per_frame, Unity Maximum Allowed Timestep).

• Teleports smear across the screen with interpolation on: the renderer

blends from the old position. Godot: call reset_physics_interpolation() after moving the node. Unity: move interpolated bodies through the Rigidbody; a direct transform write is ignored unless followed by Physics.SyncTransforms().

• Feel changes after raising the physics rate: Godot (GodotPhysics and Jolt

alike) damps by multiplying velocity by 1 - damp / ticks_per_second each tick, an approximation that drifts as damp approaches the tick rate (at damp >= ticks_per_second the body stops in one tick). Small damping values barely change; re-tune large ones after changing physics_ticks_per_second.

References

• references/timestep-and-ccd.md — the fixed-timestep accumulator loop,

interpolation math, substepping, CCD modes, solver/iteration tuning, sleeping, and a stability checklist.

Related skills

• godot-physics, unity-physics — concrete bodies, colliders, and callbacks.
• input-systems — responsive controls, jump buffering, coyote time.
• game-ai — agent movement that must agree with the physics step.
• platformer, fps-shooter — genres whose feel depends on this tuning.