Ejecutar CUDA en una GPU AMD con ZLUDA y ROCm en Windows: tutorial paso a paso

Se puede ejecutar código escrito para CUDA en una tarjeta AMD, en Windows, y sin tocar una línea del programa. No es teoría: el 13 de septiembre un proyecto de la comunidad completó el entrenamiento real de una red de aprendizaje por refuerzo de 2,2 millones de parámetros en PyTorch sobre una Radeon RX 9060 XT, y al día siguiente el resultado llegó a la portada de Hacker News. La pieza que lo hace posible se llama ZLUDA, lleva años desarrollándose y funciona mejor de lo que mucha gente cree. En esta guía te explicamos qué es, cómo montarlo paso a paso y —sobre todo— qué no va a funcionar, que es la parte que casi nadie cuenta.

Qué es ZLUDA y qué hace exactamente

ZLUDA es una capa de traducción. Cuando un programa compilado para CUDA se ejecuta, va haciendo llamadas a la interfaz de programación de Nvidia: reserva memoria en la GPU, copia datos, lanza núcleos de cálculo, sincroniza. ZLUDA se coloca en medio, intercepta esas llamadas y las reescribe hacia ROCm y HIP, que es la pila equivalente de AMD.

La consecuencia es que el programa no se entera de dónde está. No hay que recompilarlo, no hay que portarlo y no hay que cambiar el código. El binario cree que está hablando con una GPU de Nvidia y en realidad está hablando con una Radeon a través de un intérprete.

Es exactamente la misma idea que esta semana ha permitido que DLSS 5 se ejecute en tarjetas Radeon mediante un mod: no reimplementar la tecnología del rival, sino traducir sus llamadas. Y como toda traducción, funciona bien en lo común y se atasca en lo idiomático.

Lo que se demostró el 13 de septiembre

El hito que ha reactivado el interés es concreto y medible, que es lo que lo hace valioso. El proyecto CUDA-for-AMD-Windows, alojado en GitHub, documentó el entrenamiento completo de una red de aprendizaje por refuerzo de 2,2 millones de parámetros en PyTorch, ejecutada sobre una Radeon RX 9060 XT con arquitectura gfx1200.

Las cifras publicadas: 65.536 pasos de tiempo completados, con una mediana de 13.278 pasos por segundo. No es un «hola mundo» ni una comprobación de que la biblioteca carga: es una carga de trabajo real, con su bucle de entrenamiento, ejecutándose de principio a fin.

Eso importa porque el listón habitual de estas demostraciones suele ser mucho más bajo. Que un programa arranque bajo una capa de traducción es relativamente fácil; que complete un entrenamiento entero sin desmoronarse por el camino es otra cosa.

Para quién es esto y para quién no

Antes de que inviertas una tarde, conviene que te sitúes. Esta guía te interesa si:

• Ya tienes una Radeon y quieres exprimirla para aprendizaje automático sin comprar otra tarjeta.
• Estás en Windows y no quieres montar una instalación de Linux sólo para esto.
• Trabajas con PyTorch en proyectos propios o de aprendizaje, donde puedes permitirte que algo falle.
• Te divierte trastear. Honestamente, esto es medio hobby.

Y no te interesa si tienes algo en producción, si tu tiempo vale más que el precio de una GPU o si necesitas garantías de que funcionará dentro de seis meses. Para esos casos, la respuesta sensata es comprar hardware compatible o usar Linux con ROCm nativo, que es un camino mucho más sólido.

Requisitos antes de empezar

Paso 1: identifica tu GPU y su arquitectura

Lo primero es saber qué tienes exactamente, porque el soporte va por arquitectura, no por nombre comercial. Abre una terminal de Windows y comprueba el modelo:

wmic path win32_VideoController get name

Lo que buscas es el identificador de arquitectura, del estilo gfx1200 para RDNA 4. Si tienes una RX 9000 vas por buen camino. Con una RX 7000 (RDNA 3) es posible que funcione, pero estás fuera de lo validado y vas a tener que probar. Con generaciones anteriores, mejor no empieces.

