TL;DR: The open-weight frontier moved a lot since June — GLM-5.2 now beats GPT-5.5 on SWE-bench Pro, and Inkling is the best American open model. None of it runs on your GPU. The best single-card picks are unchanged: Qwen3.6-35B-A3B on 24GB, Gemma 4 26B-A4B QAT on 16GB.

	Qwen3.6-35B-A3B	GLM-5.2	Inkling 975B
Best for	Daily driver on one 24GB card	Frontier coding via API	Apache 2.0 frontier via API
License	Apache 2.0	MIT	Apache 2.0
Smallest usable quant	~22GB Q4_K_M	~239GB 2-bit	~270GB 1-bit
Runs on a consumer GPU?	Yes — 50–65 tok/s on a used RTX 3090	No — 256GB+ box or cloud	No — cluster or cloud
The catch	Not frontier-quality	$1.40/$4.40 per M via API anyway	1-bit quant loses real quality

Honest take: If you own a 24GB card, download Qwen3.6-35B-A3B and stop refreshing the leaderboard — every headline model released since June needs 10× your VRAM. Use GLM-5.2 through the API for hard coding tasks and let the hype cycle pay for your electricity instead of your hardware.

The June edition of our open-source LLM shootout compared Qwen3.6, Gemma 4, Llama 4, GLM-5.1, and DeepSeek V4. Five weeks later, three of those five have been overtaken by newer releases, and the leaderboard sites are churning out fresh July rankings. Here’s what actually changed, what the new rankings mean if your hardware budget is a used GPU rather than a datacenter, and the specific model-quant combo to download for each VRAM tier this month.

What changed since June

Three releases moved the frontier:

GLM-5.2 (Z.ai, June 13, MIT license) is the headline. It’s a ~744B-parameter MoE with ~40B active per token and a 1M-token context window, and it scored 62.1% on SWE-bench Pro — ahead of GPT-5.5’s 58.6%. That’s the first time an open-weight model has beaten OpenAI’s flagship on that benchmark. On Terminal-Bench 2.1 it posts 81.0, the strongest open-weight result, though still behind GPT-5.5 (84.0) and Claude Opus 4.8 (85.0). Our GLM-5.2 hardware guide has the full VRAM math.

Inkling (Thinking Machines Lab, July 15, Apache 2.0) is Mira Murati’s lab’s first open-weights release: 975B total, 41B active, multimodal, 1M context, trained on 45T tokens. It scores 77.6% on SWE-bench Verified, 97.1% on AIME 2026, and 87.9% on GPQA Diamond, and Artificial Analysis ranks it at 41 on its Intelligence Index — the top American open-weights model. Full breakdown in our Inkling hardware guide.

Kimi K3 (Moonshot AI, announced July 16) is the biggest open model ever announced at 2.8 trillion parameters (16 of 896 experts active per token). The weights aren’t out yet — Moonshot has committed to releasing them by July 27, 2026. Until then it’s API-only. Our Kimi K3 guide covers what the MXFP4-native format means for quantization.

Impressive quarter for open weights. Now the part the leaderboard articles skip.

The leaderboard vs. your VRAM

Here’s the July 2026 open-weight leaderboard with the one column that matters for a home lab — the smallest quant that’s actually worth running, and what it takes to run it:

Model	License	Total / active params	Headline score	Smallest usable quant	Minimum real hardware
Kimi K3	Modified MIT (weights Jul 27)	2.8T / ~40–60B est.	GDPval-AA v2: 1,687 (3rd overall)	~1.4TB native MXFP4	Datacenter / API
GLM-5.2	MIT	744B / 40B	SWE-bench Pro 62.1%	~239GB (Unsloth UD-IQ2_M)	256GB+ unified/RAM box, 3–9 tok/s
Inkling	Apache 2.0	975B / 41B	SWE-bench Verified 77.6%	~270GB (Unsloth 1-bit, 74.2% quality retained)	Mac Studio cluster or 8× H100
Kimi K2.7 Code	Modified MIT	1T / 32B	Vendor coding benches	~325GB (UD-Q2_K_XL)	4× RTX 3090 + 256GB RAM, ~8–12 tok/s
Qwen3.6-35B-A3B	Apache 2.0	35B / ~3B	Best-in-class for 24GB	~22GB Q4_K_M	One 24GB card, 50–65 tok/s
Gemma 4 26B-A4B	Gemma license	26B / ~4B	Best-in-class for 16GB	~15GB Q4 QAT	One 16GB card
Codestral 2	Apache 2.0	22B dense	86.6% HumanEval, FIM autocomplete	~13.3GB Q4_K_M	One 16GB card, ~40–50 tok/s on a 3090

