Python in.
Verified Rust out.

Transpiles precision-critical numerical Python hot-paths to zero-allocation native Rust, backed by automated differential testing against original CPython bytecode across 900+ randomized test vectors. Zero float drift, zero unverified speed hype, zero telemetry.

✓ 900/900 Seeded Cases Matched ✓ 0 Observed ULP Float Delta ✓ Seed 1337 Randomized Fuzzing ✓ Local bwrap Sandbox · Zero Telemetry ✓ Linux x86-64 / macOS Apple Silicon

INTERACTIVE RUNTIME PROOF EMPIRICAL DEMONSTRATION

Input Python.
Generated Rust. Zero delta.

Fresh quickstart run on Linux x86-64 (CPython 3.13, rustc 1.98.1) converting financial pricing algorithms through COMPARE.

input/src/pricing.py · Original Typed Python Python 3.13
# Precision pricing hot-path
def ema(window: int, alpha: float, prices: list[float]) -> list[float]:
    if not prices or window <= 0:
        return []
    out = [prices[0]]
    for p in prices[1:]:
        out.append(alpha * p + (1.0 - alpha) * out[-1])
    return out

def max_drawdown(equity: list[float]) -> float:
    peak = equity[0]
    max_dd = 0.0
    for val in equity:
        if val > peak: peak = val
        dd = (peak - val) / peak
        if dd > max_dd: max_dd = dd
    return max_dd
crate/src/pricing.rs · Synthesized Native Rust Zero Allocations
// Auto-generated by ELYREON Rust Transfer
pub fn ema(window: i64, alpha: f64, prices: &[f64]) -> Vec<f64> {
    if prices.is_empty() || window <= 0 {
        return Vec::new();
    }
    let mut out = Vec::with_capacity(prices.len());
    out.push(prices[0]);
    for &p in &prices[1..] {
        let prev = *out.last().unwrap();
        out.push(alpha * p + (1.0 - alpha) * prev);
    }
    out
}

pub fn max_drawdown(equity: &[f64]) -> f64 {
    let mut peak = equity[0];
    let mut max_dd = 0.0;
    for &val in equity {
        if val > peak { peak = val; }
        let dd = (peak - val) / peak;
        if dd > max_dd { max_dd = dd; }
    }
    max_dd
}
elyreon-rust verification report · 900 Differential Fuzzing Vectors ALL CASES PASS
$ elyreon-rust verify --target pricing --seed 1337 --cases 900
[TEST ENGINE] Initializing bwrap sandbox with Python 3.13 and native compiled cdylib...
[SUITE: pricing:ema]          Generating 300 randomized price streams (len 100..5000)...
  ✓ Batch 01 (100 cases) -> PASS · max observed ULP delta = 0
  ✓ Batch 02 (100 cases) -> PASS · max observed ULP delta = 0
  ✓ Batch 03 (100 cases) -> PASS · max observed ULP delta = 0
[SUITE: pricing:max_drawdown] Generating 300 randomized volatility sequences...
  ✓ Batch 01 (100 cases) -> PASS · max observed ULP delta = 0
  ✓ Batch 02 (100 cases) -> PASS · max observed ULP delta = 0
  ✓ Batch 03 (100 cases) -> PASS · max observed ULP delta = 0
[SUITE: pricing:fees_total]   Generating 300 randomized tier calculations...
  ✓ Batch 01 (100 cases) -> PASS · max observed ULP delta = 0
  ✓ Batch 02 (100 cases) -> PASS · max observed ULP delta = 0
  ✓ Batch 03 (100 cases) -> PASS · max observed ULP delta = 0
----------------------------------------------------------------------------------------------------
FINAL VERDICT: 900 / 900 PASS · 0 MISMATCHES · 0 EXCLUDED · 0 ULP DIFFERENCE · VERIFIED

THE 4-STAGE PIPELINE GROUNDED VERIFICATION

Mathematical rigor.
Never hallucinated.

