JoltPhysics: Why AAA Studios Are Ditching Legacy Engines

JoltPhysics: Why AAA Studios Are Ditching Legacy Engines

The Physics Engine Crisis Nobody Talks About

Your physics simulation is choking. Again. You've optimized every shader, batched every draw call, yet your frame rate collapses the moment twenty rigid bodies collide. Sound familiar? You're not alone—and you're not the problem. The dirty secret of game development is that most physics engines were architected for single-core processors in an era when "multi-threading" meant running audio on a second thread. Legacy engines force you into brutal trade-offs: lock the world during queries, stall your render thread during simulation, or accept non-deterministic chaos that breaks networked multiplayer. Pick your poison.

But what if I told you a physics engine exists that treats multi-core CPUs as first-class citizens? What if collision queries could run parallel to simulation steps? What if deterministic replication across clients required merely syncing inputs—not entire world states? This isn't hypothetical. JoltPhysics, the engine powering Horizon Forbidden West and Death Stranding 2: On the Beach, is rewriting the rules of what's possible in real-time physics simulation.

Created by Jorrit Rouwe, JoltPhysics isn't another me-too physics library. It's a surgical strike against decades of accumulated technical debt in game physics. And it's completely open source under the MIT license.

What is JoltPhysics?

JoltPhysics is a multi-core friendly rigid body physics and collision detection library written in modern C++17. Born from Rouwe's frustration with existing engines that treated concurrent access as an afterthought, Jolt was architected from the ground up for the realities of contemporary game development: heterogeneous workloads, background streaming, and the insatiable demand for more interactive objects.

The engine's pedigree speaks louder than any marketing. When Guerrilla Games needed physics for Horizon Forbidden West—a game featuring massive mechanical beasts collapsing into dynamic environments—they didn't default to industry stalwarts. They built on Jolt. When Kojima Productions crafted Death Stranding 2's intricate cargo physics and terrain interactions, Jolt was their foundation. These aren't indie experiments; they're technical showcases with hundreds of millions in development budgets.

Jolt's design philosophy centers on pragmatic concurrency. Rather than bolting thread-safety onto a single-threaded architecture, every subsystem considers parallel access patterns. Background loading of physics bodies happens without simulation locks. Collision queries execute concurrently with body modifications. The broad phase runs ahead of narrow phase checks, enabling long-running operations like navigation mesh generation to distribute across frames without stalling gameplay.

The engine targets games and VR applications specifically, acknowledging that real-time constraints demand different approximations than scientific simulation. It compiles with Visual Studio 2022+, Clang 16+, or GCC 12+, depends only on the standard template library, and explicitly avoids RTTI and exceptions—critical for console certification requirements.

Key Features That Separate JoltPhysics from the Pack

JoltPhysics delivers a staggering feature set that rivals or exceeds commercial alternatives, but its true differentiators lie in architectural decisions invisible to feature checklists.

Deterministic Simulation stands paramount. In an industry where networked physics typically demands state snapshot compression or complex rollback systems, Jolt achieves deterministic replication through input synchronization alone. Replicate the inputs to the simulation, and remote clients converge to identical states. This isn't theoretical perfection with impractical constraints—Rouwe documents the specific limits in the Deterministic Simulation documentation, providing honest guidance rather than marketing promises.

Concurrent Query Architecture redefines runtime flexibility. Traditional engines force a binary choice: query the world or modify it, never simultaneously. Jolt's coarse-to-fine approach permits broad phase queries before simulation steps while narrow phase checks execute in background threads. Navigation mesh generation, AI perception systems, and audio occlusion calculations can span multiple frames without blocking critical path execution.

Wake Control Precision solves a subtle performance killer. Creating or destroying bodies in legacy engines often triggers cascading wake-up of neighboring objects, destroying carefully managed sleep state optimizations. Jolt defaults to manual wake control—bodies don't automatically activate on creation, and removals don't disturb neighbors. This proves essential during level streaming, where background loading/unloading would otherwise thrash simulation stability.

The shape support encompasses spheres, boxes, capsules, tapered capsules, cylinders, tapered cylinders, convex hulls, planes, compounds, triangle meshes, and terrain height fields. Constraint systems cover fixed, point, distance (with springs), hinge, slider/prismatic, cone, rack and pinion, gear, pulley, smooth spline paths, swing-twist for humanoid shoulders, and full 6-DOF configurations—all with motor drives.

