SmolLM3-3B

Updated
24.08.2026
Reasoning
Multilingual
Tools
Thinking

A fully open 3B reasoning model from Hugging Face with dual-mode thinking, six native languages, tool calling, and 128K context.

At a glance

  • License: Apache 2.0
  • Parameters: 3.08B
  • Context length: 64K trained, up to 128K tokens with YaRN
  • Modalities: Text only
  • Minimum hardware: 2 GB of memory (UD-IQ2_M GGUF, 1.15 GB)

What is SmolLM3-3B?

SmolLM3-3B is a 3B parameter language model from Hugging Face, built to push what a small model can do. It reasons in two modes: extended thinking is on by default and writes a trace before the answer, and a /no_think flag switches it off for fast direct replies. It is also fully open in a way few releases are: open weights plus the complete training details, including the public data mixture and the training configs. Hugging Face released it on July 8, 2025 under Apache 2.0, and at this size it runs on nearly any machine, no dedicated GPU required.

SpecificationSmolLM3-3B
Total parameters3.08B
ArchitectureDecoder-only transformer, GQA and NoPE (3:1 ratio)
Pretraining11.2T tokens, staged web, code, math and reasoning curriculum
Context window64K trained, up to 128K tokens with YaRN
LanguagesEnglish, French, Spanish, German, Italian, Portuguese
ReasoningDual mode, thinking on by default, /think and /no_think flags
Tool callingXML tool calls or Python-style code calls
Release dateJuly 8, 2025
LicenseApache 2.0

Post-training is where the reasoning comes from: midtraining on 140B reasoning tokens, then supervised fine-tuning and alignment with Anchored Preference Optimization. Tool calling works in two formats, JSON blobs inside XML tags or Python-style function calls in a code snippet. Six languages are supported natively; the model has also seen Arabic, Chinese and Russian data, though fewer tokens of each, so treat those as secondary. The shipped config caps context at 65,536 tokens, and YaRN rope scaling takes it to 128K. Hugging Face recommends temperature 0.6 and top_p 0.95 for sampling, and lists llama.cpp, ONNX, MLX, MLC and ExecuTorch for local inference.

SmolLM3-3B benchmarks

Hugging Face's launch numbers, from the model card, compare SmolLM3-3B with extended thinking off against Qwen2.5-3B, Llama3.1-3B, Qwen3-1.7B and Qwen3-4B:

BenchmarkSmolLM3-3BQwen2.5-3BLlama3.1-3BQwen3-1.7BQwen3-4B
AIME 2025
Competition math
9.32.90.38.017.1
GSM-Plus
Math problems
72.874.159.268.382.1
LiveCodeBench v4
Competitive coding
15.210.53.415.024.9
GPQA Diamond
Expert science
35.732.229.431.844.4
IFEval
Instruction following
76.765.671.674.068.9
Global MMLU
Multilingual knowledge
53.550.5446.849.565.1

The larger Qwen3-4B takes most rows. Inside the 3B class the picture is different: SmolLM3-3B wins instruction following outright and leads on AIME, LiveCodeBench and GPQA Diamond, while Qwen2.5-3B keeps a small edge on GSM-Plus. Switching extended thinking on moves the math and science scores sharply, with AIME 2025 climbing from 9.3 to 36.7 and GPQA Diamond from 35.7 to 41.7.

SmolLM3-3B hardware requirements

The system requirement to check is memory, and at 3B parameters almost every tier clears it. The builds and file sizes below are from the unsloth/SmolLM3-3B-GGUF repo.

MemoryBuild to pickFile size
2 GBUD-IQ2_M1.15 GB
4 GBQ4_K_M1.92 GB
8 GBQ8_03.28 GB
16 GB and upBF166.16 GB

Neighbouring files differ by a few hundred megabytes, so when two builds both fit, take the larger one. Even the full BF16 file is only 6.16 GB, so most machines can skip the low-bit quants entirely. If the format is new to you, start with what GGUF is.

