Skip to content

Benchmark suites · coming soon

Results anyone can check,
or nothing gets published.

Run standard kernel suites through the same optimizer and verifier the product uses, score every result against the hardware’s speed-of-light, and publish a proof page only when the measurement conditions hold.

Get started See it work

0 live · 3 coming soon · every feature below

What is a speed-of-light score?

A speed-of-light (SOL) score says how close a kernel runs to what the hardware can do. Kernalin computes the floor T_SOL as the larger of FLOPs ÷ peak FLOP/s and bytes moved ÷ peak memory bandwidth, from datasheet peaks, and reports T_SOL ÷ measured time as a percentage.

In three steps

Same optimizer, same verifier, public evidence.

Suites, SOL scores and proof pages are built and tested, and waiting for GPU verification. No suite result has been recorded yet, so this page explains the method and shows no scores.

01 / 03 · Run

Standard tasks, the everyday pipeline.

Suite runs don’t get a special harness. Each task goes through the same optimizer and verifier you use, so a suite result says something about the product, not a demo path.

rnx suite run

Suites

  • KernelBench-Verified MIT licence, pinned commit Coming soon
  • SOL-ExecBench results only; data never redistributed Coming soon
  • CPU mini suite pipeline check, never publishable Coming soon

Every run bundles

  • Raw logs and per-task verdicts Coming soon
  • Environment fingerprint, harness version Coming soon
  • Clock-lock and L2-flush evidence, SHA256SUMS Coming soon
The suites Kernalin runs, and what every run bundles.

02 / 03 · Score

Speedup is relative. Speed-of-light isn’t.

“5× faster” from a slow baseline can still be far from good. The SOL fraction says how much of the hardware’s limit a kernel reaches, and it will sit next to every optimizer speedup.

Speed-of-light · how close to the hardware
Coming soonGPU verification pending

The floor

TSOL = max( FLOPs ÷ peak FLOP/s , bytes ÷ peak DRAM bandwidth )

Work counted on the reference: FLOPs by torch.utils.flop_counter, bytes as compulsory traffic.

The score

SOL fraction = TSOL ÷ Tmeasured

0%"now at X% of speed-of-light"100%
A time under the floor is flagged ABOVE_SOL: the count or the kernel is wrong.
How the speed-of-light score is computed (from Kernalin's benchmark-suites documentation). No suite result has been recorded yet, so none is shown.

03 / 03 · Publish

A proof page, or a refusal.

Publishing is refused unless every condition holds. A result that can’t be checked doesn’t get a page.

Publish gate · proof page
  • Ran on a GPU Coming soon
  • Clocks locked, and held under load both sides of every measurement Coming soon
  • L2 flushed both sides of every measurement Coming soon
  • SOL from datasheet peaks, none above SOL Coming soon
  • A model did the optimizing scripted runs are pipeline checks only Coming soon
  • Public page with JSON and bundle download Coming soon
The conditions a run must meet before Kernalin will publish its proof page.

Everything in it

What benchmark suites includes

Live features are in the app today. Coming soon means built and tested, waiting for the next release. GPU verification pending means no result is published until it has run on GPUs.
  • Coming soonGPU verification pending

    Benchmark suites

    KernelBench-Verified, SOL-ExecBench and a built-in CPU mini suite. Every run is a bundle with raw logs, per-task verdicts, environment fingerprint, clock-lock and L2-flush evidence, harness version and checksums.

    Coming soon: Built; GPU verification is pending. No suite result has been recorded yet.

  • Coming soonGPU verification pending

    Speed-of-light score

    T_SOL = max(FLOPs ÷ peak FLOP/s, bytes ÷ peak bandwidth): how close a kernel is to what the hardware can do, from datasheet peaks.

    Coming soon: Built; GPU verification is pending.

  • Coming soonGPU verification pending

    Public proof pages

    A published run gets a public page with JSON and a bundle download. Publishing is refused unless it ran on a GPU with clocks locked and held under load, L2 flushed, datasheet peaks, and a model did the optimizing.

    Coming soon: Built; GPU verification is pending.

How it works

Step by step.

  1. 1

    Pick a suite

    KernelBench-Verified (MIT, pinned commit), SOL-ExecBench (NVIDIA evaluation licence: only results are published, never the data) or the built-in CPU mini suite.

  2. 2

    Run it through the product

    One optimizer run per task and seed, through the same optimize path and verifier as everyday use, with fixed seeds and budgets.

  3. 3

    Score against speed-of-light

    Every speedup gets a SOL fraction and SOL-ExecBench’s anchored score. A time under the floor is flagged ABOVE_SOL.

  4. 4

    Bundle the evidence

    Raw logs, per-task verdicts, environment fingerprint, clock-lock and L2-flush evidence, harness version and SHA256SUMS.

  5. 5

    Publish, if it qualifies

    A public proof page with JSON and a bundle download, only when the publish gate passes.

Honest limits

What it doesn’t do (yet).

  • No suite result has been recorded yet. When one is, it will appear here with its proof page.
  • The CPU mini suite is a pipeline check and can never be published.
  • NVIDIA’s leaderboard derives T_SOL differently (SOLAR), so scores agree in kind, not to the digit.

FAQ

Questions, answered directly

Has Kernalin published KernelBench or speed-of-light results?

No. Benchmark suites (KernelBench-Verified, SOL-ExecBench), the speed-of-light score and public proof pages are built and coming soon, but no suite result has been recorded yet, so none is cited. Proof pages will refuse to publish unless the run used a GPU with locked clocks and a flushed L2.

Related

Point Kernalin at your slowest kernel.

Sign-up is open and self-serve. Connect GitHub or upload a file, and get a profile, a benchmark and verified rewrites, without changing how you ship.

Get started Talk to us