Manual de DGX Spark

Autor: @0xSero

Revisores: @alexocheema y @alexzfunk

Agradecimiento especial a: @MiaAI_lab

Si estás pensando en correr inferencia de forma local, seguro vas a toparte con este pequeño ladrillo dorado. Es una máquina diseñada para servir IA de manera local: compacta, limpia, silenciosa y relativamente económica (página de la DGX Spark de NVIDIA).

Cuando escuché por primera vez sobre 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 muy bajo. Para que te des una idea, una RTX 5090 tiene aproximadamente 6.5 veces más ancho de banda (1,792 GB/s), y eso que solo cuenta con 32 GB de VRAM.

Cuando salió la Spark, prácticas de ingeniería de inferencia como el decodificado especulativo 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 por ingeniería de inferencia está creciendo.
2. Los LLMs son cada vez más competentes en ingeniería de inferencia.
3. Una inferencia de alta calidad mejora el sistema.

Hoy, la DGX Spark es capaz de correr modelos sumamente 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 tus impuestos, estudiar o simplemente entretenerte.

Cuando hablo de 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 costo por token, así que a ti te toca menos. En casa, la caja 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. Por lo general, se mantienen alrededor de los 95 W con un modelo cargado y sirviendo.

Por eso, no necesitan mucha refrigeración y son bastante silenciosas comparadas con las GPUs discretas. Puedes apilar de 2 a 4 en un circuito eléctrico estadounidense estándar sin ningún miedo. Ese es justamente el punto, no la eficiencia bruta: por unidad de velocidad de memoria, una B300 de centro de datos hace aproximadamente el doble de trabajo por julio (mira las notas avanzadas). La Spark solo necesita enchufarse a un tomacorriente normal.

Cada Spark tiene una tarjeta de red ConnectX-7 con dos puertos QSFP, 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 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 las pruebas 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 detalles aquí).

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

Poder apilar Sparks resuelve su mayor limitación: el menor ancho de banda de memoria. Su bajo consumo en un enchufe común la vuelve 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: sparse (dispersos) y dense (densos). 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 LLMs sparse sean ideales para la DGX Spark. Combinan perfecto con su menor ancho de banda de memoria, ofreciendo 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 cambió para el uso local fue cruzar un umbral: esperamos cierta velocidad, y los modelos densos lo suficientemente inteligentes eran demasiado grandes para correr así de rápido en casa. Los modelos MoE superaron esa barrera, por lo que ahora son útiles y rápidos en hardware local. Puede que los modelos densos también lleguen ahí eventualmente.

LLMs Dense vs MoE

Decodificado especulativo

Cualquier LLM con MTP, DSpark o DFlash será una mejor opción, 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 alcanzar las Sparks, a cambio de 1 o 2 GB de memoria, algo que a la Spark le sobra.

Al igual que el MoE, el decodificado especulativo ayuda en todas partes, no solo en casa. Pero juntos fueron los que empujaron a la IA local a superar ese umbral. Antes, los mejores modelos abiertos corrían dolorosamente lento en hardware doméstico.

Cómo el decodificado especulativo mejora el rendimiento

Varios agentes a la vez

Una sola Spark puede atender ocho o más solicitudes simultáneas, cada una a velocidad de conversación. Por ejemplo, Qwen3.6-35B, capaz de programar a nivel básico, usar la computadora y el navegador, editar video e imagen y dar soporte general, puede manejar hasta 8 sesiones concurrentes, cada una a unos 40 tok/s.

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

Velocidades promedio de Astra

Esto funciona porque la Spark tiene muchísimo poder de cómputo 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, tiene unos 100 TFLOPS por 273 GB/s, lo que equivale a unas 370 operaciones por cada byte de memoria leído. Un M3 Ultra tiene unos 26 TFLOPS por 819 GB/s, es decir, unas 32 (cifras de EXO). Eso es unas 11 veces más cómputo por byte, sin contar el hardware de 4 bits de la Spark, que las Mac no tienen.

Trabajo real

Qwen3.6-35B en una sola Spark creó un video que superó las 80,000 vistas en un día. Le tomó apenas 3 minutos: tomó una carpeta con 3 videos, los unió y aceleró el resultado 4 veces, manteniendo los fotogramas por segundo por debajo del límite de X.

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

Costos

La DGX Spark salió originalmente a $3,999, y ese precio subió a $4,699. Los precios de todo el hardware aumentaron en 2026.

El precio real es aún mayor. La tienda oficial de NVIDIA está agotada. La más barata que encuentro ronda los $5,000, las usadas se venden por unos $6,000, y el 21 de septiembre vi que la página 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 caja con GB10 sirve. ASUS, Dell, MSI y otros venden sus propias versiones del mismo chip. Corren el mismo software y las mismas recetas. Revisa el tamaño del SSD: 1 TB se llena rapidísimo si guardas un par de modelos grandes. Yo me iría por 4 TB.
• Compra el cable junto con la segunda Spark, lo necesitas para conectarlas entre sí.
• Algunos fabricantes ofrecen Sparks con mejor flujo de aire

