Jolt Physics in Evergine

The first step toward industrial simulation and Physical AI

Evergine was born to build industrial 3D applications: digital twins, training tools and process visualizations that run on the desktop, the web, mobile and XR. More and more, those applications are asked not only to show things, but to simulate how they behave. To be useful there, the physics has to be believable.

That is why we have rebuilt the physics of Evergine on Jolt Physics, a modern, multicore physics engine. It replaces Bullet, which served us well for years, and it is the first step of a roadmap to make Evergine an even stronger simulation platform: next comes MuJoCo, which will make the engine more capable for Physical AI.

In short:

• A new engine. Physics is now powered by Jolt and ships inside Evergine.Framework. There is nothing extra to install.
• Built for today’s hardware. The simulation spreads across CPU cores and can be made deterministic.
• More responsive apps. Picking, collisions and interactions respond faster, from desktop tools to XR applications built with MRTK.
• More to simulate. Wheeled and tracked vehicles, a new character controller, ragdolls, and soft bodies such as cloth.
• A new physics sample. A forklift in a warehouse, with real-world scale and masses, picking up and carrying pallets.
• A clear direction. Jolt is the foundation, and MuJoCo will make the engine even more capable for Physical AI.

In this article

• Why simulation matters
• Where we are going
• Why Jolt
• Faster, more responsive applications
• The new physics sample
• What’s new in Evergine physics
• Getting started
• Upgrading from Bullet
• What’s next: MuJoCo and Physical AI
• Try it and tell us what you think

Why simulation matters

In industry, changing the real world is expensive. Rearranging a warehouse, commissioning a new production line or training an operator on a heavy machine all cost time, money and, sometimes, safety. Simulation lets you do it first in a virtual copy, where mistakes are free:

• Logistics and layout. Check whether a vehicle fits through an aisle, how high a rack can be loaded or where traffic gets stuck, before moving a single shelf.
• Virtual commissioning. Test the logic of a line or a robot cell against a simulated plant before the real one is built.
• Operator training. Let people practice with a forklift, a crane or a machine that reacts like the real thing, without putting anyone at risk.
• Digital twins. Go beyond a model that mirrors live data: a twin that also behaves like the real asset can answer “what if” questions.

All of these depend on the same thing: when something is pushed, lifted, dropped or driven, it must react the way it would in reality. If the physics is not credible, the simulation is not useful for making decisions.

Where we are going

Better physics in Evergine is not a one-off feature. It is a roadmap with two steps, and both point in the same direction: Physical AI.

1. Jolt Physics, available now. A fast and stable real-time engine for interactive industrial scenes, on every platform Evergine supports.
2. MuJoCo, in progress. The reference engine for robotics research, to simulate robots with their real joints, actuators and contacts.

Physical AI, AI that perceives and acts in the physical world, is one of the most demanded fields today, and it relies on simulation to train and validate its systems. Each step of this roadmap makes Evergine more capable for it.

This article is about Jolt. We come back to MuJoCo at the end.

Why Jolt

Jolt Physics is an open-source physics engine created by Jorrit Rouwe and released under the permissive MIT license. It was designed from the start for modern multicore CPUs, it has a large and very active community, and it has proven itself in demanding, high-profile commercial productions. Its source code and its architecture documentation are open, so we know exactly what the solver does.

Bullet was the physics engine of Evergine for years, and it is still a respected library. But its development has slowed down (its latest release, 3.25, dates from 2022), while Jolt is actively developed and keeps adding features. For us, the switch was about the future: picking the engine we want to grow with.

This is what changes for an Evergine developer:

	Bullet (before)	Jolt (now)
Package	Evergine.Bullet, installed separately	Built into Evergine.Framework
Multicore	The step ran on a single thread	The step is spread across CPU cores
Determinism	Not guaranteed	Optional: the same scene gives the same result every time
Vehicles	Wheeled vehicles	Wheeled and tracked vehicles, with engine and gearbox
Characters	Kinematic character controller	Climbs steps, rides moving platforms and pushes objects
Soft bodies	Not available	Cloth, pressurized and volumetric soft bodies
Development	Latest release in 2022	Actively developed

Faster, more responsive applications

Physics in Evergine is not only about simulating machines. Most interactive applications rely on it every frame, often without anyone noticing: colliders tell the application what the user is pointing at, ray casts pick objects, and collision events trigger actions. That is the case of XR applications, where hands and controllers press buttons, grab objects and move through menus, and of desktop applications where users select and manipulate 3D models.

With Jolt, all of this is faster and more responsive. Collision detection and ray casts take less time, contacts are more stable, and the work is spread across CPU cores, so interactions respond immediately even in scenes with many objects. Applications built with Evergine MRTK, our Mixed Reality Toolkit, benefit directly: its buttons, sliders, menus and hand interactions are all built on colliders, and they now react faster and more smoothly.

The new physics sample

To show the new physics in an industrial setting, we built a new sample: a forklift in a warehouse that picks up a pallet from a rack and carries it.

The new physics sample, built with Evergine and Jolt Physics

