Chrono in Unreal, part 1: why Chrono, which effects, two days of work

A heavy 4x4 starts on the beach, climbs a dune of loose sand, dodges boulders, brakes for a pedestrian, jumps off a jetty into the sea and floats. Then it floods and sinks, a boat towing a parasail runs its laps off the coast, the sun goes down, the full moon rises behind the dune, and the boat runs itself up the beach at full throttle. None of it is animated. Every movement of the vehicle, the boat, the line, the canopy and the drone comes out of a multibody simulation, the wheels really dig into the sand, and the parasail stays up because a lift model computes that from the airflow.

This post is the first of nine. It answers three questions: why Project Chrono®, which effects are in the demo, and how it came together in two days. The other parts: part 2 describes the architecture of the integration, part 3 the traps we walked into, part 4 the fully procedural sound, part 5 tracks, spray, drops and the price of the pictures, part 6 the model of boat, line and canopy, part 7 the drone as a controlled body, part 8 the light of the night, part 9 the sequence as a phase programme.

The full run, 9 minutes 28 seconds, with the procedural sound from part 4. Split screen: main camera with telemetry on the left, driver’s view top right, drone bottom right. The differential locks on the dune, from minute 3:30 the finale: sinking, drone flight, evening, parasail, moon, beaching. On YouTube in 1080p the console is readable.

Why Chrono

Unreal Engine® has physics, and for games it is good. For vehicle dynamics you want to base a statement on, it is not enough: no drivetrain with a torque converter and shaft inertias, no tyre models with slip curves, and above all no ground that gives way. A tyre on sand is, in a game engine, a tyre on a hard surface with less friction. It looks similar and computes something else.

Project Chrono is a multibody library from the academic world, open source, with a vehicle module, Chrono::Vehicle®. It has what we were missing: an engine map, a torque converter, an automatic gearbox, axles with suspension, tyre models, and a deformable ground after Bekker and Janosi, the Soil Contact Model (SCM). The soil parameters are physical quantities you can measure on real ground with a bevameter. That is the point: a simulation you can calibrate, rather than one you can only tune to look nice.

Chrono can visualise: viewers based on Irrlicht and VSG ship with it. That is enough for development and debugging, but no substitute for a production render engine with materials, lighting, a camera system and an asset pipeline. That is exactly why we wanted to see the physics in Unreal Engine: a mature C++ engine with very good render quality for simulations of any kind. There is no official bridge between Chrono and Unreal, so we built one as our own plugin in C++. The division of labour is strict: Chrono computes the vehicle, tyres, sand, stones, gearbox, boat, line, canopy and drone with fixed time steps of 2 ms. Unreal displays the states and contributes nothing to the dynamics.

The demo

The setting is an invented island one kilometre on a side, from a height map computed by a Python script. If it reminds you of the Whitsunday Islands, you are probably not wrong. On the island lies a corridor of deformable sand, 500 by 924 metres with 15 cm node spacing, and on it the course: sandbank, wet beach, a field of 420 cobbles, whoops, a jump, the 36 metre dune with 160 small stones and boulders, the north beach with its wash, a jetty with a kicked-up end and a 4.5 metre deep pool in front of it. Off the coast a boat runs its laps from the start, towing a parasail, in sight and in earshot whenever it passes close.

An autopilot runs a phase programme so that every run is reproducible: start with the starter motor, course, dune, drift, ball game on the beach with an emergency stop for the runner, jetty, jump, floating. Once the vehicle is in the water the engine goes off, the hull floods and the vehicle sinks in thirty seconds. A pufferfish circles the wreck and now and then looks in through the windscreen. The drone flies one lap around the car, climbs and makes its low flight back to the start point on the dune crest, by daylight. Once it is up there the evening begins: the sun sinks, the boat switches on its side lights, headlights and searchlight, the drone dives from the crest down to the parasail and laps the canopy and the boat. The moon rises behind the dune, a land breeze freshens, the boat runs at full throttle into the wind onto the beach, slides over the sand and sticks. The breeze dies and turns onshore, the parasail drifts over the boat and comes down on the sand. The drone flies back over the wreck at 15 percent battery, goes into a forced landing at 10 percent, touches down on the water and floats there, strobe still blinking, in the beached boat’s searchlight. The pufferfish pass the windscreen one last time, at 8 percent the drone shuts down, the end. All of it in split screen: the main camera with telemetry on the left, the driver’s view top right, the drone bottom right.

Which effects

It pays to separate cleanly what is computed and what is staged. A demo quickly promises more than it computes.

From Chrono, unchanged:

