Codex-driven QR kernel search reached 232x baseline speedup after 1,500 contest submissions
- In GPU Mode's compact-Householder QR contest, the author placed 12th of 183 participants with a 232x speedup over the baseline solution.
- The task required batched square FP32 CUDA matrices to return the compact representation used by
torch.geqrf, while correctness checks reconstructed Q and tested $A≈QR$, $Q⊤Q≈I$, and $Q⊤A≈R$. - GPU Mode's popcorn CLI let agents test, benchmark, and submit directly, and the checker returned per-shape timing feedback plus an overall geometric-mean score.
- The author made more than 1,500 submissions during the 14-day contest, using the feedback loop to iterate on the kernel.
- The leaderboard measured geometric-mean runtime across matrix shapes and conditioning cases, including batched square matrices up to 4096 x 4096; internal FP16, FP8, and NVFP4 were allowed, but outputs still had to pass FP32-style QR checks.
Hacker News opinions
I gave DeepSeek v4 a semi-abandoned video codec with a verifier, compiler profiler, and VTune. In a few hours it wrote SSE and AVX paths that nearly doubled single-core performance, then began a CUDA version guided by Nsight. With constraints and self-verification, I can leave this sort of work on autopilot.
I tried DeepSeek-V4-Flash on a FlashAttention optimization job. It took 1 to 2 hours and cost about $0.20, which makes well-defined constrained optimization work look ready for agent handoff.
I use the same benchmark, profile, verify, research, improve loop. The tight feedback cycle is the whole point.
I used Claude to compare C# protobuf with its C++ version after finding a dotnet gRPC uint32 streaming path was CPU-bound. It found cheap optimizations that C++ and Rust had but C# lacked, and the more popular Tokio/Prost library also missed this particular one.
I have had similar results decompiling old video game ROMs. Give the model a correctness check and a loop, and it can be surprisingly effective.
I got real-time 4K 10-bit HEVC to 1080p SDR AVC transcoding on a Raspberry Pi 4 with Opus 5 and Fable 5 writing NEON kernels. Fusing memory-moving and conversion steps mattered, though I had to steer the model a lot before it worked.
My Rust JSONLogic evaluator had thousands of tests and a benchmark script. After basic optimization hints, the full benchmark fell from 1.6 seconds to 200 ms; three hand-written versions had taken three years, while the fourth took under a month.
A solo engineer doing this makes the apparent output around OpenAI and Anthropic look weak.
This submission was nowhere near the top result. Labs with thousands of engineers, far more tokens, and stronger private models would still have a large advantage.
GPU kernels and SIMD may be unusually well represented in training data, perhaps because they are useful to model researchers, or because language models fit this domain well.
On the poorly documented ESP32-P4 SIMD ISA, Opus 5 proposed an overcomplicated unrolling scheme for a simple biquad. But it derived operations and arguments from GCC, flagged likely pitfalls, and reasoned its way to working algorithms despite limited training material.
GPU kernels are heavily co-designed around abstractions such as asynchronous tile pipelines and MMA primitives. Once a model learns that language it can produce correct-looking work by construction, but choosing good abstractions still matters or it will generate spaghetti.