A quiet shift is happening in the local-LLM world, and it changes the math on what "frontier" means for people running models on their own hardware.
For the last two years, running a frontier model locally meant one of two things: either you rented a beefy GPU and ran a big dense model at 5 tokens a second, or you settled for a 7B–14B model that was good enough but clearly a step behind what the cloud could do. The gap between "local" and "frontier" felt like a physical law.
The Flash family just broke that law. GLM-5.3-Flash, DeepSeek-V4.1-Flash, MiniMax-M3.1-Flash, and Qwen3.8-Flash are distilled, optimized variants of full-size frontier models — and they're small enough to run on a Mac mini or a mid-range GPU while punching far above their parameter count. These aren't "small models that are okay." These are "frontier models that happen to fit."
The problem? Nobody has written the guide that tells you which one fits your hardware. That's what this post is for.
What a "Flash" Model Actually Is
Before we get to the hardware tables, let me define the thing, because the naming is doing a lot of work.
A Flash model is a distilled, aggressively-optimized variant of a larger frontier model. Think of it as the "student" in knowledge distillation: a smaller network is trained to mimic the outputs of a huge "teacher" model, then further optimized for inference — quantized, pruned, and tuned so it runs fast on consumer hardware without losing the teacher's behavior.
The result is a model with a parameter count in the single-digit billions (or low teens) that retains a surprising amount of the full-size model's reasoning, coding, and instruction-following ability. The trade is usually in breadth — a Flash model won't hold a candle to its parent on obscure trivia or long-horizon planning — but for the tasks most self-hosters actually run (chat, coding help, summarization, tool use), it's often indistinguishable.
The reason this matters for self-hosters specifically: Flash models sit right on the line where "frontier quality" meets "runs on hardware I already own." A full-size frontier model needs 40–80GB of VRAM. A Flash model needs 4–16GB. That's the difference between a $4,000 server and the Mac mini sitting on your desk.
The Four Contenders, At a Glance
Here's the field as of November 2026. These are the four Flash models people are actually running, with the numbers that matter for hardware matching.
| Model | Params | Context | Q4 Size | Sweet Spot | Best For |
|---|---|---|---|---|---|
| Qwen3.8-Flash | ~3.8B | 32K | ~2.4GB | 8–16GB RAM, no GPU | The smallest. Runs on almost anything. |
| GLM-5.3-Flash | ~8B | 128K | ~5.0GB | 16GB Mac / 12GB GPU | Best long-context + bilingual value |
| MiniMax-M3.1-Flash | ~11B | 64K | ~6.5GB | 16GB+ GPU / 32GB Mac | Best raw quality-per-gigabyte |
| DeepSeek-V4.1-Flash | ~14B | 128K | ~8.5GB | 24GB GPU / 64GB Mac | Closest to full frontier behavior |
Two numbers decide everything, same as always: RAM capacity and memory bandwidth. On a Mac, that's unified memory. On a PC, it's VRAM. The tables below break each tier down.
Tier 1: The Cramped Box (8–16GB, No GPU)
The pick: Qwen3.8-Flash at Q4_K_M.
This is the Intel N100 mini PC, the old laptop, the Raspberry Pi-class machine, or a lightweight Proxmox LXC with 8GB. The rest of the Flash field is out of reach here — GLM-5.3-Flash wants 5GB just to load, and that's before your OS takes its share — but Qwen3.8-Flash is a genuine surprise.
At Q4_K_M it's about 2.4GB, which means it runs comfortably in 8GB and happily in 16GB, even on CPU-only. You're not going to get instant responses, but 8–18 tokens per second is realistic on a modern CPU, which is perfectly fine for a Home Assistant voice assistant, quick summarization, or a local coding autocomplete.
The part that feels like cheating: Qwen3.8-Flash is a distillation of Qwen3.8's frontier lineage, so its instruction-following and reasoning are far ahead of what a 3.8B model "should" be. A year ago, a model this size was a toy. Now it's a tool.
Recommended hardware in this tier:
- Intel N100 Mini PC — Fanless, ~$150, and it'll run Qwen3.8-Flash all day on ~8W.
- Beelink EQ13 (N200) — A touch faster, still silent.
Tier 2: The Mac Mini Sweet Spot (16–24GB Unified Memory)
The pick: GLM-5.3-Flash at Q4_K_M.
This is where the Flash family really earns its name, and it's the tier I care about most because it's my setup — an M-series Mac mini with 16–24GB of unified memory.
GLM-5.3-Flash is the standout here for two reasons. First, its 128K context window is enormous for an 8B model, which means you can feed it a whole codebase or a long document without it forgetting the beginning. Second, it's a distillation of GLM-5.3, which was already a strong bilingual (English + Chinese) model — so if you do any bilingual work, this is the one to beat.
On Apple Silicon's unified memory, GLM-5.3-Flash at Q4_K_M (~5GB) runs at 15–30 tokens per second via Metal. That's chat-snappy, and it leaves you with plenty of RAM left over for the rest of the OS. On a 24GB Mac mini you can even run it at Q5_K_M or Q8_0 if you want more reasoning quality.
MiniMax-M3.1-Flash is the runner-up here if you've got 32GB and want more raw quality, but for 16GB it's genuinely tight — the model plus the OS is a squeeze.
Recommended hardware:
- Mac mini M4 (24GB) — The local-LLM value king, and it eats GLM-5.3-Flash for breakfast.
- Mac mini M4 Pro (48GB) — Steps up to MiniMax-M3.1-Flash or even DeepSeek-V4.1-Flash territory.
Tier 3: The GPU Box (12–16GB VRAM)
The pick: MiniMax-M3.1-Flash at Q4_K_M.
If you've got an RTX 3060 12GB, an RTX 4060 Ti 16GB, or an older 3090-class card, this is your tier, and MiniMax-M3.1-Flash is the best thing you can run without compromise.
At ~6.5GB at Q4_K_M, it fits in 12GB of VRAM with room to spare, and on a dedicated GPU it'll do 30–60 tokens per second. That's faster than most people read, and the quality is the best in the field below 16GB — MiniMax-M3.1-Flash consistently edges out GLM-5.3-Flash and Qwen3.8-Flash on reasoning and coding benchmarks, and it only loses to DeepSeek-V4.1-Flash because that model is bigger.
The honest framing: if you have 12GB VRAM and want the most capable model you can fully offload to your GPU, this is the answer. GLM-5.3-Flash is the answer if you need the long context instead. Qwen3.8-Flash is the answer if you want blistering speed and don't need the extra reasoning.
VRAM rule of thumb for Flash models: at Q4_K_M, you need roughly 0.6GB of VRAM per billion parameters (Flash models are denser-optimized than older ones). So:
- 12GB VRAM → up to ~14B Flash comfortably (MiniMax-M3.1-Flash, or DeepSeek-V4.1-Flash with partial offload)
- 16GB VRAM → DeepSeek-V4.1-Flash fully offloaded, or multiple smaller Flash models side-by-side
- 24GB VRAM (3090/4090) → DeepSeek-V4.1-Flash at Q5_K_M or Q8_0, running like a dream
Recommended hardware:
- NVIDIA RTX 3060 12GB — Still the value king. Used market ~$200, and it runs the whole Flash field.
- NVIDIA RTX 4060 Ti 16GB — Future-proofs you for DeepSeek-V4.1-Flash at higher quants.
Tier 4: The Power Box (24GB+ VRAM, 64GB+ Unified Memory)
The pick: DeepSeek-V4.1-Flash at Q5_K_M or Q8_0.
This is the tier where the Flash family stops being a compromise and starts being the thing you'd run even if you had the big model. A dual 3090 setup, a Mac Studio with 64GB, or a threadripper with 128GB.
DeepSeek-V4.1-Flash is the largest of the four (~14B), and it's the one that gets closest to full-size frontier behavior — which makes sense, because it's a distillation of DeepSeek-V4.1, a model that's been leading open-weight coding and reasoning charts. At Q5_K_M (~11GB) or Q8_0 (~14GB), it does 25–60 tokens per second on a 24GB card, and the quality is the kind of thing that makes you forget you're not calling an API.
Here's the kicker, though: at this tier you can also run several Flash models simultaneously — GLM-5.3-Flash for long-context reading, Qwen3.8-Flash for fast autocomplete, and MiniMax-M3.1-Flash for chat — all resident in VRAM at once. That's a workload that used to require a server, and it's now a single workstation.
Recommended hardware:
- NVIDIA RTX 4090 24GB — Runs DeepSeek-V4.1-Flash at Q8_0 without breaking a sweat.
- Mac Studio M2 Ultra (64GB) — The unified-memory route; runs the whole field with bandwidth to spare.
The New Runner Tools: project-maya and PolyStrata
Here's the part that made me want to write this post in the first place. The Flash models themselves are getting all the attention, but the runner layer underneath them is changing just as fast — and it's the piece that decides whether "runs on my hardware" actually means "runs well on my hardware."
Two projects are exploding right now:
project-maya (2.6k★) is a model runner built specifically for Flash-class models. Its whole pitch is that these distilled models have different characteristics than big dense models — they're memory-bandwidth-bound rather than compute-bound, they respond well to aggressive KV-cache optimizations, and they don't need the full vLLM/PagedAttention machinery. So project-maya strips the serving stack down to exactly what a Flash model needs and nothing else. The result is noticeably higher throughput on the same hardware, and a config surface that's tiny compared to vLLM. If you're serving a Flash model to multiple apps or users, this is the tool that gets you the most tokens per second per watt.
PolyStrata (898★) is the other direction — a cross-backend runner that targets every accelerator, from Apple Metal to CUDA to ROCm to the new NPUs, with a single command. Its claim is that the Flash models are small enough to be "write once, run everywhere," and PolyStrata is the proof: it detects your hardware and picks the right backend automatically, so a poly run glm-5.3-flash works on a Mac mini, a Linux box with an RTX card, and an AMD machine with a ROCm GPU. It's younger than project-maya and the AMD/NPU paths are still rough, but the direction is exactly right.
Both are worth watching, and both are the kind of thing that slots into the stack I've already written about. If you've used my Local LLM Runtime Picker, you know the landscape: Ollama as the batteries-included default, vLLM for serious serving, llama.cpp as the engine underneath. project-maya is positioning itself as "the Flash-specific server," and PolyStrata as "the one-command cross-platform runner." Neither replaces Ollama today, but for Flash models specifically, they're already better tools.
Use-Case Quick Picks
Don't want to think about tiers? Here's the right Flash model for the job:
| What You Want | Best Flash Model | Hardware Needed |
|---|---|---|
| Home Assistant / voice / edge | qwen3.8-flash |
8GB RAM |
| Daily chat + long documents (128K) | glm-5.3-flash |
16GB Mac / 12GB GPU |
| Coding + reasoning, best quality | minimax-m3.1-flash |
16GB VRAM |
| Closest-to-frontier, tool use | deepseek-v4.1-flash |
24GB VRAM / 64GB Mac |
| Bilingual (English + Chinese) | glm-5.3-flash |
16GB Mac / 12GB GPU |
| Fastest possible autocomplete | qwen3.8-flash |
8GB RAM |
| Serve to multiple apps | minimax-m3.1-flash + project-maya |
16GB VRAM |
Understanding the Quant Trade-Off (It's Slightly Different for Flash)
The quantization rules I laid out in my homelab hardware guide still apply — Q4_K_M is the default sweet spot — but Flash models add one wrinkle worth knowing.
Because Flash models are already distilled and optimized, they're more sensitive to aggressive quantization than their full-size parents. A 2-bit or 3-bit quant of a Flash model can degrade faster than you'd expect, because the distillation process already stripped a lot of the redundancy that quantization normally exploits. The practical takeaway:
- Q4_K_M — the default. Best balance, and it's what I recommend for almost everyone.
- Q5_K_M — worth it for DeepSeek-V4.1-Flash and MiniMax-M3.1-Flash if you have the VRAM, since the extra precision helps their reasoning.
- Q8_0 — only for small Flash models (Qwen3.8-Flash) on capable hardware, or DeepSeek-V4.1-Flash on 24GB+.
- Q3 and below — avoid for Flash models. The quality cliff is steeper than on dense models.
Final Thoughts
The Flash family is the missing piece that makes "run frontier models on your own hardware" stop being a compromise and start being a legitimate default.
A year ago, the honest advice was: run a 7B model locally, and reach for the cloud when you need real quality. Today, GLM-5.3-Flash gives you 128K context on a Mac mini. MiniMax-M3.1-Flash gives you near-frontier coding on a $200 GPU. DeepSeek-V4.1-Flash gets close enough to frontier behavior that you'll forget you're not paying per token. And Qwen3.8-Flash means even a fanless N100 can run a genuinely useful model.
The runner layer is catching up too — project-maya and PolyStrata are the first tools built for this new class of model rather than bolted onto it afterward. When the serving layer stops being a thing you have to fight with, the whole proposition changes: it's not "can I run AI at home," it's "which of my boxes do I point at which Flash model."
If you're just getting started, here's my honest three-step path:
- Match the model to your hardware using the tables above — don't reach for the biggest model first, reach for the one that fits.
- Start with Ollama and Q4_K_M. It's still the easiest on-ramp, and all four Flash models are a
ollama pullaway. - Try project-maya or PolyStrata once you want more speed or want to serve the model to other apps — that's where the new tools earn their keep.
You don't need a $4,000 server to touch the frontier anymore. You need the right Flash model and a box you probably already own.
Want the exact list of everything I actually run? → My Gear — the homelab & local AI hardware I use
Related Posts
- Local LLM Runtime Picker — Ollama, llama.cpp, LM Studio, vLLM, Lemonade, or Jan — which runtime for your hardware?
- Local LLMs for Homelab: Which Model Runs Best on Your Hardware — The full hardware-matching guide for all model sizes
- Running Local LLMs on Your Mac Mini — The complete setup, from Ollama to VS Code
Questions or benchmark data from your own setup? The source for this post is on GitHub. PRs welcome.