# Godot Jolt: Jolt Physics Inside Godot 4, and Why the Extension Is Now in Maintenance Mode

> Godot Jolt swaps Godot Physics for Jolt Physics through GDExtension, keeping the usual RigidBody3D and CharacterBody3D nodes. As of Godot 4.4 the same integration ships inside the engine, which changes the adoption calculus.

**godot-jolt/godot-jolt** — Godot Jolt is a Godot extension that integrates the Jolt physics engine

- Repository: https://github.com/godot-jolt/godot-jolt
- Stars: 2,570 · Forks: 98
- Language: C++
- License: MIT
- Published: 2026-09-28 · Updated: 2026-09-28 · Language: en
- Canonical page: https://hysenlabs.com/projects/godot-jolt-godot-jolt

## What Godot Jolt Replaces, and Who Should Care

Godot Jolt is a native extension for the Godot game engine that lets Jolt Physics power Godot's 3D physics. It is a drop-in replacement for Godot Physics: it implements the same nodes you already use, such as RigidBody3D and CharacterBody3D, so a project does not need its scenes rewritten to switch engines. The audience is Godot developers working in 3D who are unhappy with the default solver, either because of simulation stability or because they want behaviour the default joints do not expose.

The README names better performance as the main draw, but also claims a more stable simulation compared to Godot Physics. It also ships optional substitute nodes for every joint, which line up better with Jolt's own interface and allow breakable joints, soft limits, and per-joint solver iteration overrides. That last group is the part you cannot get by flipping a project setting alone, because the substitutes are separate node types, not configuration on the stock joints.

One caveat is worth stating plainly: the README says that as of Godot 4.4 this integration is built into Godot itself as an engine module, and that the extension is therefore considered to be in maintenance mode going forward, with only bug fixes considered for merging. If you are starting today, the extension is not the default path; it is the path for projects that need something the module does not yet provide.

## How the Extension Plugs Jolt Into Godot's Physics Server

The mechanism is GDExtension. Godot exposes a physics server abstraction, and Godot Jolt implements that interface on top of Jolt Physics rather than modifying the engine. The README describes the result as a drop-in replacement, which is why the node-level API stays the same: your RigidBody3D, CharacterBody3D, and joint nodes keep working, and the extension supplies the simulation behind them. The repository is C++ with a CMakeLists.txt, CMakePresets.json, a cmake/ directory, src/, tools/, and scripts/, which matches a native extension built against Godot's extension API.

Switching engines is a project setting, not a code change. The README's getting-started steps end with changing "Physics Engine" under "Physics" then "3D" to "Jolt Physics (Extension)" and restarting Godot. That single setting is the whole data flow change from the user's perspective: Godot still dispatches physics work through its server, and the extension answers those calls with Jolt.

Because the extension sits behind the same interface, differences show up as behaviour rather than as new API surface. The README lists several: scale is actually used for all bodies, shapes and shape queries except SoftBody3D; springs and linear motors are actually implemented in Generic6DOFJoint3D; shape-casts should be more accurate but their cost scales with cast distance; and contact impulses are estimations that will not be accurate when colliding with multiple bodies. Those are the places where a project that looked fine under Godot Physics may behave differently after the switch.

## Installing Godot Jolt and Switching the Physics Engine

The README's own instructions are download-and-extract, not a package manager. Download the release from the project's releases page, extract the files into your project directory, then start or restart Godot. There is no install command to run; the extension files land in the project and Godot picks them up. The repository also contains examples/project.godot and examples/scenes/, which are the project's own example project rather than an installer.

After restarting, open your project settings and make sure "Advanced Settings" is enabled, otherwise the physics engine dropdown is not visible.

```text
Project Settings -> Advanced Settings -> Physics -> 3D -> Physics Engine
Change "Physics Engine" to "Jolt Physics (Extension)"
```

Then restart Godot again. If the engine is selectable and the project loads without errors, the extension is active. The README does not document a rollback procedure, so the practical way back is to set "Physics Engine" to the previous value and restart.

For a first real use, take an existing 3D scene with a RigidBody3D and watch it under both engines. The README's platform notes matter here: Linux support is limited to glibc 2.35 or newer, which for Ubuntu means 22.04 or newer, and the supported Godot versions are only those between 4.3 and 4.6.

## Determinism, Thread Safety, and Other Limits You Should Know Before Switching

The most important limitation is determinism. Jolt itself offers deterministic simulations, but the README states that Godot Jolt is not able to make such guarantees. Simulations may look deterministic, and may even happen to be deterministic, but the project says this should not be relied upon if determinism is a hard requirement. If your design depends on lockstep replay or rollback netcode, that sentence should end the evaluation.

Three more items are listed as unsupported. The physics server is not thread-safe. Memory usage is not reflected in Godot's performance monitors, so profiling memory through the editor's monitors will not show Jolt's allocations. And SoftBody3D does not support any interactions with Area3D. Each of these is a case where the extension is the wrong tool for a specific feature rather than a general quality problem.

