Manual de DGX Spark

Autor: @0xSero

Revisores: @alexocheema y @alexzfunk

Agradecimientos especiales a: @MiaAI_lab

Si estás pensando en ejecutar inferencia de forma local, seguro que ya te has topado con este pequeño ladrillo dorado. Es una máquina diseñada para servir IA en local, pensada para ser compacta, limpia, silenciosa y relativamente económica (página de la DGX Spark de NVIDIA).

Cuando escuché hablar por primera vez de la DGX Spark, no me convencía. A pesar de sus 128 GB de memoria, el ancho de banda de 273 GB/s me parecía demasiado bajo. Como referencia, una RTX 5090 tiene aproximadamente 6,5 veces más ancho de banda (1.792 GB/s), aunque solo cuente con 32 GB de VRAM.

Cuando se lanzó la Spark, prácticas de ingeniería de inferencia como la decodificación especulativa no estaban tan extendidas, y la mayoría de los modelos pequeños no eran tan capaces.

A medida que la industria de la IA avanza y crece, la inteligencia se está comprimiendo en tamaños cada vez más reducidos, lo que permite exprimir al máximo el potencial de estas cajitas.

1. La demanda de ingeniería de inferencia está creciendo.
2. Los LLM son cada vez más competentes en ingeniería de inferencia.
3. Una inferencia de alta calidad mejora el sistema.

Ahora, la DGX Spark es capaz de ejecutar modelos muy inteligentes a la misma velocidad que los servicios en la nube, todo desde la comodidad de tu casa u oficina. Hay un montón de software de IA que puede ayudarte a programar, hacer la declaración de impuestos, estudiar o simplemente entretenerte.

Con velocidad me refiero a los tokens por segundo que ve una sola persona. El hardware en la nube es mucho más rápido, pero los proveedores lo reparten entre muchos usuarios y lo optimizan para reducir el coste por token, así que a cada usuario le toca menos. En casa, la máquina es tuya, así que toda esa potencia va para ti. Más detalles en las notas avanzadas.

Las Sparks están hechas para conectarse

Las DGX Spark consumen muy poca energía. Suelen quedarse alrededor de los 95 W con un modelo cargado y sirviendo peticiones.

Por eso, no necesitan mucha refrigeración y son bastante silenciosas en comparación con las GPU discretas. Puedes apilar de 2 a 4 de estas en un circuito eléctrico estadounidense estándar sin ningún miedo. Ese, y no la eficiencia bruta, es el punto clave: por unidad de velocidad de memoria, una B300 de centro de datos hace aproximadamente el doble de trabajo por julio (consulta las notas avanzadas). La Spark simplemente se enchufa a una toma de corriente normal.

Cada Spark tiene una tarjeta de red ConnectX-7 con dos puertos QSFP, con una capacidad de 200 Gb/s, o 25 GB/s. Esto te permite conectar varias Sparks entre sí para aumentar la memoria y el ancho de banda efectivo.

Cómo se conectan las DGX Spark

Con el paralelismo de tensores, cada matriz de pesos se divide entre las Sparks, y cada una lee únicamente su parte, desde su propia memoria, al mismo tiempo que las demás. Así, la velocidad de lectura se suma (prueba de escalabilidad de la propia NVIDIA):

• 546 GB/s con dos Sparks
• 819 GB/s con tres
• 1.092 GB/s con cuatro

Esto escala de forma casi lineal. En la prueba de NVIDIA, la escritura fue 2 veces más rápida con dos Sparks y 3,7 veces más rápida con cuatro (tabla 3). Funciona tan bien porque el enlace ConnectX-7 tiene una latencia bajísima, y CUDA puede mover datos entre las Sparks directamente desde el código de la GPU (más sobre por qué aquí).

La memoria se suma de la misma manera: 128 GB cada una, 512 GB con cuatro, de los cuales unos 120 GB por Spark son realmente utilizables para cargas de trabajo de IA.

La posibilidad de apilar Sparks mitiga su mayor inconveniente: el menor ancho de banda de memoria. Su bajo consumo en un enchufe normal la hace increíble para un solo usuario o un hogar pequeño.

DGX Spark conectadas en la vida real

Dense vs MoE

Ahora mismo hay dos arquitecturas principales de modelos: dispersos (sparse) y densos (dense). Los modelos Mixture-of-Experts (MoE) como Qwen3.6-35B activan solo 3B de parámetros por cada token generado, 9 veces menos que Qwen3.8-27B.

Esto hace que los LLM dispersos sean especialmente adecuados para la DGX Spark. Combinan perfectamente con su menor ancho de banda de memoria, ofreciendo a los usuarios una experiencia rápida a pesar del tamaño total del modelo.

