Ejecuta modelos de clase 70B a 120B en 128 GB de memoria unificada
Un DGX Spark tiene 128 GB de memoria compartida por su CPU y su GPU, así que modelos que nunca caben en una tarjeta gráfica de 24 o 32 GB se cargan de una pieza. Caber no es lo mismo que ser rápido. La memoria mueve 273 GB/s, y cada token generado lee una vez los pesos activos del modelo. En uno de mis Sparks, un Llama 3.3 70B denso generó 6,0 tokens por segundo con una sola solicitud. Un modelo mixture-of-experts solo lee una parte de sus pesos por token: gpt-oss-120b alcanza 58,7 tok/s en el mismo chip, según las mediciones publicadas. Elige el modelo según el ancho de banda y luego alquila un Spark por las horas que necesites.
Primera recarga: paga 20 $ y recibe 30 $ de crédito, unas 37 horas en un Spark. Facturado por minuto con crédito prepago. Termina la instancia cuando acabes y se deja de facturar.
Qué cabe y a qué velocidad va una solicitud
| Modelo y formato | Leído por token | Una solicitud | Fuente |
|---|---|---|---|
| Qwen3-Coder 30B-A3B, AWQ de 4 bits | unos 3B parámetros | 80,9 tok/s | Mi ejecución, vLLM 0.27.1, 2 sep. 2026 (log sin editar) |
| gpt-oss-120b, MXFP4 | 5,1B de 117B | 58,7 tok/s | Publicado: resultados de llama.cpp en DGX Spark, build 7941, 5 feb. 2026 |
| gpt-oss-120b, MXFP4 | 5,1B de 117B | 33,5 tok/s | Publicado: Dendro Logic, vLLM, prompts de 1500 tokens y salida JSON, 22 abr. 2026 |
| Nemotron-3-Super-120B-A12B, NVFP4 | 12B de 120B | unos 24 tok/s | Publicado: foro de NVIDIA, vLLM con un arreglo de CUTLASS, 29 mar. 2026 |
| Llama 3.3 70B, AWQ de 4 bits | los 70B (denso) | 6,0 tok/s | Mi ejecución, vLLM 0.27.1, 2 sep. 2026 (log sin editar) |
| Nemotron Super 49B v1.5, NVFP4 | los 49B (denso) | 5,79 tok/s | Publicado: Dendro Logic, 22 abr. 2026 |
| Qwen3-235B-A22B, UD-Q4_K_XL (134 GB) | 22B de 235B | unos 1,8 tok/s; no cabe | Publicado: foro de NVIDIA, llama.cpp, 17 dic. 2025 |
Las filas "Publicado" son mediciones de otras personas, que recopilé y comprobé con sus fuentes el 11 de octubre de 2026 para la página de benchmarks; no las he reproducido. Las dos filas de gpt-oss-120b muestran cuánto cambian el motor y la carga de trabajo un mismo modelo en un mismo chip. El número de parámetros de gpt-oss-120b procede de su ficha del modelo, a través de la calculadora de memoria.
Por qué un 70B denso es lento y un MoE de 120B no
Generar un token implica leer una vez de memoria los pesos activos, así que el techo es el ancho de banda de memoria dividido entre los bytes leídos por token:
tokens/s ceiling ≈ 273 GB/s ÷ GB of active weights read per token Llama 3.3 70B, 4-bit: about 37 GB per token → about 7.4 tok/s (measured 6.0) gpt-oss-120b, MXFP4: about 3 GB per token → about 90 tok/s (reported 58.7)
Los motores reales quedan entre aproximadamente la mitad y cuatro quintos del techo. Por debajo de unos 10 tok/s, un modelo se nota lento en una ventana de chat, por eso un 70B denso en un Spark es un modelo para lotes: con 128 solicitudes en curso, mi ejecución de 70B llegó a 485 tok/s en total, contando tokens del prompt y generados, pero cada solicitud bajó a 1,4 tok/s. Las curvas completas de concurrencia están en la página de benchmarks.
Lo que yo ejecutaría
- Un modelo de clase 120B con el que puedes conversar: gpt-oss-120b en MXFP4. Los pesos ocupan 65,2 GB, lo que deja margen para un contexto largo, y lee unos 5B parámetros por token.
- Si prima la velocidad: un modelo mixture-of-experts de Qwen3 a 4 bits, como Qwen3-30B-A3B o Qwen3.6-35B-A3B. Leen unos 3B parámetros por token.
- Un 70B denso: solo para trabajos por lotes, o cuando necesitas exactamente ese modelo. Cuenta con unos 6 tok/s por solicitud.
- Cuantiza a 4 bits. MXFP4, NVFP4, AWQ o Q4_K_M reducen a la mitad los bytes por token respecto a FP8 y aproximadamente duplican el techo. El coste en calidad varía según el formato; la guía de velocidad de cuantización los compara en este chip.
- Más de 128 GB: dos Sparks enlazados, a 1,79 $ la hora por el clúster de dos nodos cuando la consola lo ofrece. El informe de Qwen3-235B de arriba pasó de unos 1,8 tok/s en un Spark a unos 12,5 en dos. La guía de dos nodos explica qué aporta emparejarlos.
Ejecuta gpt-oss-120b con llama.cpp
Para un usuario cada vez, llama.cpp es el motor más rápido en este chip. Despliega DGX Spark 1× con la imagen DGX OS, abre el terminal del navegador, compila llama.cpp para el GB10 (de 5 a 10 minutos) y arranca el modelo. Los pasos de compilación son los mismos que en mi guía de llama.cpp.
apt-get update && apt-get install -y build-essential cmake libcurl4-openssl-dev git clone https://github.com/ggml-org/llama.cpp /workspace/llama.cpp cd /workspace/llama.cpp cmake -B build -DGGML_CUDA=ON -DGGML_CURL=ON -DCMAKE_CUDA_ARCHITECTURES=121a-real cmake --build build --config Release --target llama-server -j # downloads about 65 GB the first time ./build/bin/llama-server -hf ggml-org/gpt-oss-120b-GGUF --jinja \ --host 127.0.0.1 --port 30000
Cuando el log diga que el servidor está escuchando, mide tu propia velocidad desde un segundo terminal. llama-server devuelve sus tiempos con cada respuesta:
curl -s http://127.0.0.1:30000/v1/chat/completions -H "Content-Type: application/json" \
-d '{"messages":[{"role":"user","content":"Explain memory bandwidth in three sentences."}],"max_tokens":300}' \
| python3 -c 'import json,sys; t=json.load(sys.stdin)["timings"]; print(round(t["predicted_per_second"],1), "tok/s")'
El reloj corre también durante la descarga, así que lánzala primero y ve leyendo mientras baja. Para llegar al servidor desde tu portátil, usa un túnel SSH con tu propia clave, o arráncalo con --host 0.0.0.0 --api-key y una clave aleatoria larga: cada instancia tiene su propia dirección IPv4 pública. Para varios usuarios a la vez, vLLM agrupa mejor las solicitudes; la guía de vLLM tiene los cálculos de memoria unificada.
Límites que conviene conocer antes
- No he medido gpt-oss-120b en mi flota. Sus cifras de arriba son publicadas por terceros, y tus prompts darán resultados distintos. Mide antes de planificar en función de una cifra.
- Los prompts largos van lentos en modelos densos grandes. Mi ejecución de 70B leyó un prompt de 8192 tokens a 391 tok/s, unos 21 segundos antes del primer token.
- La cuantización cuesta calidad. Un modelo de 4 bits no es el de precisión completa. Comprueba las respuestas con tus propios prompts.
- El Spark es ARM64 con una GPU sm_121. Los motores y paquetes de Python necesitan compilaciones aarch64 para él, y un simple
pip install vllmpuede instalarse bien y luego no arrancar; la guía de vLLM explica la trampa. - Se ejecuta en un contenedor. En muchos Sparks tiene su propio demonio de Docker, así que funcionan los contenedores arm64 de los fabricantes; los demás ejecutan un contenedor sencillo sin Docker, donde la vía es la compilación nativa de arriba. No puedes elegir cuál.
- Sin SLA ni copias de seguridad. Las descargas de modelos fuera de
/workspacese pierden al reconstruir, y terminar lo borra todo.
Precio y dónde están los Sparks
0,79 $ la hora por un Spark, facturado por minuto con crédito prepago: 6,32 $ por una jornada de ocho horas. Primera recarga: paga 20 $ y recibe 30 $ de crédito. Una instancia detenida conserva su espacio de trabajo y se factura al 75% de la tarifa por hora. Termina la instancia cuando acabes y se deja de facturar; eso borra el espacio de trabajo. Los precios no incluyen el IVA cuando corresponda.
Mis propios Sparks están en un centro de datos en Hradec Králové, República Checa. Los Sparks de socios, propiedad de socios que los alojan en sus propias instalaciones, están en EE. UU., Suecia, los Países Bajos, Eslovaquia y Hong Kong; un socio tiene acceso físico a su máquina. La consola muestra el país, y si está en el EEE, antes de desplegar. Todas las ubicaciones ofrecen las imágenes DGX OS y Ubuntu usadas arriba.
Quién está detrás
GPUwerk es nuevo. Lo dirijo yo, Samuel Seidel, a través de PRINT IT! SE, una empresa registrada en Praga. A 9 de noviembre de 2026, 94 desarrolladores han iniciado 374 instancias desde septiembre. El estado en tiempo real está en status.gpuwerk.com, y la página de contacto llega directamente a mí si quieres comprobar un modelo antes de alquilar.
Preguntas frecuentes
¿Puede un DGX Spark ejecutar un modelo de 70B?
Sí. Llama 3.3 70B en AWQ de 4 bits ocupa unos 37 GiB de pesos y cabe con margen, pero generó 6,0 tokens por segundo con una sola solicitud en uno de mis Sparks (vLLM 0.27.1, 2 de septiembre de 2026). Eso encaja mejor con trabajos por lotes que con chat.
¿Cabe gpt-oss-120b en un solo DGX Spark?
Sí. Sus pesos MXFP4 suman 65,2 GB, y lee unos 5,1B parámetros por token. Los mantenedores de llama.cpp publican 58,7 tok/s para una solicitud; Dendro Logic publica 33,5 con vLLM, con prompts más largos y salida JSON. No lo he medido en mi flota.
¿Y los modelos de más de 128 GB?
Necesitan dos Sparks enlazados. Una versión de Qwen3-235B-A22B de 134 GB funcionó a unos 1,8 tok/s en un Spark y a unos 12,5 en dos, según un informe en el foro de desarrolladores de NVIDIA. El clúster de dos nodos de GPUwerk cuesta 1,79 $ la hora cuando la consola lo ofrece.
¿Cuánto cuesta probar un modelo grande?
0,79 $ la hora por un Spark, facturado por minuto con crédito prepago; la primera descarga y la compilación de llama.cpp también cuentan. Primera recarga: paga 20 $ y recibe 30 $ de crédito, unas 37 horas. Termina la instancia cuando acabes y se deja de facturar.