• Vehicle dynamics of the heavy 4x4 from the Chrono model library (HMMWV® model): engine, torque converter, gearbox, double wishbone axles, tyres.
• The driveline as a shaft model with a centre differential and two axle differentials, each with a locking clutch. The dune shows it: the climb starts with open differentials, and as soon as the vehicle drops under 8 km/h the centre and the rear lock, the front stays open. The torque then goes from the spinning wheel to the one with grip, and the vehicle gets up. The library model’s locking clutch is too weak at 100 Nm to really lock; it is set to 3000 Nm through the driveline’s physics items. The HUD shows the state of the three differentials.
• Deformable sand: sinkage, rolling resistance, shear, compaction under the track. Three soil presets (dry dune sand, wet beach sand, firm ground) and saturated sand below the waterline with half the friction angle.
• 420 cobbles, 160 dune stones, ten boulders, 26 coastal rocks and the jetty as rigid bodies with collision.

Own physics in the plugin, fed back into Chrono as forces:

• Water: buoyancy at four corners against a wave function with swell, water drag per wheel, paddle thrust from the spinning wheels at a quarter of the tread force, quadratic damping. After the engine stop the hull floods, the buoyancy goes to zero, the vehicle sinks.
• Droop stops on the suspension and steering stops at the knuckle, both missing in the Chrono model and both needed by a wheel that is unloaded in the water.
• ABS, retrofitted. The model’s brakes are plain torque brakes without control, and in the emergency stop for the runner all four wheels locked. Now each wheel’s brake is released once its slip drops under minus 35 percent and re-applied after 40 milliseconds or as soon as the wheel rolls again; that pulses at 10 to 15 hertz like a real ABS, and the pulses are the drumming in part 4. Plus an idle governor, which Chrono’s shaft engine does not have either: under 900 rpm the engine gets throttle, otherwise the converter stalls it under braking.
• Shift logic with selector position 2 for the dune, because the Chrono automatic in sand either does not shift up at all or shifts up on spinning wheels.
• The boat with the parasail after the same pattern: a hull with buoyancy at four points, drag, thrust at the stern, the rudder as a yaw torque and ground contact for the beaching. The tow line as a chain of ten rigid links with spherical joints, the canopy as a body with lift and drag from the airflow, the pilot as a pendulum at the yoke with water drag on his feet. The boat controls the canopy’s height through its speed. The model is described in part 6.
• The drone as a Chrono body with four rotors, motor lag, drag and a geometric attitude controller. The choreography provides setpoints, the drone has to fly them itself, with a gimbal with end stops and a battery model that decides the end of the demo. That is part 7.
• Fuel consumption from engine speed and torque, sideslip angle, slip and sinkage per wheel, boat speed, canopy height, airspeed and line tension, wind, sun and moon, all in the HUD.

Presentation, derived from the physical quantities:

• Tyre tracks as decals every 28 cm along the actual wheel path.
• Spray and sand dust as instanced meshes per wheel by tread speed and sinkage, forward when rolling forward, backward in reverse, on parabolas.
• Water drops on the windscreen as small lenses that show the driver’s view behind them shrunk and mirrored, more on the side of the wheel running in the water.
• Visible swell: the same wave function that computes the buoyancy deforms a grid in the sea, fine close by, coarse out to 1.5 kilometres.
• A Lego® style paint material as a three-dimensional cell lattice, no texture, on the car, the boat and the canopy.
• The night without filters: from the sunset on, the exposure is locked at the daylight value, like a camera with a fixed setting. What is dark or bright after that is decided by the light sources alone: the sun, which stays just above the horizon and drops to 0.3 percent of its intensity, the moon at a seventh of the daytime sun, side lights red and green after the collision regulations, two headlights, a searchlight with shadows, the drone’s blinking LED. The light of the night has its own part, part 8.

Staging:

• Sunset, moonrise with a procedurally generated moon disc, nine hundred twinkling stars, shooting stars, and the land breeze that freshens with the moon and dies down after the beaching.
• Two ball players and the ball. The wide throw is staged, the vehicle’s braking is not: stopping distance estimate with hysteresis, full braking with split friction, reversing after the stop.
• The driver figure with the author’s face, waving at the drone at the start.
• The pufferfish. They are kinematic, built from engine primitives, a sphere, cones as spikes, fins, eyes, and they know nothing of Chrono. The big one circles the wreck after the sinking, always under the surface, with depth, radius and pace wandering slowly, and about every twelve seconds it comes to the windscreen, stops, turns to the driver and puffs up in 0.4 seconds with a small overshoot; the puffing reads mostly from the spikes shooting out. The three little ones, a third of the size, swim 1.3 seconds apart on its trail, alternating left and right of it. The trail is the list of its last poses, and because it piles up on the fish when it stops, the little ones keep a minimum distance behind it, or they would swim through it. When the drone sits on the water at the end, the family passes the windscreen one last time.