El MoE no solo es bueno para la DGX Spark. También es una arquitectura superior en los centros de datos. Lo que ha cambiado para el uso local es un umbral: esperamos cierta velocidad, y los modelos densos que eran lo bastante inteligentes resultaban demasiado grandes para ir así de rápido en casa. Los modelos MoE han cruzado esa línea, por lo que ahora son útiles y rápidos en hardware local. Puede que los modelos densos también lleguen ahí con el tiempo.

LLM densos vs MoE

Decodificación especulativa

Cualquier LLM con MTP, DSpark o DFlash encajará mejor, ya que los modelos borrador suelen ser diminutos y no requieren mucha computación para generar un token correcto.

Mejora significativamente el rendimiento que pueden ofrecer las Sparks, a costa de 1 o 2 GB de memoria, algo que a la Spark le sobra.

Al igual que el MoE, la decodificación especulativa ayuda en todas partes, no solo en casa. Pero juntas son las que han empujado a la IA local más allá del límite. Antes, los mejores modelos abiertos funcionaban de forma desesperantemente lenta en hardware doméstico.

Cómo mejora el rendimiento la decodificación especulativa

Varios agentes a la vez

Una sola Spark puede atender ocho o más peticiones simultáneamente, cada una manteniendo la velocidad de una conversación. Por ejemplo, Qwen3.6-35B, capaz de programación básica, uso de ordenador y navegador, edición de vídeo e imagen y soporte general, puede gestionar hasta 8 sesiones concurrentes, cada una a unos 40 tok/s.

Como referencia, con la suscripción ChatGPT Pro, GPT-6-Astra funciona a una velocidad media de 37 tok/s.

Velocidades medias de Astra

Esto funciona porque la Spark tiene mucha potencia de cálculo para su velocidad de memoria. Atender a ocho personas sigue implicando leer el modelo una vez por paso, pero haciendo ocho veces más cálculos, y a la Spark le sobra capacidad matemática. A 16 bits, ofrece unos 100 TFLOPS por 273 GB/s, aproximadamente 370 operaciones por cada byte de memoria leído. Un M3 Ultra da unos 26 TFLOPS por 819 GB/s, unas 32 operaciones (cifras de EXO). Eso supone unas 11 veces más cómputo por byte, sin contar el hardware de 4 bits de la Spark, del que los Mac carecen.

Trabajo real

Qwen3.6-35B en una sola Spark creó un vídeo que superó las 80.000 visualizaciones en un día. Le llevó apenas 3 minutos: tomó una carpeta con 3 vídeos, los unió y aceleró el resultado 4 veces, manteniendo la tasa de fotogramas por debajo del límite de X.

https://x.com/0xSero/status/2072206209323802746

Costes

La DGX Spark salió originalmente a la venta por 3.999 $, y ese precio subió a 4.699 $. Los precios subieron en todo el hardware durante 2026.

El precio real es aún mayor. La tienda oficial de NVIDIA está agotada. La más barata que puedo encontrar ronda los 5.000 $, las de segunda mano se venden por unos 6.000 $, y el 21 de septiembre vi que la web de NVIDIA pedía 7.999 $ por la misma caja por la que yo pagué 4.699 $ cinco semanas antes.

Precios de la GX10

Marketplace de NVIDIA el 21 de septiembre. Publicación

4000$ - 4700%

Consejos de compra

• Cualquier equipo con GB10 sirve. ASUS, Dell, MSI y otros venden sus propias versiones del mismo chip. Ejecutan el mismo software y las mismas recetas. Revisa el tamaño del SSD: 1 TB se llena rápido si guardas varios modelos grandes. Yo optaría por 4 TB.
• Compra el cable junto con la segunda Spark, lo necesitarás para conectarlas entre sí.
• Algunos fabricantes ofrecen Sparks con mejor flujo de aire

Consumo, ruido y tu factura de la luz

El ruido y el calor que generan las GPU discretas no son ninguna broma; con 4x 3090 podrías consumir fácilmente entre 1600 y 2000 W para tener 1/5 de la memoria. Tuve que sacar mi torre con RTX Pro 6000 del despacho porque convertía la habitación en un horno a 35 °C de forma habitual.

Un circuito doméstico normal en EE. UU. puede soportar de forma segura unos 1.440 vatios todo el día (código eléctrico de EE. UU.). Cualquier cosa por encima requiere un circuito nuevo, lo que significa llamar a un electricista.

