[opensourcedex]

JoltPhysics is a free, open source gaming project written in C++ and released under MIT. It has 11,616 GitHub stars, 980 forks and 14 open issues, and was last pushed 12 hours ago. On this registry it ranks #16 of 30 tracked projects in Gaming, with 5 head-to-head comparisons available.

What is JoltPhysics?

Jolt Physics is an MIT-licensed, multi-core-friendly rigid body physics and collision detection library written in C++, intended for games and VR applications and used by Horizon Forbidden West and Death Stranding 2: On the Beach.

What it is

Jolt Physics is a C++ library that simulates rigid bodies and detects collisions, designed from the outset for multi-core hardware. It covers shapes from spheres, boxes, capsules and cylinders through convex hulls, planes, compounds, triangle meshes and height-field terrain, and it simulates constraints including fixed, point, distance with springs, hinge and slider joints. The project is MIT licensed, carries 11,616 stars and 980 forks, has 14 open issues, and was last pushed on 27 September 2026. Its topics place it in game development, game engines, physics simulation and VR.

The problem it solves is that games do more than simulate physics, and that other work happens across multiple threads. The README presents Jolt as an alternative to the physics engines a game would otherwise embed, aimed squarely at concurrent access to physics data outside the main simulation update: batches of bodies can be prepared on a background thread, collision queries run alongside body changes and alongside the simulation itself, and bodies avoid the accidental wake-ups that cost performance when content is loaded and unloaded.

Key capabilities

  • Continuous collision detection for sphere, box, capsule, tapered-capsule, cylinder, tapered-cylinder, convex hull, plane, compound, mesh (triangle) and terrain (height field) shapes.
  • Constraints between bodies, including fixed, point, distance with springs, hinge and slider joints.
  • Background preparation of batches of physics bodies, inserted into the simulation with minimal performance impact and without locking.
  • Collision queries that run parallel to adding, removing or updating a body, with same-thread changes immediately visible and a consistent before-or-after state across threads.
  • Collision queries that run parallel to the main simulation, using a broad phase before the step and narrow phase checks in the background so work such as navigation mesh generation can spread across frames.
  • Bodies that do not automatically wake on creation, and neighbours that stay asleep when a body is removed, with waking available manually.
  • Deterministic simulation that lets a remote client be replicated by replicating only the inputs, within documented limits.

Who uses it and how

  • Shipping games and VR applications: the README states the library suits games and VR simulations and is used by Horizon Forbidden West and Death Stranding 2: On the Beach.
  • C++ game engine teams that need physics to run alongside rendering, streaming and other per-frame systems rather than inside one simulation update.
  • Projects that stream content at runtime, where prepared body batches and suppressed wake-ups keep loading and unloading from stalling the simulation.
  • Networked titles that benefit from deterministic simulation, replicating inputs to a remote client instead of full physics state.
  • Applications with expensive spatial queries, such as navigation mesh generation, spread over multiple frames.

Getting started

The README excerpt specifies no package-manager, Docker image or hosted option; Jolt Physics is consumed as a C++ library that you build and integrate into your own project, with samples and documentation linked from Docs/Samples.md and the project documentation site.

How it compares

The facts do not name a commercial product that Jolt Physics replaces, nor any similar physics engine for contrast. In this registry it stands alone, and its own README describes it as an alternative to existing physics engines rather than a substitute for a named one.

When to use it — and when not to

Jolt Physics suits C++ projects that want a physics library they build and embed themselves, especially games that load and unload content across threads. It is not a managed or hosted service, and the facts give no package-manager install path. It approximates real-world behaviour and is intended for games and VR rather than accuracy-critical simulation, deterministic simulation comes with documented limits, contributions appear to require a CLA, and the README excerpt supplied ends mid-sentence in the feature list, so the upstream documentation should be checked for the current feature set.

project readme (upstream, from github) — read inline

CLA assistant Build Status Quality Gate Status Bugs Code Smells Coverage

Jolt Physics

A multi core friendly rigid body physics and collision detection library. Suitable for games and VR applications. Used by Horizon Forbidden West and Death Stranding 2: On the Beach.

