Product ยท deterministic numerical runtime
LuxiQuant: numerical computing with defined behavior and receipts.
LuxiQuant is a deterministic numerical and quantitative runtime for workloads where the same input must produce the same output, every time, with proof attached. It is a numerical execution engine - not an LLM weight-quantization tool, and not an inference serving stack.
What it is
A compact, locally executed numerical runtime with documented execution modes. You choose the contract; the engine behaves as documented for that contract.
Binary and API surfaces
Ships as a single compact binary with a REST interface. JSON expressions in, results plus a SHA-256 receipt out. Runs locally with no cloud dependency after deployment.
Defined execution behavior
Each execution mode carries a documented contract: the f64 CPU gold path provides the strongest reproducibility contract; fast f32 and GPU paths carry configuration-specific contracts that are never presented as equivalents.
Reproducible numerical work
Defined execution order and canonical requests and outputs, so supported workloads can be re-run and compared byte-for-byte under the documented conditions.
Cryptographic receipts
Every response can carry a SHA-256 receipt over the output bytes. Store it at computation time; a matching receipt on re-run confirms byte-identical output under the same documented configuration.
Quant and risk workloads
Receipt-enabled risk, Greeks, streaming statistics, online covariance, and scenario-batch processing for reproducible quantitative pipelines.
Supported platforms
CPU scalar, AVX2, AVX-512, and ARM Neon paths; CUDA on tested NVIDIA GPUs. Vulkan is available but experimental. Per-platform status: Capabilities.
Independently evaluated - TestFort, December 2025
TestFort QA Lab independently evaluated a defined deterministic numeric workload on NVIDIA H100 hardware. The evaluation did not certify every function, platform, backend, or expression.
TestFort evaluation report - December 2025 (PDF) → · Scope detail: Proof: independent evaluation
Edge and constrained deployment
LuxiQuant is the engine; the edge is one place that engine can run. The same deterministic numerical core that runs on servers can execute close to the device, without a heavyweight AI-serving stack, for systems constrained by power, latency, memory, or connectivity.
Native core, no service overhead
A native Rust numerical core that can be called directly as an engine, with no HTTP or JSON overhead in the execution path. The REST interface is optional, not required.
ARM64 and NEON execution
ARM64/NEON execution paths run the same deterministic contracts on ARM systems. An internal direct-engine benchmark on Apple Silicon ARM64 has exercised this path; independent validation is next. Per-platform status: Capabilities.
no_std-capable core
The core supports a no_std-capable configuration for constrained targets. It is implemented in source, with the first physical embedded-board run on the validation roadmap.
Receipts at the point of computation
Cryptographic SHA-256 receipts are generated where the computation happens, so results from remote or disconnected devices can be replayed and audited later.
The practical value: reproducible numerical results with proof attached, on hardware that cannot afford a serving stack. That fits industrial control, sensor processing, robotics, aerospace, energy systems, and other numerical workloads that run where the data is produced.
A target-device evaluation measures latency, energy, memory use, and receipt stability on your actual hardware, under the same pilot workflow described below.
What a paid pilot looks like
A design-partner pilot measures LuxiQuant against your reference workload, on agreed hardware, under an agreed measurement protocol.
- Define the workload, reference method, and acceptance criteria together.
- Run matched comparisons with receipt-attested outputs.
- Deliver a scoped measurement report: correctness, throughput, and measured energy for the agreed configuration.