Paso 2: instala el HIP SDK de AMD

ROCm es la pila de cómputo de AMD y en Windows se distribuye como HIP SDK. Descárgalo del sitio oficial de AMD y asegúrate de coger la versión 7.0.2 o posterior, que es la que incorporó el soporte de las RX 9060.

Durante la instalación, apunta la ruta donde se coloca. La vas a necesitar. Después de instalar, reinicia y comprueba que la variable de entorno existe:

echo %HIP_PATH%

Si no devuelve nada, añádela a mano en las variables de entorno del sistema apuntando a la carpeta de instalación. Es la causa número uno de que después «no funcione nada» sin mensaje claro.

Paso 3: descarga ZLUDA y colócalo

ZLUDA se distribuye como un conjunto de bibliotecas que sustituyen a las de CUDA. El proyecto de referencia para este montaje concreto es CUDA-for-AMD-Windows, que empaqueta ZLUDA junto con las piezas necesarias para Windows.

Descomprime el paquete en una carpeta sin espacios ni tildes en la ruta —esto ahorra problemas raros más adelante— y añádela al PATH:

setx PATH "%PATH%;C:\zluda"

La idea es que cuando un programa busque las bibliotecas de CUDA, encuentre las de ZLUDA primero. Hay dos formas de conseguirlo: colocando las bibliotecas de ZLUDA donde el programa espera las de CUDA, o usando el lanzador que trae el propio ZLUDA, que prepara el entorno por ti. El lanzador es más limpio porque no toca nada del sistema.

Paso 4: prepara el entorno de Python

Entorno virtual siempre, sin excepción. Lo que vas a instalar es una combinación experimental y no quieres que contamine tu Python del sistema:

python -m venv venv-zluda
venv-zluda\Scripts\activate
pip install --upgrade pip

Ahora instala PyTorch. Y aquí viene el detalle contraintuitivo: instala la versión de PyTorch para CUDA, no la de ROCm. Suena al revés, pero tiene toda la lógica del mundo: ZLUDA traduce llamadas de CUDA, así que lo que necesitas es un PyTorch que hable CUDA. Si instalas la versión de ROCm, no hay nada que traducir y ZLUDA se queda sin trabajo.

pip install torch torchvision --index-url https://download.pytorch.org/whl/cu121

Paso 5: lanza tu código bajo ZLUDA

Con todo en su sitio, ejecutar es cuestión de anteponer el lanzador a tu comando habitual:

zluda -- python entrenar.py

La primera ejecución será notablemente más lenta que las siguientes. ZLUDA compila los núcleos de cálculo la primera vez que los ve y los guarda en caché, así que el arranque inicial incluye ese trabajo. No lo interpretes como el rendimiento real: mide a partir de la segunda pasada.

Paso 6: verifica que está usando la GPU de verdad

Éste es el paso que más gente se salta y el que más disgustos evita. Es perfectamente posible que todo «funcione» mientras el cálculo se está haciendo en la CPU, lentísimo y sin decir nada. Comprueba con un script mínimo:

import torch
print("Disponible:", torch.cuda.is_available())
print("Dispositivo:", torch.cuda.get_device_name(0))
x = torch.randn(4096, 4096, device="cuda")
y = x @ x
torch.cuda.synchronize()
print("Multiplicacion completada en GPU:", y.shape)

Si is_available() devuelve verdadero y el nombre del dispositivo se corresponde con tu Radeon, la traducción está funcionando. Si devuelve falso, el problema está casi siempre en el PATH o en la variable del HIP SDK del paso 2.

Y un consejo que vale para cualquier trabajo con GPU: ten abierto el monitor de rendimiento de Windows mirando la ocupación de la tarjeta. Es la forma más rápida de detectar que algo ha caído silenciosamente a CPU.

Qué NO va a funcionar

Aquí está la parte honesta, y es la más importante de toda la guía. ZLUDA no es una implementación completa de CUDA, y en Windows las limitaciones se acumulan:

