Al terminar esta guía conocerás la ruta documentada para ejecutar un modelo GGUF en una Intel Arc con llama.cpp, por SYCL o por Vulkan, y sabrás comprobar que la tarjeta hace el trabajo. La tarjeta más barata para esto es la que ya tienes.
Léelo antes de copiar un comando. No tenemos ninguna tarjeta Intel Arc y no hemos ejecutado ni un solo paso de esta página. Ninguna velocidad es nuestra. Cada paso, opción, paquete y cifra sale de la fuente primaria enlazada a su lado, leída el 16 de noviembre de 2026. Si las fuentes callan o se contradicen, lo decimos.
Para quién es
Tienes una Arc serie A, B o Pro B, o un portátil Intel reciente con Arc integrada, y quieres que los modelos corran en ella. No es una recomendación de compra: para eso está nuestro catálogo de hardware, que no afirma ninguna velocidad para Arc.
Versiones revisadas, todas leídas el 16 de noviembre de 2026:
- llama.cpp 1.0.0, publicada el 13 de noviembre de 2026, y la compilación nocturna
b12430. - El documento del backend SYCL (último cambio, 10 de noviembre) y la guía de compilación (12 de noviembre).
- La guía de instalación del oneAPI Toolkit para Linux, 2026.2, de Intel, con fecha 15 de octubre de 2026.
Las tarjetas y su memoria
La memoria decide qué modelos caben. Las cifras son de las fichas de Intel; las columnas de Linux, de sus tablas de GPU con controlador Xe e i915.
| Tarjeta | Memoria | Ancho de banda | Consumo de la placa | Controlador | Soporte completo en Linux desde |
|---|---|---|---|---|---|
| Arc A380 | 6 GB | 186 GB/s | 75 W | i915 | Ubuntu 24.04 (6.2) |
| Arc A580 | 8 GB | 512 GB/s | 185 W | i915 | Ubuntu 24.04 (6.2) |
| Arc A750 | 8 GB | 512 GB/s | 225 W | i915 | Ubuntu 24.04 (6.2) |
| Arc A770 16GB | 16 GB | 560 GB/s | 225 W | i915 | Ubuntu 24.04 (6.2) |
| Arc B570 | 10 GB | 380 GB/s | 150 W | xe | Ubuntu 24.04 (6.12) |
| Arc B580 | 12 GB | 456 GB/s | 190 W | xe | Ubuntu 24.04 (6.12) |
| Arc Pro B50 | 16 GB | 224 GB/s | 70 W | xe | Ubuntu 24.04 (6.14) |
| Arc Pro B60 | 24 GB | 456 GB/s | 200 W | xe | Ubuntu 24.04 (6.15) |
| Arc Pro B70 | 32 GB | 608 GB/s | 230 W | xe | Ubuntu 25.10 (6.17) |
Existe también una A770 de 8 GB: mira cuál tienes. Entre paréntesis, el kernel que Intel da para el soporte completo. El documento de SYCL añade las Arc integradas (Meteor Lake, Arrow Lake, Lunar Lake) y las GPU integradas desde Core de 11.ª generación, y avisa: con menos de 80 unidades de ejecución, una integrada es demasiado lenta.
La guía de inicio rápido de Intel pide activar Resizable BAR (Smart Access Memory en placas AMD) para un rendimiento óptimo en todas las aplicaciones. Actívalo en la UEFI antes que nada.
SYCL o Vulkan: qué dice la documentación
El README de llama.cpp lista los dos backends en una tabla: SYCL para «Intel GPU» y Vulkan para «GPU». Ningún documento recomienda uno sobre otro para Arc ni publica una comparación.
| SYCL | Vulkan | |
|---|---|---|
| Necesita | Controlador de GPU Intel con Level Zero, y el oneAPI Toolkit para compilar | Un controlador Vulkan, y las cabeceras de Vulkan y glslc para compilar |
| Funciona en | Solo GPU Intel: el soporte de otros fabricantes se retiró en febrero de 2026 | Cualquier GPU con Vulkan |
| Lo mantiene | Un grupo propio de colaboradores, con un documento detallado | La guía general de compilación, una sección |
| Binarios publicados | Ubuntu (FP16 y FP32), Windows | Ubuntu, Windows |
Nuestra lectura, no la del proyecto: Vulkan si quieres el mínimo de piezas, SYCL si quieres el backend escrito para este hardware. Luego mide los dos con tu modelo.
Qué necesitas (Linux)
- Un kernel igual o posterior al de la tabla. La guía de instalación de Intel lo resume: Ubuntu 24.04 si tu tarjeta pide 6.8 o posterior; 26.04 si pide 6.17.
- Los paquetes de cómputo de Intel (paso 1).
- Tu usuario en el grupo
render. - Un modelo GGUF. Para elegir el archivo: cómo elegir la cuantización GGUF.
El documento de SYCL da como verificados Ubuntu 22.04, Fedora Silverblue 39 y Arch Linux, y Windows 11.
Paso 1: instala el controlador de cómputo
Comprueba que el sistema ve la tarjeta y que hay un nodo de render:
lspci -nn | grep -Ei 'VGA|DISPLAY'
uname -r
ls /dev/driEn Ubuntu 24.04 o 26.04, la página del PPA de Intel indica:
sudo apt-get update
sudo apt-get install -y software-properties-common
sudo add-apt-repository -y ppa:kobuk-team/intel-graphics
sudo apt-get install -y libze-intel-gpu1 libze1 intel-metrics-discovery intel-opencl-icd clinfo intel-gsc
sudo gpasswd -a ${USER} render
newgrp render
clinfo | grep "Device Name"Debe aparecer el nombre de tu tarjeta. En Ubuntu 24.04, las serie B necesitan el kernel HWE, el que Ubuntu Desktop trae por defecto.
Otras distribuciones. La guía de Intel solo cubre Ubuntu, y recomienda el kernel y los paquetes de tu distribución. Fedora empaqueta el mismo runtime como intel-compute-runtime, junto a intel-level-zero e intel-opencl. No encontramos página de Intel para Fedora ni Arch: toma esos nombres como punto de partida.
Paso 2: instala el oneAPI Toolkit (solo SYCL)
Desde la versión 2026.0, los toolkits Base y HPC de Intel son un solo producto, el Intel oneAPI Toolkit. El documento de SYCL lo recomienda frente a Deep Learning Essentials, más pequeño, porque este ya no incluye oneDNN. Sus versiones verificadas son 2026.2, 2026.1, 2025.3.3, 2025.2.1, 2025.1 y 2024.1.
Ubuntu y Debian, según la página de APT de Intel:
wget -O- https://apt.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB \
| gpg --dearmor | sudo tee /usr/share/keyrings/oneapi-archive-keyring.gpg > /dev/null
echo "deb [signed-by=/usr/share/keyrings/oneapi-archive-keyring.gpg] https://apt.repos.intel.com/oneapi all main" \
| sudo tee /etc/apt/sources.list.d/oneAPI.list
sudo apt update
sudo apt install intel-oneapi-toolkitFedora y RHEL, según la página de YUM/DNF: crea el archivo del repositorio e instala.
tee > /tmp/oneAPI.repo << EOF
[oneAPI]
name=Intel® oneAPI repository
baseurl=https://yum.repos.intel.com/oneapi
enabled=1
gpgcheck=1
repo_gpgcheck=1
gpgkey=https://yum.repos.intel.com/intel-gpg-keys/GPG-PUB-KEY-INTEL-SW-PRODUCTS.PUB
EOF
sudo mv /tmp/oneAPI.repo /etc/yum.repos.d
sudo dnf install intel-oneapi-toolkitopenSUSE, según la página de Zypper: sudo zypper addrepo https://yum.repos.intel.com/oneapi oneAPI y después sudo zypper install intel-oneapi-toolkit.
Las tres páginas coinciden: el toolkit no trae controladores de GPU. Eso es el paso 1.
Paso 3: carga el entorno y busca la tarjeta
source /opt/intel/oneapi/setvars.sh
sycl-lsEjecuta setvars.sh en cada terminal nueva. El ejemplo del documento tiene una línea que empieza por [level_zero:gpu][level_zero:0] y sigue con el nombre de la tarjeta. Sin ella no hay GPU para SYCL: ve a la tabla de fallos.
Paso 4: compila llama.cpp con SYCL
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
source /opt/intel/oneapi/setvars.sh
cmake -B build -DGGML_SYCL=ON -DCMAKE_C_COMPILER=icx -DCMAKE_CXX_COMPILER=icpx -DGGML_SYCL_F16=ON
cmake --build build --config Release -j -vGGML_SYCL_F16=ON es la compilación FP16, la que el documento recomienda en la mayoría de los casos; quita la opción para FP32. También pide probar las dos, porque cambian en precisión y velocidad según el modelo. El script ./examples/sycl/build.sh fp16 hace lo mismo.
Sobre los nombres: el inicio rápido del README usa ahora un único comando llama (llama cli, llama serve). Los documentos de los backends siguen nombrando las herramientas de una compilación, como llama-cli y llama-server. Esta guía usa esas.
Paso 5: comprueba que se usa la tarjeta y ejecuta un modelo
./build/bin/llama-ls-sycl-device
./build/bin/llama-server --list-devicesEl primero imprime una fila por dispositivo, marcada [level_zero:gpu:0], con su memoria en bytes. El segundo, en el ejemplo del documento:
Available devices:
SYCL0: Intel(R) Arc(TM) A770 Graphics (15473 MiB, 15473 MiB free)Ahora ejecuta con todas las capas en la tarjeta:
ZES_ENABLE_SYSMAN=1 ./build/bin/llama-completion -no-cnv -m models/MODEL.gguf \
-p "Building a website can be done in 10 simple steps:" -n 400 -e \
-ngl 99 -sm none -mg 0 --load-mode auto-ngl 99 pide todas las capas en la GPU. -sm none -mg 0 fija el dispositivo 0. ZES_ENABLE_SYSMAN=1 deja que llama.cpp lea la memoria libre de la tarjeta. En el registro, busca una de estas líneas, según el documento:
detect 1 SYCL GPUs: [0] with top Max compute units:512
use 1 SYCL GPUs: [0] with Max compute units:512Añade que el tamaño cargado aparece como llm_load_tensors: buffer_size. En nuestros registros con CUDA, la prueba de carga completa es una línea como offloaded 33/33 layers to GPU. El documento de SYCL no la enseña: no podemos prometer su redacción ahí.
Con GPU integrada y tarjeta a la vez, la tarjeta sale primero. Elige con --device SYCL0 o con export ONEAPI_DEVICE_SELECTOR="level_zero:0".
Paso 6: sírvelo
ZES_ENABLE_SYSMAN=1 ./build/bin/llama-server -m models/MODEL.gguf -ngl 99 -c 8192El README del servidor da como dirección por defecto 127.0.0.1:9931. Guías anteriores, la nuestra incluida, decían 8080: pasa --port si dependes de un número, y fija -c tú.
Windows
- Sin compilar. El documento de SYCL dice que el paquete de Windows de la página de versiones (
llama-<tag>-bin-win-sycl-x64.zip) incluye el runtime de SYCL, así que no hace falta oneAPI. Es solo FP32; la compilación FP16 es una petición abierta. Instala antes el controlador desde la página de controladores Arc de Intel. - Compilando. Instala Visual Studio y oneAPI, abre el «Intel oneAPI command prompt» y ejecuta
examples\sycl\win-build-sycl.bat. La sección de Windows aún nombra el antiguo Base Toolkit, y la compilación oficial del proyecto instala Deep Learning Essentials 2026.2 más un oneDNN aparte. No hemos podido aclarar cuál es la correcta. - Vulkan.
llama-<tag>-bin-win-vulkan-x64.zipsolo necesita el controlador gráfico.
Sobre WSL, el documento de Docker dice de sus imágenes SYCL que el soporte aún no se ha verificado.
La ruta Vulkan
Sin oneAPI. En Ubuntu o Debian, la guía de compilación indica:
sudo apt-get install libvulkan-dev glslc spirv-headers
vulkaninfo
cmake -B build -DGGML_VULKAN=1
cmake --build build --config Release
./build/bin/llama-cli -m "PATH_TO_MODEL" -p "Hi you how are you" -ngl 99En Fedora y openSUSE el paquete de cabeceras es spirv-headers-devel. Si vulkaninfo da errores, arregla antes el controlador. Al arrancar, busca una línea así, con el nombre de tu GPU:
ggml_vulkan: Using Intel(R) Graphics (ADL GT2) | uma: 1 | fp16: 1 | warp size: 32Para no compilar, usa llama-<tag>-bin-ubuntu-vulkan-x64.tar.gz. Los paquetes SYCL para Ubuntu son menos autónomos: según el documento, necesitan controladores y un oneAPI de la misma versión que la compilación (2026.2 este mes), y recomienda la imagen Docker de Intel. Existen las imágenes ghcr.io/ggml-org/llama.cpp:server-intel y :server-vulkan; el documento de Docker avisa de que la CI las compila pero no las prueba.
Fallos que documentan las fuentes
| Qué ves | Causa y solución documentada | Fuente |
|---|---|---|
error while loading shared libraries: libsycl.so: cannot open shared object file | Falta oneAPI o no está cargado. source /opt/intel/oneapi/setvars.sh | Documento SYCL |
Ninguna línea level_zero:gpu en sycl-ls | Prueba sudo sycl-ls. Si ahí aparece, añade tu usuario a render y video y vuelve a iniciar sesión. Si no, revisa el controlador | Documento SYCL |
Native API returns: 39 (UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY) o failed to allocate SYCL0 buffer | Sin memoria en el dispositivo. Pon -c 8192 o menos, o una cuantización o un modelo menores | Documento SYCL |
can't allocate 5000000000 Bytes of memory on device | Solo si la ruta Level Zero está desactivada: export UR_L0_ENABLE_RELAXED_ALLOCATION_LIMITS=1 | Documento SYCL |
| Serie B: se rechaza la carga si el modelo no cabe | Es deliberado. El controlador aceptaría la reserva y la volcaría en la RAM del sistema (incidencia 1047 de compute-runtime, abierta). Reduce el modelo o el contexto | Documento SYCL |
Cierre inesperado tras poner SYCL_CACHE_PERSISTENT=1 | El documento lo desaconseja. Borra ~/.cache/libsycl_cache/ y quita la variable | Documento SYCL |
| Errores del compilador a mitad | Borra la carpeta build y compila de cero | Documento SYCL |
| Primer arranque lento | Es lo esperado: los kernels se compilan la primera vez. Después la velocidad no cambia | Documento SYCL |
La última fila es un informe de usuario de esta semana, no una solución documentada.
Qué cabe en cada tarjeta
Una Arc es VRAM dedicada: vale la cuenta de nuestra guía de VRAM: pesos, más caché de contexto por ranuras en paralelo, más búferes. El catálogo la resuelve en Q4_K_M para una persona: 6,49 GB un 8B con 8k de contexto (9,71 GB con 32k), 11,10 GB un 14B (15,93), 16,67 GB un 24B (20,70) y 23,00 GB un 32B (29,44). Una tarjeta se reserva 0,5 GB. «Justo» es más del 85 % del resto. Cada celda se lee 8k / 32k.
| Memoria de la tarjeta | Útil | 8B | 14B | 24B | 32B |
|---|---|---|---|---|---|
| 6 GB (A380) | 5,5 GB | no | no | no | no |
| 8 GB (A580, A750) | 7,5 GB | justo / no | no | no | no |
| 10 GB (B570) | 9,5 GB | sí / no | no | no | no |
| 12 GB (B580) | 11,5 GB | sí / sí | justo / no | no | no |
| 16 GB (A770, Pro B50) | 15,5 GB | sí / sí | sí / no | no | no |
| 24 GB (Pro B60) | 23,5 GB | sí / sí | sí / sí | sí / justo | justo / no |
| 32 GB (Pro B70) | 31,5 GB | sí / sí | sí / sí | sí / sí | sí / justo |
Para otros modelos, contextos o varios usuarios, usa el explorador de VRAM, corregido hoy con esta misma cuenta. Una salvedad: contrastamos la cuenta con cargas CUDA nuestras, no con SYCL ni Vulkan. Pesos y caché son aritmética; el margen de búferes puede cambiar en Arc.
Velocidad: lo que otros han reportado
Nada de esto es nuestro. Los colaboradores de SYCL mantienen un hilo de resultados donde los usuarios publican ejecuciones de llama-bench. Su cabecera dice que los datos no se revisan. Todas las filas son SYCL, con una tarjeta y flash attention desactivado salvo indicación; pp512 es el procesado del prompt y tg128 la generación, en tokens por segundo.
| Tarjeta | Modelo, cuantización | Compilación | pp512 | tg128 | Sistema, fecha |
|---|---|---|---|---|---|
| Arc A380 | Llama 2 7B Q4_0 | FP16 | 495,16 | 23,84 | Ubuntu 24.04.4, 5-6-2026 |
| Arc A770 | Llama 2 7B Q4_0 | FP32 | 937,24 | 59,03 | Ubuntu 24.04.4, 19-5-2026 |
| Arc A770 | Llama 2 7B Q4_0 | FP16 | 1.876,79 | 68,72 | Debian 13, 5-11-2026 |
| Arc B570 | Llama 2 7B Q4_0 | FP16 | 1.355,95 | 72,52 | Ubuntu 24.04.4, 1-6-2026 |
| Arc B580 | Llama 2 7B Q4_0 | FP16 | 2.063,52 | 73,76 | Ubuntu 25.10, 27-5-2026 |
| Arc Pro B60 | Llama 2 7B Q4_0 | FP16 | 1.869,16 | 80,03 | Fedora 43, 27-8-2026 |
| Arc Pro B70 | Llama 2 7B Q4_0 | FP16 | 2.830,14 | 105,64 | Ubuntu 26.04, 26-8-2026 |
| Arc Pro B70 | Llama 3.1 8B Q4_K_M | FP32, flash attention activado | 1.068,94 | 88,49 | Ubuntu 26.04, 23-6-2026 |
Casi todas las filas usan un modelo antiguo: es la prueba de referencia del hilo. Las dos filas de la A770 difieren en compilación, sistema y cinco meses de cambios. No encontramos ninguna cifra de Vulkan en una Arc que nombre hardware, modelo, cuantización y backend: no damos ninguna, y la de nuestra versión de septiembre está retirada. Para obtener la tuya: mide un modelo local en 30 minutos.
Ollama, OpenVINO e IPEX-LLM
Ollama. Su página de hardware nombra en tablas tarjetas NVIDIA y AMD, y ninguna Intel. Tiene una sección Vulkan: soporte adicional de GPU en Windows y Linux, activo por defecto si ese backend está instalado, con enlace a las instrucciones de Intel para Linux. Para que el planificador conozca la memoria da sudo setcap cap_perfmon+ep /usr/local/bin/ollama; OLLAMA_VULKAN=0 desactiva Vulkan. No menciona SYCL. La última versión en GitHub era la v0.40.16 (9 de noviembre de 2026). El documento de SYCL añade que sus responsables no atienden problemas de Ollama: reprodúcelos antes en llama.cpp. Si quieres Ollama, empieza por instalar Ollama.
OpenVINO. llama.cpp tiene un backend OpenVINO, marcado «In Progress» en el README. Según su documento, se validó en portátiles Core Ultra, admite un subconjunto de operaciones y solo sirve para modelos de texto. Para seguirlo, no para empezar con una Arc.
IPEX-LLM. El puente de Intel para llama.cpp y Ollama, que nuestra versión de septiembre sugería, está archivado. Su README dice que Intel ya no lo mantiene y que tiene problemas de seguridad conocidos.
Precios
Solo dos Arc están en nuestro catálogo de hardware, leído el 16 de noviembre de 2026: la B580 a 470,13 EUR nueva y la Pro B70 a 2.058,49 EUR, ambas en PcComponentes. La RTX 3060 de 12 GB costaba allí 509,00 EUR ese mismo día. De las demás no tenemos precio con fuente: no damos ninguno.
Cuándo no hacerlo
- Ya tienes una NVIDIA. Úsala. Ollama la nombra; nuestra guía de CUDA en Fedora cubre el controlador.
- Vas a comprar una tarjeta de 12 GB y quieres el mínimo de fricción. La B580 costaba 38,87 EUR menos que la RTX 3060 ese día. Ese es todo el ahorro, frente a la ruta que acabas de leer.
- Necesitas 24 GB. La RTX 3090 de segunda mano del catálogo se pedía a entre 900 y 1.400 EUR, por debajo de la Pro B70 de 32 GB, que tiene más memoria. No podemos decirte cuál es más rápida.
- Quieres SYCL solo por no compilar. Coge el binario de Vulkan.
Preguntas frecuentes
¿Necesito oneAPI para usar una Arc? No. Vulkan no lo pide, y el paquete SYCL de Windows trae su propio runtime.
¿Qué es más rápido, SYCL o Vulkan? La documentación no lo dice, y el hilo de SYCL no admite tablas que comparen backends. Mide los dos con llama-bench.
¿FP16 o FP32? El documento recomienda FP16 en la mayoría de los casos. Según el hilo, mejora sobre todo el procesado del prompt, resta algo a la generación, y FP32 es más preciso.
¿Puedo usar dos Arc? Sí. --split-mode layer es el modo por defecto; tensor está afinado para dos GPU; row no está soportado en SYCL.
¿Vale una Arc integrada? Está soportada y comparte la memoria del sistema. El documento pide al menos 8 GB compartidos para un 7B en Q4_0.
¿Sirve SYCL también para mi NVIDIA o mi AMD? No desde febrero de 2026. Usa CUDA, HIP o Vulkan.
Límites
No hemos ejecutado nada: ningún comando de esta página, en ninguna Arc ni en ningún sistema. La tabla de lo que cabe es aritmética contrastada en otro hardware. Las velocidades son informes de usuarios que su propio hilo no verifica. No encontramos página de Intel sobre controladores para Fedora o Arch ni un benchmark primario de Vulkan, y un enlace del documento de SYCL (requisitos de oneAPI) ya no resolvía. Estos proyectos cambian cada semana: compara nuestras fechas con lo que encuentres.
Próximos pasos
- Haz la cuenta de memoria para tu tarjeta: cuánta VRAM necesita un LLM local.
- Elige el archivo: cuantización GGUF.
- Mídelo tú: benchmark en 30 minutos.
Trabaja con nosotros
Dimensionamos modelo y máquina midiendo, no suponiendo, y decimos cuándo no hemos medido. Si quieres una segunda opinión antes de comprar, escríbenos o mira cómo trabajamos en consultoría.