Skip to content
Ecosystem

Built for the kernels
you actually run.

Kernalin meets your workloads where they live — native CUDA, Triton, PyTorch, and ONNX — and carries one verification verdict from your editor to your CI. No rewrite of how you already work.

Request early access Explore the platform
One engine, many surfaces

The stack you have, not the one you’d have to adopt.

Optimization only helps if it speaks your frameworks and lands in your pipeline. Kernalin ingests the four kernel formats that dominate GPU work, benchmarks against the runtimes teams actually deploy on, and gates every result through the tools your team already opens each day.
Coverage

Everything Kernalin connects to.

Frameworks it optimizes, runtimes it benchmarks against, and the developer surfaces it gates through — one map of the whole ecosystem.
CU
CUDA ●
C++ kernels (optimize: preview)
Tr
Triton ●
@triton.jit kernels
Py
PyTorch ●
Modules & subgraphs
ON
ONNX ●
Intake + benchmark
Te
TensorRT ●
Benchmark runtime
ON
ONNX Runtime ●
Benchmark runtime
Gi
GitHub ●
PR gate & Actions
VS
VS Code ●
Editor extension (preview)
● Available ● Preview
Frameworks

Four kernel formats, verified natively.

Each format is ingested with its real contract — shapes, dtypes, launch config — so the correctness gate and anti-cheat run on what you actually ship, not a simplified stand-in.
CU
Preview

CUDA

Native C++ kernels, compiled by the engine inside the sandbox and verified against your reference before any rewrite counts. CUDA C++ optimization is in preview.

Tr
Available

Triton

@triton.jit kernels ingested with their launch grid and meta-params, so shape sweeps and anti-cheat run on the exact configuration you ship.

Py
Available

PyTorch

Modules and subgraphs captured with their tensor contracts, so an optimized block is checked against the eager reference within dtype tolerance.

ON
Available

ONNX

An intake format and benchmark runtime: upload an exported model and time it across ONNX Runtime, TensorRT and PyTorch. Kernalin does not rewrite ONNX graphs.

Benchmark runtimes

Timed against what you deploy on.

A speedup that only holds on one runtime isn’t a speedup you can trust. Kernalin measures candidates against production inference runtimes under its statistically honest methodology.
Te
Available

TensorRT

Used as a benchmark runtime — candidates are timed against TensorRT engines under the same measurement and ROPE-verdict methodology as everything else, and a TensorRT engine whose output diverges is disqualified.

ON
Available

ONNX Runtime

A second independent benchmark runtime (CUDA provider), so a speedup claim isn’t hostage to a single execution provider’s quirks.

Developer surfaces

Gated where the work already happens.

The verdict shows up in your editor, your pull requests, and your pipeline — same engine behind each, so there’s never a discrepancy to reconcile.
Available

GitHub

A PR performance gate and Actions workflow that block regressions with an auditable metric-diff — the same verdict, posted where review already happens.

Preview

VS Code

The editor extension (preview, not yet on the Marketplace) surfaces optimizable functions and inline metrics, and hands work to the same engine the CLI and CI use.

Available

CI/CD

The rnx CLI runs in any pipeline — Jenkins, GitLab, Buildkite — so the gate travels with your build, not just one vendor.

No disagreements

One engine, every surface.

The editor, the CLI, and CI run the same contracts-first engine — so they never disagree about what a kernel is or whether it’s correct. The number you see in VS Code is the number that gates your PR is the number your pipeline ships.
See the developer tools How the engine works
Early access is open

Optimize the stack you already run.

Bring verified GPU optimization to CUDA, Triton, PyTorch, and ONNX — gated in the tools your team already uses.

Request early access Explore the platform