Horizon Forbidden West Cover Art Death Stranding 2 Cover Art

Ragdoll Pile
A YouTube video showing a ragdoll pile simulated with Jolt Physics.

For more demos and videos go to the Samples section.

Design considerations

Why create yet another physics engine? Firstly, it has been a personal learning project. Secondly, I wanted to address some issues that I had with existing physics engines:

  • Games do more than simulating physics. These things happen across multiple threads. We emphasize on concurrently accessing physics data outside of the main simulation update:
    • Sections of the simulation can be loaded / unloaded in the background. We prepare a batch of physics bodies on a background thread without locking or affecting the simulation. We insert the batch into the simulation with a minimal impact on performance.
    • Collision queries can run parallel to adding / removing or updating a body. If a change to a body happened on the same thread, the change will be immediately visible. If the change happened on another thread, the query will see a consistent before or after state. An alternative would be to have a read and write version of the world. This prevents changes from being visible immediately, so we avoid this.
    • Collision queries can run parallel to the main physics simulation. We do a coarse check (broad phase query) before the simulation step and do fine checks (narrow phase query) in the background. This way, long running processes (like navigation mesh generation) can be spread out across multiple frames.
  • Accidental wake up of bodies cause performance problems when loading / unloading content. Therefore, bodies will not automatically wake up when created. Neighboring bodies will not be woken up when bodies are removed. This can be triggered manually if desired.
  • The simulation runs deterministically. You can replicate a simulation to a remote client by merely replicating the inputs to the simulation. Read the Deterministic Simulation section to understand the limits.
  • We try to simulate behavior of rigid bodies in the real world but make approximations. Therefore, this library should mainly be used for games or VR simulations.

Features

  • Simulation of rigid bodies of various shapes using continuous collision detection:
    • Sphere
    • Box
    • Capsule
    • Tapered-capsule
    • Cylinder
    • Tapered-cylinder
    • Convex hull
    • Plane
    • Compound
    • Mesh (triangle)
    • Terrain (height field)
  • Simulation of constraints between bodies:
    • Fixed
    • Point
    • Distance (including springs)
    • Hinge
    • Slider (also called prismatic)
    • Cone
    • Rack and pinion
    • Gear
    • Pulley
    • Smooth spline paths
    • Swing-twist (for humanoid shoulders)
    • 6 DOF
  • Motors to drive the constraints.
  • Collision detection:
    • Casting rays.
    • Testing shapes vs shapes.
    • Casting a shape vs another shape.
    • Broadphase only tests to quickly determine which objects may intersect.
  • Sensors (trigger volumes).
  • Animated ragdolls:
    • Hard keying (kinematic only rigid bodies).
    • Soft keying (setting velocities on dynamic rigid bodies).
    • Driving constraint motors to an animated pose.
    • Mapping a high detail (animation) skeleton onto a low detail (ragdoll) skeleton and vice versa.
  • Game character simulation (capsule)
    • Rigid body character. Moves during the physics simulation. Cheapest option and most accurate collision response between character and dynamic bodies.
    • Virtual character. Does not have a rigid body in the simulation but simulates one using collision checks. Updated outside of the physics update for more control. Less accurate interaction with dynamic bodies.
  • Vehicles
    • Wheeled vehicles.
    • Tracked vehicles.
    • Motorcycles.
  • Soft body simulation (e.g. a soft ball or piece of cloth).
    • Edge constraints.
    • Dihedral bend constraints.
    • Cosserat rod constraints (an edge with an orientation that can be used to orient geometry, e.g. a plant leaf).
    • Tetrahedron volume constraints.
    • Long range attachment constraints (also called tethers).
    • Limiting the simulation to stay within a certain range of a skinned vertex.
    • Internal pressure.
    • Collision with simulated rigid bodies.
    • Collision tests against soft bodies.
  • A strand based hair simulation running on GPU
    • System is based on Cosserad rods.
    • Can use long range attachment constraints to limit the stretch of hairs.
    • Supports simulation (guide) and render (follow) hairs.
    • Hair vs hair collision is handled by accumulating the average velocity in a grid and using those velocities to drive hairs.
    • Supports collision with the environment, although it only supports ConvexHull and CompoundShapes at the moment.
    • The roots of the hairs can be skinned to the scalp mesh.
  • Water buoyancy calculations.
  • An optional double precision mode that allows large worlds.

