A Tiny Compiler Startup Is Trying to Free AI Code From Nvidia's Grip

Nvidia has sold the world's most sought-after AI chips for more than a decade, and the reason is a programming language called CUDA. A small startup called Spectral Compute is trying to compile that CUDA code so it runs on competitors' chips instead, going after the compiler layer that has kept the world's AI software on Nvidia hardware.

The lock-in is the toolchain, not the chip. CUDA is both a programming language and the compiler system that turns CUDA code into something a GPU can run. When a research lab trains a model in PyTorch or a hospital builds a vision system for CT scans, the heavy lifting underneath is CUDA code targeting Nvidia hardware. AMD, Intel, and a handful of AI accelerator startups sell faster or cheaper chips, but rewriting CUDA code for a different architecture is expensive and slow, which is why most production AI still runs on Nvidia.

Spectral Compute was founded in 2018 by four engineers with 60 years of combined HPC optimization experience. Their product, SCALE, is a drop-in replacement for NVCC, Nvidia's CUDA compiler. SCALE is built on Clang/LLVM, the same open-source compiler infrastructure that powers most non-Nvidia language toolchains, and accepts standard CUDA source code as input. The first target was AMD GPUs; support is now broadening to other AI accelerators. Spectral also still supports Nvidia GPUs on the theory that Nvidia leaves software-side performance on the table to sell more hardware.

"CUDA represents roughly 80% of HPC code in the wild," Spectral's head of growth, Giulio Malitesta, told HPCwire at ISC 2026 in Hamburg. That figure is an internal estimate, not an independent measurement, but it captures the company's thesis: if most scientific and AI code is written for one vendor's compiler, the only durable way to break the moat is to attack the compiler itself.

Spectral is not the only one trying. AMD's HIPIFY translates CUDA source code to HIP, AMD's C++ extension for the ROCm software stack. Intel-origin SYCLomatic does the same for SYCL, the Khronos-standard C++ framework for heterogeneous computing. ZLUDA, a separate project, takes a different approach: it just-in-time translates compiled CUDA binaries to run on AMD hardware without source changes. HIPIFY and SYCLomatic work at the source level; ZLUDA works at the binary level.

Spectral argues its mechanism is closer to the compiler itself. By front-ending LLVM and accepting standard CUDA as input, SCALE can target any backend LLVM supports, which the company says makes it more durable than a translator that has to keep up with each new CUDA release. A public validation repository, a documented toolchain site, and an ACM peer-reviewed paper on cross-vendor GPU programming anchor the reproducibility claim.

The skepticism in HPCwire's "Will It Succeed?" headline is warranted. CUDA's moat has held for more than a decade. AMD's HIP and Intel's oneAPI/SYCL have existed for years with limited developer uptake. Nvidia itself ships CUDA updates regularly to keep the toolchain ahead of any compatibility layer. The r/Amd discussion thread on SCALE shows genuine interest and a familiar refrain: waiting on real benchmarks against native CUDA performance.

What is new is that four efforts are visible at once, with different mechanisms and different backers. If any of them, Spectral's compiler-level attack, AMD's source translator, Intel's SYCL pipeline, or ZLUDA's JIT layer, gains enough developer mindshare to make porting CUDA code to alternative hardware routine rather than heroic, the cost of switching away from Nvidia drops sharply. Cheaper AI compute, more hardware competition, and less single-vendor risk for cloud providers and enterprises running large training and inference workloads would follow.

The next test is whether SCALE can match native CUDA performance on production kernels, the small performance-critical loops that dominate real workloads, without forcing developers to rewrite code. Spectral says broader accelerator support is on the way and the team has not yet published head-to-head numbers. A working 80% of native performance on a real model, on hardware that costs less than the equivalent Nvidia box, would be the result that finally loosens the moat. Until then, the compiler is still the wall.