Advanced features include soft body simulation with edge constraints, dihedral bend constraints, Cosserat rod constraints, tetrahedron volume constraints, long range attachment constraints, skinned vertex limits, internal pressure, and rigid body collision. A GPU-accelerated strand-based hair simulation using Cosserat rods supports guide and follow hairs with grid-based hair-hair collision. Vehicle systems handle wheeled, tracked, and motorcycle configurations. Water buoyancy calculations and optional double precision for large worlds round out the capabilities.

Use Cases Where JoltPhysics Dominates

Massive Open World Streaming

Consider Horizon Forbidden West's seamless world. Traditional physics engines require complete world locks during sector loading, causing hitches perceptible at 30fps. Jolt's background batch preparation allows physics bodies to construct on worker threads, inserting into simulation with minimal disruption. The manual wake control prevents streaming operations from destabilizing distant active simulations. For any open world game, this architectural advantage translates directly to smoother player experience.

Networked Multiplayer with Physics Authority

Deterministic simulation enables authoritative server architectures previously considered impractical for complex physics. Rather than server-side simulation with state broadcast (bandwidth-prohibitive) or client-side prediction with reconciliation (complexity-prohibitive), Jolt permits input-authoritative models where clients simulate identically. Fighting games, physics-based platformers, and cooperative manipulation puzzles benefit enormously from this deterministic foundation.

VR Interaction at 90+ FPS

Virtual reality demands consistent frame times below 11.1ms for 90Hz experiences. Physics stalls manifest as debilitating discomfort. Jolt's concurrent query architecture allows haptic feedback systems, hand tracking collision, and environmental audio occlusion to execute without blocking the simulation step. The virtual character controller—updated outside physics ticks—provides responsive VR movement with acceptable dynamic body interaction accuracy.

Procedural Animation and Ragdoll Systems

Jolt's animated ragdoll capabilities enable sophisticated character death and injury systems. Hard keying (pure kinematic control), soft keying (velocity-driven dynamic bodies), and constraint motor driving to animated poses provide graduated control. The skeleton mapping system allows high-detail animation skeletons to drive low-detail ragdoll structures and vice versa—critical for performance when dozens of characters require simultaneous simulation.

Step-by-Step Installation & Setup Guide

JoltPhysics offers multiple integration paths depending on your build system and platform requirements.

Prerequisites

Ensure your toolchain meets minimum requirements:

• Visual Studio 2022+, Clang 16+, or GCC 12+
• C++17 support
• Platform SDK for your target (Windows SDK, Xcode, Android NDK, etc.)

CMake Integration (Recommended)

For modern projects, CMake FetchContent provides clean dependency management:

# In your CMakeLists.txt
include(FetchContent)

FetchContent_Declare(
    JoltPhysics
    GIT_REPOSITORY https://github.com/jrouwe/JoltPhysics.git
    GIT_TAG        v5.0.0  # Pin to specific release
    SOURCE_SUBDIR  Build   # CMakeLists.txt location
)

FetchContent_MakeAvailable(JoltPhysics)

# Link against your target
target_link_libraries(YourGame PRIVATE Jolt)

A complete standalone example demonstrating this pattern is available at JoltPhysicsHelloWorld.

Manual Compilation

Clone the repository and build directly:

# Clone with submodules for test assets
git clone --recursive https://github.com/jrouwe/JoltPhysics.git
cd JoltPhysics/Build

# Generate build files (Linux/macOS example)
cmake -B Linux_Debug -S . -DCMAKE_BUILD_TYPE=Debug

# Compile
cmake --build Linux_Debug --parallel

# For optimized builds
cmake -B Linux_Release -S . -DCMAKE_BUILD_TYPE=Release
cmake --build Linux_Release --parallel

Platform-Specific Notes

Windows: Open Build/VS2022/JoltPhysics.sln in Visual Studio 2022. Select configuration (Debug/Release/Distribution) and platform (x86/x64/ARM64).

Console Development (Platform Blue): Due to NDA requirements, you must provide your own build environment and PlatformBlue.h header. This file is available through the Platform Blue developer forum. Jolt's clean STL-only dependency makes console porting straightforward.

WebAssembly: Use the separate JoltPhysics.js project for browser deployment.

CPU Feature Configuration

On x86/x64, Jolt auto-detects available instruction sets but can be forced via compile definitions:

# Options: SSE2 (default), SSE4.1, SSE4.2, AVX, AVX2, AVX512
set(JOLT_CPU_ARCH "AVX2" CACHE STRING "Target CPU architecture")

