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.

Ontology Resolution Experience

Ontology modules for SNOMED, GO, HPO, LOINC in the standard library. Type-level binding planned for 2026.

Ontology Term Resolution (Stdlib Modules)

Automated Prover Feedback

Refinement type checking at compile time. SMT solver integration planned for 2026.

Compile-Time Refinement Engine (Z3)

Mathematical guarantee of confidence bounds across entire system execution paths.

// Refinement type constraint

type Reliable<T> = Knowledge[T]

where confidence >= 0.95

// Z3 Prover checks this pipeline mathematically

fn analyze_dosing(patient_data: Knowledge[f64]) -> Reliable<f64> {

let clearance = patient_data * 0.4
let dosing = compute_auc(clearance)
return dosing // Must prove: dosing.ε >= 0.95

}

SMT Solver Status

Awaiting AST

Constraints:1

Variables:4

Time:--

Actionable Error Traceability

Clear provenance and explanations when formal models clash.

Logic Conflict Traceability

When the prover finds a contradiction, it traces exactly where the conflicting boundaries were established.

Epistemic Refinement Conflict (E0421)

Cannot prove that measure_drug_response() satisfies the confidence bounds of Reliable<f64>.

42

models/oncology/tumor_growth.sioTarget

let efficacy: Reliable<f64> = measure_drug_response()

Type requires: confidence >= 0.95

118

stdlib/medical/measurement.sio

fn measure_drug_response() -> Knowledge<f64> { ... }

Returns: confidence = 0.92 (due to historical variance)

Z3 Model: UNSATProof Time: 12ms

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.

Renal Function [CrCl mL/min]Range: 40 - 60

Lower Bound

Upper Bound

Dose [mg Q12H]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