How to run SmolLM3-3B in Atomic Chat

Atomic Chat is a free local app for macOS, Windows and Linux. It includes a Hugging Face model browser and a built-in chat, with no manual llama.cpp build required.

  1. Download Atomic Chat for your platform and open it.
  2. Search for SmolLM3-3B in the model browser and open Download Options.
  3. Pick the build that fits the memory you have, then start a chat.

For the rest of the family, see every SmolLM model you can run locally, or the pocket-sized sibling SmolLM2-135M-Instruct.

SmolLM3-3B license

SmolLM3-3B is released under Apache 2.0. That permits commercial use, modification and redistribution with no royalties, so you can build products on top of the model and run it on your own hardware without a usage fee. Hugging Face adds the usual caveat: outputs can be inaccurate or biased, so treat the model as an assistive tool rather than a source of record.

Get the weights from Hugging Face

pip install -U "transformers>=4.53.0"
huggingface-cli download HuggingFaceTB/SmolLM3-3B
# OpenAI-compatible server:
vllm serve HuggingFaceTB/SmolLM3-3B --enable-auto-tool-choice --tool-call-parser=hermes
curl http://localhost:8000/v1/chat/completions \
  -H "Content-Type: application/json" \
  -d {
    "model": "HuggingFaceTB/SmolLM3-3B",
    "messages": [{"role": "user", "content": "Give me a brief explanation of gravity."}],
    "temperature": 0.6,
    "top_p": 0.95,
    "chat_template_kwargs": {"enable_thinking": false}
  }
from transformers import AutoModelForCausalLM, AutoTokenizer
model_id = "HuggingFaceTB/SmolLM3-3B"
tokenizer = AutoTokenizer.from_pretrained(model_id)
model = AutoModelForCausalLM.from_pretrained(model_id)
messages = [{"role": "user", "content": "Explain gravity simply."}]
inputs = tokenizer.apply_chat_template(messages, add_generation_prompt=True, return_tensors="pt")
out = model.generate(**inputs, max_new_tokens=512, temperature=0.6, top_p=0.95)
print(tokenizer.decode(out[0]))
import OpenAI from "openai";
const client = new OpenAI({ baseURL: "http://localhost:8000/v1", apiKey: "EMPTY" });
const res = await client.chat.completions.create({
  model: "HuggingFaceTB/SmolLM3-3B",
  messages: [{ role: "user", content: "Explain gravity simply." }],
  temperature: 0.6,
  top_p: 0.95,
});
console.log(res.choices[0].message.content);
Desktop
macOS
(Intel and Apple Silicon)
Download
Windows
(x64)
Download
Windows
(ARM64)
Download
Linux
(x86_64)
Download

Frequently asked questions

SmolLM3-3B is a 3-billion-parameter decoder-only language model released by Hugging Face in 2025. It is an instruction-tuned model with dual-mode reasoning, native support for six languages, and context handling up to 128K tokens.

Yes. SmolLM3-3B is released under the Apache 2.0 license, which permits commercial use, modification, and redistribution. Hugging Face also published the full training details, including the data mixture and training configs, making it a fully open model.

At 3B parameters, SmolLM3-3B runs on a GPU with roughly 8 GB of VRAM in 4-bit quantization, and full bf16 inference fits in about 6-8 GB. Quantized GGUF builds also run on CPU and on Apple Silicon via llama.cpp or MLX, making it usable on consumer laptops.

SmolLM3-3B was trained on a 64K context window and extends to 128K tokens using YaRN extrapolation. The shipped config.json is set to 65,536 tokens by default; you enable the longer window by adding the YaRN rope_scaling settings.

Both are small reasoning models with thinking modes. Qwen3-4B is larger and scores higher on most benchmarks such as AIME and GPQA, while SmolLM3-3B is smaller, fully open with published training data, and leads on instruction following (IFEval 76.7 in no-think mode). SmolLM3 supports six native languages versus Qwen3's broader multilingual coverage.