Qwen 3.6 Review: Claude-Level Coding on a 24GB Card?

Alibaba's Qwen 3.6 landed this April, and the local-AI crowd has been losing its collective mind ever since — because for once, the good stuff wasn't locked inside a datacenter. Two open-weight models, both Apache-licensed, both claiming coding scores level with the big cloud names, and both running on the same graphics card you bought for gaming. Is a 27-billion-parameter model really matching frontier assistants on software benchmarks? The honest answer is "kind of, with asterisks" — and the asterisks are the interesting part.

Two models and a tease

Qwen 3.6 is really two local models plus a tease. There's a 27-billion-parameter dense model aimed at coding, and a mixture-of-experts model with 35 billion total parameters but only 3 billion active per token — it routes through nine of 256 experts at each step. Both ship under Apache 2.0, both carry a 262,000-token context window, both have vision baked in, and both use a hybrid design that pairs three linear-attention DeltaNet layers with every regular attention layer. That hybrid layout is why they don't fall off a speed cliff at long context. The tease is Qwen 3.7 Max: cloud-only, closed weights, API access at $2.50 per million input tokens. You cannot download it, so stop asking.

Squeezing it onto real hardware

Quantization is where these models get squeezed onto real hardware, and the menu is long. For the mixture-of-experts model, the standard four-bit Q4_K_M lands around 22GB, a three-bit dynamic quant is about 16.5GB, and Unsloth's so-called one-bit dynamic quant drops to 10GB — though it's secretly all two-bit tensors wearing a one-bit name tag. The dense 27B runs from about 14GB at three-bit up to 29GB at eight-bit. One fair warning from the research: the Qwen 3 family degrades harder below three bits than Llama did, and the hybrid layers get especially cranky at two-bit. Treat anything under three-bit as an act of desperation, not a lifestyle.

The honest hardware math

A single 24GB card — an RTX 3090 or 4090 — fits the mixture-of-experts model at four-bit with room left for context, and that's the pairing most people are actually running. The dense 27B at four-bit is around 17GB, so it also fits 24GB cards, while a 32GB RTX 5090 lets you run it at six-bit with genuinely long context. Sixteen-gigabyte cards get the three-bit mixture-of-experts quant, Macs with 32GB or more of unified memory are comfortably in the game, and there's even a llama.cpp offloading trick that runs the MoE on a 6GB card — slowly, but it runs.

Real cards, real speeds

Now the numbers you came for: measured speeds on real cards. The mixture-of-experts model on an RTX 3090 at four-bit does about 101 tokens per second on short prompts, dropping to 81 once the context gets long, and community reports put an RTX 4090 past 120. The dense 27B is a different animal: on a 4090 at four-bit you get about 39 tokens per second plain, or 43 with speculative decoding, while an RTX 5090 manages 77 plain and over 120 with a draft model. Apple Silicon M4-class machines report roughly 45 to 80 tokens per second on the MoE at four-bit, and even that 6GB offload setup hits around 30. The mixture-of-experts model really is the speed bargain here.

The hype detector

Time for the hype detector. The marketing says the 27B scores 77.2 on SWE-bench Verified — level with Claude Sonnet 4.5 — and outperforms a 397-billion-parameter predecessor. The community's reply: nice benchmark, now explain why it fumbles tool calls on long agent runs, why the mixture-of-experts model gets lost when tasks need many steps, and why researchers keep warning that SWE-bench scores are inflated by patches that pass the tests without actually being correct. Then there were the launch-week bloopers: a CUDA 13.2 bug that produced pure gibberish, Ollama not supporting the models on day one, and speculative-decoding setups that quietly corrupted JSON while posting gorgeous speed numbers. Fast wrong answers are still wrong.

So who should actually run it?

If you have a 24GB card, the answer is easy: grab the 35-billion mixture-of-experts at Unsloth's dynamic four-bit quant, run it in llama.cpp with a quantized KV cache, and enjoy triple-digit token speeds from a genuinely capable coder. Pick the dense 27B only if you have a 5090 or infinite patience, because its quality edge comes at roughly one-third the speed. Sixteen-gigabyte owners take the three-bit MoE; Mac owners take the MLX four-bit. And yes, it's worth it — this is the best capability-per-gigabyte deal in local AI right now, warts and all. Two great open models, one closed tease, and a pile of asterisks we read so you don't have to.