Skip to content
For LLM inference teams

Faster tokens.
None of them wrong.

Attention, RoPE, and KV-append are exactly the kernels where a fast rewrite can be silently, structurally wrong — and a demo-case test will never catch it. Kernalin optimizes your serving path and proves each speedup holds before it reaches production.

✓ CUDA · Triton · PyTorch · ONNX ✓ Verified before it counts
kernalin · blind-spot demo auto
Kernel under test ATTENTION_TILE flash_attn_fwd.cu

Injected bug: max never subtracted from the exponent

A single demo-case probe

how most tools check
PASS
output matches on the demo case

With kv_len = 1, softmax over one element is exactly 1.0 — the output is v₀ regardless of the entire score path.

Kernalin · structural verification

how we check
REFUTED
ptx-symbolic · bounded-recurrence

A structural check sees the missing subtraction immediately — it doesn't need an input that happens to trigger the overflow.

Demo probe passes
0 / 14 bugs
Kernalin refutes
14 / 14 bugs
Where it hurts

Why LLM kernels are the dangerous ones to optimize

01

The bug hides at position 0

A single decode probe runs at kv_len=1 with an empty cache — where softmax is 1.0 and a rotation is the identity. Whole classes of attention and RoPE bugs are invisible there.

02

Corruption surfaces far from the cause

A stray KV-cache write self-heals for a step, then shows up as garbage tokens many steps later — or in another head entirely. Impossible to bisect by eye.

03

A wrong kernel is worse than a slow one

Ship a fast-but-wrong attention kernel and you degrade every response quietly. No stack trace, no crash — just worse output at scale.

What you get

Speed on the decode path, proven safe.

Kernalin targets the kernels that actually move tokens-per-second, and gates every candidate through the correctness gate on adversarial shapes. Structural PTX verification of these ops is in research preview for megakernels.

Attention & flash-decode tuning

Online-softmax tiling, KV-cache layout, and fusion across the decode step — measured on your shapes, not a demo case.

Structural verification of ATTENTION, ROPE, KV_APPEND (research preview)

For megakernels, the three ops a pos-0 gate cannot reach are checked by PTX-symbolic methods that catch the bug classes a pos-0 probe misses: 5 of 6, 3 of 5 and 3 of 5.

Bayesian benchmark on your GPUs

A verdict over a bootstrap posterior vs. your hardware’s noise floor — so a real tokens/sec win is never confused with jitter.

Lower cost per token

Faster verified kernels mean fewer GPUs for the same throughput — the savings flow straight to cost-per-token.

The statistically honest verdict

A tokens/sec win you can take to production.

The same −2% headline can be a real win or pure noise. Kernalin decides with a Bayesian ROPE verdict against your GPU’s own noise floor — credibly faster, equivalent, or regressed. Never a lucky run dressed up as a speedup.
kernalin · rope verdict 0 resamples
Headline reading
−32.7%
Honest verdict
Credibly faster
0.5× 0.75× 1.0× baseline 1.3×

99.4% of the posterior mass sits below the ROPE — convincingly beyond what this GPU's jitter could fake. This one earns the number.

5
of 6 attention bug classes a pos-0 gate misses — caught here
3
LLM ops verified structurally: attention, RoPE, KV-append
14
known-bad PTX test fixtures — all refuted, none passes
Tol.
outputs held within your dtype’s tolerance, or the candidate is rejected

Ship faster tokens, not faster bugs.

Bring verification-first optimization to your LLM serving stack. Join the early-access program.