Consumo, ruido y tu recibo de luz

El ruido y el calor que generan las GPUs discretas no son cosa de risa; con 4x 3090 podrías consumir fácilmente entre 1600 y 2000 W para tener apenas 1/5 de la memoria. Tuve que sacar mi torre RTX Pro 6000 de la oficina porque calentaba la habitación a 35 °C constantemente.

Un circuito doméstico normal en EE. UU. soporta de forma segura unos 1,440 watts todo el día (código eléctrico de EE. UU.). Cualquier cosa por encima requiere un circuito nuevo, y eso significa llamar a un electricista.

• Una Spark corriendo un modelo consume entre 90 y 200 watts (ServeTheHome). Eso son unos $12 al mes si la dejas encendida las 24 horas.
• Cuatro Sparks consumen unos 500 watts en total, más un switch que usa unos 240 W. Entre $66 y $100 al mes, y todo cabe en un solo enchufe.
• Mi equipo de cuatro GPUs alcanza picos de 1,600 watts. Eso es más de lo que aguanta un solo circuito, y cuesta unos $300 al mes.

De dónde salen estos números. Cada cifra representa un tipo de medición distinta, así que aquí las tienes lado a lado. El costo mensual asume que la máquina funciona con 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 en promedio según mis mediciones. Así que $12 y $66 al mes es lo que costaría tenerlas funcionando a tope sin parar. El uso real, con tiempos de inactividad, sale más barato.

Y la electricidad tampoco se está abaratando. Los precios residenciales en EE. UU. subieron 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 propio recibo se duplicó a $1,000 al mes, con el equipo de GPUs, dos Sparks y cuatro aires acondicionados funcionando al mismo tiempo.

Sonido de la DGX Spark

¿Y el ruido? Mi equipo de GPUs suena como el motor de un avión. Esto es lo más fuerte 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 comunidades de Discord, Reddit o X para que te ayuden a resolver problemas
• Configura Tailscale en todo tu equipo

Los seis modelos que realmente uso

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

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

Por qué cada número indica una tarea. La mayoría de estas recetas usan decodificado especulativo, donde un modelo auxiliar pequeño se adelanta a adivinar. El código y el JSON son fáciles de predecir, la prosa no, así que un mismo modelo en la misma máquina puede correr el doble de rápido en uno que en otro. Los prompts largos también ralentizan las cosas. Por eso, cada velocidad aquí aclara qué se estaba generando y qué tan largo era el prompt:

Una forma adecuada de medir esto en múltiples tareas es el SPEED-Bench de NVIDIA, que prueba el decodificado especulativo con prompts reales de 11 categorías y longitudes de entrada de 1K a 32K tokens. Todavía no lo he corrido 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 jueguito. (21 de septiembre) Publicación

Dónde conseguirlos. Cada modelo tiene su 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 siquiera entren

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, aunque se pierde algo de detalle. El objetivo es acercarse lo más posible al comportamiento del modelo original mientras se comprimen los pesos.

Mientras 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 es más pequeño, más abajo es más fiel 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 que importan en la Spark:

• NVFP4 es el formato de 4 bits de NVIDIA, y el chip de la Spark lo lee de forma nativa. 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 pesa 176 GB y cabe en dos Sparks. A 2 bits pesa 85 GB y entra en una sola, aunque pierde un poco de nitidez.

Consejo:

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

Cómo saber si un modelo comprimido sigue siendo bueno. Las model cards de calidad indican qué tan cerca se mantiene la versión pequeña del original. Dos métricas clave:

• Coincidencia Top-1: con qué frecuencia el modelo pequeño elige la misma siguiente palabra que el original. Mientras más alto, mejor. Mi GLM-5.3-Flash para una Spark coincide alrededor del 80 % de las veces.
• Divergencia KL: cuánto se desvían sus predicciones respecto al original. Mientras 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 detente cuando estés satisfecho.

La mayoría de las recetas de abajo vienen de MiaAI Lab, quienes empaquetan las mejores configuraciones para Spark en repositorios que puedes clonar y arrancar con un solo script. Algunas son mías. Todas detallan en qué se probaron y qué tan rápido corrieron.

Haz esto una sola vez, en cada Spark:

1. Actualízala. Corre las actualizaciones en el DGX Dashboard y luego reinicia.
2. Accede desde tu laptop. Usa NVIDIA Sync o SSH tradicional. Para acceder desde fuera de tu casa, NVIDIA tiene un playbook de Tailscale.
3. Crea una cuenta y un token de Hugging Face. Casi todas las recetas descargan modelos con él. Guárdalo en un archivo .env, nunca dentro del repo.
4. Revisa 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 fábrica, y casi todas las recetas corren 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 tomará cerca de una hora. Esto te confirma que la caja funciona antes de meterte con cosas más complejas.

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

