Performance
What Pulse Water costs on the CPU, measured with the specs PulseWater.Perf.*. The numbers are a baseline to compare changes against, not limits: yours depend on the hardware and the content (number of waves, pontoons, water bodies).
How it was measured
- Pulse Water 1.0 in development (state of 11 October 2026), Unreal Engine 5.8.
- Intel Core i9-14900KF (24 cores, 32 threads), 64 GB RAM, Windows 11. Everything ran on the game thread.
- Editor build in the Development configuration (optimized), headless (
-nullrhi). DebugGame builds are many times slower and say little. - Plugin content: the default waves (
DA_PulseWater_DefaultWaves, 12 waves), 4 surface solver iterations (the default), the sail boat (8 pontoons). - Every value is the mean of two runs with many repetitions each. Single threaded values differed by less than 5 % between the runs, values of batches split over worker threads by up to 30 % (terrain traces the most).
To measure on your machine, run the specs and search the log for PulseWaterPerf:
<Project>Editor-Cmd.exe <Project>.uproject -ExecCmds="Automation RunTests PulseWater.Perf; Quit" -nullrhi -unattended -log=Perf.log
Water queries
Time per point of one QueryWaterBatch call on the game thread, points spread over 2 km x 2 km between 3 m below and the calm sea level. From 64 points (Min Parallel Query Points) the batch is split over worker threads:
| Configuration | 1 point | 64 points | 1024 points | 16384 points | One by one |
|---|---|---|---|---|---|
| Ocean, height | 0.51 µs | 0.25 µs | 0.11 µs | 0.06 µs | 0.65 µs |
| Ocean, normal and velocity | 0.57 µs | 0.25 µs | 0.12 µs | 0.07 µs | 0.70 µs |
| 25 lakes of 100 m, height | 0.53 µs | 0.35 µs | 0.13 µs | 0.09 µs | 0.79 µs |
| Terrain (band rule, traces), height | 0.93 µs | 0.40 µs | 0.50 µs | 0.69 µs | 1.10 µs |
Terrain and water depth (Depth) | 1.62 µs | 0.71 µs | 1.12 µs | 1.40 µs | 1.70 µs |
The last column is the cost per point without worker threads (Min Parallel Query Points = 0).
- The ocean costs about 0.65 µs per point on one thread. It grows with the number of waves of the wave set and with
Surface Solver Iterations. Split over the workers, 16384 points take about 1 ms instead of 11 ms. - Batches are worth it: query many points at once (
QueryWaterBatch), or let components that query every frame queue their points for the batch of the frame (RequestQueries, buoyancy does it). - The terrain check with traces adds about 0.45 µs per point on one thread,
Depthanother trace down to the ground (about 0.6 µs). Traces gain less from the workers. A terrain provider that answers from the height function of your world generator costs what that function costs. - Water bodies add about 0.15 µs per point near them.
Floating objects
| Per object | 100 objects | |
|---|---|---|
| Buoyancy with 8 pontoons (crates of 1 m) | 5.7 µs | 0.57 ms per frame |
The pontoons of all floating objects go into the query batch of the frame (0.85 ms for 100 objects when every object queried alone). The rest is the physics calls per pontoon (velocity at the point, the force); fewer pontoons cost less. The physics simulation is not included.
Mass
| Per entity | 10,000 entities | |
|---|---|---|
UPulseWaterSampleProcessor (height, normal, velocity) | 0.17 µs | 1.7 ms per frame |
The processor runs on the game thread and queries each chunk of entities in one batch, which is split over worker threads (7.2 ms for 10,000 entities on one thread).
Materials and meshes
Work only for what players see. Large parts of it run in background tasks; the game thread copies the inputs and applies the results a frame or two later.
| What | When | Game thread | In the background |
|---|---|---|---|
| Surface mesh of a lake of 100 m | the lake or water near it changed | 0.24 ms | 1.6 ms |
| Surface mesh of a lake of 1 km (70,000 triangles) | the lake or water near it changed | 7.6 ms | 132 ms |
| Body mask, 25 lakes within 1 km | the view moved 256 m, water bodies changed | copies of the outlines | 1.2 ms |
| Environment grid, 512 points per frame | every frame | copy of the grid and the zones | 5 µs, 38 µs with 10 zones |
APulseWaterOcean::RequestTerrainUpdate refreshes the surfaces of all water bodies (their blending depends on the terrain), so many large lakes add up there. Providers that cannot be sampled off the game thread sample the environment grid on it (the column on the right). Measured by PulseWater.Perf.Visuals.
Editor views
The views of level viewports and PIE windows (never in a game) query 64 x 64 points. Game thread time of one build, measured by PulseWater.Perf.Views in a world with an ocean, a sea floor and terrain (band rule, traces):
| View | Grid that comes into view | Build that moves the heights | Build that queries 1024 cells again |
|---|---|---|---|
| Depth | 5.1 ms | 0.9 ms | 1.6 ms |
| Source | 1.6 ms | 0.8 ms | 1.0 ms |
| Terrain Cover | 4.2 ms | 0.8 ms | 1.8 ms |
| Network | 0.01 ms | 0.00 ms | 0.07 ms |
A view builds every 0.05 s for each viewport it is on in. Every build moves the cells with the waves (4096 points without the terrain check: 0.4 ms) and queries again what a cell shows when it is older than a second, at most 1024 cells per build. A grid that comes into view (the camera jumped, or the cells got bigger or smaller) is queried at once: 4096 points with the terrain check take 1.6 to 2.4 ms, with the water depth (a trace down to the ground per point) 3.9 to 5.8 ms. Finding what the camera looks at costs 0.1 ms per build.
Boats
| What | Time |
|---|---|
SimulateMove, one step of the sail boat | 5.3 µs |
| Movement tick of a boat (simulation, hull sweep, moving the components) | 16 µs |
| Hull tick of a boat (flooding, sinking) | 3.0 µs |
| Moving and turning a boat with its components | 7.6 µs |
| Replay of 30 moves after a correction (simulation only) | 156 µs |
A boat that a client drives is simulated on that client and on the server. Corrections replay the unconfirmed moves; stat PulseWater counts them (Boat Corrections).
Fluid simulation
One step of 1/60 s of the shallow water solver (Pulse::Water::Fluid::FSolver) on 256 x 256 cells of 50 cm, as many cells as 64 chunks of 32 x 32. The rows of every pass run on worker threads; one thread gives the same result, bit for bit:
| Water | Advection | Worker threads | One thread |
|---|---|---|---|
| A lake at rest | momentum conserving (default) | 2.2 ms | - |
| A basin full of waves | momentum conserving (default) | 2.8 ms | 12.4 ms |
| A basin full of waves | MacCormack | 2.8 ms | - |
Every step needed one sub step: with cells of 50 cm and the default Courant number 0.5, a step of 1/60 s stays one sub step while flow speed plus wave speed is below 15 m/s (still water up to 23 m deep).