Supported platforms

  • Windows x86/x64/ARM64
  • Linux (tested on Ubuntu) x86/x64/ARM32/ARM64/RISC-V64/LoongArch64/PowerPC64LE
  • FreeBSD
  • Android x86/x64/ARM32/ARM64
  • Platform Blue (a popular game console) x64
  • macOS x64/ARM64
  • iOS x64/ARM64
  • MSYS2 MinGW64
  • WebAssembly, see this separate project.

Required CPU features

  • On x86/x64 the minimal requirements are SSE2. The library can be compiled using SSE4.1, SSE4.2, AVX, AVX2, or AVX512.
  • On ARM64 (AArch64) the library uses NEON and is compatible with Armv8-A. On ARM32 (AArch32) it doesn't use any special CPU instructions.

Documentation

To get started, look at the HelloWorld example. A HelloWorld example using CMake FetchContent is also available to show how you can integrate Jolt Physics in a CMake project.

Every feature in Jolt has its own sample. Running the Samples application and browsing through the code is a great way to learn about the library!

To learn more about Jolt go to the latest Architecture and API documentation. Documentation for a specific release is also available.

Some algorithms used by Jolt are described in detail in my GDC 2022 talk: Architecting Jolt Physics for 'Horizon Forbidden West' (slides, slides with speaker notes, video).

Compiling

  • Compiles with Visual Studio 2022+, Clang 16+ or GCC 12+.
  • Uses C++ 17.
  • Depends only on the standard template library.
  • Doesn't use RTTI.
  • Doesn't use exceptions.

If you want to run on Platform Blue you'll need to provide your own build environment and PlatformBlue.h due to NDA requirements. This file is available on the Platform Blue developer forum.

For build instructions go to the Build section. When upgrading from an older version of the library go to the Release Notes or API Changes sections.

Performance

If you're interested in how Jolt scales with multiple CPUs and compares to other physics engines, take a look at this document.

Folder structure

  • Assets - This folder contains assets used by the TestFramework, Samples and JoltViewer.
  • Build - Contains everything needed to build the library, see the Build section.
  • Docs - Contains documentation for the library.
  • HelloWorld - A simple application demonstrating how to use the Jolt Physics library.
  • Jolt - All source code for the library is in this folder.
  • JoltViewer - It is possible to record the output of the physics engine using the DebugRendererRecorder class (a .jor file), this folder contains the source code to an application that can visualize a recording. This is useful for e.g. visualizing the output of the PerformanceTest from different platforms. Currently available on Windows, macOS and Linux.
  • PerformanceTest - Contains a simple application that runs a performance test and collects timing information.
  • Samples - This contains the sample application, see the Samples section. Currently available on Windows, macOS and Linux.
  • TestFramework - A rendering framework to visualize the results of the physics engine. Used by Samples and JoltViewer. Currently available on Windows, macOS and Linux.
  • UnitTests - A set of unit tests to validate the behavior of the physics engine.

Bindings for other languages

Integrations in other engines

See a list of projects that use Jolt Physics here.

License

The project is distributed under the MIT license.

Contributions

All contributions are welcome! If you intend to make larger changes, please discuss first in the GitHub Discussion section. For non-trivial changes, we require that you agree to a Contributor Agreement. When you create a PR, CLA assistant will prompt you to sign it.

Note that all PRs will be squashed before merging, so there's no need to force-push to git to keep the history clean.

Frequently asked questions

Is JoltPhysics free to use?

JoltPhysics is open source under the MIT licence. There is no licence fee and no seat count — you can self-host it or, where the project offers one, pay a vendor for a managed version instead.

What does JoltPhysics do?

A multi core friendly rigid body physics and collision detection library. Written in C++. Suitable for games and VR applications. Used by Horizon Forbidden West

What is JoltPhysics written in?

JoltPhysics is primarily written in C++. Its source is publicly available at https://github.com/jrouwe/JoltPhysics, and it has 11,616 GitHub stars.