• Una Spark ejecutando un modelo consume entre 90 y 200 vatios (ServeTheHome). Eso son unos 12 $ al mes si la dejas encendida las 24 horas.
• Cuatro Sparks consumen unos 500 vatios en total, más un switch que gasta unos 240 W. Entre 66 y 100 $ al mes, y todo cabe en un solo enchufe.
• Mi equipo de cuatro GPU alcanza picos de 1.600 vatios. Eso es más de lo que un solo circuito puede soportar, y supone unos 300 $ al mes.

De dónde salen estos números. Cada cifra es un tipo de medición distinta, así que aquí las tienes una al lado de la otra. El coste mensual asume que la máquina funciona a ese consumo 24 horas al día, a 18 centavos por kWh:

Mis pruebas

Por qué cuatro Sparks consumen más de cuatro veces 90 W. La cifra de 90 W corresponde a una Spark sirviendo un modelo por su cuenta. Cuando un modelo grande se divide entre cuatro, cada Spark trabaja en cada palabra y mantiene ocupado su enlace de red, por lo que cada una consume más: unos 125 W de media según mis mediciones. Así que esos 12 $ y 66 $ al mes son lo que costaría funcionar a tope sin parar. El uso real, con tiempos de inactividad, cuesta menos.

Y la electricidad tampoco se está abaratando. Los precios residenciales en EE. UU. han subido alrededor de un 5 % este año, hasta unos 18 centavos por kWh, en parte por todos los nuevos centros de datos. En agosto, mi propia factura se duplicó hasta los 1.000 $ al mes, con el equipo de GPU, dos Sparks y cuatro aires acondicionados funcionando a la vez.

Sonido de la DGX Spark

¿Y el ruido? Mi equipo de GPU suena como el motor de un avión. Esto es lo máximo que llegan a sonar mis cuatro Sparks:

Unas cuantas notas prácticas:

• Úsalas con todo tipo de modelos de IA, modelos de mundo, generación de imágenes, etc.
• Ponlas de lado. Las mías se enfrían mejor así, dejando espacio alrededor de la rejilla.
• Únete a las comunidades de Discord/Reddit/X para que te ayuden a depurar errores
• Configura Tailscale en todo tu parque de máquinas

Los seis modelos que realmente uso

He probado docenas. Estos son los seis a los que siempre vuelvo.

Un token equivale aproximadamente a tres cuartos de palabra, y cualquier cosa por encima de 30 se siente como una conversación normal.

Por qué cada cifra indica una tarea. La mayoría de estas recetas usan decodificación especulativa, donde un pequeño modelo auxiliar se adelanta. El código y el JSON son fáciles de predecir; la prosa no, así que el mismo modelo en la misma máquina puede ir el doble de rápido en uno que en otro. Los prompts más largos también ralentizan las cosas. Por eso, cada velocidad aquí especifica qué se estaba generando y cuánto medía el prompt:

Una forma adecuada de medir esto en muchas tareas es el SPEED-Bench de NVIDIA, que prueba la decodificación especulativa con prompts reales de 11 categorías y longitudes de entrada de 1K a 32K tokens. Aún no lo he ejecutado en las Sparks.

• Una Spark: Qwen3.6-35B, Qwen3.8-Flash-Next, Qwen3.8-27B
• Dos Sparks: GLM-5.3-Flash.
• Cuatro Sparks: DeepSeek-V4.1-Flash.

Qwen3.8-Flash-Next en dos Sparks creando animaciones y un pequeño juego. (21 de septiembre) Publicación

Dónde conseguirlos. Cada modelo tiene una página oficial, y la sección 6 incluye una receta probada para Spark de cada uno:

• Qwen3.6-35B, o la versión de 4 bits de NVIDIA
• Qwen3.8-27B
• Qwen3.8-Flash-Next
• GLM-5.3-Flash, o mi versión para una Spark
• DeepSeek-V4.1-Flash
• GLM-5.3, o mi versión de 3 bits

Cómo es posible que los modelos grandes quepan

La respuesta es la cuantización. La cuantización comprime los pesos de un modelo, y tiene pérdida: cada peso se almacena con menos bits (digamos 4 en lugar de 16), por lo que el modelo se reduce a una cuarta parte de su tamaño, pero se pierde algo de detalle. El objetivo es acercarse lo máximo posible al comportamiento del modelo original mientras se comprimen los pesos.

Cuanto más comprimes, peor es la calidad. Turboderp midió esto para Qwen3.8-27B. Cada punto es una versión comprimida. Más a la izquierda significa más pequeño; más abajo, más parecido al original:

Divergencia KL media frente al tamaño en disco para versiones comprimidas de Qwen3.6-35B-A3B, de varios proveedores. Escala logarítmica. Gráfico: https://huggingface.co/turboderp/Qwen3.8-27B-exl3

Hay dos formatos importantes en la Spark:

