ZLUDA on Windows: Run CUDA Apps on AMD GPUs (Guide + Limits)
A guide to the ZLUDA-based Windows project that runs unmodified CUDA apps on AMD GPUs, with install steps, benchmarks, and known limitations.
What is ZLUDA and why does it matter for AMD GPU owners?
ZLUDA is a translation layer that lets unmodified CUDA applications run on non-Nvidia GPUs. It sits between a CUDA app and the underlying hardware, intercepting CUDA calls and redirecting them to AMD’s equivalent libraries and runtime, so the app runs on an AMD GPU without being rewritten or recompiled. This matters because nearly all of the AI software ecosystem, from training scripts to inference tools, is built on CUDA, and CUDA is tied to Nvidia hardware. Anyone with an AMD card has historically been locked out of a huge share of that software, regardless of how capable the GPU itself is. ZLUDA is one of the longest-running attempts to break that lock without waiting for every developer to add AMD support.
A new project, a GitHub repo called “CUDA for AMD on Windows” built by a developer going by “speed,” packages ZLUDA together with AMD’s HIP SDK and ROCm into a single, more reproducible Windows setup. It doesn’t replace ZLUDA. It wraps it.
How does ZLUDA actually make a CUDA app run on AMD hardware?
Picture a small stack of layers, each one handing work down to the next:
- The top layer is the original CUDA Windows application, written for Nvidia and completely unaware of anything else happening underneath it.
- Below that sits ZLUDA, which behaves like CUDA from the app’s point of view. When the app makes a call to a CUDA math library, ZLUDA maps it to the AMD equivalent: cuBLAS calls get mapped to rocBLAS, cuSPARSE calls get mapped to rocSPARSE, and so on.
- Those translated calls then drop down into HIP and ROCm, AMD’s own GPU compute runtime.
- At the bottom, the AMD GPU executes the actual work.
Other agents start typing. Remy starts asking.
Scoping, trade-offs, edge cases — the real work. Before a line of code.
From the app’s perspective, none of this translation is visible. It thinks it’s talking to Nvidia CUDA the entire time. That illusion is the entire point, and it’s also where the project’s name comes from: in Polish, “zluda” translates roughly to delusion or illusion, something that looks real but isn’t quite what it claims to be.
What has this new Windows packaging project actually achieved?
The core contribution isn’t a new translation technique. It’s an installer and setup pipeline that automates a process which has traditionally been fragile and manual on Windows. ZLUDA has generally been more stable and more actively developed on Linux, so getting a clean, repeatable path working on Windows is a meaningfully harder problem, and that’s the gap this project is targeting.
The one performance data point that exists so far comes from the project author’s own testing: a reinforcement learning training workload run through this ZLUDA-based Windows setup landed at roughly 3% slower than running the same workload natively. That’s a single test on a single card with a single workload, not a broad benchmark suite, but it’s a promising signal that the translation overhead can be small in at least some real cases.
How do you set it up?
The setup follows five steps:
- Install the AMD driver and the AMD HIP SDK. This is the AMD side of the bridge, and version 6.4 is the one the project has been tested against.
- Clone the GitHub repo.
- Run the installer script. This script detects your GPU, downloads ZLUDA and a compatible version of PyTorch, verifies file hashes, and runs a built-in check to confirm CUDA calls are working against the AMD stack.
- Run the diagnostic scripts (referred to as the “doctor” and GPU scan tools) to confirm the system is correctly detected before trusting it with real workloads.
- Point the launcher at your CUDA application. The launcher stages the ZLUDA files alongside the app and runs it.
The exact commands live in the project’s GitHub repo. Because this is early, actively-changing software, checking the repo directly before running anything is worth doing rather than relying on a static command list.
Is ZLUDA on Windows actually worth using right now?
For experimentation, yes. For anything you depend on, not yet. The honest limitations are significant:
- Only one GPU, the AMD RX 9060 XT, has actually been validated by the project’s author. Every other AMD card is untested, not confirmed broken, but not confirmed working either.
- The stable Windows HIP SDK lacks cuDNN support, which means convolution-heavy models, including a lot of image processing and computer vision workloads, may simply fail to run.
- ZLUDA is not a complete reimplementation of CUDA. Whether a given app works depends entirely on which CUDA features it uses.
- More advanced CUDA components, like NCCL for multi-GPU communication, TensorRT, and custom CUDA extensions, likely won’t run at all.
- The repo itself is small and new, maintained by essentially one contributor.
That combination makes this a genuinely interesting thing to test on a spare machine or a side project, and a reasonable thing to contribute to if you have the skills. It is not something to build a production pipeline around today.
Why does ZLUDA keep almost dying and coming back?
The project’s history explains why it feels fragile even as it keeps producing real results. ZLUDA started in 2020 as an effort to run CUDA applications on Intel GPUs. AMD later funded its development for a couple of years to get it working on Radeon cards instead. In 2024, AMD withdrew that funding, and shortly afterward, according to the project’s account, AMD’s legal team asked for the AMD-funded code to be taken down. The developer rebuilt the project from an earlier, pre-AMD codebase to keep it clean of any disputed code. It picked up a different sponsor for a period, but as of the most recent release, that funding has also ended, leaving ZLUDA as a solo, spare-time project again.
That back-and-forth, corporate interest, corporate withdrawal, legal pressure, and a return to one person working alone, is the pattern that makes ZLUDA both exciting and precarious. The technical idea keeps proving itself workable. The support behind it keeps disappearing.
What does this mean for the future of CUDA on non-Nvidia hardware?
Projects like this one don’t need to be perfect to matter. They demonstrate that the core idea, running unmodified CUDA software on AMD silicon, is technically achievable and not just a theoretical exercise. Even a rough, single-contributor Windows installer with known gaps is a working proof that GPU vendor lock-in isn’t an unbreakable law of software. Whether this specific project becomes the long-term answer or gets superseded by something else built on the same ZLUDA foundation, the direction is what’s worth watching: a future where the brand on your graphics card doesn’t fully determine which AI software you’re allowed to run.
Frequently Asked Questions
What is ZLUDA in simple terms?
ZLUDA is software that translates CUDA calls, the instructions Nvidia GPU software normally sends, into equivalent calls that AMD GPUs can execute. It lets CUDA applications run on AMD hardware without being rewritten.
Does ZLUDA work on all AMD GPUs?
Not confirmed. In the Windows packaging project covered here, only the RX 9060 XT has actually been tested and validated by the developer. Other AMD cards may work but haven’t been verified.
Is this project stable enough for real work?
No. It’s described as early, experimental software with a single-contributor codebase, missing cuDNN support in the stable HIP SDK, and no support yet for features like NCCL, TensorRT, or many custom CUDA extensions. It’s suited to testing and experimentation, not production workloads.
How much slower is CUDA-on-AMD via ZLUDA compared to native Nvidia?
The only reported figure comes from a single reinforcement learning training benchmark run by the project author, which showed about a 3% slowdown compared to native execution. That’s one workload on one GPU, not a general benchmark.
Why is ZLUDA’s development history relevant?
ZLUDA has been funded and defunded multiple times, first as an Intel-focused project, then AMD-funded, then rebuilt after AMD withdrew support and reportedly requested code removal. It currently runs without corporate sponsorship, which affects how quickly it can be developed and how much support users can expect.