• cuDNN y MIOpen no están disponibles en la ruta estable del HIP SDK que se ha validado. Eso descarta bastantes operaciones de redes convolucionales optimizadas.
• NCCL no funciona. Si esperabas entrenar con varias GPUs en paralelo, olvídalo.
• TensorRT no funciona. Toda la parte de inferencia optimizada de Nvidia queda fuera.
• Las extensiones CUDA personalizadas pueden fallar. Cualquier proyecto con núcleos escritos a mano es una lotería.
• Windows sólo expone un subconjunto de ROCm. El ecosistema completo está en Linux, y eso no va a cambiar pronto.

Hay además una consideración de sostenibilidad que conviene conocer antes de construir nada encima: ZLUDA v6 se publicó en junio de 2026 y su creador anunció que el desarrollo ya no cuenta con financiación comercial, volviendo a ser un proyecto de fines de semana. Puede seguir mejorando durante años o puede pararse. No lo sabemos, y él tampoco.

Problemas frecuentes y cómo salir de ellos

• «No se encuentra el dispositivo CUDA». Casi siempre es el PATH. Comprueba que la carpeta de ZLUDA está antes que cualquier resto de una instalación previa de CUDA, y que HIP_PATH apunta donde debe.
• Va lentísimo. Si la primera ejecución es lenta, es normal: está compilando núcleos. Si la tercera también lo es, revisa con el monitor si estás en CPU.
• Se queda sin memoria antes de lo esperado. La traducción tiene sobrecarga de memoria. Baja el tamaño de lote respecto a lo que usarías en una Nvidia equivalente.
• Un paquete se instaló en la versión de ROCm. Revisa que todo el árbol de dependencias sea el de CUDA. Mezclar las dos ramas produce errores que no apuntan a la causa real.
• Funcionaba y ha dejado de funcionar. Sospecha de una actualización de Adrenalin. Anota siempre qué versión de controlador tenías cuando funcionaba.

El hardware que conviene para esto

Si vas a montar o ampliar equipo pensando en aprendizaje automático local, lo que manda es la memoria de vídeo. Un modelo que no cabe en la VRAM no se ejecuta más lento: no se ejecuta.

• GIGABYTE RX 9060 XT Gaming OC de 16 GB. Es la tarjeta sobre la que se ha validado el montaje, y 16 GB dan mucho margen para el precio que tiene. Ver precio actual en Amazon
• ASUS Dual RX 9060 XT de 16 GB White Edition. Misma GPU con acabado claro. Ver precio actual en Amazon
• ASRock RX 9060 XT Challenger de 16 GB. Otra variante de la misma base. Ver precio actual en Amazon
• Sapphire Pulse RX 9070 XT. Si quieres más músculo dentro de RDNA 4. Ver precio actual en Amazon
• Crucial Pro DDR5 de 64 GB. La memoria del sistema importa mucho más de lo que la gente cree al preparar datos y cargar pesos. Ver precio actual en Amazon
• Crucial P310 de 2 TB. Entre el SDK, las ruedas de PyTorch y los conjuntos de datos, el disco se llena a una velocidad sorprendente. Ver precio actual en Amazon
• Fuente MSI MAG A850GLS de 850 W. Entrenar mantiene la GPU al máximo durante horas, que es un perfil de consumo distinto al de jugar. Ver precio actual en Amazon

Antes de comprar, merece la pena leer nuestra review de la RX 9060 XT de 16 GB y la comparativa de la RX 9070 XT, además de la guía general de GPUs para IA local.

Alternativas más sensatas, según tu caso

Sería deshonesto terminar esta guía sin decir que, para la mayoría de la gente, hay caminos mejores:

• Si sólo quieres ejecutar modelos de lenguaje, no necesitas nada de esto. Ollama funciona sobre Radeon sin capas de traducción y con muchísimo menos dolor. Tienes la guía completa de Ollama y el tutorial de instalación de Llama en local.
• Si vas a entrenar en serio, monta Linux con ROCm nativo. Es más trabajo al principio y muchísimo menos después.
• Si tu proyecto depende de cuDNN, TensorRT o varias GPUs, compra Nvidia. No hay vuelta de hoja y perder una semana para descubrirlo es caro.
• Si lo tuyo es generación de imagen o vídeo, echa un vistazo a nuestro tutorial de generación de vídeo en local con ComfyUI.