• NVFP4 es el formato de 4 bits de NVIDIA, y el chip de la Spark lo lee directamente. Qwen3.6-35B pasa de 72 GB a 24 GB y cabe en una sola Spark con espacio de sobra.
• EXL3 te permite elegir exactamente cuántos bits usar. GLM-5.3-Flash a 4 bits ocupa 176 GB y cabe en dos Sparks. A 2 bits son 85 GB y cabe en una, aunque pierde algo de nitidez.

Consejo:

4 bits es el punto óptimo para modelos más pequeños, 3 bits para modelos más grandes

Cómo saber si un modelo comprimido sigue siendo bueno. Las tarjetas de modelo (model cards) de calidad indican lo cerca que se mantiene la versión pequeña del original. Dos cifras que debes buscar:

• Coincidencia Top-1: con qué frecuencia el modelo pequeño elige la misma siguiente palabra que el original. Cuanto más alto, mejor. Mi GLM-5.3-Flash para una Spark coincide aproximadamente el 80 % de las veces.
• Divergencia KL: cuánto se desvían sus predicciones respecto al original. Cuanto más baja, mejor. Mi GLM-5.3 sin podar a 3 bits obtiene 0,089. La versión podada de 197 GB saca 0,511. Ese es el precio de caber en menos Sparks.

6. De una a cuatro Sparks: guía paso a paso

Esta es la parte por la que más me preguntan. Ve paso a paso. Cada etapa funciona por sí sola, así que puedes detenerte cuando estés satisfecho.

La mayoría de las recetas siguientes vienen de MiaAI Lab, que empaqueta las mejores configuraciones para Spark en repositorios que puedes clonar y arrancar con un solo script. Algunas son mías. Todas indican en qué se probaron y a qué velocidad funcionaron.

Haz esto una vez, en cada Spark:

1. Actualízala. Ejecuta las actualizaciones en el DGX Dashboard y reinicia.
2. Accede desde tu portátil. Usa NVIDIA Sync o SSH normal. Para acceder desde fuera de casa, NVIDIA tiene un playbook de Tailscale.
3. Crea una cuenta y un token de Hugging Face. La mayoría de las recetas descargan modelos con él. Ponlo en un archivo .env, nunca en el repositorio.
4. Comprueba tu disco. Los modelos son enormes. Una receta para una Spark necesita entre 25 y 130 GB libres. La receta de DeepSeek para cuatro Sparks requiere unos 476 GB libres en la primera Spark.
5. Docker ya viene instalado. DGX OS lo incluye de serie, y casi todas las recetas se ejecutan dentro de él, así que no tienes que instalar paquetes de Python a mano.

Paso 1: una Spark

Empieza con LM Studio. Sigue la guía paso a paso de NVIDIA, descarga Qwen3.6-35B y empieza a chatear. Te llevará una hora. Así confirmas que la máquina funciona antes de meterte en cosas más complicadas.

Luego pasa a una receta. Las recetas usan vLLM o SGLang, que son más rápidos que LM Studio y permiten atender a varios agentes a la vez. Elige una:

1. Qwen3.6-35B (NVFP4 de 4 bits) MiaAI Lab 95 tok/s para un usuario, 317 en total para ocho ~50 GB
2. Qwen3.8-27B (NVFP4 de 4 bits) MiaAI Lab ~51 tok/s en código con el asistente DSpark, ~23 en chat ~24 GB
3. Qwen3.8-Flash-Next (NVFP4 de 4 bits) MiaAI Lab 48,7 tok/s para un usuario, 162,9 en total para ocho ~130 GB
4. GLM-5.3-Flash (EXL3 de 2 bits) la mía, o la versión para una Spark de la receta de Mia 10 a 25 tok/s, contexto de 262K, visión ~85 GB

La primera es la más fácil. Son tres líneas:

1git clone <https://github.com/MiaAI-Lab/Unsloth-Qwen3.6-35b-NVFP4-DGX-Spark.git>
2cd Unsloth-Qwen3.6-35b-NVFP4-DGX-Spark
3./start.sh

Cuando esté en marcha, tendrás una dirección estilo OpenAI en la Spark. Apunta hacia ella Pi, opencode, Open WebUI o la herramienta que uses.

Consejo:

si un modelo no arranca, casi siempre es por falta de memoria. Cierra primero los demás modelos. Una Spark ejecuta un modelo grande a la vez.

Paso 2: dos Sparks

Esta es la configuración que más recomiendo. Como dije en agosto: "2 DGX Sparks y listo."

2 dgx sparks

El cable. Necesitas un cable QSFP corto entre los dos puertos QSFP. Cualquiera de estos sirve (guía de cables):