The scene uses simulation-ready assets with real-world scale and masses. The forklift is a 3.4-tonne vehicle with an engine and real steering, its mast and forks are driven by motors, and the pallets and boxes weigh what they would in a real warehouse. A soft strip curtain hangs at the door. All of the physics is set up from Evergine Studio, without physics code.

The driver camera. Racks, pallets and boxes are all part of the simulation

You can try it in your browser and browse its source code on GitHub. The 3D models come from NVIDIA SimReady and are licensed under CC BY 4.0.

What’s new in Evergine physics

Beyond the engine swap, the physics API has been redesigned with simpler names, and there is a lot more to simulate. These are the highlights.

Vehicles

A vehicle is a single body with a controller: an engine, a gearbox, steering, brakes and a suspension for each wheel. That keeps it stable at speed and cheap to simulate. Next to wheeled vehicles, there is now a tracked vehicle controller for machines such as bulldozers and excavators.

A tracked vehicle, new in this release

Characters and ragdolls

The new character controller walks up steps, follows slopes, rides moving platforms and pushes the objects it walks into. It is what you need for a walkthrough of a plant or for a person in a training scenario.

The character controller climbing steps

Ragdolls let the simulation take over a figure. A character can walk under its animation and, at any moment, fall and react physically, keeping the momentum it had.

A figure going from its animation to a ragdoll

Soft bodies and cloth

Soft bodies are completely new. Cloth drapes and folds, a balloon squashes when it lands, and a cushion gives way and springs back. Any mesh can become a soft body, and parts of it can be pinned in place or to another object, like a banner on a pole or the strip curtain in the new physics sample.

Cloth, pressurized and volumetric soft bodies

Designed in Studio

All of this can be set up from Evergine Studio, in the inspector, and tested with Play Mode without leaving the editor. Read more about it in What’s new in Evergine Studio. When something does not behave as expected, debug rendering draws the physics shapes and joints over the scene.

Getting started

Physics lives in the Evergine.Framework.Physics namespace. Register a PhysicsManager in your scene, then add a body and a collider to any entity:

using Evergine.Framework.Physics;

public class MyScene : Scene
{
    public override void RegisterManagers()
    {
        base.RegisterManagers();

        // One physics world per scene
        this.Managers.AddManager(new PhysicsManager());
    }

    protected override void CreateScene()
    {
        // A 20 kg box that falls and collides (add a mesh and a material to see it)
        var box = new Entity("box")
            .AddComponent(new Transform3D() { Position = new Vector3(0f, 3f, 0f) })
            .AddComponent(new RigidBody() { Mass = 20f })
            .AddComponent(new BoxCollider());

        this.Managers.EntityManager.Add(box);
    }
}

The physics section of the Evergine documentation covers every component in detail, with videos and examples.

Upgrading from Bullet

If your project uses the previous physics, it will need to be migrated. The Evergine.Bullet package is no longer needed, and every component has a new name: RigidBody3D is now RigidBody, BoxCollider3D is now BoxCollider, HingeJoint3D is now HingeConstraint, and so on.

To do the mechanical part of the work, we built a migration tool that updates C# code, project files, scenes and prefabs. It runs as a dry run by default, makes a backup of every file it changes, and reports everything that needs a human decision. The Migrating from Bullet guide, in the physics section of the Evergine documentation, has the full list of equivalences and the recommended process.

What’s next: MuJoCo and Physical AI

Jolt gives Evergine a solid real-time foundation. The next step, which we are already working on, is integrating MuJoCo.

MuJoCo, short for Multi-Joint dynamics with Contact, is a physics engine created for robotics, biomechanics and machine learning research. It has been maintained by Google DeepMind since 2021 and has been open source under the Apache 2.0 license since 2022. MuJoCo describes a robot directly by its joints, so an arm cannot drift apart and its dynamics are computed accurately. A robot is defined in a model file with the masses, inertias, joint limits and actuators of the real hardware, and a large catalog of real robots is already available in that format. That is why MuJoCo has become one of the standard simulators in robotics research.

Bringing MuJoCo to Evergine will let you place a real robot model in an industrial scene and see it move like the real one, rendered with Evergine on any platform.

With MuJoCo, the engine of Evergine becomes even more capable for Physical AI: AI systems that perceive, understand and act in the physical world, from robot arms and autonomous mobile robots to self-driving forklifts. It is one of the most demanded and fastest-growing fields today. These systems are trained and validated in simulation long before they are deployed, because a simulator can run thousands of scenarios safely and much faster than reality. For that, they need physics they can trust and environments that look like the real ones. Credible industrial scenes with Jolt, accurate robots with MuJoCo and Evergine’s rendering on every device are exactly that.

Try it and tell us what you think

Jolt Physics is part of the November 2026 release of Evergine. Update Evergine, open a scene and give it something to push, lift and carry.

• Try the new physics sample in your browser, and explore its source code.
• Browse the Evergine documentation, where the physics section covers every component with videos and examples.
• Explore the Evergine samples for more scenes.
• Found a problem, or have an idea? Tell us in the Evergine feedback repository.

We’d love to see what you build, and to hear which simulations you would like to run next.