llama.cpp en una GPU Intel Arc con SYCL: 16 GB de VRAM al precio de una 3060 de segunda mano

Al terminar este artículo tendrás llama.cpp compilado contra el toolchain oneAPI de Intel, tu tarjeta Arc listada como dispositivo SYCL y un modelo cuantizado respondiendo en ella. El hardware más barato con el que funciona: una Arc A770 de 16 GB de segunda mano o una Arc B580 de 12 GB nueva, las dos por lo que cuesta una RTX 3060 usada.

Una aclaración antes de empezar. No tenemos ninguna GPU Intel Arc. Todas las velocidades de este artículo son mediciones de terceros con su enlace, y decimos de dónde sale cada una. Los comandos vienen de la documentación oficial de llama.cpp para SYCL tal y como estaba el 09-09-2026.

Por qué merece la pena mirar una Arc

La memoria es lo que decide qué modelos puedes ejecutar, e Intel la vende barata. La Arc A770 tiene 16 GB de GDDR6 a 560 GB/s y se encuentra por unos 250 a 300 dólares. La Arc B580 tiene 12 GB por unos 249 dólares. Como referencia, una RTX 3060 de 12 GB usada se movía entre 250 y 278 dólares en agosto de 2026.

Con 16 GB cabe un modelo de 8B en Q8_0 (unos 8 GB), uno de 14B en Q4_K_M (unos 9 GB) o uno de 8B con un contexto largo. La pega es el software: CUDA está más maduro y Ollama no tiene backend nativo para Arc. llama.cpp con SYCL es el camino directo, y no es difícil.

Qué necesitas

• Un PC con una tarjeta Intel Arc de la serie A o B, o un procesador Intel de 13.ª generación o posterior con Arc integrada. La documentación avisa de que una iGPU con menos de 80 unidades de ejecución “probablemente será demasiado lenta para un uso práctico”.
• Resizable BAR activado en la UEFI. Las guías de terceros lo consideran imprescindible para el rendimiento de Arc. La A770 necesita además dos conectores PCIe de 8 pines.
• Linux (Ubuntu 22.04 o 24.04 son las rutas más probadas) con el driver de GPU de Intel instalado y tu usuario en los grupos render y video. En Windows también funciona; la documentación lo cubre.
• Unos 20 GB libres en disco para oneAPI, la compilación y un modelo. Unos 45 minutos la primera vez.
• Un modelo GGUF, por ejemplo Llama-3.1-8B-Instruct-Q4_K_M.gguf de Hugging Face.

Paso 1: instala oneAPI y comprueba que la GPU es visible

Instala el Intel oneAPI Base Toolkit, o el paquete más pequeño Intel Deep Learning Essentials, manteniendo la ruta por defecto /opt/intel/oneapi. La documentación lista como verificadas las versiones 2025.3.3, 2025.2.1, 2025.1 y 2024.1. Después carga el entorno y lista los dispositivos SYCL:

source /opt/intel/oneapi/setvars.sh
sycl-ls

Buscas una línea con [level_zero:gpu] y tu tarjeta Arc. Si no aparece, añade tu usuario a los grupos render y video, cierra sesión y vuelve a entrar. Si más adelante falta libsycl.so, es que no ejecutaste setvars.sh en esa terminal.

Paso 2: compila llama.cpp con el backend SYCL

git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_SYCL=ON -DCMAKE_C_COMPILER=icx \
  -DCMAKE_CXX_COMPILER=icpx -DGGML_SYCL_F16=ON
cmake --build build --config Release -j -v

GGML_SYCL_F16=ON es la compilación FP16 recomendada. También existe el script ./examples/sycl/build.sh, que ejecuta los mismos pasos. Resultado esperado: binarios en build/bin/, entre ellos llama-ls-sycl-device, llama-cli, llama-completion y llama-server.

Paso 3: confirma que llama.cpp ve la tarjeta y ejecuta un modelo

./build/bin/llama-ls-sycl-device
ZES_ENABLE_SYSMAN=1 ./build/bin/llama-completion \
  -m models/Llama-3.1-8B-Instruct-Q4_K_M.gguf \
  -ngl 99 -sm none -mg 0 --load-mode auto \
  -p "Escribe tres asuntos para un correo de seguimiento de un presupuesto."

-ngl 99 descarga todas las capas a la GPU. -sm none -mg 0 fija una sola GPU. ZES_ENABLE_SYSMAN=1 permite a llama.cpp consultar la memoria libre del dispositivo. Si tienes dos tarjetas Arc, sustituye -sm none -mg 0 por -sm layer para repartir las capas. Para elegir un dispositivo concreto, exporta ONEAPI_DEVICE_SELECTOR="level_zero:0". Flash attention viene activado por defecto (GGML_SYCL_ENABLE_FLASH_ATTN=1).

