A DGX Spark with 128 GB of unified memory runs open models up to the class of roughly 120 billion parameters, as long as they come in 4 bit or smaller. Going by vendor specs and file sizes, that covers Qwen3.8-27B, Muse Glimmer 30B, Gemma 4 (31B and 26B-A4B), gpt-oss-120b, Mistral Small 4 and the three Nemotron 3.5 models Super, Bolt and Lightning. Nvidia itself quotes models of up to 200 billion parameters for a single 128 GB unit. The large open models of this autumn, such as DeepSeek V4, Kimi K3, Muse Spark Open or Mistral Large 4, do not fit on a single unit. On my own DGX Spark, Qwen3.8-27B ran under SGLang at 50.7 tokens per second when I measured it in August 2026. Which of the other models works fastest and most reliably on my machine is what the test series in this article shows. Three of the candidates, gpt-oss-120b, Mistral Small 4 and Nemotron 3.5 Super, I don't measure myself. For them I cite published third-party measurements on the DGX Spark.
The short verdict of my test series from November 3 and 4, 2026: the fastest model was Nemotron 3.5 Lightning at 80.4 tokens per second on German prose and, with the DSpark draft model, 144.1 on code. Gemma 4 31B, Muse Glimmer 30B and Qwen3.8-27B without a draft model passed the most of the six quality tasks, five each. For German text Gemma 4 31B came out ahead, as the only model that passed both the customer email and the summary, but at 22.2 tokens per second it is slow. For coding, Qwen3.8-27B with DFlash2 stays strong: 50.1 tokens per second on code, with the Python task and the agent run passed.
I run my business with a team of fifteen AI employees built on Claude. The DGX Spark next to it is my test bed for how far local models get without the cloud. What the machine itself can do and where its traps are is covered in DGX Spark Tested: Worth Buying?. This article answers the follow-up question: which model to run on it. Everything I write about local AI is collected on my AI page.
What fits on the DGX Spark: the math first
The DGX Spark has 128 GB of unified memory on paper; my system reports about 119 GB as usable. CPU and GPU share this memory. Nvidia's product page says: "Test, validate, and inference with AI models up to 200 billion parameters." For two connected units Nvidia quotes up to 400 billion, for four up to 700 billion parameters.
For the shortlist I use a rough rule: weights in 4 bit need about half a byte per parameter, so a model with 120 billion parameters lands somewhere around 60 to 75 GB. On top of that comes the memory for the context, which grows with every request the model holds at the same time. That is a rule of thumb, not a measurement.
One rule of my own narrows this further. Under SGLang I never set --mem-fraction-static above 0.50, because an overly generous allocation on unified memory can freeze the whole machine. The same limit applies to vLLM for me (--gpu-memory-utilization), because the trap sits in the shared memory, not in the software. By that math, a little under 60 GB remain for weights and context. Three candidates have larger weights than that: gpt-oss-120b at 65.2 GB, Mistral Small 4 in NVFP4 at 70.8 GB and Nemotron 3.5 Super in NVFP4 at 75.0 GB, each going by the file sizes on Hugging Face. So I don't measure these three myself; the exact reasons are further down with the third-party measurements. On top of that, other services of mine run on the GPU next to Qwen, such as Whisper large-v3 for speech recognition at 3 to 4 GB and a text-to-speech service. As long as they run, their memory is missing for the model under test.
According to their model cards, models from several hundred billion parameters upward are too large for a single unit: DeepSeek-V4-Pro with 1.6 trillion, Kimi K3 with 2.8 trillion, Muse Spark Open with 816 billion and Mistral Large 4 with about one trillion parameters. Kimi K3.1 Pro has since joined this class on Hugging Face, also with about 2.8 trillion parameters (as of November 15, 2026). Those run in a data center or through a cloud service, not on your desk.
The candidates: nine models by vendor specs
The list includes the models that fit into memory according to their vendors and come under a license that also allows commercial use. I measured six of them myself; for gpt-oss-120b, Mistral Small 4 and Nemotron Super I cite third-party measurements. The values in this table come from the model cards and file lists on Hugging Face and from the Ollama library, as of October 26, 2026, checked again on November 15, 2026. My own values are in the results tables further down.
On licenses: Apache 2.0 allows commercial use. For Nemotron 3.5 Super, Nvidia writes on the card of the NVFP4 version: "This model is ready for commercial or non-commercial use." All three Nemotron models come under the same OpenMDW-1.1 license. That is my reading of the license information, not legal advice. How the licenses of open models differ in detail is covered in my article on open-weight licenses.
The test setup
Every number in the two results tables comes from this setup; it applies to the six models I measure myself. If I change anything, it is noted in the row.
Machine. One DGX Spark with a GB10 chip, 128 GB of unified memory on paper, about 119 GB usable, DGX OS based on Ubuntu 24.04. I have no passwordless admin rights on the machine, so every model under test runs as its own container or user service on its own port. Only one language model runs at a time. For the runs of the other models I stop my production Qwen server. That interrupts my own operations, and a restart takes 5 to 12 minutes, so I measure within a fixed time window. The other services on the GPU, including speech recognition and text-to-speech, kept running during all runs and took about 12 GiB together.
Runtime. Where a model has an official SGLang recipe, I use SGLang, as in my Qwen setup. For the Nemotron models I use Nvidia's DGX Spark recipes, but with my memory limit of 0.50, for Muse Glimmer Nvidia's NVFP4 version. Where no suitable recipe exists, I use Ollama with the library's default tag. I can't update the Ollama version on my Spark without admin rights; if it doesn't load a new model, Ollama runs in a container. Each row states the runtime and its version.
Memory. 0.50 at most: under SGLang as --mem-fraction-static, always set explicitly, under vLLM as --gpu-memory-utilization. Nvidia's vLLM recipe for Lightning sets 0.85. I don't adopt that value. The value I actually ran per model is in the table.
Speed. Decode in tokens per second: 300 output tokens, one stream, called from my Mac over Tailscale, as in my Qwen measurement in August. Prefill in tokens per second and time to first token: a prompt of about 7,000 tokens, 6,770 to 7,332 depending on the tokenizer. Every measurement runs three times; the table shows the median.
Same conditions. My Qwen measurement in August ran without thinking and with the DFlash2 draft model for speculative decoding. In the new setup I measure every model once without speculative decoding. Where the vendor ships a drafting method, that is DFlash2 for Qwen, DFlash for Muse Glimmer or MTP, DSpark and LiLiCorr for the Nemotron models, a second run with it is added. Thinking or reasoning is off or at the lowest level for every model.
Memory use and context. Size of the weights on disk, memory in use during the run and the configured context. I also check whether the model starts with a 128,000-token context.
Quality. Six fixed tasks from my daily work, the same wording for every model, all in German:
- Write a customer email from five bullet points (tone, spelling, all points covered).
- Summarize a German document of about six pages and answer five check questions on it (facts correct).
- Call tools: JSON following a given schema for three functions, including a deliberately broken tool response (does the model notice and retry).
- Write a Python function with given tests (do the tests pass).
- An agent run in the terminal agent Pi: a small change across two files in a test repository (tests green, number of steps).
- Read a table from a screenshot (only models with image input).
I rate each task as passed, partly passed or failed, against criteria fixed before the first run. I deliberately do not compute an overall percentage score. Six tasks are too few for that.
Download. The five new models I measure myself bring about 110 GB of weights together. Container images and draft models come on top; the SGLang image for my Qwen server alone is 39 GB. So I load them one after the other and delete each model under test after its run. The two Gemma models came down at about 8 MB/s, 18 GB in 37 minutes.
Deviations from the plan. Some things ran differently from what is described above; the values in the tables apply to this actual setup:
- All vLLM models ran on vLLM 0.33.0 instead of the versions in Nvidia's recipes.
- The Gemma models ran in an Ollama container, version 0.40.13, because the Ollama on my Spark (0.20.7) does not load Gemma 4. They ran in 4 bit (Q4_K_M) through llama.cpp, the other models in NVFP4 through SGLang or vLLM. Speed and memory are therefore values of the whole setup, not a pure model comparison.
- Qwen without a draft model ran without torch.compile and with a cache capped at 150,000 tokens, because the first start with default settings took too much memory.
- I only measured Qwen (DFlash2) and Lightning (DSpark) with a draft model. Muse Glimmer with DFlash and Bolt with LiLiCorr are missing, because the time window on the machine was not long enough.
- On top of German prose I measured output once with code (300 tokens, a small Python class with tests), because speculative decoding depends heavily on the content. Prose remains the main value.
- Bolt crashed with a memory access error in the runtime on its first agent run. That is not a model result, so I repeated the run once after a restart.
Three models I don't measure myself: third-party measurements
I don't measure gpt-oss-120b, Mistral Small 4 and Nemotron 3.5 Super myself. There are two reasons. First, the memory limit: with 0.50, by the math, a little under 60 GB remain, and the weights of the three are larger at 65.2, 70.8 and 75.0 GB. The third-party measurements below show that they take even more in operation, about 99 GB for Mistral Small 4 and almost 100 GiB for Nemotron Super. Second, ongoing operations: my production Qwen server runs on the machine, plus speech recognition and text-to-speech. For one of these models I would have to stop all of that for many hours, plus the download of 65 to 75 GB per model.
For these three I therefore cite published measurements by third parties on the DGX Spark or a machine with a GB10 chip, each marked as a third-party measurement, with date and setup. I have not verified any of them. The setups differ from mine, so compare the numbers only roughly with my own values.
Two things stand out. In the third-party measurement, gpt-oss-120b, with only 5.1 billion active parameters, lands in the range of my Qwen value from August, but its weights are almost three times as large. Nemotron Super needs practically the whole machine with Nvidia's own recipe; the recipe sets 0.75 instead of my 0.50, and the author of the measurement writes that this means "dedicating the entire DGX Spark to this model".
Results: speed, memory, context
I described the decode value from August in my article DGX Spark Tested: Worth Buying?. I only measured prefill myself on October 24, 2026: a prompt of about 125,000 tokens without cache took 123 seconds, so about 1,000 tokens per second, while other services were running on the same GPU. The figure of about 1,500 tokens per second for prefill comes from the setup recipe I follow; I did not measure it. To keep all rows comparable, I measured Qwen again in the new setup, once with and once without the draft model. The values for gpt-oss-120b, Mistral Small 4 and Nemotron Super are above with the third-party measurements.
¹ With 0.50, vLLM always reserves about half of the machine for weights, context cache and graphs. The number shows that reservation, not the actual need. For the actual need, count the weights plus the context.
Every value is the median of three runs, measured on November 3 and 4, 2026, with thinking off or at the lowest level. Three things stand out. First, speculative decoding depends heavily on the content: Qwen with DFlash2 reaches 50.1 tokens per second on code, in line with the August value of 50.7, but only 18.2 on German prose. Without the draft model it is 12.6, whatever the content. For Lightning, DSpark almost doubles the speed on code and adds hardly anything on prose. Second, prefill is faster without a draft model, 2,058 instead of 1,432 tokens per second for Qwen, because no draft model computes alongside. Third, Lightning is by far the fastest; it has only 3 billion active parameters but cannot process images. The vLLM recipes for Muse Glimmer and the Nemotron models also ran with my memory limit of 0.50 and all started with a 131,072-token context. A follow-up measurement on November 4 on my Qwen service, by then configured differently, gave 20.8 tokens per second on prose and 51.2 on code. Whether the difference comes from the configuration or from day-to-day variation cannot be told from one run each.
Results: the six quality tasks
For gpt-oss-120b, Mistral Small 4 and Nemotron Super there are no own results here, because I don't run them myself.
What stood out: in the customer email, Muse Glimmer invented an "order" that did not exist, and Lightning a date "requested by you". On the check questions, both Qwen runs wrote down the right calculation, 30 minus 10 minus 4, and still arrived at 26 instead of 16. After the deliberately broken tool response, Qwen without a draft model, Muse Glimmer and both Nemotron models retried and only sent the email after the appointment had been created. Qwen with DFlash2 and Gemma 4 31B sent the email in the same step as the failed first attempt. Both Gemma models reported the error honestly but did not try again. All seven runs passed the Python task and the agent run in Pi, Qwen with DFlash2 in 23 seconds, Bolt in just under six minutes.
Which model for which job
Two things already follow from the model cards. If you need image input, for screenshots or scanned receipts for example, gpt-oss-120b and Nemotron 3.5 Lightning drop out; both handle text only. If you need very long context, Qwen3.8-27B and the Nemotron models Super and Lightning list up to one million tokens, while Muse Glimmer lists 131,072 and more. How much of that is actually usable on the machine depends on memory, and the column "Starts with 128k" shows it.
From my measurements, per job:
- German text and emails: Gemma 4 31B was the only model to pass both the customer email and the summary. You need patience for it: 22.2 tokens per second and 11.7 seconds to the first token with about 7,000 tokens of input.
- Coding and agent runs: Qwen3.8-27B with DFlash2 reaches 50.1 tokens per second on code and finished the agent run in Pi with 5 tool calls in 23 seconds. Lightning with DSpark is even faster on code at 144.1, but only partly passed the email and failed the summary.
- Long documents: there is no clear winner here. Lightning reads in fastest at 5,756 tokens per second, but answered only 3 of 5 check questions correctly. Muse Glimmer and Gemma 4 31B got all five right, but read in much more slowly at 1,121 and 614 tokens per second.
- Quick answers on the side: Gemma 4 26B-A4B at 68.0 tokens per second on prose and 19.4 GiB of memory, with four of six tasks passed.
For coding on the DGX Spark, these values still make the strongest case for Qwen3.8-27B with DFlash2.
What this test does not show
It is one machine, one software version per runtime and a handful of tasks from my daily work. With a new driver, a new SGLang version or different quantizations, the numbers look different. A model that is weak on my six tasks can be strong on yours. So take the tables as a starting point for your own test, not as a ranking.
Frequently asked questions
What is the best model for the DGX Spark?
That depends on what you need it for. For image input only the models with a vision encoder qualify, for long documents the ones with a large context.
In my setup there was no overall winner. Gemma 4 31B at 22.2 tokens per second, Qwen3.8-27B without a draft model at 12.6 and Muse Glimmer 30B at 12.2 each passed five of six tasks. Qwen with DFlash2 passed four tasks and, at 50.1 tokens per second on code, is about four times as fast as the run without the draft model, which also ran without torch.compile.
How large can a model be on the DGX Spark?
Nvidia quotes models of up to 200 billion parameters for a 128 GB unit. In practice, what counts is the size of the weights plus the memory for the context. With my 0.50 rule under SGLang, the math leaves me a little under 60 GB, enough for every model of the 30B class in 4 bit.
Does gpt-oss-120b run on the DGX Spark?
Yes. The llama.cpp project measured it on a DGX Spark: 58.7 tokens per second without prior context and 42.8 at 32,768 tokens of prior context, as of February 5, 2026. That is a third-party measurement. I don't measure gpt-oss-120b myself, because its 65.2 GB of weights exceed my memory limit of 0.50.
Ollama or SGLang on the DGX Spark?
For Qwen3.8-27B I measured 50.7 tokens per second under SGLang in August 2026, and 24 to 26 under vLLM with MTP. Ollama is easier to set up and good for a quick test. For continuous operation with one interface for several tools, I stay with SGLang.
Do DeepSeek V4 or Mistral Large 4 run on the DGX Spark?
Not on a single unit. DeepSeek-V4-Pro has 1.6 trillion parameters according to its model card, Mistral Large 4 about one trillion according to Mistral. Even in 4 bit that is several hundred gigabytes: the NVFP4 version of Mistral Large 4 on Hugging Face is 610 GB, several times what a DGX Spark has.
Where to go from here
If you do not own a DGX Spark yet, read DGX Spark: Price and Alternatives and Your Own AI Server: Hardware and Cost before buying. How to get a model running under Ollama, vLLM or SGLang is covered in Setting Up Local AI: Ollama to SGLang. For an overview of all open models, including the ones that are too large, see my comparison of open source AI models. The head-to-head of the 30B-class models is in Muse Glimmer vs Qwen 3.8 vs Gemma 4. What Mistral Small 4, Ministral and Large 4 bring in terms of hardware and license is covered in Running Mistral Locally: Models and Licenses.
