RESOLVE: Language-Agnostic Validation of GPU Kernels Through Testing, Reduction, and Proof
AuthorsAshkan Vedadi Gargary, Guido Martínez, Sebastian Burckhardt, Gabriel Ebner, Abhinav Jangda, Madan Musuvathi, Tyler Sorensen
AffiliationsUniversity of California, Riverside, Riverside, California, USA · Math, Inc., New York City, New York, USA · Microsoft Research, Redmond, Washington, USA
Resources
RESOLVE makes AI-written GPU kernels safer by combining race-finding tests with formal proofs that optimized code still computes the right result.
Key results
Breadth evaluation set used for determinism and validation analysis.
Faults detected out of 143 runnable mutated kernels.
Maximum speedup over the PyTorch implementation.
Repairs changed performance by less than this on three of four cases.
What the paper found
RESOLVE is a language-agnostic pipeline for validating AI-generated NVIDIA GPU kernels without relying on fragile numeric tolerances. It first uses NVBit binary instrumentation to perturb scheduling-relevant memory operations and expose schedule-dependent nondeterminism; it then uses agents, including GitHub Copilot workflows with GPT-5.6 and Claude Opus 5, to rewrite candidate and reference kernels into reduced-concurrency versions that must remain bitwise identical on tested inputs. Finally, those reductions are translated into Kuiper and verified with F*/Pulse proofs against a shared algebraic specification over real arithmetic, allowing valid floating-point reorderings even when outputs differ bitwise. On 100 KernelBench-derived candidates, 15 were classified immediately as deterministic and bitwise identical, while 14 requiring the full workflow produced 11 formally verified results. A mutation study caught 92 of 143 synchronization faults. RESOLVE also validated fused MLP implementations in Triton, Gluon, and NVIDIA CUTLASS, including kernels that ran up to 2.5× faster than the PyTorch implementation. Testing three production-style mega-kernels uncovered four previously unreported issues, including two clear bugs; agent repairs changed performance by less than 2% on three of four cases. The approach therefore separates concurrency evidence from functional proof, extending rigorous validation to optimized kernels whose asynchronous pipelines, tensor-core operations, and source languages exceed existing verifier coverage, while exposing limitations around intra-warp races, unsupported Kuiper features, and approximating functions.
Original abstract
AI systems can now write and optimize production GPU kernels, but validating them remains an important challenge. Evaluating the kernel on a few random inputs and checking that its outputs match a trusted reference kernel within numeric tolerances is not sufficient: races can cause nondeterministic behavior that fails to manifest in tests, and numeric tolerances can hide bugs and cause false positives even after extensive calibration. To address this challenge, we present RESOLVE, which combines testing and formal verification to build a comprehensive kernel validation pipeline. It operates in three steps: First, it tests for nondeterminism using binary instrumentation that perturbs execution timing to expose races. Second, an agent rewrites the candidate and reference kernels to obtain "reduced-concurrency" versions that are simpler to analyze but still produce bitwise-identical outputs in all tests. Third, the reduced kernels are formally analyzed in the F*/Pulse framework and prove that they perform the same computation on real numbers. This sidesteps the need for numeric tolerances. We show that RESOLVE can validate a broad selection of kernels using KernelBench, and prove equivalence across fused GEMMs in three state-of-the-art frameworks and languages: CUTLASS, Triton, and Gluon. It also analyzes mega-kernels, notoriously difficult to validate, and finds four previously unreported issues, including two clear bugs. We show that agents can use RESOLVE to repair the issues, with minimal performance impact, highlighting that agents can optimize aggressively when they can rigorously check their results.
Read the original paperMore in AI Hardware
Browse all 34 papers →AI as a Compiler: Compiling Triton kernels without the Triton compiler
François Costa, Charly Castes, Thomas Bourgeat, Azalia Mirhoseini
An LLM learns to replace parts of the GPU compiler stack by translating Triton code directly into fast, verified PTX kernels.
Purlin: Separating Orchestration from the Datapath of Collectives
Osayamen Jonathan Aimuyo, Swapnil Gandhi, Christos Kozyrakis
Purlin makes GPU collective communication more modular and faster, improving large-scale LLM and diffusion inference across modern hardware.
Coherent error threshold for quantum LDPC codes
Zhengyi Han, Yuanchen Zhao, Yijia Xu, Yixu Wang, Zi-Wen Liu
This work shows that quantum LDPC codes can still reliably correct coherent errors below a universal noise threshold, strengthening the foundations of scalable fault-tolerant quantum computers.