Para tener una API local permanente, cambia llama-completion por llama-server con los mismos parámetros -m y -ngl; escucha en el puerto 8080 con un endpoint compatible con OpenAI.

Paso 4: arregla los dos errores que todo el mundo se encuentra

Síntoma	Qué hacer
UR_RESULT_ERROR_OUT_OF_DEVICE_MEMORY	Acorta el contexto con -c 8192 o usa una cuantización menor (Q4 en vez de Q5).
“can’t allocate 5GB” en Level Zero	Ejecuta con UR_L0_ENABLE_RELAXED_ALLOCATION_LIMITS=1.
No aparece [level_zero:gpu] en sycl-ls	Revisa los grupos render/video; cierra sesión y vuelve a entrar.
No se encuentra libsycl.so	source /opt/intel/oneapi/setvars.sh en esa terminal.
El primer arranque es lento	Es normal: el backend SYCL compila los kernels en el momento (JIT). La velocidad en ejecución no cambia.

Las cinco salen directamente de la sección “Known Issues” del documento oficial.

Lo que han medido terceros

Ninguna de estas cifras es nuestra. Todas usan llama-bench de llama.cpp: tg128 es la velocidad de generación sobre 128 tokens y pp512 el procesado de un prompt de 512 tokens.

GPU	Modelo	Generación (tg128)	Prompt (pp512)	Fuente y fecha
Arc A770 16 GB	llama-2-7b Q4_0	55,5 tok/s (64,5 con flash attention)	894 tok/s	Discusión #23313 de llama.cpp, 22-05-2026
Arc B580 12 GB	llama-2-7b Q4_0	73,8 tok/s	2.064 tok/s	mismo hilo, 27-05-2026
Arc Pro B60	llama-2-7b Q4_0	84,4 tok/s	1.869 tok/s	mismo hilo, 27-08-2026
Arc Pro B70	llama-2-7b Q4_0	109,7 tok/s	2.830 tok/s	mismo hilo, 26-08-2026
iGPU Lunar Lake	llama-2-7b Q4_0	19,2 tok/s	652 tok/s	mismo hilo, 02-06-2026
Arc B580 12 GB (backend Vulkan)	Llama 3.1 8B	12,9 tok/s	no indicado	InsiderLLM, actualizado el 27-07-2026

Lee la dispersión con honestidad. La misma B580 da 73,8 tok/s en un informe y 12,9 tok/s en otro. Las diferencias están en el backend (SYCL frente a Vulkan), la versión del driver, el modelo y la fecha de compilación. El documento oficial recoge que solo la versión 2025.2 de oneAPI subió la A770 de 42 a 55 tok/s en Q4_0. La lección: compila desde un commit reciente, usa una versión verificada de oneAPI y ejecuta llama-bench tú mismo antes de juzgar la tarjeta.

Si SYCL te da problemas, Vulkan es la alternativa con menos piezas móviles: cmake -B build -DGGML_VULKAN=1 solo necesita el driver Vulkan de Mesa, a cambio de perder velocidad con algunos modelos.

Dónde encaja y qué no puede hacer

Una Arc A770 ejecutando un modelo de 8B a más de 50 tokens por segundo es un motor válido para un asistente interno, resúmenes de documentos o un ayudante de programación, con una tarjeta de menos de 300 EUR. Los 16 GB dejan sitio además para un modelo de 14B en Q4_K_M, algo que una tarjeta de 12 GB no permite.

Límites que conviene planificar:

• Ollama no soporta Arc de forma nativa. El proyecto IPEX-LLM de Intel ofrece un puente, pero el camino limpio es llama-server de llama.cpp. Las herramientas que hablan la API de OpenAI (Open WebUI, n8n, la mayoría de SDK) funcionan con él sin cambios.
• Sensibilidad al driver. Las versiones de kernel y de driver importan más que en NVIDIA. Quédate en una distribución LTS soportada.
• Sin --split-mode row y sin compilación anticipada en el backend SYCL a fecha de la actualización 2026.02; el primer arranque es lento mientras se compilan los kernels.
• SYCL no funciona ahora mismo con tarjetas NVIDIA ni AMD; los plugins no están disponibles. Para esas usa los backends CUDA, HIP o Vulkan.

Siguientes pasos

• Elige la cuantización adecuada para 12 o 16 GB: La cuantización explicada.
• Compara Arc con una Jetson, un Mac mini o un NUC: Mejores dispositivos para IA local en 2026.
• Calcula si la tarjeta se amortiza: Nube o local: tu punto de equilibrio.

Trabaja con nosotros

Ayudamos a equipos pequeños a elegir una GPU por memoria antes que por marketing, y después montamos llama.cpp u Ollama para que los datos no salgan del edificio. Si quieres una segunda opinión antes de comprar, escríbenos o mira cómo trabajamos en consultoría.