ARM64 builds utilize NEON and FP16 automatically. ARM32 compiles without special instructions for broad compatibility.

REAL Code Examples from JoltPhysics

The repository's HelloWorld/HelloWorld.cpp provides the canonical introduction. Let's examine critical patterns with detailed annotation.

Basic World Initialization and Body Creation

#include <Jolt/Jolt.h>
#include <Jolt/RegisterTypes.h>
#include <Jolt/Core/Factory.h>
#include <Jolt/Core/TempAllocator.h>
#include <Jolt/Core/JobSystemThreadPool.h>
#include <Jolt/Physics/PhysicsSettings.h>
#include <Jolt/Physics/PhysicsSystem.h>
#include <Jolt/Physics/Collision/Shape/BoxShape.h>
#include <Jolt/Physics/Body/BodyCreationSettings.h>
#include <Jolt/Physics/Body/BodyActivationListener.h>

// Layer definitions for collision filtering
namespace Layers
{
    static constexpr JPH::ObjectLayer NON_MOVING = 0;  // Static environment
    static constexpr JPH::ObjectLayer MOVING = 1;      // Dynamic objects
    static constexpr JPH::ObjectLayer NUM_LAYERS = 2;
};

// Simple layer interface: moving objects collide with everything
class ObjectLayerPairFilterImpl : public JPH::ObjectLayerPairFilter
{
public:
    virtual bool ShouldCollide(JPH::ObjectLayer inObject1, JPH::ObjectLayer inObject2) const override
    {
        // Non-moving objects don't collide with each other (optimization)
        if (inObject1 == Layers::NON_MOVING && inObject2 == Layers::NON_MOVING)
            return false;
        return true;  // All other combinations collide
    }
};

int main()
{
    // Initialize Jolt's global systems
    JPH::RegisterDefaultAllocator();
    JPH::Factory::sInstance = new JPH::Factory();
    JPH::RegisterTypes();
    
    // Temporary allocator: 10MB pool for simulation scratch space
    JPH::TempAllocatorImpl temp_allocator(10 * 1024 * 1024);
    
    // Job system: use all hardware threads minus one for main thread
    JPH::JobSystemThreadPool job_system(
        JPH::cMaxPhysicsJobs,           // Maximum concurrent jobs
        JPH::cMaxPhysicsBarriers,       // Synchronization barriers
        std::thread::hardware_concurrency() - 1  // Worker threads
    );
    
    // Physics system configuration
    const uint cMaxBodies = 1024;           // Maximum simultaneous bodies
    const uint cNumBodyMutexes = 0;         // 0 = auto-detect
    const uint cMaxBodyPairs = 1024;        // Max colliding pairs
    const uint cMaxContactConstraints = 1024; // Max simultaneous contacts
    
    JPH::PhysicsSystem physics_system;
    physics_system.Init(
        cMaxBodies, cNumBodyMutexes, cMaxBodyPairs, cMaxContactConstraints,
        new ObjectLayerPairFilterImpl(),      // Layer collision rules
        nullptr,                              // Broad phase layer interface (omitted for brevity)
        nullptr                               // Broad phase layer filter (omitted for brevity)
    );
    
    // Create static floor: 100x1x100 box at origin
    JPH::BoxShapeSettings floor_shape_settings(JPH::Vec3(50.0f, 0.5f, 50.0f));
    JPH::ShapeSettings::ShapeResult floor_shape_result = floor_shape_settings.Create();
    JPH::ShapeRefC floor_shape = floor_shape_result.Get();  // Reference-counted shape
    
    JPH::BodyCreationSettings floor_settings(
        floor_shape,
        JPH::RVec3(0.0_r, -0.5_r, 0.0_r),   // Position (double precision capable)
        JPH::Quat::sIdentity(),              // No rotation
        JPH::EMotionType::Static,            // Never moves
        Layers::NON_MOVING                   // Collision layer
    );
    
    // Create and add floor to world (returns locked body pointer)
    JPH::Body* floor = physics_system.GetBodyInterface().CreateAndAddBody(
        floor_settings,
        JPH::EActivation::DontActivate       // Static bodies don't need activation
    );
    
    // Create dynamic box: 1x1x1 cube dropped from height
    JPH::BoxShapeSettings box_shape_settings(JPH::Vec3(0.5f, 0.5f, 0.5f));
    JPH::ShapeRefC box_shape = box_shape_settings.Create().Get();
    
    JPH::BodyCreationSettings box_settings(
        box_shape,
        JPH::RVec3(0.0_r, 5.0_r, 0.0_r),     // Dropped from 5 units up
        JPH::Quat::sIdentity(),
        JPH::EMotionType::Dynamic,           // Affected by forces
        Layers::MOVING
    );
    box_settings.mRestitution = 0.5f;        // Bounciness
    
    JPH::Body* box = physics_system.GetBodyInterface().CreateAndAddBody(
        box_settings,
        JPH::EActivation::Activate           // Wake up for simulation
    );
    
    // Simulation loop: 60Hz fixed timestep
    const float cDeltaTime = 1.0f / 60.0f;
    for (int step = 0; step < 300; ++step)  // 5 seconds of simulation
    {
        // Step physics: collision detection, integration, constraint solving
        physics_system.Update(cDeltaTime, 1, &temp_allocator, &job_system);
        
        // Query box position (can run concurrently with other operations!)
        JPH::RVec3 position = physics_system.GetBodyInterface().GetPosition(box);
        // ... render, game logic, etc.
    }
    
    // Cleanup: remove bodies, destroy shapes, shutdown systems
    physics_system.GetBodyInterface().RemoveAndDestroyBody(box);
    physics_system.GetBodyInterface().RemoveAndDestroyBody(floor);
    
    JPH::UnregisterTypes();
    delete JPH::Factory::sInstance;
    JPH::Factory::sInstance = nullptr;
    
    return 0;
}

