Performance

MIND's compiler frontend processes tensor programs in microseconds, produces bit-identical deterministic builds, and generates gradient code at compile-time.

Important: What We Measure

MIND benchmarks measure the compiler frontend only: parsing, type checking, and IR lowering. This does not include code generation, optimization passes, linking, or producing an executable.

1. ParsingMeasured
2. Type checkingMeasured
3. IR loweringMeasured
4. Code generation, optimization passes, linking, executableNot included

Comparisons with PyTorch torch.compile(), Mojo mojo build, and JAX jax.jit() are shown for context, but these tools perform fundamentally more work (full compilation to runnable code). The ratios reflect this scope difference, not just speed.

Frontend Speed (Verified)

In-process Criterion benchmarks measuring compile_source(), the complete frontend pipeline (parse + typecheck + IR lowering):

MIND Frontend vs PyTorch torch.compile()

Scope difference: MIND measures frontend only (parse + typecheck + IR). PyTorch torch.compile() includes graph capture, optimization, and code generation (Inductor/Triton). These are not equivalent operations.

What This Means

MIND's frontend is 35,000-176,000x faster than PyTorch's full GPU torch.compile() pipeline. This is expected because:

Key takeaway: MIND's frontend is microsecond-fast, enabling instant feedback during development. A full end-to-end comparison would require MIND to also generate and compile executable code.

MIND Frontend vs Mojo 0.26.1

Scope difference: MIND measures frontend only (parse + typecheck + IR). Mojo mojo build performs full LLVM compilation to a native binary. These are not equivalent operations.

What This Means

MIND's frontend is 135,000-458,000x faster than Mojo's full mojo build compilation. Mojo compiles through LLVM to produce a native binary, while MIND's frontend only performs parsing, type checking, and IR lowering.

MIND Frontend vs JAX 0.9 jax.jit()

Scope difference: MIND measures frontend only (parse + typecheck + IR). JAX jax.jit() performs full XLA compilation (HLO lowering + optimization + code generation). These are not equivalent operations.

What This Means

MIND's frontend is 21,200-95,100x faster than JAX's cold-start XLA compilation. JAX compiles through XLA to produce optimized GPU/CPU kernels, while MIND's frontend only performs parsing, type checking, and IR lowering.

Reproduce It Yourself

# MIND frontend benchmarks (Criterion, in-process)
cargo bench --bench simple_benchmarks
cargo bench --bench compiler

# PyTorch comparison (same machine)
pip install torch
python benchmarks/scientific_benchmark.py

Deterministic Compilation

MIND's build gates check bit-identical reproducibility for the covered same-target builds with fixed source, toolchain, flags, dependencies, and other build inputs. Separate cross-substrate gates compare computational output hashes; they do not compare x86 instruction bytes with ARM instruction bytes.

40 total runs, 0 hash collisions, bit-identical output. MIND guarantees bit-identical output across runs, machines, and time.

Compile-Time Autodiff

MIND generates gradient code once at compile-time, not on every training iteration. This eliminates per-iteration autodiff overhead entirely.

Optimization Levels

The compiler provides several optimization profiles:

Compiler Optimizations

The MLIR-based pipeline applies several optimization passes:

Target Performance (CPU)

Design targets (not measured results) for Core v1 operations on CPU. The measured runtime wins to date are the hand-lowered deterministic integer GEMM paths (see Benchmarks); MIND makes no general claim of beating C/Rust -O3 codegen:

Framework Comparison

Comparison of MIND frontend speed vs other frameworks' full compilation pipelines. All numbers verified on the same machine (Feb 2026).

Different scope: MIND measures frontend only. Other frameworks measure full compilation to runnable code. Ratios reflect this difference.

Profiling

Built-in profiling support for performance analysis:

# Generate a trace profile
mindc run model.mind --profile=trace --output=trace.json

# CPU time breakdown
mindc run model.mind --profile=time

Memory Efficiency

GPU Runtime Performance (Enterprise)

Available under commercial license. GPU / multi-vendor accelerator execution ships in the commercial mind-runtime today; it is not part of the open-source v0.10.2 compiler in this repository. What remains on the roadmap is the differentiator: bit-identical determinism across these GPU substrates.

Performance for the Enterprise CUDA backend, benchmarked on an Ada-class GPU (sm_89):

GPU runtime requires Enterprise license. Performance scales with GPU capabilities. Benchmarks verified February 2026.

WebGPU Runtime: GEMM Benchmark

Commercial runtime. WebGPU execution ships in the commercial mind-runtime, not the open-source v0.10.2 compiler in this repository. The figures below are measured on that backend; bit-identical determinism across GPU substrates is the differentiator that remains on the roadmap.

In-browser WebGPU benchmark comparing MindLang AOT-compiled WGSL shaders against ONNX Runtime Web 1.21's WebGPU backend. Both perform the identical operation (C = A × B, f32). MindLang compiles .mind → optimized .wgsl at build time; ONNX RT generates shaders at runtime.

Key Findings

MindLang is 7.5-19x faster than ONNX Runtime Web across all matrix sizes. At 4096×4096, MindLang achieves ~4.5 TFLOPS peak on consumer WebGPU hardware. The 8×4 register-tiled shader with 128×64 workgroup output, bank-conflict-free shared memory, and vec4 vectorized loads delivers up to 4,451 GFLOPS: the advantage comes from AOT compilation with aggressive kernel optimization vs runtime shader generation.

With the Include Compile Time toggle enabled, the advantage grows further: MindLang's compile cost is ~50-80 ms (fetch pre-built WGSL + pipeline creation) vs ONNX RT's ~500-2,000 ms (model load + runtime WGSL generation).

Run the benchmark yourself →

Learn More