CUDA on AMD GPUs on Windows with ZLUDA

Video authored by the channel shown, not by IANIA; all rights belong to the creator. Transcript and summary generated automatically; the original-language content is preserved.

Original language: English

Original video: CUDA on AMD GPUs on Windows with ZLUDA · Channel: Fahd Mirza · 09:23 · Watch on YouTube

Topics: Software engineering with AI, AI infrastructure and hardware, Local and open-source models

Summary

The video introduces ZLUDA, a translation layer intended to let unmodified CUDA applications run on non-Nvidia GPUs, and focuses on a Windows package that combines ZLUDA with AMD HIP and ROCm. The presenter explains how the software stack works and outlines the setup process, while noting that the project has only been validated on an RX 9060 XT and remains experimental. Limitations include incomplete CUDA coverage and missing support for some workloads and tools, so it is not recommended for production use. Despite its fragile funding and development history, the presenter sees it as a promising glimpse of a future where GPU brand does not determine which software users can run.

Key points

ZLUDA translates CUDA calls so unmodified CUDA applications can run on non-Nvidia GPUs without rewriting or recompiling the app.
The featured GitHub project, CUDA for AMD on Windows, is a package built around official ZLUDA, AMD HIP, and ROCm; it is not ZLUDA itself.
The project author reported a small reinforcement-learning training run performing about 3% slower than a native single-card run.
The described stack maps CUDA libraries to AMD equivalents, then passes work through HIP and ROCm to the AMD GPU.
The setup involves installing the AMD driver and HIP SDK, cloning the repository, running its installer and diagnostics, and launching a CUDA application.
The author has validated only the RX 9060 XT; other AMD cards are candidates rather than confirmed working hardware.
The stable Windows HIP SDK lacks QDNN, which may cause convolution-heavy models and image workloads to fail.
ZLUDA does not fully implement CUDA, and advanced features such as TensorRT and some custom CUDA extensions may not work.
The presenter describes the project as experimental and suitable for experimentation, not production.
ZLUDA began in 2020, received AMD funding for a period, and is now described as a one-person weekend project.

Chapters

Start	Chapter	Summary
00:01	What ZLUDA does	The presenter introduces ZLUDA and explains how it aims to bridge CUDA applications and non-Nvidia GPUs.
02:45	The Windows project and its architecture	The video presents a Windows package combining ZLUDA with AMD HIP and ROCm, then explains how the software layers pass CUDA calls to an AMD GPU.
05:35	Setup steps and limitations	The presenter outlines the installation process and cautions that hardware validation and CUDA feature coverage are limited.
07:49	ZLUDA’s history and future	The video recounts ZLUDA’s funding and development history and frames the project as an experimental but promising effort.

Quotes

Zluda is a translation layer, you would say. — 01:39

This is not ZLUDA itself. — 03:19

I have laid it out as five clean steps, as you can see on your screen. — 05:35

It is not something to bet production on. — 07:49

that future is worth watching closely. — 09:23

Concepts and entities

ZLUDA, CUDA for AMD on Windows, speeds2, HIP, ROCm, RX 9060 XT, AMD, NVIDIA

Full transcript (original language)

00:01 There is a word you are going to hear a lot in the next few minutes. Zluda. And here is a fun part. In Polish, Zluda means delusion and illusion. Something that looks real but isn’t quite what it seems. And that is almost the perfect name for what we are looking at today. Because the whole idea sounds like a delusion. Running Nvidia’s CUDA applications on an AMD GPU on Windows.

00:32 Something that on paper is not supposed to work at all. But it does. So, let’s talk about it as how. Another fun fact is that fourth largest subscriber base on my channel is from Poland. Very grateful for all of those people from the beautiful Poland and also, of course, to all the members and rest of the viewership. So, this is Fahad Mirza and I welcome you to the channel. Recently, I also have started this free weekly AI newsletter, which you can subscribe at fahadmirza.substack.com.

01:07 So, here is a situation in one breath. Almost all of AI runs on CUDA. And CUDA only runs on Nvidia. That is Nvidia’s moat. If you own an AMD card, most of the CUDA world is simply closed to you. And we have discussed it a lot on the channel. You can have great hardware sitting right there and still be locked out. And that’s the problem people have been trying to walk around for years and years. And Zluda is one of the most

01:39 interesting attempt to do it so far. And now, if you have been to this channel before, you already know Zluda. I have covered it more than once and those videos did really well because this idea just captures the imagination. Zluda is a translation layer, you would say. It lets unmodified CUDA applications run on non-Nvidia GPUs. You don’t rewrite the app. You don’t recompile it. ZLUDA sits in the middle and does the translating for you. Today

02:13 we are looking at something new built on top of it. So, if this is your first time hearing about ZLUDA, stick around. It will all make sense in a minute. But, one thing I still believe ZLUDA is really going very slow. Anyway, look at this diagram. So, let’s build the mental model first, nice and simple. Picture three characters. On one side you have a CUDA app, and it only speaks Nvidia. On the other side, you have an AMD GPU, and it only speaks AMD. These