Cómo medir si de verdad te compensa

Una vez que tengas el montaje en pie, la pregunta que importa no es «¿funciona?» sino «¿me sale a cuenta?». Y esa se responde con números propios, no con los de la demostración de otro. Un método razonable para averiguarlo en media hora:

• Escoge la carga que vas a usar de verdad. No midas con una multiplicación de matrices sintética: mide con tu bucle de entrenamiento, tus datos y tu tamaño de lote. Las capas de traducción rinden muy distinto según qué operaciones domine tu código.
• Descarta la primera pasada y promedia al menos tres ejecuciones iguales. La varianza en estos montajes es más alta de lo normal.
• Anota el tamaño de lote máximo que aguanta. Es tan importante como la velocidad: si por la sobrecarga de memoria tienes que bajar el lote a la mitad, el tiempo total por época puede empeorar aunque cada paso vaya rápido.
• Compara contra la CPU, no sólo contra una GPU ideal. Tu punto de referencia real es lo que tenías antes. Si antes entrenabas en procesador, incluso una fracción del rendimiento de una Nvidia equivalente puede ser una mejora enorme.
• Cuenta el tiempo que has invertido. Suena obvio y casi nadie lo hace. Si el montaje te ha costado dos tardes y te ahorra diez minutos por semana, el balance tardará meses en ponerse a favor.

Y si te pasas a Linux, ¿cambia mucho?

Cambia bastante, y conviene saberlo antes de invertir demasiado en la vía de Windows. En Linux no necesitas ZLUDA para la mayoría de los casos: ROCm es nativo y PyTorch tiene compilaciones oficiales para él. Eso significa que desaparece la capa de traducción entera, con su sobrecarga y con sus incompatibilidades.

Las diferencias prácticas más relevantes:

• MIOpen sí está disponible, que es el equivalente de AMD a cuDNN. Recuperas las operaciones de convolución optimizadas que en Windows quedaban fuera.
• El soporte multi-GPU existe, aunque con sus propias peculiaridades.
• El ecosistema de herramientas es mucho más completo, incluidos los perfiladores, que en Windows brillan por su ausencia.
• La documentación está pensada para ahí. Cuando busques la solución a un error, la mayoría de respuestas asumirán Linux.

El coste es el evidente: montar y mantener otro sistema. Para mucha gente, arrancar desde una instalación en un disco aparte o en una partición es un término medio razonable, porque te permite seguir en Windows para lo demás y arrancar en Linux cuando toque entrenar. Si el aprendizaje automático va a ser algo recurrente y no una curiosidad de un fin de semana, es la inversión de tiempo que mejor se amortiza de todas las que aparecen en esta guía.

Veredicto Arkaia

Merece la pena como experimento y como señal, no como cimiento.

Lo que se ha demostrado esta semana es sólido: una red real, entrenada de principio a fin, en una tarjeta que oficialmente no debería poder. Eso tiene valor técnico y tiene valor político, porque cada vez que una de estas capas funciona, el argumento de que CUDA es insustituible se erosiona un poco. No es casualidad que esté ocurriendo justo cuando Nvidia refuerza su posición comprando la plataforma donde vive el ecosistema abierto.

Dicho eso, no montes tu trabajo encima. Un proyecto sin financiación, con la mitad de las bibliotecas fuera y dependiente de que no cambie nada en tres piezas distintas, no es una base. Úsalo para aprender, para aprovechar una tarjeta que ya tienes o para satisfacer la curiosidad. Si el aprendizaje automático es tu oficio y no tu afición, compra el hardware que corresponde y dedica el tiempo a tu problema, no a la capa de traducción.

Lecturas relacionadas

• Las mejores GPUs para inteligencia artificial local
• Portátiles para desarrollo con IA local
• DSPy: programar modelos de lenguaje desde Python
• DLSS 5 en Radeon mediante un mod
• Radeon RX 9060 XT de 16 GB: review y guía de compra