1. Qwen3.6-35B (4 bits NVFP4) MiaAI Lab 95 tok/s para un usuario, 317 en total para ocho ~50 GB
2. Qwen3.8-27B (4 bits NVFP4) MiaAI Lab ~51 tok/s en código con el auxiliar DSpark, ~23 en chat ~24 GB
3. Qwen3.8-Flash-Next (4 bits NVFP4) MiaAI Lab 48.7 tok/s para un usuario, 162.9 en total para ocho ~130 GB
4. GLM-5.3-Flash (2 bits EXL3) 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é arriba, tendrás una dirección estilo OpenAI en la Spark. Apunta Pi, opencode, Open WebUI o la herramienta que uses hacia ella.

Consejo:

si un modelo no arranca, casi siempre es falta de memoria. Cierra primero los otros modelos. Una Spark corre 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 oficial de 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, de 0.5 m, entre $159 y $187 aprox.
• 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. Le asigna una dirección a cada puerto y verifica la velocidad. Luego configura SSH sin contraseña desde la primera Spark (el "head") hacia la segunda (el "worker"). Todas las recetas para dos Sparks lo requieren.

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

Elige una receta:

1. Qwen3.8-Flash-Next (4 bits NVFP4) MiaAI Lab 52.1 tok/s para un usuario con MTP, hasta 1M de contexto
2. GLM-5.3-Flash (4 bits EXL3) MiaAI Lab 62.9 tok/s para un usuario, 146.5 en total para cuatro, contexto de 850K
3. DeepSeek-V4.1-Flash (2.9 bits EXL3) MiaAI Lab 38.8 a 43.0 tok/s en código, contexto de 600K
4. GLM-5.3 (3 bits EXL3, podado a 197 GB) mi model card 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     # configura HEAD_IP y WORKER_IP
2./download.sh
3./start.sh

Ojo:

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 en triángulo: A con B, B con C, C con A. Eso son tres cables. NVIDIA soporta esto como un anillo sin switch.

Tres Sparks te dan unos 384 GB. Eso alcanza para cosas que dos no pueden contener:

• DeepSeek-V4.1-Flash a su precisión nativa. La receta de MiaAI Lab lo corre en un triángulo de tres Sparks a 51.0 tok/s para un usuario, con 256K de contexto. Tiene un comando doctor que revisa SSH, Docker y los enlaces de red antes de empezar.
• GLM-5.3-Flash con más espacio. 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    # revisa ssh, docker, enlaces, 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. Verifica que la receta diga "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 (lo que yo uso). Cada Spark lleva un cable a un switch 200 GbE, de modo que todas están a un 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 armado 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 está en medio. Te ahorras el switch, pero es más difícil 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 específica.
• Esta receta de GLM-5.3-Flash corre en un anillo de cuatro Sparks con cuatro cables cortos de 100G y un NCCL parcheado. Unos 45 tok/s en promedio, 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 en promedio, ~100 en caliente

Mis mejores resultados con cuatro Sparks son 118 tok/s para GLM-5.3-Flash usando 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 más.
• \\local-ai-registry:\\ mis recetas y todas las pruebas de velocidad que he hecho.
• \\b12x:\\ la matemática rápida que impulsa muchas recetas de Spark. No lo instalas tú; las recetas lo hacen por ti. Mira las notas avanzadas más abajo.

Conclusión

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

Si empiezas hoy:

1. Compra uno y corre Qwen3.6-35B desde LM Studio el primer día.
2. Pásate a una receta cuando quieras más velocidad o usar muchos agentes.
3. Compra el segundo Spark y el cable cuando necesites GLM-5.3-Flash o DeepSeek-V4.1-Flash. Para la mayoría, aquí es donde conviene parar.
4. Ve por tres o cuatro solo si quieres correr los modelos más grandes o 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 esto para usar un Spark. Es para cuando quieras entender por qué los números son como son.

Casi lineal, para 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 a lo lineal porque el enlace ConnectX-7 tiene una latencia muy baja, y los intercambios entre Sparks pueden ocurrir dentro del propio código de la GPU. Esta explicación para Macs detalla la misma idea con más profundidad.

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 suma un poco de tiempo que no se reduce al agregar 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 hay problema porque los intercambios son pequeños.
• Usa RDMA. Los datos van directo 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 alcanzar 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 suman 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 paralelismo de tensores con "paralelismo de expertos", donde distintos Sparks guardan diferentes 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 con esa única lectura. Por eso, la velocidad total sube mucho más rápido que la de un solo usuario.
• Un modelo decodificador especulativo que adivina por adelantado. MTP, DSpark y DFlash2 hacen exactamente esto. Un asistente pequeño y rápido propone varias palabras, y el modelo grande las revisa 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 comparten cada GPU entre muchos usuarios, y eligen un punto de equilibrio entre el costo por token y la velocidad por usuario. La mayoría prioriza el costo, así que cada usuario recibe menos tokens por segundo de los que el hardware podría darle a una sola persona. InferenceX grafica ese equilibrio 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 su cuenta

