Running a simulation

August 26, 2026

"Getting started" ran a model offline, as fast as the engine can go, with no relationship to wall-clock time. That's the right default for most runs, but not the only mode: this page covers online/paced execution, pausing mid-run, reading back how the engine actually executed and extending a finished run instead of starting it over. All of it on the bundled "Thermal Management" example again.

Offline vs. online

The run dialog's Online simulation toggle switches between the two modes.

The run dialog with online simulation enabled
Synchronize the run with wall-clock time for live interaction: the description names exactly what online mode is for.

Offline runs at maximum speed with no synchronization at all, the right choice for "just show me the result." Online paces the simulation against wall-clock time instead, at a rate set by Online pacing (real time, or a custom ratio). That trade only matters once something on the other end is watching or steering the run live: a plotted value updating as it happens, or a Live parameter (mentioned in "The graph canvas") adjusted mid-run and felt immediately, rather than only after the fact in a completed result.

While it's running

An online run can be paused and resumed at its synchronization boundaries, without losing any state.

The simulation paused partway through an online run
Every node's current value is visible live, not just at the end: 0.25 s into a 4 s run here.

The status bar names exactly where you are: "Running" while it's live, "Paused" once you've stopped it and eventually "Model locked" once it's done. The model stays read-only for as long as a result exists, whether that result finished instantly (offline) or took several real seconds to pace through (online).

How it actually ran

Once a run completes, an execution summary is available describing how the engine actually executed it: serial, thread-pooled or partitioned across workers, chosen automatically based on the model's size.

The execution summary panel
This model ran serially: small enough that parallelizing it would cost more than it saves.

For a model too small to benefit from it, that's a one-line explanation. A larger, partitioned run reports the actual partitioning strategy and the communication cost it produced. That's useful when a model's execution time stops matching expectations and the question becomes "where did that time actually go."

Extending instead of restarting

A completed run doesn't have to be thrown away to see further: Extend simulation continues from the exact final checkpoint rather than recomputing everything from the start.

The run dialog reopened to extend a completed run
"Continue from 4 s": the model's state at that checkpoint carries forward untouched.

It reopens the same run dialog, pre-filled with the previous run's settings (online/offline, pacing) and a target time to raise. Starting it appends new results onto the existing timeline instead of replacing it.

The extended result, now available to 5 seconds
"Available 5 s · target 5 s": one continuous timeline, not two separate runs.

Where to go from here

Everything here has been about producing a result. Next up: reading a result back in more depth than a single node's live value, scrubbing the full timeline, comparing signals and branching a result into an alternative continuation.


Follow Konjugate on LinkedIn for updates.

Comments