The computational engine that doesn't hide the math.
One engine forsignal processing.
Node-based signal processing, N-dimensional arrays, and Simulink-class simulation on a native Rust core. Physical units and measurement uncertainty flow correctly through every operation — from a single byte to an N-D tensor — end to end.
- Native Rust core
- Windows · macOS · Linux
- Units + uncertainty, native
- Open project format
- ~730×
- Faster sims
- AOT-compiled hot loop
- 11
- ODE solvers
- MATLAB-class suite
- ±σ
- Uncertainty
- through every op
- 128k
- Lines of Rust
- in the compute core
Built for people who work in the details
- Researchers
- Control & signal engineers
- Universities
- National labs
- R&D teams
- Serious hobbyists
Two things no other tool does — together
MATLAB gives you numeric power without units. Mathematica gives you symbolic depth without live simulation. Captyse refuses the trade-off: units and uncertainty are first-class citizens of every value on every wire.
Native physical units
Every quantity carries its dimension. Multiply a m/s signal by a s signal and get m. Add volts to seconds and Captyse rejects it — loudly — instead of returning garbage.
- Full dimensional analysis with the seven SI base dimensions
- Affine units done right (°C, °F, K coexist with offsets)
- Units flow through matrices, tensors, complex numbers — and the ODE solver
- Typed unit parser: kg·m/s², mV/√Hz, and custom units
Native measurement uncertainty
Every value can carry a standard uncertainty (±σ) that propagates continuously through the whole pipeline — arithmetic, FFTs, filters, fits, and a live simulation.
- First-order Gaussian propagation with correlation-aware lineage
- X − X correctly yields ~0 variance, even across compound boundaries
- Nonlinear ops use moment-matching (Clark's method) for correct σ
- Confidence bands (±kσ) render directly on plots
Engineered for the load
- <100 ms
- Target sim execution
- with units + speed + σ
- 100k+
- Points per plot
- Skia/GPU, decimated LOD
- Bit-exact
- Reproducibility
- deterministic by choice
- 5
- Vector export formats
- SVG · PDF · TikZ · PNG · JPEG
It doesn't niche itself. You choose the domain.
One unified Array type spans scalars to tensors; one wire family carries bytes, complex numbers, DataFrames, date-times, audio, and bundles. Write a transform once and it works across ranks.
Signal processing
FFT, FIR/IIR filter design, windowing, resampling, envelopes, derivatives, integration, and sensor transfer functions — native and fast.
Simulink-class simulation
Turn a cyclic feedback graph into a solved ODE system. 11 solvers, zero-crossing events, and σ through the integration via forward sensitivity analysis.
Linear algebra & tensors
An Intel-MKL-backed backend: matmul, Cholesky, decompositions, norms, einsum, broadcasting, and special-matrix generators.
Statistics & fitting
Descriptive stats, correlation, entropy, KDE, confidence ellipses, curve fitting and Levenberg–Marquardt identification with ±σ.
Symbolic math console
Send commands to the Rust core, reference any signal or output by name with {{variable}}, and bind parameters reactively across the whole project.
Publication-grade visualization
A unit-driven multi-axis plot system, phase-space portraits, a Blender-grade playback timeline, and true vector + LaTeX/TikZ figure export.
Data acquisition
A hardware-agnostic acquisition core (audio, SYSAM, NI-DAQmx) with graceful degradation. Rolling out beyond the early-access build.
2D scene & kinematics
A CAD-grade 2D scene reactive to live simulation, with forward/inverse kinematics and two-way variable binding. Coming after 0.8.
Why it's this fast, and this trustworthy
The heavy math lives in a native Rust core — not in the UI. That's not an implementation detail; it's why the numbers are fast, correct, and reproducible.
A native Rust compute core
~128k lines of Rust organized into focused modules, preferring proven optimized crates over hand-rolled loops. The UI never blocks; a numeric edge case never corrupts a result.
An AOT simulation compiler
The scalar residual is compiled once into a flat f64 slot program with constant folding — 46.6 ms, ~730× faster — and validated bit-for-bit against the generic path. If they ever disagree, it bails.
Reproducible by choice
Deterministic RNG, compensated (Kahan/Neumaier) summation, and a compute mode that trades speed against bit-exactness explicitly. Same inputs, same outputs — every run.
A panic firewall
Rust panics are caught at every FFI boundary. Runtime DLLs load through a hardened safe loader. The event/solver honesty gate refuses to run wrong physics silently.
See it work
A dockable, pro-grade workspace — closer to a VFX compositor or a DAW than a web form. Density without chaos.
Where Captyse stands
An honest comparison. Captyse is young (0.8) and not as broad as decades-old incumbents — but on the things that make results physically meaningful, it does what they don't.
| Captyse | MATLAB + Simulink | Mathematica | |
|---|---|---|---|
| Native physical units | Toolbox | ||
| Measurement uncertainty (±σ) | Add-on | ||
| Units + σ through a live ODE solve | |||
| Node-based dataflow | Simulink | ||
| Native Rust performance core | |||
| Bit-level reproducibility control | Partial | Partial | |
| True vector + TikZ/LaTeX figure export | Partial | ||
| Open, JSON-based project format | |||
Most simulation tools hide the math behind black boxes. Captyse exposes it — with a unified data model, transparent solver algorithms, and bit-level parameter control. It's built for those who refuse to compromise on the details.
Questions, answered
No. Captyse is proprietary commercial software. We're in Early Access — pay once now and lock in a lifetime discount (and a lifetime license on the Founder plan) before general-availability pricing takes effect.
Lock in Early-Access pricing before it's gone
Pay once now, keep the discount for life. Every update through 1.0 is included.