Indie Tooling

Jolt Physics 5.7 is always deterministic now. Check your build

Jolt 5.7.0 removes its determinism switch and its std::vector option. Here's who that affects, from C++ engine builders to Godot and GDevelop users.

By

4 min read

Frame from Jolt Physics' 160 ragdolls in a pile demo: piles of red and yellow ragdolls heaped on wooden tables and benches in a grey, untextured village scene with buildings and cliffs.
Image: Jorrit Rouwe (Jolt Physics samples video)

Jolt Physics 5.7.0 is out, and it makes two small breaking changes. The simulation is now always deterministic, so the setting that switched determinism off is gone. Support for swapping Jolt’s own array type for the standard C++ std::vector has also been removed. GameDev.net covered the release on 14 November 2026.

Jolt is the open-source (MIT licence) physics engine Guerrilla Games built for Horizon Forbidden West. It also runs inside Godot, GDevelop and a long list of smaller engines. If you make 3D games with any of those, Jolt is probably handling your collisions already, whether or not you’ve ever typed its name.

What changed in 5.7.0

The two breaking changes first, because they’re the reason to read the release notes.

PhysicsSettings::mDeterministicSimulation has been removed. Deterministic means the same inputs always give the same results, which matters for replays, lockstep multiplayer and tests that compare physics runs. Jolt’s notes say turning determinism off used to make stacked objects behave worse, so the project now keeps it on everywhere.

Frame from Jolt Physics' stable box stacking demo: a long wall of small boxes in many bright checkered colours, stacked about ten rows high on a grey floor against a dark blue sky.
Jolt's stable box stacking demo. Stacking is the behaviour the old determinism switch made worse. Image: Jorrit Rouwe, Jolt Physics samples

The JPH_USE_STD_VECTOR define has also gone. Some projects used it to make Jolt store data in std::vector instead of JPH::Array, usually to fit in with their own memory tools or debuggers. That option no longer exists.

The rest of the release adds features and fixes bugs:

  • The Samples app, Jolt’s demo and test program, now runs on iOS and Android.
  • Object layers can be 64-bit, which gives you more collision groups when you filter with a mask.
  • A new ModifyShapes overload on MutableCompoundShape changes position, rotation and shape in one call.
  • Collision response estimates now take surface velocity into account, which helps with things like conveyor belts.
Frame from Jolt Physics' conveyor belt demo: coloured checkered cubes travel in a line around a rectangular grey conveyor track, seen from above at an angle.
Jolt's conveyor belt demo, which relies on surface velocity. Image: Jorrit Rouwe, Jolt Physics samples

The bug fix list is long. Highlights for game makers include a clamp that stops the simulation exploding when your delta time varies, and a fix for virtual characters stepping onto each other on stairs. Gear constraints now apply the right torque, and vehicle engine inertia and damping now save and load properly. On the threading side, a race in JobSystemWithBarrier that could corrupt memory or hang is fixed. So is a Linux bug that could end waits early.

Who this affects

How much this matters depends on where Jolt sits in your stack.

You compile Jolt into your own C++ engine. This is the group that needs to act. If your code sets mDeterministicSimulation, it will no longer compile, so delete the line. If you defined JPH_USE_STD_VECTOR, remove it and check any code that passed Jolt containers to functions expecting std::vector. Jolt keeps a separate API changes document, linked from the release notes, which you should read before upgrading.

You use Godot. Jolt has been built into Godot since 4.4, and Godot 4.6 made it the default for new 3D projects. You don’t set Jolt’s C++ options yourself. Godot ships its own copy and updates it as part of engine releases. When a future Godot version moves to Jolt 5.7, the changes should reach you as better behaviour rather than broken code. The Godot 4.8 beta 3 notes, published on 9 November, don’t mention a Jolt update, so don’t expect it in 4.8 unless the release notes say otherwise.

You use GDevelop or another engine with Jolt inside. Same story. Your engine’s developers handle the upgrade, and you’ll see it in their changelog.

You use a Jolt plugin for Unreal. Jolt’s own list of projects includes three Unreal plugins: Unreal Jolt, Bonjolt and Artillery Eco. Each one bundles its own copy of Jolt, so the upgrade is up to the plugin’s maintainer. Check the plugin’s changelog before you update it mid-project, and keep a branch you can roll back to. A physics library change is the kind of update that shows up as a character that suddenly slides on slopes.

You make a multiplayer game that depends on determinism. This is good news. If you had determinism switched on already, nothing changes. If you had it off for speed, you’ll now get deterministic results whether you like it or not. Jolt’s notes say turning it off hurt stacking anyway.

What to check before you upgrade

If you build against Jolt directly:

  1. Search your code for mDeterministicSimulation and JPH_USE_STD_VECTOR, and remove both.
  2. Read the API changes document linked from the release notes.
  3. Run your physics tests with a varying delta time. The new impulse clamp may change behaviour that you tuned around the old bug.
  4. If you have character controllers on stairs or vehicles saved to disk, test those first. Both were touched in this release.
  5. If you build with MSVC and /fp:fast, or with MinGW32, rebuild cleanly. Both had compiler-specific fixes.

If you’re on Godot, check which Jolt version your Godot build bundles before you file a physics bug. A problem fixed in Jolt 5.7.0 may not be fixed in your Godot version yet. The usual way is to check the third-party libraries listed in the engine’s source for your version.

Should you care?

If Jolt is a line in your engine’s credits, you can skip this and wait for your engine to update. If you link Jolt into your own code, set aside an hour. The breaking changes are small and well signposted, and the bug fixes are worth having, especially the threading ones if you’ve seen rare hangs on Linux.

Godot users get the most from this indirectly. Every Jolt release with fixes to characters, vehicles and collision edge cases eventually lands in the engine, and Godot’s 3D physics has improved fastest since it adopted Jolt. We’ll note it when a Godot release picks up 5.7.

Sources

Topicsjolt physicsphysics enginegodotc++determinism

See how GDevelop and Godot Engine stack up in our game engine comparison, updated with every release.

Filed under Game Engine Guides for Godot, Unity & Unreal.

All Engines