Performance

Benchmarks

Each number says how it was measured and links to its record. The WebGPU benchmark runs on your own GPU.
Measured runs as bars, with a level line settling on the reference.

How to read the labels

Measured
A recorded run, with its method and raw record in a public repository.
Measured on your GPU
Runs in this browser tab. The number is your measurement, not ours.
Reported
Measured on the commercial runtime. Cited in public docs; the raw record is not public.

Determinant

A deterministic int8 GEMM

MIND's int8 GEMM is byte-identical by construction, so identical inputs reproduce identical bits run to run, a property the vendor libraries structurally lack. It is also faster than the reference it is measured against.

Measured · CPU

2.0×

MIND int8 against single-core OpenBLAS f32 on commodity x86, 1024³, byte-exact. The shipped CPU path.

MIND int82.0×
OpenBLAS f32baseline
Relative speed, single pinned core, 1024³.

Source: bench/RESULTS-int8-2026-06-08.md

Reported · commercial runtime

1.28×

GPU int8 against cuBLAS int8 on an Ampere-class GPU, byte-exact. This path runs in the commercial mind-runtime.

MIND int8 GPU1.28×
cuBLAS int8baseline
Relative speed, Ampere-class GPU.

Source: docs/optimization-frontier.md

Why the bits repeat

  1. Exact-integer accumulation

    Products sum in integers, so the result does not depend on the order the hardware adds them in.

  2. Fixed tiling

    The blocking is fixed at compile time, so every run walks the matrices the same way.

  3. No atomics

    No atomic adds race to a shared total, so there is no scheduling-dependent rounding.

Three runs of the int8 GEMM write the same output bytes, and each run matches run 1.run 1refrun 2= 1run 3= 1
Same inputs, fixed blocking, integer sums: every run writes the same output bytes.
  • CPU path: shippedmeasured on commodity x86
  • GPU path: commercialMIND-Runtime
  • GPU-to-GPU byte identity: plannedon the roadmap

Across the stack

Compiler, format and protocol

Smaller benchmarks across the stack. Each card opens its full table and method.

Measured on your GPU

Your GPU

A register-tiled WGSL GEMM shader and ONNX Runtime Web's WebGPU backend, same operation, same GPU.

  • 1024, 2048 and 4096 square f32 matrices
  • Dispatch time, GFLOPS and optional compile overhead
  • Needs a browser with WebGPU (Chrome or Edge 113+)
Source: your own runRun the benchmark
Measured

12.4×

Fewer bytes: the same reference IR is 90 B as mic@3 binary and 1,117 B as JSON.

mic@3 binary90 B
JSON1,117 B
Bytes for the same reference IR.
  • mic@2: 5.6× fewer tokens than JSON (cl100k_base; 10.3× by the len/4 heuristic)
  • mic@1 is the canonical text form; mic@2 is a demoted legacy lineage kept for token efficiency
Measured

4.3×

Fewer tokens than JSON-RPC for an agent session: 58 against 251.

MAP tokens58
JSON-RPC tokens251
MAP bytes234
JSON-RPC bytes1,004
One agent session, tokens and bytes on the wire.
  • 234 bytes on the wire against 1,004 (77% smaller)
Methodology and sources

Determinant, CPU. MIND int8 VNNI GEMM at 1024³ on one pinned physical core, median of 64 runs, against a single-core OpenBLAS f32 reference. The byte-identity gate passed on every configuration. The best configuration recorded 2.02×, rounded to 2.0× above.

Determinant, GPU. The int8 tensor-core kernel runs in the commercial mind-runtime. The 1.28× figure is cited in the public optimization notes; its raw record is not public, which is why it carries the Reported label. Cross-device byte identity across GPU substrates is not part of the public gate.

Compiler frontend. In-process Criterion.rs timings of parse, typecheck and IR lowering. They do not include binary emission. Earlier versions of this page quoted compile-time ratios against other frameworks; the benchmark record classifies those as cross-harness observations, not tier-matched speedups, so they are not repeated here.

MIC and MAP. Byte and token counts for one 6-node MLP IR reference and one agent session. Token counts use the cl100k_base tokenizer unless marked as the len/4 heuristic.

Compiler benchmarks reproduce from source. Results vary by hardware.

A deterministic int8 matrix multiply drawn as a cube: rows of A and columns of B meet tile by tile in one fixed order, and the finished output C carries a byte-exact seal.

Reproduce the numbers.

The reproduction guide lists the exact commands, inputs and environments behind each benchmark.