02:45 two cannot talk to each other. They are in different languages. ZLUDA is the live translator standing between them. The app speaks. ZLUDA translates on the fly, and the AMD card hears it in its own language. Nothing gets rewritten. The app has no idea it’s even talking to AMD. That’s the trick. That’s the whole magic in one plain picture. And this is the topic of this video. And this is what brings us to the actual project this video is all about. It’s a

03:19 GitHub repo called CUDA for AMD on Windows by a developer going by speeds2. Now, here is a key thing to understand, and I want to be really clear about it. This is not ZLUDA itself. This is a Windows package built around official ZLUDA plus AMD’s HIP and ROCm. Think of it as someone taking all the messy setup, the pieces that normally fight you on Windows, and wiring them together into one reproducible path.

03:50 The author tested it on real workload, a small reinforcement learning training run, and reported it landing about 3% slower than native one card one workload, but a genuinely promising result. And the reason that really appeals to me at least is Windows. ZLUDA has always been stronger on Linux. We have seen it firsthand in those videos. Getting this working cleanly on Windows is, I think, still the hard part, and that is exactly what this project is attempting to do. Now, the reason why I cover these

04:24 projects is that they are the hope. These are the first few steps, and my belief is that if not this project, someone else might pick up this cross and walk with it, and we might see something which would be valuable for the larger community. Let’s go one step deeper and see what’s actually happening under the hood. Because it’s not just one translator, it’s a little stack. At the top is your CUDA Windows app, written for Nvidia, completely unaware of any of this. Below it sits ZLUDA,

04:59 pretending to be CUDA. When the app calls a CUDA math library, ZLUDA maps that call across to the AMD equivalent. CUBLAS becomes ROCm BLAS, CU SPARS becomes ROCm SPARS. Those calls then go down into HIP and ROCm, which is AMD’s own GPU runtime. And finally, at the bottom, the AMD GPU does the real work. Each layer hands off to the next, and to the app at the top, it all just looks like CUDA. That layered hand off is the entire design.

05:35 Now, so how would you actually run this yourself? I have laid it out as five clean steps, as you can see on your screen. Step one, install the AMD driver and the AMD HIP SDK. That’s the AMD half of the bridge and version 6.4 is the tested one. Step Step two, clone the repo. Step three, run the installer script as you can see here. This is the one that does the heavy lifting, by the way. It detects your GPU, pulls down ZLUDA and libtorch, checks the hashes, and runs a built-in

06:09 CUDA check against your AMD stack. Step four, run the diagnostic script, the doctor, and the GPU scan, just to confirm everything is actually seen before you trust it. And step five, point the launcher at your CUDA app, and it stages its ZLUDA piece right next to it and runs it. That’s the full path, start to finish. Commands are all on the screen if you want to pause and copy them. I don’t have that, uh, you know, physical hardware to actually test it. I’m actually yearning to do it. So, if you are from AMD or, you know, if you want

06:42 to sponsor it, so that I could do a hands-on feel, we do reach out through the contact page from the homepage of channel, and I will be happy to do a hands-on video if that is what is, um, going to make sense. But, again, and there’s always a but. This is a part I never skip because I want you going in with these clear eyes. This is early experimental software, and it has real limits. Only one GPU has actually been validated by the author, the RX 9060 XT. Every other AMD card is a candidate, not a

07:18 promise. There is no QDNN in the stable Windows HIP SDK, which means convolution heavy models, a lot of image work, may just simply fail. ZLUDA is not a complete CUDA implementation, so coverage depends entirely on your specific workload. Advanced pieces like Nickel, TensorRT, and some custom CUDA extensions may not run at all and the repo itself is very tiny, one contributor, very new, very very new. So, this is a fantastic thing

07:49 to experiment with, maybe go and contribute. It is not something to bet production on. Both of those things are true at once. And I think the story behind ZLUDA actually tells you why all of this feels a bit fragile and a bit heroic at the same time. ZLUDA started back in 2020. That’s right, as a way to run CUDA on Intel GPUs. Then AMD quietly funded it for a couple of years to make it work on uh Radeon cards. Then in 2024, AMD

08:20 pulled the funding and shortly after their lawyers asked for the code to be taken down. So, the developer rebuilt it from scratch from his older pre-AMD code base to keep it clean. It found a sponsor for a while and now as of the version 6 release, even that funding is gone and it’s back to being one person’s weekend project. One developer developer but walking around a monopoly in his spare time. When you know that the name lands even harder, delusion. Except it keeps refusing to stay a delusion. But look,

08:50 I’m I have still very much um high hopes with ZLUDA or if not ZLUDA, maybe some other project. Maybe, you know, someone would sponsor um this or any other project to do that because you can already see the idea is not that um fantasy. I think this is quite workable. So, look, um this project won’t replace an Nvidia setup today, that’s for sure, and it’s not trying to be to be fair. But it’s a real working glimpse of a future where your GPU brand doesn’t decide what

09:23 software you’re allowed to run and that future is worth watching closely. I will drop the link to the repo in video’s description, so check it out. Let me know your thoughts in the comments. And again, if you would subscribe to this newsletter, that would be really really good. And if you want to help out the channel, please become a member. Thank you for all the support.