• El de la propia NVIDIA: Cable QSFP de 0,4 m para DGX Spark, 99,99 $. Suele estar agotado.
• Los que menciona la documentación de NVIDIA: Amphenol NJAAKK-N911 o Luxshare LMTQF022-SD-R, 0,5 m, entre 159 $ y 187 $ aproximadamente.
• Una opción 200G más barata: NVIDIA MCP1650-V00AE30, unos 84 $.

El enlace funcionará a 200 Gb/s compres el que compres. No uses USB-C ni el puerto 10 GbE para esto. Son demasiado lentos.

Configura el enlace. Sigue el playbook de NVIDIA para conectar dos Sparks. Asigna una dirección a cada puerto y comprueba la velocidad. Después, configura SSH sin contraseña desde la primera Spark (el "head") a la segunda (el "worker"). Todas las recetas para dos Sparks lo requieren.

Te recomiendo pedirle a Claude o GPT que te lo configure, es más fácil.

Elige una receta:

1. Qwen3.8-Flash-Next (NVFP4 de 4 bits) MiaAI Lab 52,1 tok/s para un usuario con MTP, hasta 1M de contexto
2. GLM-5.3-Flash (EXL3 de 4 bits) MiaAI Lab 62,9 tok/s para un usuario, 146,5 en total para cuatro, contexto de 850K
3. DeepSeek-V4.1-Flash (EXL3 de 2,9 bits) MiaAI Lab de 38,8 a 43,0 tok/s en código, contexto de 600K
4. GLM-5.3 (EXL3 de 3 bits, podado a 197 GB) mi tarjeta de modelo cabe; velocidad aún no medida

La mayoría de las recetas para dos Sparks son iguales: copia la configuración de ejemplo, pon las direcciones de ambas Sparks, descarga y arranca. Esta es la de GLM-5.3-Flash:

1cp .env.example .env     # establece HEAD_IP y WORKER_IP
2./download.sh
3./start.sh

Aviso:

conectar Sparks funciona, pero es donde el software está menos pulido. Sigue una receta probada y reserva una tarde entera la primera vez.

Paso 3: tres Sparks

Tres Sparks no necesitan switch. Cada Spark tiene dos puertos QSFP, así que las cableas formando un triángulo: A con B, B con C, C con A. Eso son tres cables. NVIDIA admite esta configuración como un anillo sin switch.

Tres Sparks te dan unos 384 GB. Suficiente para cosas en las que dos se quedan cortas:

• DeepSeek-V4.1-Flash a su precisión nativa. La receta de MiaAI Lab lo ejecuta en un triángulo de tres Sparks a 51,0 tok/s para un usuario, con 256K de contexto. Tiene un comando doctor que comprueba SSH, Docker y los enlaces de red antes de empezar.
• GLM-5.3-Flash con más margen. La receta EXL3 para dos Sparks incluye un start-tp3.sh para tres.
• GLM-5.3 sin podar. Mi versión de 293 GB necesita la memoria equivalente a unas tres Sparks.

La receta de DeepSeek es un buen ejemplo de cómo funcionan las más grandes. Son varios pasos, no uno solo:

1./start.sh doctor    # comprueba ssh, docker, enlaces y disco
2./start.sh share     # comparte la carpeta del modelo con las otras Sparks
3./start.sh serve     # inicia los workers y luego el head

Consejo:

algunos modelos solo se dividen de forma uniforme entre 2 o 4. Comprueba que la receta indique "3x" antes de comprar la tercera.

Paso 4: cuatro Sparks

Cuatro Sparks te dan unos 512 GB. Hay dos formas de conectarlas.

Opción A: un switch (la que yo uso). Cada Spark lleva un cable a un switch 200 GbE, de modo que todas están a un solo salto de distancia entre sí. NVIDIA tiene un playbook para esto. Los switches que usa la gente:

• MikroTik CRS812-8DS-2DQ-2DDQ-RM. Sus puertos 400G se dividen cada uno en dos enlaces 200G.
• MikroTik CRS804-4DDQ-hRM. Una opción más pequeña (notas de montaje para cuatro Sparks).
• Exxact tiene una buena lista de compras para un clúster de cuatro Sparks: switch, cables y alimentación.

Como dije en septiembre: "No creo que haya una mejor oferta en el mercado que 4 Sparks con un switch MikroTik."

Opción B: sin switch. Conecta las cuatro en anillo, cada Spark cableada a sus dos vecinas. Las que no son vecinas se comunican a través de la que tienen en medio. Te ahorras el switch, pero es más complicado de configurar:

