Skip to content

How it works

Profile. Rewrite. Verify.
Ship. Keep watching.

One loop, from a slow kernel to a merged, measured, cheaper one. Here is every step, what runs where, and what stays your decision.

Get started How it works

What is Kernalin?

Kernalin is a GPU kernel optimization platform: it profiles PyTorch, Triton, CUDA and ONNX workloads, uses AI to rewrite slow kernels, keeps a rewrite only when a verifier shows it matches the reference (within per-dtype tolerance) and is measurably faster, and ships it as a GitHub pull request guarded by a CI regression gate.

The loop

Seven steps, one of them yours.

Kernalin does the measuring, rewriting and proving. Merging stays a human decision, in the pull request you already review.
  1. 01 ConnectGitHub or upload
  2. 02 Profilewhere time goes
  3. 03 Benchmarkevery runtime
  4. 04 OptimizeAI rewrites
  5. 05 Verifycorrect, honest, faster
  6. 06 ShipPR + CI gate
  7. 07 Watchauto-sync, alerts

  1. 01 · step

    Connect

    Connect GitHub (or GitHub Enterprise Server) and link a workload file on a branch, or upload one: .py for PyTorch and Triton, .cu/.cuh for CUDA C++, .onnx, .pt/.pth, up to 100 MB. Uploads are scanned statically and never executed on intake. A workload exposes make_inputs() and run(), so Kernalin can time it and check its output.

    More on connect

  2. 02 · step

    Profile

    An op profile ranks where the time goes and an Amdahl what-if says what fixing each op is worth. Memory, warp-divergence and heatmap views explain why; Nsight Compute and torch.profiler output can be imported.

    More on profile

  3. 03 · step

    Benchmark

    The same workload across PyTorch eager, torch.compile, ONNX Runtime and TensorRT, in the precisions and batch sizes you choose. Every output is checked; every verdict is Bayesian.

    More on benchmark

  4. 04 · step

    Optimize

    Claude Opus gets the kernel, its profile and its benchmark, and proposes rewrites (3 by default, up to 8).

    More on optimize

  5. 05 · step

    Verify

    Each rewrite must match the reference through five correctness stages, pass the anti-cheat audit and win a speed verdict. Only those are kept; the rest are shown with their reasons.

    More on verify

  6. 06 · step

    Ship

    A kept rewrite opens a GitHub pull request with its audit. Your CI’s rnx-benchmark gate measures it again before anyone merges.

    More on ship

  7. 07 · step

    Watch

    Auto-sync profiles and benchmarks every new commit of a linked file. Schedules and the regression agent alert Slack, Teams, email or a webhook when something slows down.

    More on watch

What runs where

CPU sandbox, or your GPUs.

You can start without a GPU. When you need GPU numbers, attach a runner.

Kernalin’s CPU sandbox

  • Op profiles and benchmarks of PyTorch workloads (eager, torch.compile, ONNX Runtime on CPU)
  • AI rewrites of PyTorch kernels, fully verified
  • Imports of profiles captured elsewhere
  • No network, read-only root, unprivileged user

Your GPU runner

  • GPU timings, TensorRT, Triton and CUDA C++ rewrites
  • Hardware counters, where the host allows them
  • Attach with the runner protocol (RunPod setup script included); capability labels route jobs
  • The same sandbox self-test on every runner

Every area

Go deeper on any step.

FAQ

Questions, answered directly

What is Kernalin?

Kernalin is a GPU kernel optimization platform. It profiles PyTorch, Triton, CUDA and ONNX workloads, uses AI (Claude) to rewrite slow kernels, keeps a rewrite only when a verifier shows it matches the reference (within per-dtype tolerance) and is measurably faster, and ships it as a GitHub pull request guarded by a CI performance regression gate.

How is Kernalin different from asking an AI assistant to optimize a kernel?

An assistant gives you code and a claim. Kernalin runs every rewrite through a five-stage correctness gate, an anti-cheat audit and a Bayesian speed verdict in a sandbox, keeps only rewrites that pass, shows you every rejected one, and then re-checks the change in CI. You merge evidence, not a claim.

Which frameworks and file types does Kernalin support?

Uploads and linked files can be PyTorch or Triton (.py), CUDA C++ (.cu, .cuh), ONNX (.onnx) and PyTorch checkpoints (.pt, .pth), up to 100 MB. Benchmarks cover PyTorch eager, torch.compile, ONNX Runtime and TensorRT in fp32, fp16, bf16 and fp64.

Do I need a GPU to try it?

No. Profiling, benchmarking and AI rewrites of PyTorch kernels run in Kernalin’s CPU sandbox. Triton and CUDA C++ rewrites, TensorRT, GPU timings and hardware counters need a GPU runner, which you can attach yourself (a RunPod setup script is included).

Why are some of your published numbers from a CPU sandbox?

Because those are the runs we recorded end to end, and we only publish recorded numbers with their date and context. The H100 numbers come from a dry run on 27 September 2026. Features still waiting for GPU verification never show results on this site.

How much does Kernalin cost?

Pricing is not finalized. Sign-up is open and self-serve; teams and enterprises talk to us about terms. There are no published prices yet.

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