Toda 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 (primer vistazo de Simon Willison). La RTX 5090 y la RTX PRO 6000 son sm_120, una prima cercana. Los chips de data center de NVIDIA, B200 y B300, son sm_100 y sm_103, una familia distinta.

Eso importa porque el código de IA más rápido se escribe para una familia a la vez. Cuando salió el Spark, gran parte simplemente no corría 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 matemática de matrices 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 anterior de b12x. El link viejo ahora redirige a b12x. Mi receta de DeepSeek para un Spark usa su código de atención tanto para leer como para escribir. No lo confundas con sparkinfer de gittensor, un runtime aparte para tarjetas RTX (solo sm_120).
• ExLlamaV3 es lo que corre los modelos EXL3. MiaAI Lab mantiene un fork con el port para Arm (GB10) y soporte para modelos asistentes.
• lil es el launcher de Local Inference Lab. Lee la configuración de tu máquina y arma el comando de vLLM correcto para un Spark o para un grupo conectado.

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

Esto no me lo esperaba. El Spark es lento para escribir, pero es excelente leyendo. Y casi todo el trabajo de investigación con modelos consiste en leer.

Lo que mejor hace el Spark: prefill

Un modelo cumple dos tareas distintas:

• Prefill es leer tu prompt. Todo el prompt entra de golpe, así que el límite es la potencia bruta de cómputo. El GB10 tiene de sobra: hasta 1 petaflop de matemática de 4 bits.
• Decode es escribir la respuesta, una palabra a la vez. Cada palabra implica volver a leer el modelo desde la memoria, así que el límite es la velocidad de la memoria. Ese es el punto débil del Spark.

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 mantiene 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 achicar modelos es lectura, no escritura:

• 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 bits. 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.
• Verificar la calidad. La concordancia top-1 y la divergencia KL salen de leer el mismo texto con el modelo original y con el reducido, y comparar sus predicciones. Lectura otra vez.
• Pruebas de contexto largo. Comprobar que un modelo puede encontrar un dato entre 262,000 tokens es básicamente una lectura larguísima.

Mi propio flujo de trabajo cambió exactamente por esto. "Ahora corro todo mi pruning/exl3/benchmarking en los DGX Sparks, dejo las 6000 para inferencia. Es más lento, pero 2-3 días contra 12h está bien." El DeepSeek para un Spark que superó las 100,000 descargas es un modelo podado con REAP y comprimido con EXL3.

Cómo se conecta esto con los objetivos de investigación

Si tu meta es aprender algo sobre un modelo, el Spark encaja perfecto:

• Guarda el modelo grande. Puedes medir un modelo de 300B en una o dos cajas en lugar de alquilar un clúster.
• Corre durante días con la luz de tu casa. Las calibraciones y evaluaciones largas pueden ejecutarse solas sin que te llegue una factura enorme.
• 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 textos, que son privados y no salen de mi escritorio.
• Es un buen host para agentes de investigación. Llegué a tener cuatro agentes trabajando en objetivos de investigación en los Sparks al mismo tiempo, cada uno a unos 120 tok/s.
• El entrenamiento escala bien entre Sparks. En la prueba de NVIDIA, el fine-tuning corrió 2x más rápido con dos Sparks y 4x más rápido 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 todavía no cronometré entrenamientos 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 chica de ese concepto, con una CPU Arm de 20 núcleos desarrollada junto a MediaTek.

El GB300 es la versión para data centers: una CPU Grace con GPUs Blackwell Ultra (B300). Va montado en los racks GB300 NVL72 de NVIDIA, y un GB300 es el corazón de la DGX Station. El GB10 no es un pedazo recortado de un GB300. Es el mismo diseño, pero miniaturizado, y por eso el mismo software corre en ambos.

Conclusión

El DGX Spark se ganó su lugar en mi casa, y cada día suma más soporte, utilidad y capacidad.

Fuentes y lecturas recomendadas

• Mis publicaciones: todo lo fechado arriba está en mi perfil de X. Las velocidades vienen de mis propias pruebas, publicadas en local-ai-registry.
• Recetas: MiaAI Lab en GitHub, mis modelos en Hugging Face.
• Hardware y precio: 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 clustering 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: Review de ServeTheHome, Tom's Hardware sobre el consumo en reposo, Precios de 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 + Mac Studio.
• Para empezar: Playbooks de Spark de NVIDIA.
• El panorama general: State of Local AI: 2026.