• SparkRing es un stack de software completo para pares sin switch y anillos de cuatro Sparks. Está en fase alfa, así que fija una versión concreta.
• Esta receta para GLM-5.3-Flash funciona en un anillo de cuatro Sparks con cuatro cables cortos de 100G y un NCCL parcheado. Unos 45 tok/s de media, hasta unos 100 cuando ya está caliente.

Elige una receta:

• DeepSeek-V4.1-Flash (nativo) MiaAI Lab, start-tp4.sh 45,4 tok/s para un usuario, 134,2 en total para dieciséis, contexto de 1M
• GLM-5.3-Flash (NVFP4 de 4 bits) anillo sin switch ~45 tok/s de media, ~100 en caliente

Mis mejores resultados con cuatro unidades han sido 118 tok/s para GLM-5.3-Flash con un asistente DFlash2, y entre 83,8 y 95,3 tok/s para DeepSeek-V4.1-Flash con prompts cortos (publicación).

Herramientas que te ayudan en cada paso

• \\sparkDash:\\ un panel web para ver todos tus Sparks en una sola ventana. GPU, memoria, red y tokens por segundo en tiempo real. Varias de las velocidades de esta guía se midieron con él.
• \\Playbooks de Spark de NVIDIA:\\ guías oficiales para LM Studio, Ollama, vLLM, cómo conectar Sparks y mucho más.
• \\local-ai-registry:\\ mis recetas y todas las pruebas de velocidad que he hecho.
• \\b12x:\\ las matemáticas rápidas que hay detrás de muchas recetas para Spark. No lo instalas tú; lo hacen las propias recetas. Mira las notas avanzadas más abajo.

Conclusión

El Spark es una caja de memoria. Almacena modelos enormes, los ejecuta en silencio con la corriente de casa y mejora cada vez que le añades uno más.

Si empiezas hoy:

1. Compra uno y el primer día pon a correr Qwen3.6-35B desde LM Studio.
2. Pásate a una receta cuando necesites más velocidad o quieras usar muchos agentes.
3. Compra el segundo Spark y el cable cuando quieras usar GLM-5.3-Flash o DeepSeek-V4.1-Flash. Para la mayoría de la gente, aquí es donde hay que parar.
4. Ve a tres o cuatro solo si quieres los modelos más grandes o ejecutar varios a la vez.

¿Los volvería a comprar? Sí. Y si empezara de cero, compraría dos desde el primer día.

Avanzado: cómo escala la conexión de Sparks

No necesitas saber esto para usar un Spark. Es para cuando quieras entender por qué los números son como son.

Casi lineal, al escribir

Cada palabra que genera el modelo implica leer sus pesos activos desde la memoria. Si divides el modelo entre varios Sparks, cada uno lee su parte al mismo tiempo, así que las velocidades de lectura se suman.

NVIDIA lo midió. Al pasar de uno a dos y luego a cuatro Sparks, el tiempo para generar cada palabra bajó de 269 ms a 133 ms y después a 72 ms. Eso es 2,0x con dos y 3,7x con cuatro (blog de NVIDIA, tabla 3).

Se acerca tanto porque el enlace ConnectX-7 tiene una latencia muy baja y los intercambios entre Sparks pueden hacerse dentro del propio código de la GPU. Esta explicación para Macs desarrolla la misma idea con más detalle.

Después de cada capa, los Sparks intercambian sus resultados parciales antes de que pueda empezar la siguiente. El intercambio es pequeño, pero ocurre en cada capa y con cada palabra. Cada uno consume un poco de tiempo que no se reduce por añadir más Sparks.

• El enlace es de 200 Gb/s, unos 25 GB/s. Eso es una décima parte de la velocidad de memoria del propio Spark. No pasa nada porque los intercambios son pequeños.
• Usa RDMA. Los datos van directos de la memoria de un Spark a la del otro sin que la CPU tenga que copiarlos. Cada puerto QSFP aparece como dos mitades de 100 Gb/s, y el software tiene que usar ambas para llegar a los 200 completos (detalles). NCCL, la biblioteca de NVIDIA para esto, se encarga de ello.
• La lectura escala peor que la escritura. En la misma prueba de NVIDIA, leer un prompt de 32K tokens fue 1,6x más rápido con dos Sparks y 2,1x con cuatro. La lectura mueve muchos más datos entre Sparks en cada paso.
• Los anillos añaden saltos. En un triángulo de tres Sparks, cada uno está conectado por cable a los otros dos. En un anillo de cuatro, algunos pares se comunican a través de un vecino. Un switch deja a todos a un salto de distancia. SparkRing escribe su propio código de intercambio (SIRCL) para acelerar los anillos.
• Los modelos mixture-of-experts añaden una segunda división. Las recetas suelen combinar tensor parallel con "expert parallel", donde distintos Sparks guardan distintos expertos.

