Specify
A mathematical specification (PyTorch or JAX) of what the model computes
Kernels at the speed of light,
on any chip.
Describe what your model computes and we'll search for the fast implementation on each chip and formally prove the winner computes exactly what you asked for.
Search
Architecture-aware candidates generated and ranked automatically.
Prove
The fastest kernel with a formal proof that it's correct
Why kernels stay hard
The fastest kernel is specific to the chip. Your model should't have to be
Every high-performance kernel is shaped by a given chip's instructions, memory system and execution model, which is why we treat the math as fixed and the implementation as a search problem, not a compiler problem, so that every target gets it own kernel without anyone having to write it.
Memory hierarchy
We model access patterns, placement, caching and the cost of moving data through the chip.
Execution topology
We account for the way that different instructions, lanes, warp, cores and synchronization behaves on the chip.
Measured hardware profile
We run hundreds of millions of tests on each new chip to ensure that our hardware model is accurate to the chip.
How it worksSearch the implementations, while
Search the implementations, while
preserving the calculation.
With traditional compiler passes, you improve a program while keeping its structure intact, while we can search for a new program that performs the same calculation more efficiently on a specific target.
Specify the calculation
We start with the mathematical operation the workload needs, expressed as a clear reference rather than a hand-tuned implementation.
Explore equivalent programs
We generate candidates across algebraic rewrites, fusion, tiling, loop order, memory placement and execution schedule.
Prune, model and measure
We eliminate poor candidates early, rank the survivors against the target architecture and benchmark the most promising kernels.
Prove before production
We compare the optimized kernel with its specification, reject semantic errors and return concrete counterexamples when a proof fails.
Beyond autotuning
Don't benchmark billions of possibilities, make the search intelligent.
A modern kernel can have billions of valid-looking implementations, but compiling and benchmarking every one would make optimization its own compute problem.
Prune obvious losses
Our cost model discards candidates that can't win before they are ever built.
Propose what compiler's wont
Agent and learned search suggests candidate kernels that a rule-based compiler would never try.
Measure only the finalists
We only measure the most promising candidates on real hardware, calibrate to each chip.
Correctness built in
A test checks the inputs you thought of, a proof covers every input.
Having a faster kernel only matters if it's still computing the right thing, which is why we compare every optimized kernel symbolically against its reference across every input it accepts, so that if it's wrong on any inputs, it'll never reach production.
Workload-specific
Optimize the operations that make your model yours
We optimize the operations your model actually runs in production, using its real tensor shapes, precision and deployment hardware.
Attention
Forward and backward kernels specialized for your sequence lengths, head sizes, masking, and precision, including variants you invented.
Linear algebra
Optimized matrix operations tuned to your exact shapes and data types, from training to deployment.
Normalization & reductions
Fuse memory-bound operations and choose schedules that reduce traffic and synchronization overhead.
Novel operators
Give new architectures a path from readable reference code to hardware-specific implementation.
How close to the speed of light could your model run?
Every model runs on its kernels and if you tell us what you're training, we'll show you how much faster it can go on the hardware you have.