Read the last two columns together and the story is plain: the leaderboard’s top four entries need between 10× and 60× the VRAM of a RTX 3090. GLM-5.2’s 2-bit dynamic quant is 239GB on disk — Unsloth’s own guidance is a 256GB unified-memory Mac or a 24GB GPU plus 256GB of system RAM with MoE offloading, which lands at 3–9 tok/s. That’s batch-job speed, not chat speed. Inkling’s 1-bit build is ~270GB and retains 74.2% of the model’s quality — you’re paying cluster money to run a deliberately lobotomized copy of a model whose API costs less per month than the electricity.

Even the single most capable consumer card changes nothing here. An RTX 5090 has 32GB; the 96GB RTX PRO 6000 — a $8,000+ workstation card — still falls 143GB short of GLM-5.2’s 2-bit file. There is no clever flag that fixes a 7× capacity gap.

What to run on the card you own

The winners by VRAM tier are unchanged from June, which is itself the news: five weeks of frontier releases and zero movement in the consumer tiers.

24GB (RTX 3090, RTX 4090)

Qwen3.6-35B-A3B, Q4_K_M. ~22GB, Apache 2.0, and because only ~3B parameters are active per token, it decodes at 50–65 tok/s on a used RTX 3090 — some of Unsloth’s dynamic Q4 builds push past 100. It’s the best blend of quality and speed a single card delivers in July 2026, and the used 3090 (averaging ~$1,254 in July 2026 listings, down to ~$1,050 on patient eBay hunting) remains the cheapest way to own this tier.

ollama pull qwen3.6:35b
ollama ps

Expected output — the SIZE and PROCESSOR columns are the health check:

NAME            ID            SIZE     PROCESSOR    UNTIL
qwen3.6:35b     a1b2c3d4      22 GB    100% GPU     4 minutes from now

Anything other than 100% GPU means you’re spilling into system RAM and leaving half your tokens/sec on the table — our Ollama speed-tuning guide walks the fix order.

If you write code all day, Codestral 2 (Apache 2.0, 13.3GB at Q4_K_M) is still the cleanest-licensed dense coder for FIM autocomplete, and it leaves VRAM headroom for long contexts that the 35B MoE can’t spare.

16GB (RTX 5060 Ti 16GB, RTX 4060 Ti 16GB)

Gemma 4 26B-A4B, QAT build. Google’s June quantization-aware checkpoints put the 26B MoE in ~15GB — it fits a RTX 5060 Ti 16GB with a couple of GB to spare for KV cache. Pull the -it-qat tags; hand-converting the HuggingFace BF16 checkpoints yourself reintroduces the accuracy loss QAT was trained to avoid, as we covered in the Gemma 4 QAT update.

8–12GB

Gemma 4 12B QAT (~7GB) is the quality pick; Qwen3.6’s smaller tags are the speed pick. The full tier-by-tier map lives in best local AI models by VRAM and the RTX 50-series model guide.

The trap this month: downloading a leaderboard winner your rig can’t load

A reader-repeated failure pattern we keep seeing in July: grab the GLM-5.2 or Inkling GGUF because it topped a chart, wait out a 250GB download, and then hit either an out-of-memory crash at load or — on an un-updated runtime — Error: unknown model architecture. The fix for the second one is a runtime update, not a re-download: new architectures need llama.cpp/Ollama support that landed within the last few weeks, and we decoded that error in the unknown-architecture fix guide. The fix for the first one is arithmetic before bandwidth: file size + KV cache must fit VRAM + RAM you’re willing to offload to, and MoE offload below ~10 tok/s is a batch tool, not an assistant. Do the math from the table above before you start a download measured in hundreds of gigabytes.

When the API is the right answer (usually)