Las otras dos formas de ir más rápido

• Muchos usuarios a la vez. El Spark lee el modelo una vez por paso y responde a todos a partir de esa única lectura. Por eso la velocidad total sube mucho más rápido que la de un solo usuario.
• Un modelo de decodificación especulativa que se adelanta. MTP, DSpark y DFlash2 hacen exactamente esto. Un asistente pequeño y rápido propone varias palabras, y el modelo grande las comprueba todas en una sola lectura. Cuando acierta, consigues varias palabras por el precio de una. Así es como GLM-5.3-Flash pasa de 27 tok/s en texto libre a 65 en salidas estructuradas con la misma receta.

Qwen3.6-35B-A3B a 4 bits en un solo Spark, con un asistente de aceleración activado. Fuente: prueba de velocidad de local-ai-registry, agosto de 2026.

La IA en la nube y la IA local son cosas distintas

Una GPU en la nube es muchísimo más rápida que un Spark. Pero los proveedores cloud reparten cada GPU entre muchos usuarios y eligen un punto de equilibrio entre coste por token y velocidad por usuario. La mayoría prioriza el coste, así que cada usuario recibe menos tokens por segundo de los que el hardware podría darle a una sola persona. InferenceX muestra ese equilibrio en una gráfica para Qwen3.8-Flash-Next.

En casa, ese dilema no existe. La máquina es tuya, así que puedes dedicarle toda su potencia a una sola persona. Por eso un Spark puede sentirse tan rápido como un servicio en la nube, aunque su hardware no lo sea.

sm_121: por qué el software de Spark va por libre

Cada GPU de NVIDIA tiene un número de "capacidad de cómputo" que le indica al software qué instrucciones tiene disponibles. La GPU del Spark es 12.1, o sm_121 (primeras impresiones de Simon Willison). La RTX 5090 y la RTX PRO 6000 son sm_120, una prima hermana. Los chips de centro de datos de NVIDIA, B200 y B300, son sm_100 y sm_103, una familia distinta.

Esto importa porque el código de IA más rápido se escribe para una familia cada vez. Cuando salió el Spark, gran parte del software simplemente no funcionaba o iba lento (foro de NVIDIA, issue de vLLM).

La solución ha sido que la gente escriba código específico para Spark:

• b12x, de Local Inference Lab, es una biblioteca de kernels para sm_120 y sm_121: el DGX Spark, el RTX Spark, la RTX 5090 y la RTX PRO 6000. Cubre operaciones matriciales de 4 bits (NVFP4, MXFP4), atención para modelos estilo DeepSeek, capas mixture-of-experts y un cargador de modelos rápido. Se instala con pip install b12x, y las recetas de vLLM lo activan con flags como flashinfer_b12x. La receta de Qwen3.6-35B lo usa.
• SparkInfer es el nombre antiguo de b12x. El enlace viejo ahora redirige a b12x. Mi receta de DeepSeek para un solo Spark usa su código de atención tanto para leer como para escribir. No lo confundas con sparkinfer de gittensor, un runtime independiente para tarjetas RTX (solo sm_120).
• ExLlamaV3 es lo que ejecuta los modelos EXL3. MiaAI Lab mantiene un fork con el port para Arm (GB10) y soporte para modelos asistentes.
• lil es el lanzador de Local Inference Lab. Lee la configuración de tu máquina y construye el comando de vLLM adecuado para un solo Spark o para un grupo conectado.

Avanzado: el Spark como máquina de investigación

Esta es la parte que no me esperaba. El Spark es lento escribiendo, pero muy bueno leyendo. Y casi todo el trabajo de investigación con modelos consiste en leer.

Lo que mejor hace el Spark: prefill

Un modelo realiza dos tareas distintas:

• Prefill es leer tu prompt. Todo el prompt entra de golpe, así que el límite es la potencia de cálculo bruta. El GB10 va sobrado: hasta 1 petaflop en operaciones de 4 bits.
• Decode es escribir la respuesta, palabra por palabra. Cada palabra implica volver a leer el modelo desde la memoria, así que el límite es la velocidad de la memoria. Y ahí es donde el Spark flojea.

Por eso un Spark lee prompts entre 13 y 41 veces más rápido de lo que escribe:

DeepSeek-V4.1-Flash en cuatro Sparks: 3.360 tok/s leyendo un prompt de 32K tokens, 3.273 a 131K, mientras que la escritura se queda entre 70 y 95. (20 de septiembre) Publicación

Por qué eso es justo lo que necesita la investigación

Casi todo lo que hago para reducir modelos consiste en leer, no en escribir:

