Why it's this fast, and this trustworthy
The heavy math lives in a native Rust core — not in the UI. That isn't an implementation detail. It's the reason the numbers are fast, correct, and reproducible.
Strict separation, by design
A bug in a widget can never corrupt a scientific result. The math engine can be tested, optimized, and even run headlessly — the UI is strictly a viewer.
A native Rust compute core
~128k lines of Rust, organized into focused modules: signal processing, statistics, an Intel-MKL-backed linear-algebra backend, tensor algebra, curve fitting, complex arithmetic, uncertainty & lineage, and a CAS bridge.
The philosophy is explicit — prefer proven, optimized crates over hand-rolled loops, except where there's a clear reason not to. That keeps results fast and trustworthy.
An AOT simulation compiler
Naively, a formula-based ODE re-parses its expression on every derivative evaluation. Captyse instead ahead-of-time compiles the scalar residual once into a flat f64 slot program with constant folding.
It's gated and self-validating: the fast path validates bit-for-bit against the generic path and bails out if they ever disagree — so it can never silently produce wrong physics.
Units and uncertainty, carried natively
Every value carries its physical dimension and, optionally, a standard uncertainty — and both propagate correctly through every operation, including a live ODE solve.
Dimensional algebra
shippingUnit algebra runs on every binary operation. Multiplying a velocity by a time yields a length; adding incommensurable quantities is rejected loudly.
Uncertainty propagation
shippingFirst-order Gaussian propagation with correlation-aware lineage, so X − X correctly yields ~0 variance.
Reproducible by choice
Deterministic RNG, compensated (Kahan/Neumaier) summation, and Welford's online variance keep long simulations from leaking catastrophic-cancellation error. A user-chosen compute mode trades speed against bit-exactness explicitly:
- Deterministic — one thread, bit-exact across machines.
- Reproducible · Parallel — all cores + Intel CBWR, fast and bit-exact (the default).
- Fast · Parallel — all cores, maximum speed.
A panic firewall
Rust panics are caught at every FFI boundary, so a numeric edge case never takes down the app. Runtime DLLs load through a hardened safe loader. And the event/solver honesty gate refuses to run an event-bearing model on an event-blind solver — rather than silently giving you wrong physics.
Proven by thousands of Rust tests and adversarial physics checks against analytic facts.
Numbers you can trust, at speed
The engine is the product. Come build on it.