Last updated: November 22, 2026
Nemotron-Labs-Sigma is NVIDIA’s new family of 3B and 8B continuous diffusion language models, published on Hugging Face on November 12, 2026. They write text in parallel blocks instead of token by token, ship in base, instruct, few-step distilled and self-speculative versions, and run free on your own NVIDIA GPU.
Contents
- What is new
- The models in the release
- How continuous diffusion decoding works
- How to run Nemotron-Labs-Sigma
- Sampler settings that matter
- Speed and benchmark claims
- How it compares
- Limitations
- Frequently asked questions
What is new
NVIDIA Research describes Nemotron-Labs-Sigma as “a family of 3B and 8B continuous diffusion language models for reasoning and coding” on its project page. The model cards give a Hugging Face release date of November 12, 2026, the same day the accompanying paper was revised to version 2 on arXiv. The paper calls Sigma the first family of large-scale continuous diffusion language models.
The paper contrasts Sigma with discrete diffusion language models, such as masked models, that work directly on tokens. Sigma instead denoises compact continuous token embeddings, only 16 numbers per token, and then reads out the final tokens. NVIDIA says this smooth path makes three things practical: steering the output at inference time, generating in very few steps, and using the model as its own draft model for speculative decoding.
The models in the release
The Hugging Face collection lists 14 checkpoints. Here is how they divide, using figures from the model cards:
| Variant | Sizes | What it is for | Context |
|---|---|---|---|
| Base (Nemotron-Labs-Sigma-3B / -8B) | 3B, 8B | Research, fine-tuning, distillation; not a chat model | 4,096 tokens |
| Instruct (-instruct) | 3B, 8B | Chat, question answering, reasoning and code; uses the bundled chat template | 8,192 tokens |
| Few-step distilled (-distill-*-nfe2/4/8/16) | 3B, 8B | Fast generation at a fixed number of denoising steps | See each card |
| Self-speculative (-distill-spec-*) | 3B, 8B | Diffusion head drafts blocks (32 tokens on the 8B card); the model’s own autoregressive head verifies them | 4,096 tokens (8B card) |
All variants are released under the NVIDIA Nemotron Open Model License, are English only, and, in NVIDIA’s words, run “offline on the user’s own hardware; NVIDIA hosts no service.” There is no API price because there is no hosted API. According to the instruct card, the models were trained on about 1.3 trillion tokens: roughly 1 trillion for autoregressive initialization and 0.3 trillion for continuous-diffusion training.
How continuous diffusion decoding works
Sigma generates one block of tokens at a time (64 tokens by default, per the model cards). For each block it starts from Gaussian noise and refines the block over a configurable number of denoising steps, conditioned on the text already written. Committed tokens are reused through a standard key-value cache, as in a normal transformer.
The backbone is a Ministral-style decoder-only transformer with grouped-query attention, SwiGLU and rotary position embeddings. NVIDIA trains an autoregressive stream and a diffusion stream on that shared backbone, starting from pretrained autoregressive weights. That design is what lets one checkpoint both draft and verify text.
How to run Nemotron-Labs-Sigma
The cards list PyTorch 2.4 or later, Transformers 4.55 or later, Linux, and an NVIDIA Ampere, Lovelace, Hopper or Blackwell GPU in bfloat16. No custom kernels or flash-attention are required. To chat with the 8B instruct model:
- Install the requirements:
pip install "torch>=2.4" "transformers>=4.55". - Load the tokenizer and model from
nvidia/Nemotron-Labs-Sigma-8B-instructwithtrust_remote_code=True, which pulls in NVIDIA’s plain-PyTorch inference code from the repository. - Move the model to the GPU in bfloat16:
model.cuda().to(torch.bfloat16).eval(). - Format your conversation with
tokenizer.apply_chat_template(..., add_generation_prompt=True). For code-completion prompts such as a bare function signature, skip the chat template, as the card advises. - Call
model.generate(input_ids, max_new_tokens=256, sampler="ddim", time_schedule="log_snr", steps=32, block_length=32, guidance_scale=3.0, score_temp=0.3). It returns the output IDs and the number of function evaluations (NFE) used. - For a speed-focused run, load a
-distill-spec-checkpoint instead and callmodel.generate_speculative(input_ids, max_new_tokens=256, return_stats=True)to see the mean accepted length per round.
If you are setting up a local model stack over the long Thanksgiving weekend, our guides to llama.cpp 0.9.0 and vLLM 0.33 cover the usual serving tools; note that Sigma’s cards list only PyTorch with Transformers as the runtime.
Sampler settings that matter
The cards recommend the DDIM sampler on the log_snr grid with 32-token blocks, and note that DDPM degenerates at low step counts. Fewer steps need a higher score temperature to stay stable:
| Denoising steps | Classifier-free guidance | Score temperature |
|---|---|---|
| DDIM-32 | 3 | 0.3 |
| DDIM-16 | 3 | 0.4 |
| DDIM-8 | 3 | 0.6 |
| DDIM-4 | 2 | 0.8 |
NVIDIA warns that below roughly 16 steps the pretrained models lose quality noticeably. For few-step use, pick a distilled variant instead. Those are trained for one fixed step count, and the bundled code deliberately does not let you override it. For example, the -nfe4 checkpoint generates each 32-token block in exactly four denoising evaluations plus a final readout.
Speed and benchmark claims
All figures below are NVIDIA’s own:
- Few-step generation: distilled models produce 8 tokens per forward pass on math and 4 on coding “with negligible accuracy loss,” according to the project page.
- Self-speculative decoding: an average 3.46x throughput speedup for the 8B model over its autoregressive decoding on an NVIDIA GB200.
- Accepted draft length: the distill-spec-8B card reports mean accepted lengths of 7.91 on HumanEval, 11.86 on GSM8K and 13.37 on MBPP, as a throughput measure rather than an accuracy measure.
- Plain throughput: roughly 120 to 140 tokens per second for 256 generated tokens on one H100, using DDPM at 32 steps per 64-token block.
Because the speculative variant’s verifier is the model’s own autoregressive head, the card states that the returned text is exactly the greedy autoregressive output. Acceptance changes only how many tokens each round commits.
How it compares
Versus masked diffusion and autoregressive baselines. The arXiv abstract says Sigma outperforms its discrete counterparts on GSM8K, Minerva, HumanEval and MBPP after pretraining, and on MATH-500 and AIME after fine-tuning, with the largest gains on coding. NVIDIA adds that after fine-tuning, average performance is on par with its earlier Nemotron-Labs-Diffusion models at both sizes.
Versus NVIDIA’s production Nemotron models. Sigma is a research release with short context windows. For NVIDIA’s mainstream open models, see our Nemotron 3.5 guide and the Nemotron for Science guide.
Limitations
- Short context: 4,096 tokens for base models and 8,192 for instruct models, prompt plus output.
- English only, and the training data is not distributed.
- No CPU or Apple silicon support: the cards say CPU output is unusable, so tools like Ollama are not a listed option.
- Remote code: loading requires
trust_remote_code=True, so review the repository code before running it.
Frequently asked questions
What is Nemotron-Labs-Sigma?
Nemotron-Labs-Sigma is an NVIDIA research family of 3B and 8B continuous diffusion language models for reasoning and coding. Instead of predicting one token at a time, it denoises blocks of 16-dimensional token embeddings in parallel. The weights were published on Hugging Face on November 12, 2026.
Is Nemotron-Labs-Sigma free to use?
The weights are a free download under the NVIDIA Nemotron Open Model License, and the model cards say the models are ready for commercial or non-commercial use. NVIDIA hosts no service for them, so you run them on your own GPU hardware.
Can I run Nemotron-Labs-Sigma on a CPU or a Mac?
No. The model cards say CPU inference is not supported because the diffusion sampler is numerically degraded on CPU. NVIDIA lists Linux with a CUDA-capable NVIDIA GPU (Ampere, Lovelace, Hopper or Blackwell) running in bfloat16.
Which Nemotron-Labs-Sigma model should I download?
Use an instruct model for chat and reasoning, a base model for research or fine-tuning, a -distill-nfe model for fast fixed-step generation, and a -distill-spec model when you want greedy autoregressive output with self-speculative speedups.
How fast is Nemotron-Labs-Sigma?
NVIDIA reports an average 3.46x self-speculative decoding speedup for the 8B model over its autoregressive decoding on a GB200. The model cards also list roughly 120 to 140 tokens per second on one H100 with the DDPM sampler at 32 steps per 64-token block.
Sources
- NVIDIA Research: Nemotron-Labs-Sigma, Large Language Continuous Diffusion Models
- Hugging Face: nvidia/Nemotron-Labs-Sigma-8B-instruct model card
- Hugging Face: nvidia/Nemotron-Labs-Sigma-distill-spec-8B model card
- arXiv: Large Language Continuous Diffusion Models (2610.02665v2, revised November 12, 2026)
- Hugging Face: Nemotron-Labs-Sigma collection
Image: NVIDIA logo, via Wikimedia Commons, public domain (simple text logo); placed on a widened white background. NVIDIA is a trademark of NVIDIA Corporation; FreeAnswers is not affiliated with NVIDIA.