Qwen3.8-27B with MLX on Apple Silicon: Yes, It Runs — Here's What You Really Need

Qwen3.8 27B runs on Apple Silicon today through MLX. The tag is qwen3.8:27b-mlx in Ollama, added in Ollama v0.32.12, and the 4-bit build downloads at about 18 GB and needs roughly 16–19 GB of unified memory — which makes a 24 GB+ Mac the realistic floor and a 16 GB Mac a no-go. The weights are Apache 2.0, free at the point of use on hardware you own, which is the entire point of the model. Ali​baba's release is two days old (August 13–14, 2026), so every number below is labeled: what comes from Ali​baba's model card, what we verified on the Ollama page today, and what is third-party projection or measurement.

The 30-second factsheet

Qwen3.8 27B is Ali​baba's dense 27-billion-parameter model, released August 13–14, 2026 under Apache 2.0 — the weights landed on Hugging Face and ModelScope on the 13th, with the LICENSE file appearing the next morning. It is the deployable dense sibling of the 2.4T-parameter Qwen3.8-Max. From the model card, all Ali​baba-reported and not yet independently reproduced:

• Size — 27B dense, 27.78B total parameters counting the vision encoder.

• Architecture — 64 layers, hidden size 5,120, vocabulary 248,320.

• Hybrid attention — 16 full-attention layers plus 48 Gated DeltaNet linear layers, a 3:1 ratio.

• Context — 262,144 tokens native, extendable to 1M via YaRN (Ollama lists the tag at 256K).

• Input — native image and video understanding on top of text, from documents to hour-scale video.

• Weights — 55.6 GB in BF16, MTP speculative-decoding head included.

On the MLX side, verified today: Ollama ships qwen3.8:27b-mlx — an MLX-native build for Apple Silicon at an ~18 GB 4-bit download — and the v0.32.12 release notes call out Apple Silicon optimization. mlx-lm, Apple's Python toolchain, supports the architecture for generation and conversion, and MLX quantizations (3/5/6-bit, plus MXFP4 and NVFP4) appeared within hours of the weights. The rest of this article assumes an M-series Mac with 24 GB or more of unified memory.

What MLX changes about memory

On Apple Silicon there is no separate VRAM. MLX runs on the M-series unified memory pool, so the number that matters is the total RAM in your Mac minus what macOS and everything else holds. A model that "fits in 17 GB" needs a machine with comfortably more than that.

The good news is that Qwen3.8 27B is cheaper to hold than its parameter count suggests. Because only the 16 full-attention layers keep a KV cache — the 48 linear layers do not — the cache costs about 64 KB per token, roughly a quarter of what a conventional 64-layer dense model pays. At the far end, the full 262K window needs ~16.4 GB of cache on top of the weights, which is a server budget, not a laptop budget.

The realistic ladder for a Mac, file size plus cache headroom:

• 4-bit MLX — ~16–19 GB total. Fits a 24 GB Mac with roughly a 64K–96K window; the sensible default.

• 6-bit MLX — ~21–22 GB. 32 GB machines; the quality jump over 4-bit is modest.

• 8-bit MLX — ~27–30 GB. 48 GB+ machines; near-lossless.

• BF16 — ~55.6 GB. Only the top-of-range M-series Max and Ultra studio machines.

Sourcing: the 4-bit figure tracks the measured GGUF Q4_K_M (17.1 GB, unsloth, August 14) and the 18 GB Ollama download; the 8-bit and BF16 figures track Ali​baba's own BF16 card and the Qwen3.6-27B lineage. The 64 KB-per-token cache figure is derived from the architecture, not printed on a spec sheet, and holds only for runtimes that skip the KV cache on the linear layers the way MLX does.

Three ways to run it, from simplest to most control

Path A — Ollama, the simplest

Upgrade to Ollama 0.32.12 or newer, then:

• ollama pull qwen3.8:27b-mlx — downloads the ~18 GB MLX build.

• ollama run qwen3.8:27b-mlx — interactive chat with the thinking template wired up.

• ollama serve — exposes the O​penAI-compatible API on localhost:11434 for your apps.

One known wart, from a live GitHub issue at the time of writing: qwen3.8:27b-mlx rejects the "developer" role on the /v1/responses endpoint, which breaks ollama launch codex for this model — while direct ollama run works fine. If you are building a Codex-style agent loop on the MLX build, test the exact endpoint you plan to use before betting the loop on it.

Path B — mlx-lm, the most control

Apple's own toolkit. Install it with pip install mlx-lm, then either pull a pre-quantized MLX checkpoint or convert the official BF16 weights yourself:

