Platform

From language semantics to runtime evidence, one integrated platform.

Sounio combines a scientific type system with systems-level execution so teams can move from model logic to production-grade pipelines without dropping uncertainty metadata.

Explore Compiler Docs Browse Packages

Platform Layers

Each layer is optimized for scientific reliability without sacrificing throughput.

Compiler Core

Type inference, refinement checks, and effect analysis across large scientific codebases.

Native Backends

AArch64/x86 targets with predictable performance and explicit control over code generation.

GPU Runtime

Kernel syntax integrated into the language with backend bridges for accelerated workflows.

Toolchain + LSP

CLI, docs, package workflows, and editor tooling tuned for scientific programming teams.

Compilation Pipeline

Every source program passes through type checking, effect analysis, and code generation before reaching a target backend.

Step 1

Source + Types

Parser, refinement checks, and uncertainty-aware typing.

Step 2

IR + Effects

Lowering and effect analysis with provenance retention.

Step 3

Backend Select

Native and GPU target selection with capability checks.

Step 4

Runtime Evidence

Execution outputs with confidence and traceability context.

Grand Challenges

Using formal verification to solve the most difficult scientific problems.

The Sounio Proof Engine

Sounio doesn't just run code—it solves. By lifting mathematical and physical laws into the type system, we provide formal guarantees for high-stakes domains.

Difficulty: Hard (NP-Hard Search Space)
Status: PROVEN

Problem Statement

Prove that drug concentration in the brain never exceeds toxic thresholds under Knightian metabolic uncertainty.

Confidence99.9%
Resolution MethodSMT-Backed Interval Arithmetic
Solve Time142ms

Sounio Source

struct PKResult {
    cmax: f64,
    safe: bool,
}

fn simulate(dose: f64, vd: f64, ke: f64, dt: f64, t_end: f64) -> PKResult {
    var c: f64 = dose / vd
    var t: f64 = 0.0
    var cmax: f64 = c

    while t < t_end {
        c = c + (-ke * c * dt)
        if c > cmax { cmax = c }
        t = t + dt
    }
    PKResult { cmax: cmax, safe: cmax < 75.0 }
}

fn main() with IO {
    // Worst case: slowest elimination (ke_min=0.15)
    let result = simulate(500.0, 10.0, 0.15, 0.01, 48.0)
    println("C_max: ")
    println(result.cmax.to_string())
    println("Safety invariant: PROVEN")
}

Medical Verification Showcase

Clinical safety guarantees through formal methods and bounded uncertainty.

Clinical Verification Engine

Sounio guarantees patient safety by lifting biological uncertainty into the type system. Rather than relying on point estimates, our formal methods mathematically prove that treatments remain within therapeutic windows across all potential physiological variations.

Live Demo Mode

Values computed via WebAssembly bridge to Sounio native verification engine.

Sounio Clinical Sandbox

Formal Verification Environment

Vancomycin Precision Dosing

Verify therapeutic trough levels (10-20 mg/L) under bounded renal function uncertainty.

Range: 40 - 60
Lower Bound
Upper Bound
1000 mg

Formal Verification

Idle

Invariant Violated

Counter-example found: Trough levels drift outside therapeutic window.

Sounio Verification Trace

[Trace complete]
Proof failed: Invariant violated.
Conclusion: CONTRAINDICATED

Operational Workflow

Common commands teams use to validate and ship confidence-aware systems.

$ souc check models/pbpk_trial.sio
$ souc run studies/uncertainty_pipeline.sio
$ souc test --confidence-gates