How ELYREON Rust Transfer transforms critical code without gambling on unverified LLM translations or dangerous compiler assumptions.

STAGE 01 · STATIC INSPECTION

AST Parsing & Strict Subset Boundary Check

"Fast code that computes the wrong number is negative value."

ELYREON reads your typed Python Abstract Syntax Tree. It validates supported constructs (checked i64, IEEE-754 binary64 floats, fixed Decimal, container typing, loops) and explicitly refuses unsafe constructs. Any file I/O, network requests, or dynamic reflection are separated and kept in Python.

STAGE 02 · ZERO-ALLOCATION SYNTHESIS

Deterministic Rust Crate Emission

"Translate the math, respect the borrow checker."

Synthesizes idiomatic Rust code with pre-allocated buffer capacities, borrow-checked slices, and zero heap-thrashing inner loops. Uses Maturin and PyO3 C-bindings to create a standalone native shared library (`.so` / `.dylib`).

STAGE 03 · DIFFERENTIAL FUZZING

Automated 900-Case Differential Verification

"Passing differential cases is finite evidence, but failure to test is negligence."

Generates hundreds of randomized edge-case inputs (fuzzing boundary values, NaN/Inf handling, empty sequences, extremes). Executes both your original Python code and the compiled Rust in parallel, comparing outputs down to the exact float bit (Unit in the Last Place / ULP). If a single mismatch occurs, compilation halts.

STAGE 04 · LOCAL ISOLATION

Sandboxed Delivery & Zero Telemetry

"Your proprietary algorithms stay on your hardware."

Runs entirely within local bubblewrap (`bwrap`) Linux namespaces. Zero network phone-home, zero remote code telemetry, and zero telemetry tokens. Delivers an offline wheel with complete SBOM and reproducibility logs.

HONEST BOUNDARIES THE SUPPORTED SUBSET

What we accelerate.
What stays in Python.

We do not claim universal Python transpilation. Real systems maintain strict, honest boundaries.

Accelerated in Native Rust

  • Checked Numerical Loops: Hot iteration over time-series, grids, and numeric arrays.
  • Typed Scalar Math: i64 integers with overflow checks, IEEE-754 binary64 floats, fixed Decimal.
  • Supported Containers: Typed lists, tuples, dictionaries, and fixed-type sets.
  • Dataclasses & Structs: Data objects with statically resolvable typed fields.
  • List Comprehensions: Deterministic filter, map, and accumulator loops.
  • Selected Math Builtins: sqrt, log, exp, floor, ceil, abs, and trig primitives.

Retained Safely in Python

  • Disk & Network I/O: Database queries, HTTP endpoints, file reading, and logging.
  • Heavy Dataframe Libraries: Pandas, Polars, and NumPy remain on their native C-backends.
  • Asynchronous Runtimes: asyncio event loops, coroutines, and generator pipelines.
  • Dynamic Reflection: eval(), exec(), inspect, and untyped dynamic monkey-patching.
  • Untyped Dynamic Objects: Missing type hints are flagged and refused before compilation.
  • External Cloud APIs: Third-party SDKs and service integrations.

EMPIRICAL PROVENANCE RECORDED TEST RUN

Audited proof.
Inspect the ledger.

Full test configuration and hardware provenance from the October 2026 verification audit.

PARAMETER VALUE VERIFICATION SCOPE
Audit Job ID rust-20261021-215954-3c4fd00935 Recorded in verification.json
Host Environment Linux x86-64 · Ubuntu 24.04 LTS · i5-10600K Isolated bwrap namespace
Compilers CPython 3.13.15 · rustc / cargo 1.98.1 Standard production toolchains
Differential Cases 900 / 900 PASS (0 mismatches, 0 errors) 300 cases each: ema, max_drawdown, fees
Observed Float Deviation 0 ULP (Bit-for-bit identical IEEE-754) Verified on binary64 IEEE-754 output
Release & Telemetry 1.0.0 Evaluation Preview · 0 Telemetry Local offline execution only