Sound: fully procedural, not a single audio file. Engine, starter motor, sand, suspension, surf, water entry, rotors and the boat’s outboard arise from oscillators and noise generators tied to the physical quantities. After the sinking the ears sit with the pilot on the parasail. That is part 4.

Two days of work

The first day went into the environment: toolchain, building Chrono 10 from source as a shared library, a test without Unreal in which the vehicle gets up the dune on SCM sand. On the evening of the first day the island came as a height map, on the morning of the second Unreal Engine itself went onto the machine. Vehicle, sand, water, course, sound, drone, boat, parasail and the night came together on that second day.

The work was done as a pair, with a clear division of roles. The engineer brought the model physics and the field knowledge that separate a calibrated simulation from a nice-looking animation, and turned that into the system’s requirements. Examples: the canopy’s lift depends on airspeed, the boat regulates the canopy’s height through its own speed and not through the camera, the line to the pilot hangs on the chest and not on a seat, the night comes from light sources and not from a filter, side lights are red to port and green to starboard and cover a 112.5-degree sector that ends cleanly aft. A banner behind the canopy looked silly and went out again. Requirements like these do not come from a prompt but from physics and hands-on practice on the water. The agent, Claude™ Code, turned those requirements into the C++ code, materials and blueprints, built, compiled, launched, took screenshots, read the telemetry and made proposals. What survived being measured against the model stayed.

A few numbers that describe the days:

• Well over a hundred build and run cycles. A cycle is 20 seconds of compiling and one to seven minutes of running, depending on which phase is being checked. Debug starts straight into a phase, floating in the pool for instance, saved half of that.
• Six attempts for the starter motor, four for the suspension noise, three for the surf. Sound is judged by ear, and the verdict comes in seconds.
• Three attempts until the pilot faced the direction of flight. In the end a measurement across the skeleton’s toes decided it, not another try.
• Two crashes while the author watched, both the same cause, appending an element of an array to the same array.
• One simulation that blew up because a torque on a light wheel spindle was too large.
• The COLREG-compliant sidelights, red port and green starboard with the correct arc, were the one place where prose corrections in the chat were not enough. The light function of the sector had to be reviewed and adjusted in the source code by hand, grounded in the collision regulations.
• The frame rate was at 30 in between and between 48 and 57 at the end. The physics was never the problem, Chrono needs 12 to 15 ms per frame in the shown run, boat, line, canopy and drone included.

The time sinks were not the physical models. Water, stops, soil parameters, line and canopy were formulated in minutes. The time went into signs, time bases, toolchains and details that are only visible in the running picture: a camera that stutters over whoops, a drone that flies through the hill, an engine whose stop was never applied. Exactly the class of problems that comes out of the interplay: the agent launches the application itself and reads the telemetry, the engineer judges in the running picture against what the model demands. High automation was the goal, because only that made two days possible at all.

Pleasingly the hardware requirements stay moderate: an ordinary workstation is enough, Ryzen® 5 7600, 32 GB, NVIDIA® GeForce RTX® 5070, Windows® 11. Unreal Engine 5.8.2, Chrono 10.0, Visual Studio® 2026.

What this is good for

The demo is a playground, the structure underneath is not. Anyone developing a controller for a vehicle, a construction machine, a boat or a mobile robot needs, early on, an environment in which control algorithms run against credible dynamics, with sensors that see a picture, by day and by night. Chrono provides physics you can calibrate with measurements, Unreal the picture to go with it. The soil parameters in the demo are literature values. With measurements from the real ground the same model computes things you can base a design on.

How the integration is built is in part 2.

Keywords: Project Chrono Unreal Engine, Chrono::Vehicle, vehicle simulation sand, Soil Contact Model, multibody simulation Unreal, deformable soil, driving simulation water, parasail simulation, drone attitude controller, agentic engineering, serious gaming, simulation consulting Switzerland, swissEmbedded

Unreal® and Unreal Engine® are trademarks or registered trademarks of Epic Games, Inc. in the United States of America and elsewhere; these articles are neither endorsed nor reviewed by Epic Games. Project Chrono is an open-source project of the University of Wisconsin-Madison and Politecnico di Milano under the BSD-3 licence.