This example demonstrates Jolt's core design patterns: reference-counted shapes for memory safety, explicit body interface for thread-safe access, and the separation of creation settings from runtime state. The RVec3 position type enables optional double precision compilation for large worlds without source modification.

Concurrent Query During Simulation

// This query executes SAFELY while physics_system.Update() runs on another thread!
void PerformNavigationRaycast(JPH::PhysicsSystem& inPhysicsSystem)
{
    JPH::RRayCast ray{
        JPH::RVec3(0.0_r, 100.0_r, 0.0_r),   // Origin: high above terrain
        JPH::Vec3(0.0f, -1.0f, 0.0f) * 200.0f  // Direction: straight down, 200 units
    };
    
    JPH::RayCastResult hit;
    
    // Broad phase query: fast rejection of distant objects
    // Narrow phase: precise collision test (executed in background)
    JPH::BroadPhaseQuery& broad_phase = inPhysicsSystem.GetBroadPhaseQuery();
    
    if (broad_phase.CastRay(ray, hit))
    {
        // hit.mBodyID: collided body
        // hit.mFraction: 0-1 intersection point along ray
        JPH::RVec3 hit_point = ray.GetPointOnRay(hit.mFraction);
        // Use for navigation mesh generation, audio occlusion, etc.
    }
}

The critical insight: GetBroadPhaseQuery() provides a consistent snapshot view. If body modifications occur on the querying thread, changes are immediately visible. Cross-thread modifications present either pre-change or post-change state—never corrupted intermediate state. This eliminates the read-world/write-world dichotomy plaguing other engines.

Deterministic Replication Setup

// Server: serialize inputs, not states!
struct PhysicsInput
{
    uint32_t frame_number;
    std::vector<PlayerInput> player_inputs;
    std::vector<ScriptedForce> environmental_forces;
};

void ServerTick(JPH::PhysicsSystem& inPhysicsSystem, const PhysicsInput& input)
{
    // Apply inputs for this frame
    ApplyPlayerInputs(inPhysicsSystem, input.player_inputs);
    ApplyEnvironmentalForces(inPhysicsSystem, input.environmental_forces);
    
    // Deterministic step: same inputs = same result on all clients
    inPhysicsSystem.Update(cDeltaTime, 1, &temp_allocator, &job_system);
    
    // Broadcast only inputs and frame number
    NetworkBroadcast(input);
}

// Client: receive inputs, simulate identically
void ClientTick(JPH::PhysicsSystem& inPhysicsSystem, const PhysicsInput& server_input)
{
    // Identical code path produces identical state
    ApplyPlayerInputs(inPhysicsSystem, server_input.player_inputs);
    ApplyEnvironmentalForces(inPhysicsSystem, server_input.environmental_forces);
    
    inPhysicsSystem.Update(cDeltaTime, 1, &temp_allocator, &job_system);
    // State now matches server without network state transfer!
}

The PhysicsSettings structure includes flags for deterministic simulation control. Consult the Architecture documentation for platform-specific floating-point consistency requirements.

Advanced Usage & Best Practices