GLM-5.2 costs $1.40 per million input tokens and $4.40 per million output on Z.ai’s first-party API ($0.26 cached input), and OpenRouter routes it cheaper still. Run the break-even: a box that fits the 239GB 2-bit quant — 256GB+ of unified memory or a multi-GPU tower — starts around $10,000. At $4.40/M output you’d need to generate over 2 billion output tokens, sustained, before the hardware pays for itself, and the local copy would be the degraded 2-bit build running at 3–9 tok/s the whole time. For a model you call a few times a day on hard problems, the API wins by an order of magnitude; if you want it wired into Cursor or Cline as a coding backend, our sister site aicoderscope.com covers that setup.

Local still wins where it always has: unlimited-volume daily inference on models that fit your card, privacy-sensitive prompts, and offline use. And if you need short bursts of big-GPU time to evaluate a frontier model properly, renting an 80GB card on RunPod for a few dollars an hour beats both a five-figure build and a monthly commitment — the rent-vs-buy math hasn’t changed.

Watch list for August

Two pending releases could actually change the consumer tiers, which none of July’s releases did:

• Inkling-Small (276B total / 12B active, Apache 2.0) — announced alongside Inkling but the weights are still unreleased while Thinking Machines finishes testing. If a 2-bit build lands under ~100GB, it becomes the first RTX PRO 6000-class single-card path to a 276B model; 12B active parameters should decode fast. We’re holding a full guide until the weights and real GGUF sizes exist.
• Kimi K3 weights, due July 27 — 2.8T parameters means no home deployment, but Moonshot ships MXFP4-native weights, so watch for what the distillation community does with them.

If either lands as promised, the August edition of this leaderboard will have actual news for GPU owners. Until then: the models above, the card you already own, and the API for the frontier.

FAQ

Is GLM-5.2 really better than GPT-5.5? On SWE-bench Pro (62.1% vs 58.6%), yes. On Terminal-Bench 2.1, GPT-5.5 still leads 84.0 to 81.0. “Beats GPT-5.5” is true on some coding benchmarks, not across the board — and either way you’ll be using it through an API, where it costs a fraction of GPT-5.5’s rates.

Can I run GLM-5.2 on a 24GB GPU with lots of system RAM? Technically, with 256GB of RAM and MoE offloading via llama.cpp, at roughly 3–9 tok/s from the 2-bit quant. That’s usable for overnight batch work and nothing else. See the run-a-70B-on-24GB guide for why partial offload speeds collapse.

What’s the best fully-open (Apache 2.0/MIT) model for a single 24GB card? Qwen3.6-35B-A3B (Apache 2.0). Codestral 2 (Apache 2.0) for dedicated coding autocomplete. Gemma 4 is excellent but ships under Google’s own license rather than OSI-standard terms.

Should I wait for Inkling-Small instead of buying a GPU now? No — its plausible landing zone is 96GB-class hardware, not 24GB cards. If you’re shopping in the $500–$1,300 range, nothing announced in July changes the used RTX 3090 calculus.

Where do these giant models actually get self-hosted? Mac Studio clusters, 256GB+ EPYC/Threadripper CPU-offload builds, and rented multi-GPU cloud pods. Our friends at aifoss.dev cover the self-hosting stacks for the open-weight giants.

Sources

• GLM-5.2 benchmarks: what 62.1% SWE-bench Pro means — Groundy
• GLM-5.2 on Terminal-Bench 2.1 — Groundy
• GLM-5.2: How to Run Locally — Unsloth Documentation
• Pricing Overview — Z.AI Developer Documentation
• Inkling: Our open-weights model — Simon Willison
• Thinky’s Inkling: 975B-A41B multimodal, with Inkling-Small 276B-A12B — Latent Space
• Thinking Machines open sources Inkling — VentureBeat
• Moonshot ships Kimi K3: 2.8T parameters, weights July 27 — HowAIWorks
• Kimi K3, and the pelican benchmark — Simon Willison
• GLM 5.2 — API Pricing & Benchmarks — OpenRouter

Last updated July 20, 2026. Prices, benchmark standings, and model availability change fast; verify current rates before purchasing.

Recommended Gear

Products linked in this guide:

• RTX 3090 — the used 24GB value pick for Qwen3.6-35B-A3B
• RTX 5090 — 32GB for Q8 quants and bigger contexts
• RTX 5060 Ti 16GB — cheapest new card that fits Gemma 4 26B QAT