• Cuantización (menos bits). Las versiones EXL3 y NVFP4 se crean pasando texto de muestra por el modelo y midiendo cuánto pierde cada capa con cada ancho de bit. Eso es leer.
• Pruning (menos expertos). REAP pasa texto de muestra por un modelo mixture-of-experts y registra cuánto se usa cada experto. Los menos útiles se eliminan. Mi GLM-5.3 de 197 GB conserva 168 de 256 expertos. También es lectura.
• Comprobar la calidad. La concordancia top-1 y la divergencia KL salen de pasar el mismo texto por el modelo original y por el pequeño, y comparar sus predicciones. Otra vez lectura.
• Pruebas de contexto largo. Comprobar que un modelo puede encontrar un dato concreto entre 262.000 tokens es básicamente una lectura larguísima.

Mi propio flujo de trabajo cambió precisamente por esto. "Ahora hago todo mi pruning/exl3/benchmarking en los DGX Sparks, dejo las 6000 para inferencia. Es más lento, pero 2-3 días frente a 12 horas me parece bien." El DeepSeek para un solo Spark que superó las 100.000 descargas es un modelo podado con REAP y comprimido con EXL3.

Cómo encaja esto con los objetivos de investigación

Si tu objetivo es aprender algo sobre un modelo, el Spark encaja perfectamente:

• Aloja el modelo grande. Puedes medir un modelo de 300B en una o dos cajas en lugar de alquilar un clúster.
• Funciona durante días con la luz de casa. Las calibraciones y evaluaciones largas pueden correr sin supervisión y sin que te arruine la factura.
• Libera tu hardware rápido. Mis GPUs sirven modelos mientras los Sparks hacen el trabajo lento y minucioso.
• Puedes calibrar con tus propios datos. He podado modelos usando mis propias sesiones de agentes y mis textos, que son privados y no salen de mi escritorio.
• Es un buen anfitrión para agentes de investigación. He llegado a tener cuatro agentes trabajando en objetivos de investigación a la vez en los Sparks, cada uno a unos 120 tok/s.
• El entrenamiento escala bien entre Sparks. En la prueba de NVIDIA, el fine-tuning fue 2x más rápido con dos Sparks y 4x con cuatro, porque los Sparks solo se sincronizan una vez por paso (tabla 5). Los playbooks de NVIDIA cubren el fine-tuning con PyTorch. Yo aún no he cronometrado el entrenamiento por mi cuenta.

Avanzado: GB10, GB300 y el Spark como memoria extra

"GB" significa Grace Blackwell: una CPU Arm y una GPU Blackwell en un solo paquete, compartiendo memoria mediante un enlace rápido llamado NVLink-C2C. El GB10 del Spark es la versión más pequeña de ese concepto, con una CPU Arm de 20 núcleos desarrollada junto a MediaTek.

El GB300 es la versión para centros de datos: una CPU Grace con GPUs Blackwell Ultra (B300). Va montado en los racks GB300 NVL72 de NVIDIA, y un solo GB300 da vida a la DGX Station. El GB10 no es un trozo recortado de un GB300. Es el mismo diseño, pero en miniatura, y por eso el mismo software funciona en ambos.

Conclusión

El DGX Spark se ha hecho un hueco en mi casa y cada día gana más soporte, utilidad y capacidad.

Fuentes y lecturas recomendadas

• Mis publicaciones: todo lo fechado más arriba está en mi perfil de X. Las velocidades vienen de mis propias pruebas, publicadas en el local-ai-registry.
• Recetas: MiaAI Lab en GitHub, mis modelos en Hugging Face.
• Hardware y precios: página del DGX Spark de NVIDIA, documentación de hardware de NVIDIA, VideoCardz sobre la subida de precio, VideoCardz sobre los precios de septiembre, rastreador de precios de pi3g.
• Conectar Sparks: documentación de clústeres de NVIDIA, blog de escalabilidad de NVIDIA, playbook con switch, guía de cables, guía de benchmarking de NVIDIA para dos Sparks.
• Consumo eléctrico: reseña de ServeTheHome, Tom's Hardware sobre el consumo en reposo, precios de la electricidad en EE. UU. (EIA vía Utility Dive), código eléctrico de EE. UU. sobre cargas continuas.
• Formatos y software: NVIDIA sobre NVFP4, ExLlamaV3, b12x, REAP, capacidades de cómputo.
• Velocidad en la nube: InferenceX de SemiAnalysis.
• GB300: especificaciones del GB300 NVL72, especificaciones de la DGX Station, EXO sobre Spark más Mac Studio.
• Para empezar: playbooks de Spark de NVIDIA.
• La perspectiva general: State of Local AI: 2026.