Job System Tuning: The default JobSystemThreadPool uses all hardware threads, but console certification often requires reserved cores for audio and I/O. Profile your title's thread utilization and cap physics workers appropriately:

// Reserve 2 cores for audio streaming and OS services
uint physics_threads = std::max(1u, std::thread::hardware_concurrency() - 2);
JPH::JobSystemThreadPool job_system(JPH::cMaxPhysicsJobs, JPH::cMaxPhysicsBarriers, physics_threads);

Memory Budgeting: The TempAllocatorImpl size directly impacts simulation capacity. Monitor allocation failures in development builds and size for your peak body/contact count. For deterministic behavior, pre-allocate generously to avoid allocator-induced timing variations.

Shape Sharing: ShapeRefC provides reference-counted shape instances. Static level geometry should share shapes across identical objects—thousands of crates referencing one box shape, not thousands of duplicate shapes. This reduces memory footprint and improves cache coherence during broad phase queries.

Activation Strategy: Jolt's default manual wake control requires explicit EActivation::Activate for dynamic bodies. For objects spawned with initial velocity, always activate; for decorative debris, consider leaving deactivated until disturbance. Profile activation patterns—excessive wake transitions destroy cache-friendly sleep optimizations.

Double Precision Migration: Enable JPH_DOUBLE_PRECISION CMake option for worlds exceeding single-precision accuracy limits (~10km effective radius). This compiles RVec3 as actual double components. Note: performance impact varies by platform; ARM64 handles this gracefully, x86 benefits from AVX-512 if available.

Comparison with Alternatives

Why Jolt over PhysX? Jolt's concurrent query architecture eliminates the read/write world split that complicates engine integration. Deterministic simulation requires less defensive coding. The MIT license provides legal clarity without attribution requirements.

Why Jolt over Bullet? Bullet's aging codebase shows its origins in academic research rather than production games. Jolt's modern C++17, active maintenance, and AAA-proven reliability address Bullet's stagnation and threading limitations.

Why Jolt over Havok? Cost and flexibility. Havok's commercial licensing excludes indie and mid-tier studios. Jolt delivers comparable multi-core performance and broader platform reach without financial barriers.

FAQ

Is JoltPhysics stable enough for commercial games? Absolutely. Horizon Forbidden West and Death Stranding 2: On the Beach are commercial releases with millions of units sold. The engine's continuous integration includes comprehensive unit tests and SonarCloud quality gates.

Can I use JoltPhysics in proprietary/closed-source projects? Yes. The MIT license permits unrestricted use, modification, and distribution, including commercial applications without source disclosure.

How does JoltPhysics handle determinism across different CPU architectures? Determinism is guaranteed for identical binary builds on identical architecture. Cross-platform determinism (x86 vs ARM) requires careful floating-point control and is documented with specific limitations. The Deterministic Simulation section provides complete guidance.

What's the performance cost of concurrent queries? Negligible for broad phase queries; narrow phase incurs copy-on-write overhead for modified bodies. The multicore scaling document provides benchmark data against competing engines.

Does JoltPhysics support continuous collision detection (CCD)? Yes, continuous collision detection is standard for all supported shape types, preventing tunneling at high velocities without per-object configuration.

Can I integrate JoltPhysics with existing engines like Unity or Unreal? Community integrations exist for Unreal Engine. Unity integration requires custom native plugin development. The engine's clean C API bindings facilitate engine integration.

How active is development and community support? Very active. The repository shows consistent commits, responsive issue resolution, and growing ecosystem bindings in Rust, C#, Python, Zig, and JavaScript^{↗ Bright Coding Blog}.

Conclusion

The physics engine landscape has been stagnant for too long. Developers accepted architectural limitations—world locks, non-determinism, single-threaded bottlenecks—as inevitable trade-offs. JoltPhysics proves these compromises were never necessary, only inherited.

From its multi-core-first design to its deterministic replication foundation, from background streaming without simulation stalls to concurrent queries that don't corrupt state, Jolt represents a generational leap in physics engine architecture. The AAA pedigree of Horizon Forbidden West and Death Stranding 2 validates its production readiness. The MIT license removes financial barriers. The active community and comprehensive documentation lower adoption friction.

If you're building a game, VR experience, or simulation requiring robust physics, the question isn't whether JoltPhysics can handle your requirements. It's whether you can afford to remain constrained by engines architected for hardware generations past.

Start your integration today: clone jrouwe/JoltPhysics, run the HelloWorld sample, and experience physics simulation without compromise. The future of game physics is already here—and it's running on all your cores.