Two new open models came out this month, and both fit under 35B parameters. NVIDIA released Nemotron 3.5 Lightning on August 11, and Meta released Muse Glimmer 30B a little earlier. Everyone compares these models using vendor benchmark tables. I wanted to know something simpler: what happens when you actually run them on one consumer GPU, side by side, on everyday tasks?
So I did that. One RTX 5090 with 32GB of VRAM, Ollama, a 64K context window, and ten simple tasks. Same prompts for both models. Here is what I found.
Two very different 30B models
On paper these look like twins. They are not. They disagree on almost every design choice, which makes the comparison fun.
| Nemotron 3.5 Lightning | Muse Glimmer 30B | |
|---|---|---|
| Maker | NVIDIA | Meta |
| Architecture | Mixture of Experts + Mamba-2 hybrid | Dense transformer |
| Total parameters | 30B | ~29.6B |
| Active per token | only 3B | all ~29.6B |
| Modality | Text only | Text + images (vision encoder built in) |
| Max context | 1M tokens | 131K tokens |
| License | OpenMDW-1.1 | Apache 2.0 |
The short version: Nemotron only "wakes up" 3B of its 30B parameters for each token, so it should be fast. Glimmer uses all of its parameters every token, so it should be smarter per parameter but slower. Glimmer can also look at images, which Nemotron cannot do at all.
My setup
- GPU: RTX 5090, 32GB VRAM
- Runner: Ollama 0.32.8 on Windows 11
- Context window: 65,536 tokens for every test
- Temperature: 0.2, one run per task
Note
I ran the 4-bit builds that Ollama ships: a 25GB GGUF for Nemotron and an 18GB K-Quant for Glimmer. These are not the exact NVFP4 and BF16 files from the Hugging Face pages. The NVFP4 build needs TensorRT-LLM or vLLM, which is not a comfortable setup on Windows. For local use through Ollama, what I tested is what you would actually run.
The tests
I kept the tasks deliberately simple.
These are the things people actually ask a local model to do all day:
- Multiply 847 × 36
- A small money word problem
- The classic "Sara has 3 brothers and 2 sisters" riddle
- Capital of Australia
- Write a palindrome checker in Python
- Fix a buggy sum function (the classic off-by-one)
- Summarize a paragraph in one sentence
- Output exactly three bullet points, nothing else
- Extract name, age, and city as JSON
- Find one hidden fact buried in a 40,000-token document
The two coding answers were not judged by eye. I executed the generated code and ran test cases against it. The needle test used the full 64K window, with the secret code planted in the middle of the document.
Result 1: Both models got everything right
Both scored 10 out of 10. Every math answer correct, both code functions passed all tests, both found the hidden code "BLUE-742" in the 40K-token haystack, and both produced valid JSON and exactly three bullets when asked.
I expected at least one slip somewhere. Nothing. Simple tasks are simply solved now, even by 4-bit quantized 30B models running on a desk. Two years ago this was not true. If your workload is everyday tasks like these, accuracy will not help you pick between these two. Speed and memory will.
Result 2: Nemotron generates much faster
Nemotron averaged about 123 tokens per second across the short tasks. Glimmer sat at a very steady 76. That is the MoE design doing its job: it only computes with 3B parameters per token, so each token is cheap.
Steady is worth a mention, actually. Glimmer printed 76 to 78 tokens per second on every single task, like a metronome. Nemotron bounced between 114 and 142 depending on the task.
Result 3: The long-context test flips the gap wide open
This chart is my favorite finding of the whole experiment. With the 40,000-token document loaded, Glimmer's generation speed collapsed from 76 to 20 tokens per second. Nemotron did not slow down at all. It actually ran at 138, slightly faster than its short-task average.
The reason is architecture. A normal transformer like Glimmer keeps a memory (the KV cache) that grows with every token in the context, and reading through that memory slows down each new token. Nemotron replaces most of its attention layers with Mamba-2 layers, which keep a small fixed-size state no matter how long the context is. NVIDIA claims the model handles 1M tokens. After watching it shrug off 40K without losing a step, I believe the design at least holds up at the sizes I could test.
Both models read the long prompt at similar speed, around 4,000 to 4,700 tokens per second. The difference is only in generation afterward.
Result 4: Glimmer is much lighter on VRAM
Here Glimmer wins clearly. With the 64K context loaded, Glimmer used about 17GB, leaving 15GB free on my card. That headroom is not decoration. It is room for a bigger context, an embedding model running next to it, or in Glimmer's case, image inputs.
Nemotron used 30.9 of my 32.6GB. It fit fully on the GPU, and it ran fine, but the card was nearly full. On a 24GB card like a 4090 the Ollama build of Nemotron would spill into system RAM at this context size, and the speed advantage would shrink or disappear. Glimmer would still fit with room to spare.
That surprised me, by the way. The "fast, light" MoE model is the heavy one on disk and in memory. Sparse compute does not mean small weights. All 30B parameters have to sit in VRAM even though only 3B work at a time.
Result 5: They think differently
Both are reasoning models, meaning they write hidden reasoning before the final answer. Watching where each one spends that effort was oddly revealing.
Glimmer thinks hard when the task deserves it. It spent its longest thinking session, over 400 words, on the sisters riddle, which is genuinely the trickiest question in my set. On easy extraction jobs like JSON it barely thought at all, under 70 words.
Nemotron thinks a lot everywhere. Even "what is the capital of Australia" got over 100 words of private deliberation. It also writes longer final answers. Faster per token, but more tokens per answer, so its wall-clock advantage on short tasks is smaller than the tokens-per-second gap suggests.
Both models nearly skipped thinking on the needle task. They found the code, stated it, done.
So which one should you run?
For me it splits cleanly by use case.
Pick Muse Glimmer 30B if you have a 24GB card, want image understanding, or want lots of VRAM headroom. It is Apache 2.0, it is frugal with memory, and its accuracy on these tasks was flawless. Just know that long contexts will slow it down a lot.
Pick Nemotron 3.5 Lightning if your work lives in long contexts: big documents, long agent sessions, large codebases. Its speed simply does not degrade as the context fills, and nothing else I have run locally does that. But budget a full 32GB card for it at this context size.
The honest summary is that both models cleared the "simple tasks" bar completely, and the real differences only showed up when I measured speed and memory instead of correctness.
Caveats
- Simple tasks only. This is not MMLU or SWE-bench, and hard problems could separate the models in ways my suite cannot.
- One run per task at temperature 0.2. Good enough for the speed numbers, thin for accuracy claims.
- Quantized community builds through Ollama, not the original NVFP4 and BF16 releases.
- I tested text only. Glimmer's vision ability is a real advantage I did not measure here.
If you have a 4090 or another 24GB card, I would genuinely like to know what Nemotron does on it.