• mlx_lm.generate --model <checkpoint> — run a checkpoint directly; community 4-bit and 8-bit quants of the 27B were still landing in mlx-community within days of release.

• mlx_lm.convert --hf-path Qwen/Qwen3.8-27B --q-bits 4 — convert once; costs about one download.

• mlx_lm.server --model <checkpoint> — O​penAI-compatible server that applies the thinking-block chat template for you.

If the exact quant you want is not up yet, converting from the official weights is a short job on any M-series Mac and removes any doubt about what a third party shipped.

Path C — LM Studio, the one click

LM Studio uses the MLX backend on Apple Silicon and picked up Qwen3.8 27B at release: search for the model, pick a quant that fits your RAM, and it downloads and runs. If you prefer a GUI, this is the friendliest route, and our companion walkthrough covers it start to finish — see "How to Run Qwen3.8 27B Locally" in the related reads below.

The template trap

Qwen3.8 27B thinks by default, and the think blocks are rendered by the chat template, not the model core. Third-party testing from the first 48 hours notes that the official template wraps every assistant turn in a think block — even empty ones — and that in multi-turn agent loops the blocks nest and the history truncates, which reads like amnesia. It is not the quantization. If a runtime ships a corrected template, use it; when you are building an agent loop and do not need the reasoning, disable thinking per request — the chat template exposes an enable_thinking flag, and the model takes a reasoning_effort of xhigh, medium, or low.

What it actually feels like

An independent test on a Mac mini M4 with 32 GB of unified memory, running the MLX 4-bit build, measured roughly 5–6 tokens/s of generation. That is the number that should set expectations: fine for interactive drafting, long-form reasoning, and occasional agent calls; painful for long agentic loops and batch jobs. The same tester's anecdote — a multi-minute think followed by a small application that looked right but did not actually add up — is a good reminder that a 27B on a laptop is a capable but not infallible assistant.

Speed scales with chip tier: an M-series Max with more memory bandwidth and cores runs meaningfully faster than the base M4 in the mini. But 5–6 tok/s on the entry point is the honest baseline, and you should judge any "runs on Apple Silicon" headline against it.

The 262K context is a server feature

Qwen3.8 27B's native 262K window is genuinely useful — but on a Mac it is gated by memory, not by the model. At 64 KB of KV cache per token, an 8K window costs about 0.5 GB, 32K about 2 GB, 128K about 8 GB, and the full 262K about 16.4 GB on top of the weights. On a 24 GB machine running 4-bit, the realistic ceiling is roughly 64K–96K tokens; reaching toward 128K+ means a 32 GB+ machine, and the full window means a machine whose unified memory is mostly cache. Plan the context you actually need and cap it in the runtime config — the model is happy, and your swap file stays quiet.

When Apple Silicon is the wrong answer

Take a different path if any of these is your workload:

• You have an 8 GB or 16 GB Mac. The 4-bit build already needs ~17 GB of unified memory; anything less swaps and the model becomes unusable. This is the single most common miss, and no amount of quantization trickery fixes it.

• You need the full 262K window or the 1M YaRN extension. That KV budget is a server budget, not a laptop budget.

• You are serving other people. A laptop is one seat; multi-user throughput needs a GPU box or a hosted API.

• You need to move fast on long agentic loops. 5–6 tok/s is fine for a human reading along, slow for a sub-agent.

The honest framing: Qwen3.8 27B's pitch is that it is free at the point of use on hardware you own — the opposite of an API model that charges per token. That is exactly why it is not in the OrcaRouter catalog (the catalog routes the earlier Qwen3.6/3.5-27B generation and the hosted Qwe​n API line). We are the wrong tool for the free-local story, and that is the point: when a workload outgrows a Mac, the alternatives are a GPU box, a rented GPU, or a hosted Qwe​n API — not a router that happens to carry this specific 27B.

Bottom line

Qwen3.8 27B on Apple Silicon is real, it is good, and it is narrowly scoped. The 4-bit MLX build fits a 24 GB+ Mac, downloads as qwen3.8:27b-mlx in Ollama, costs nothing per token, and is the first genuinely usable agent-grade open model that fits in a laptop. The trade-offs are speed (5–6 tok/s on an M4 mini) and context (cap it well below 262K unless you have the RAM). If you have a 24 GB+ Mac and a workload a 27B can carry, this is the best free local model available this week. If you have a 16 GB Mac or need production throughput, it is not — and the alternative is a paid path, which is a different decision entirely.