Skip to content

Conversions and runtimes

Convert to Triton. Try TensorRT.
Keep only what stays correct.

Kernalin converts common PyTorch ops to Triton kernels and benchmarks TensorRT next to eager and torch.compile. Every converted kernel and every runtime is held to the same correctness check.

Get started See it work

3 live · 1 coming soon · every feature below

What is PyTorch to Triton conversion?

PyTorch to Triton conversion replaces PyTorch ops with generated Triton GPU kernels. Kernalin auto-detects 11 elementwise and softmax ops, generates the Triton kernels, and runs each through its correctness gate; on an H100 the converted gelu and silu_mul kernels matched PyTorch to within 4.5e-8 and 2.2e-8.

In three steps

Faster runtimes are only faster if they are right.

01 / 03 · Convert

Eleven ops to Triton, each one checked.

Conversion targets the ops that are easy to get subtly wrong: activations, fused pairs and a row softmax. Each generated kernel has to match PyTorch before it counts.

Convert · PyTorch → Triton
  • relu correctness gate on a GPU runner converts
  • gelu H100: max abs error 4.5e-8 converts
  • silu correctness gate on a GPU runner converts
  • sigmoid correctness gate on a GPU runner converts
  • tanh correctness gate on a GPU runner converts
  • abs correctness gate on a GPU runner converts
  • add correctness gate on a GPU runner converts
  • mul correctness gate on a GPU runner converts
  • silu_mul (fused) H100: max abs error 2.2e-8 converts
  • add_relu (fused) correctness gate on a GPU runner converts
  • softmax (row) correctness gate on a GPU runner converts
The supported ops. The two error figures are from the H100 dry run, 27 September 2026.

02 / 03 · TensorRT

2× faster here. Rejected there.

On the H100, TensorRT fp16 ran a GELU+linear block 1.94–2.56× faster than eager, and its output matched. On a transformer block it was faster still, and its error failed the check.

TensorRT fp16 vs PyTorch eager fp16

Speedup over eager (×); a rejected result does not count

GELU + linear 1024×1024

TensorRT fp16 vs PyTorch eager fp16: GELU + linear 1024×1024
ItemBarValue
batch 1 1.94× correct
batch 8 2.18× correct
batch 32 2.56× correct

Transformer block, batch 1

TensorRT fp16 vs PyTorch eager fp16: Transformer block, batch 1
ItemBarValue
TensorRT fp16 max error 0.018–0.023 1.52× rejected
H100 dry run, 27 September 2026: medians of 30 timed runs, L2 flushed, clocks not locked.

03 / 03 · Precision · coming soon

Every precision, in one grid.

The TensorRT precision matrix builds an engine per precision and records build time, engine size, memory and per-layer fallbacks, verifying every cell against eager fp32. Failures are shown with the stage and node, never hidden.

It is built and awaiting GPU verification. Only cells we have actually recorded are filled in below.

TensorRT precision matrix
TensorRT precision matrix
precisionGELU+linearTransformer
FP32 ——
TF32 ——
FP16 1.94–2.56× · okerror · rejected
BF16 ——
INT8 needs ModelOptneeds ModelOpt
FP8 needs ModelOptneeds ModelOpt
Filled cells are from the H100 dry run (27 September 2026, fp16 only). Other precisions have not been recorded, so they are empty.

Everything in it

What conversions 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.
  • Live

    PyTorch → Triton conversion

    Eleven ops are auto-detected and converted: relu, gelu, silu, sigmoid, tanh, abs, add, mul, fused silu_mul, fused add_relu and row softmax. Every generated kernel runs through the correctness gate.

  • Live

    TensorRT in every benchmark

    Strongly typed TensorRT engines with TF32 off sit next to eager, torch.compile and ONNX Runtime, and are held to the same correctness check.

    Note: Needs a GPU runner.

  • Coming soonGPU verification pending

    TensorRT precision matrix

    FP32, TF32, FP16, BF16, INT8 and FP8 (NVFP4 on request) in one grid: build time, engine size, memory and per-layer fallbacks, each cell verified against eager fp32, failures shown, plus adoption advice and a Triton config.pbtxt.

    Coming soon: Built; GPU verification is pending. INT8 and FP8 need NVIDIA ModelOpt on the runner.

  • Live

    Runtime plugins

    Runtimes are plugins with declared capabilities, and runner labels route each job to hardware that supports it.

How it works

Step by step.

  1. 1

    Detect convertible ops

    Kernalin finds the 11 supported ops in your PyTorch workload automatically.

  2. 2

    Generate Triton kernels

    Each op becomes a Triton kernel. Bare exp is deliberately not offered.

  3. 3

    Verify on a GPU runner

    Converted kernels go through the correctness gate against the PyTorch original.

  4. 4

    Benchmark the runtimes

    TensorRT engines (strongly typed, TF32 off) run next to eager, torch.compile and ONNX Runtime, with the same output check.

Honest limits

What it doesn’t do (yet).

  • Conversion covers 11 ops today, not arbitrary models.
  • Triton kernels and TensorRT need a GPU runner.
  • The TensorRT precision matrix (FP32 to FP8, adoption advice, Triton config.pbtxt) is coming soon and awaiting GPU verification; INT8 and FP8 need NVIDIA ModelOpt on the runner.

Recorded results

Numbers with a date on them.

Only figures from recorded runs, with their conditions.
Recorded results with date, context and source
ResultWhat was measured
1.94–2.56× TensorRT fp16 vs PyTorch eager fp16, GELU+linear 1024×1024, batch 1/8/32NVIDIA H100 80GB HBM3 (RunPod), median of 30 timed runs, L2 flushed, clocks not locked (boost characterized), labelled as-deployedSource: H100 dry run benchmark table ·
Rejected TensorRT fp16 was fastest on a transformer block at batch 1, but its max error (0.018–0.023) failed the correctness gate, so eager won among correct variantsNVIDIA H100 80GB HBM3 (RunPod); transformer block d=1024, 16 heads, FFN 4096, seq 512Source: H100 dry run ·
4.5e-8 Max absolute error of a PyTorch → Triton converted GELU kernel (silu_mul: 2.2e-8), both passing the correctness gateNVIDIA H100 80GB HBM3 (RunPod)Source: H100 dry run conversion check ·

FAQ

Questions, answered directly

Can Kernalin convert PyTorch to Triton?

Yes, for 11 ops: relu, gelu, silu, sigmoid, tanh, abs, add, mul, fused silu_mul, fused add_relu and row softmax. Every generated kernel runs through the correctness gate; on an H100 the converted gelu and silu_mul matched PyTorch to a max absolute error of 4.5e-8 and 2.2e-8.

Does Kernalin support TensorRT and FP8?

TensorRT runs in benchmarks today on GPU runners, held to the same correctness check as every runtime. A precision matrix across FP32, TF32, FP16, BF16, INT8 and FP8 is coming soon (GPU verification pending); INT8 and FP8 need NVIDIA ModelOpt on the runner.

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