Modeloop, a model-based design tool for embedded control systems, rewrote its simulation engine from Python to Rust and published the numbers on Nov. 7. Across six engineering models, including coupled hydraulic tanks, a quarter-car suspension, a permanent-magnet synchronous motor and a thermal reactor, the Rust runtime ran models 8.6 times faster in model-in-the-loop (MIL) tests and 16.4 times faster when running the generated C code in software-in-the-loop (SIL) tests. The rewrite took several months.
The comparison was built to be fair. Both runtimes used the same model compiler, and in SIL both loaded exactly the same precompiled C library, so the gain came from scheduling, signal passing and recording, not from a different controller. Each run simulated 2,000 one-millisecond ticks: Rust finished in 45 to 121 ms for MIL against 393 to 1,080 ms for Python. Before any timing, an independent reader compared 2,609,100 recorded values from both engines, and the largest difference was zero. Rust also lets Modeloop run the same simulation core on the desktop and, through WebAssembly, in the browser.
Modeloop also published where Rust did not win big. Speedups shrank as models grew: a 64-axis actuator bank with 165 blocks and 13 levels of nesting ran only 2.89 times faster in MIL. A deliberately unoptimized test with 128 stages ran 34.5% slower in Rust, and recording all 64 elements of a signal instead of one added 25.7% to Rust’s run time. The rewrite removed most of the fixed cost Python paid on every tick; the cost that grows with the model is still there. Engineers can use these results to see where a faster language helps and where model design matters more.
The Rust compiler itself keeps getting faster. In a Nov. 4 report, compiler performance engineer Nicholas Nethercote counted improvements on 236 tests across 45 benchmarks between Sept. 28 and Nov. 2, against regressions on four. Mean wall time fell 2.85% and peak memory 4.46% in that month. Since the start of 2026, 560 of 561 instruction-count measurements have improved. One change cut how often incremental builds store span data from 20 to 40% of spans to about 1%.
A new build tool goes further. Blaze keeps the whole program in memory in a background process, recompiles only the functions you changed and patches them into the existing binary instead of relinking. On the Helix editor, its benchmark page shows editing a function rebuilding in 78 ms against 7.21 seconds with Cargo, 92 times faster. The trade-offs are real: cold builds are 1.4 to 1.9 times slower, it needs a pinned nightly toolchain and several times Cargo’s memory, and its own borrow checker still misses some errors, so its authors tell users to keep cargo check or CI as the final word.
N23D is written in Rust from end to end, so simulation, the compiler and build time all matter to us. Modeloop’s test is the pattern N23D follows for CAE: prove the new solver gives the same results before you time it, then publish where it is slower. In N23D, those verification runs, the model revision they used and the requirement they test sit in the same PLM record, so a speedup never hides a changed answer.
Sources
- Porting the simulation engine into Rust, Modeloop (Nov. 7, 2026)
- How to speed up the Rust compiler in November 2026, Nicholas Nethercote (Nov. 4, 2026)
- Benchmark history, blaze (ix.dev)
- Usage, blaze (ix.dev)
Featured photo: U.S. Air Force airmen check the fluid flow of an AV843 hydraulic test stand at March Air Reserve Base, Calif. U.S. Department of Defense photo, public domain, via Wikimedia Commons.
.jpg){kind=link}