There are also cost trade-offs hidden in features that sound like pure wins. Ray-casts returning face_index is opt-in, at a potentially heavy memory cost. Contact reporting for kinematic bodies is partially opt-in, at a potentially heavy performance and memory cost. Manipulating a body's shape after it has entered the scene tree can be costly. And the README quotes Jolt's own guidance that dynamic objects should be roughly 0.1 to 10 m long with speeds around 0 to 500 m/s, which means a project built at an unusual scale is fighting the solver's assumptions.

## Godot Jolt Versus Godot Physics and the Built-In Jolt Module

The real alternative is not another extension. It is Godot Physics, which is what you get with no extension at all, and the Jolt Physics engine module built into Godot as of 4.4. The README is explicit that at the time of writing the engine module does not have full feature parity with this extension, and specifically lacks the joint interface changes such as JoltHingeJoint3D that this extension exposes. That is the concrete difference in approach: same solver, different amount of the Jolt interface surfaced to GDScript and the editor.

Against Godot Physics the difference is the solver itself. The README claims better performance and a generally more stable simulation, plus the list of behavioural differences covered above. Against the built-in module the difference is surface area and lifetime. The module is maintained inside the engine and will eventually reach feature parity; the extension will then be considered fully deprecated and the repository will likely be archived entirely, per the README.

So the choice is not which physics is better. It is whether the extra joint interface and the extension's current behaviour are worth depending on a component that the project itself describes as maintenance mode, with bug fixes only.

## Versions, Platforms, and What Maintenance Mode Means for Upgrades

Version support is narrow and stated as such: the only supported Godot versions are between 4.3 and 4.6. Platforms are Windows (x86-64, x86), Linux (x86-64, x86), macOS (x86-64 and Apple Silicon), iOS, and Android (ARM64, ARM32, x86-64, x86). Linux is limited to glibc 2.35 or newer. Anything outside that matrix is untested by the project, whatever it may do in practice.

The upgrade cost is the part most teams underestimate. The README says that as of Godot 4.4 the integration is built into Godot as an engine module and that the extension is in maintenance mode going forward, where only bug fixes will be considered for merging. It also states that once the engine module reaches feature parity in some way and a stable Godot release ships that parity, the extension will be considered fully deprecated and the repository will likely be archived entirely. Planning a long-lived project around the extension means planning a migration to the module, and the substitute joint nodes are the thing most likely to need rewriting when that happens.

Licensing is straightforward. Godot Jolt is distributed under the MIT license, with LICENSE.txt for the project and THIRDPARTY.txt for third-party licenses. MIT is permissive and imposes no copyleft obligation on your game, but the third-party file is the one to read if you need to know what else is bundled; this is not legal advice, and the license texts are the authority.

## Conclusion

Use Godot Jolt when you are on a Godot version whose built-in Jolt module lacks something you need, most visibly the substitute joints such as JoltHingeJoint3D, or when you want to test Jolt against Godot Physics in an existing 4.3 to 4.6 project without rewriting nodes. Do not adopt it expecting new features: the README states that only bug fixes will be considered going forward, and the repository will likely be archived once the engine module reaches feature parity and a stable Godot release ships it. Before committing, verify that your target Godot version is between 4.3 and 4.6, that your platform binaries exist (Linux needs glibc 2.35 or newer), and check whether the engine module already covers the joint behaviour you depend on.

## FAQ

### What is Godot Jolt?

It is a native extension for the Godot game engine that lets Jolt Physics power Godot's 3D physics. It works as a drop-in replacement for Godot Physics by implementing the same nodes, such as RigidBody3D and CharacterBody3D.

### Is Godot Jolt deterministic?

No guarantee is made. The README states that while Jolt itself offers deterministic simulations, Godot Jolt is not able to make such guarantees, and that apparent determinism should not be relied upon if determinism is a hard requirement.

### How does Godot Jolt compare to the default Godot Physics?

The README claims better performance and a generally more stable simulation compared to Godot Physics, plus optional substitute joint nodes that allow breakable joints, soft limits, and per-joint solver iteration overrides. It also documents behavioural differences, such as scale being used for all bodies, shapes and shape queries except SoftBody3D.

## Sources

- [godot-jolt/godot-jolt on GitHub](https://github.com/godot-jolt/godot-jolt)
- [Issues](https://github.com/godot-jolt/godot-jolt/issues)
- [License: MIT](https://github.com/godot-jolt/godot-jolt/blob/master/LICENSE)
- [README](https://github.com/godot-jolt/godot-jolt/blob/master/README.md)
- [Releases](https://github.com/godot-jolt/godot-jolt/releases)

---

Hysen Labs editorial analysis, written from the project's own repository and release notes. Cite the canonical page: https://hysenlabs.com/projects/godot-jolt-godot-jolt