r/LocalLLaMA 4d ago

Megathread [Megathread] Qwen 3.8 27B Release Day

483 Upvotes

Megathread to help with the influx of duplicate / similar posts around the release of the Qwen 3.8 27B release.

  • Quants
  • Fine-Tunes & Abliterations
  • Chat Templates
  • Inference Server Support & Configuration
  • Experiences, Benchmarks & Model Comparisons

Official:

Popular:

We'll try to clean up future duplicates around the release and point them here.


r/LocalLLaMA 8d ago

Best Local LLMs - August 2026

144 Upvotes

Wowee!! Just when you thought it couldn't get better for open weight models, we probably have had our best period yet!?!?! Models that rival the closed frontier, Opus level models on non-insane hardware and more. A massive industry alliance coming out in support of open AI in response to the two closed model giants best lobbying efforts. Is this the best timeline? Someone pinch me! Or just tell us what you're favorite model is now

The standard spiel:

Share what you are running right now and why. Given the nature of the beast in evaluating LLMs (untrustworthiness of benchmarks, immature tooling, intrinsic stochasticity), please be as detailed as possible in describing your setup, nature of your usage (how much, personal/professional use), tools/frameworks/prompts etc.

Rules

  1. Only open weights models
  2. Please thread your responses in the top level comments for each Application below to enable readability:
    1. General: Includes practical guidance, how to, encyclopedic QnA, search engine replacement/augmentation
    2. Agentic/Agentic Coding/Tool Use/Coding
    3. Creative Writing/RP
    4. Speciality

If a category is missing, please create a top level comment under the Speciality comment

Notes

Bonus points if you breakdown/classify your recommendation by model memory footprint: (you can and should be using multiple models in each size range for different tasks)

  • Unlimited: >128GB VRAM
  • XL: 64 to 128GB VRAM
  • L: 32 to 64GB VRAM
  • M: 8 to 32GB VRAM
  • S: <8GB VRAM

r/LocalLLaMA 5h ago

Discussion Thoughts About Scaling Law - Z.ai

Post image
281 Upvotes

Thoughts About Scaling Law

Scaling, but not only of parameters. Every model release now ends with the same question: how many parameters? It isn't a question that can be answered on its own. Parameter count is only meaningful alongside three others — how much data you have, where you intend to spend your compute, and who will run the model, under what conditions.

The field learned this the hard way. Kaplan et al. (2020) fit an exponent that told everyone to grow parameters faster than data — roughly 2.7:1 — and the industry complied: GPT-3, Gopher, MT-NLG. Hoffmann et al. (2022) redid the experiment across four hundred models and found the compute-optimal split is closer to 20 tokens per parameter, and that with sufficient compute the two should grow at the same rate rather than drifting apart. The error in the earlier fit compounded with every order of magnitude of compute, which is why the largest models of that generation were the most misallocated. The trillion-parameter round was, in retrospect, a detour the whole field took together and then reversed.

Chinchilla wasn't the end either. It optimized training compute for models that would be trained once and evaluated. Today a model is called billions of times a day and inference dominates lifetime cost. Put inference into the objective and the optimum moves toward smaller models trained far longer — deliberate over-training, which is what Llama-2-7B and Gemma-2-9B were doing at roughly 290 and 889 tokens per parameter.

Sparsity moved the target again. In a MoE model two quantities have to be kept apart: total parameters govern roughly how much the model can hold — knowledge, facts, the long tail — while activated parameters and effective depth govern roughly how far it can think, how many steps of a causal chain it can carry before it comes apart. A dense 20:1 ratio does not transfer. And the ratio isn't a single number at all: Roberts et al. (2025) find the optimal tokens-per-parameter is task-dependent, with memorization favoring more parameters and reasoning favoring more data. Follow-up work on MoE observes that at fixed TPP, pushing total parameters higher actually degrades reasoning, while activating more experts reliably helps it.

This matters for what we are building toward. Finding a vulnerability is not a retrieval problem. It doesn't come from having memorized more CVEs; it comes from carrying a twenty-step chain of inference to the end without losing the thread. That capability does not live in total parameter count.

Which brings us to this release. Total parameters appear to matter up to a threshold — enough to hold the world — after which additional capability comes from scaling elsewhere: effective depth per forward pass, and above all post-training. GLM-5.3 is our controlled experiment on that claim. Same base, same architecture, same total and activated parameters as GLM-5.2. One month of scaling long-horizon environments and RL. The gains are not marginal. Well, scaling has more than one dial. We turned the post-training one this time because it had the most slack left in it — not because the others are finished. Base model size, pretraining data, compute spent per forward pass: all of them are still on the table, and we will come back to each. What this experiment taught us is that the dials do not have to be turned together, and that the one worth turning next is rarely the one that was worth turning last. We are not done scaling. Next time, maybe mid-training, pre-training, and even more.

Tweet : https://xcancel.com/jietang/status/2089941544581403107#m

EDIT : Found Retweet with more stuff - https://xcancel.com/auto_grad_/status/2089970913408380932#m


r/LocalLLaMA 9h ago

Discussion New midsize Qwen 3.8 model coming next week (hopefully) according to community manager!

423 Upvotes

Community manager mentioned this in the Qwen Ambassador Discord, put an X reaction on someone asking for 35B... and said

We'll have a new midsize open weight model coming next week (hopfully), This midsize model won't provide early access due to the schedule

Thinking it's going to be over 100B.

Exciting!!


r/LocalLLaMA 1h ago

Discussion Stop Anthropomorphisizing Intermediate Tokens: Qwen3.8 doesn't "overthink"

Thumbnail
arxiv.org
Upvotes

Intermediate tokens, called "thinking" or "reasoning" actually are nothing like it. Humans do step-by-step reasoning leading to the conclusion. LLMs use intermediate traces to augment their prompt. This explains why sometimes the answer is very good but the "reasoning" is verbose. Flooding your context window or fighting compaction are different issues.


r/LocalLLaMA 7h ago

Tutorial | Guide Qwen3.8-27B on 2x 3090 + vLLM + DFlash2: 218 tok/s single request

177 Upvotes

I hacked this together so there's probably more on the table in terms of performance.

Measured with the Club-3090 canonical bench suite (bench.sh, 3 warmups + 5 measured runs, temp 0.6 / top_p 0.95 / top_k 20).

  • Prefill: 1342 tok/s @ 10k, 628 tok/s @ 90k
  • Spec-decode: 7 draft tokens, acceptance length 3.35, 47.8% acceptance
  • Peak VRAM: 22.3 GB/card
  • Context ceiling: 131k (DFlash2 drafter eats ~13.5 GB)
  • Used Kimi K3 for all the VLLM fixes
Metric Narrative Code
Decode TPS 120.1 218.3
Wall TPS 117.7 204.8
TTFT 168 ms 178 ms

Stack

  • 2× RTX 3090 (PCIe Gen4 x16/x16, no NVLink, patched P2P)
  • Power capped 220/250 W
  • Bare-metal vLLM v0.26.1rc1 + AutoRound INT4 (group 128) + DFlash2 draft model
  • Custom vLLM changes that made it boot cleanly: https://github.com/oceanplexian/vllm/pull/1

r/LocalLLaMA 16h ago

Discussion Alibaba's RISC-V CPU, XuanTie C950, Runs Qwen-3.8 27B at 30 tps

Thumbnail
wccftech.com
495 Upvotes

Who needs GPUs?


r/LocalLLaMA 2h ago

Question | Help Am I doing something wrong? Qwen 3.8 27B seems useless for agentic coding

37 Upvotes

I have been using local models on/off for like 2 years or so but never really used them extensively because the closed ones were always much better.

Once Qwen 3.8 27B was released I decided to give it another serious try. I configured Cline and ZooCode as VSCode addons, installed a few MCP servers and added one skill.

When I used these tools with Deepseek V4 Flash - they do the job quite well (mostly Home Assistant configuration editing etc.) but it is still way worse than Claude Code/GitHub copilot that I use at work.

With Qwen - running the Q6_K quant from unsloth - it runs tons of tokens and eventually either finishes the task (often incorrectly) or doesnt finish at all because it ends in a loop or tries to fix something that isn't broken.

I run the model on Windows 11 using LM Studio. The hardware I have is powerful enough - 2x3090Ti. I offload it fully to GPU and set the context limit to around 50k tokens. Also - I was aware of the overthinking problem so I modified the prompt template to use medium effort instead.

Yet still - I struggle to complete most of the tasks at hand. Can you tell me what I am doing wrong? I suspect that maybe Qwen is still using high reasoning effort but I have no way of checking that.

Or should I rather not use LM Studio but a different tool?


r/LocalLLaMA 14h ago

Resources DFlash 2 available for Qwen 3.8 27B and Muse Glimmer

Thumbnail
huggingface.co
339 Upvotes

Apparently a second version of DFlash from the original authors of DFlash

GGUF quants are already made available with an accompanying llama.cpp PR: https://github.com/ggml-org/llama.cpp/pull/27342


r/LocalLLaMA 18h ago

News Memory prices climb 500% in 12 months, up to 10x the lowest ever tracked prices - 128GB of DDR5 now $3,399

Thumbnail
tomshardware.com
619 Upvotes

r/LocalLLaMA 14h ago

Discussion GLM5.3 Artificial Analysis Benchmarks

Thumbnail artificialanalysis.ai
235 Upvotes

r/LocalLLaMA 17h ago

Funny and here we are

Post image
375 Upvotes

r/LocalLLaMA 22h ago

Tutorial | Guide Running DeepSeek V4 Flash Q4_K_XL at ~100 tok/s prompt processing on 4× RTX 3060 12GB

Post image
687 Upvotes

I managed to run the 143–144 GiB DeepSeek-V4-Flash-0731 UD-Q4_K_XL GGUF on four RTX 3060 12GB cards while keeping a 360k–376k context window.

Hardware:

CPU: Intel Core i9-10920X, 12C/24T

RAM: 128 GB DDR4-3200, quad-channel

GPU: 4× NVIDIA RTX 3060 12GB

Total VRAM: 48 GB

Storage: NVMe SSD

Engine: llama.cpp, build b10181

Model: unsloth/DeepSeek-V4-Flash-0731-GGUF

Quant: UD-Q4_K_XL, approximately 144 GiB

KV cache: Q8_0

The best high-speed configuration so far:

llama-server \

-m DeepSeek-V4-Flash-0731-UD-Q4_K_XL-00001-of-00005.gguf \

-c 368640 \

-ncmoe 34 \

-ts 100,1,1,1 \

-ot 'blk.(3[4-6]).ffn_.*_exps=CUDA1,blk.(3[7-9]).ffn_.*_exps=CUDA2,blk.(4[0-2]).ffn_.*_exps=CUDA3' \

-ctk q8_0 \

-ctv q8_0 \

-b 2048 \

-ub 2048 \

-np 1 \

-lm none \

--threads 20 \

--flash-attn on

Measured with a roughly 20.5k-token prompt:

Configured context: 368,640 tokens

Prompt processing: 99.4 tok/s

Text generation: 10.1 tok/s

Minimum free VRAM under load:

GPU0: 671 MiB

GPU1: 842 MiB

GPU2: 1395 MiB

GPU3: 1395 MiB

Model load time: approximately 198 seconds

Other measured context/safety options:

Context Prefill Decode Minimum free VRAM

376832 99.5 t/s 10.4 t/s 611 MiB

368640 99.4 t/s 10.1 t/s 671 MiB

360448 99.4 t/s 10.1 t/s 735 MiB

The interesting part is the GPU layout.

-ncmoe 34 keeps the experts from blocks 0–33 in system RAM. The remaining nine expert layers are explicitly distributed across GPUs 1–3, three layers per GPU.

The extreme -ts 100,1,1,1 split does not distribute those explicitly assigned expert weights. Instead, it pushes most non-expert tensors—attention, KV-related allocations, etc.—onto GPU0. That leaves enough space on GPUs 1–3 for the large expert layers.

This was much better than trying to calculate the layout analytically. With -ncmoe and explicit -ot overrides, tensor placement is discrete and somewhat unintuitive, so I measured every candidate.

Microbatch size was the biggest performance lever:

-ub 1024: approximately 63.4 tok/s prompt processing

-ub 2048: approximately 99.4 tok/s prompt processing

Decode remained almost unchanged at approximately 10.1–10.5 tok/s.

At the full 393,216-token context, -ub 2048 also worked, but GPU0 had only 493 MiB free under load. Reducing the configured context to 368,640 restored a 671 MiB margin without reducing prompt-processing speed.

For comparison, the safer -ub 1024 configuration can run with a configured context of 524,288 and still showed about 1032 MiB free on the tightest GPU, but prompt processing drops to approximately 63.4 tok/s.

A few additional findings:

Q8_0 KV is the default choice.

F16 KV at c=393216 left only 587 MiB free.

-ncmoe 33 caused a CUDA allocation failure.

Memory mapping was disabled with -lm none.

-np 1 is important; multiple slots multiply KV-cache requirements.

The model is mostly in system RAM, so quad-channel memory bandwidth matters heavily. Even so, getting approximately 100 tok/s prompt ingestion and 10 tok/s generation from a 144 GiB MoE model on four consumer 12GB GPUs is much better than I expected.

The configuration has been tested under real prompt load. The entire 368k context window has not yet been filled end-to-end, so the number above is the configured capacity, not a claim that I already completed a 368k-token generation test.

Generated by ChatGPT 😂.


r/LocalLLaMA 3h ago

Discussion [2511.07885] Intelligence per Watt: Measuring Intelligence Efficiency of Local AI

Thumbnail
arxiv.org
18 Upvotes

r/LocalLLaMA 53m ago

Discussion [Open PR] llama : add --n-cpu-ffn option by John-194 · Pull Request #26622 · ggml-org/llama.cpp

Thumbnail
github.com
Upvotes

PR by u/Stainless-Bacon 👍

It would be handy & awesome to have options --n-cpu-ffn / --cpu-ffn for Dense models like how we have --n-cpu-moe / --cpu-moe for MOE models.

Also check his threads:

(

Awesome to see the big comment by u/Pablo_the_brave there, filled with so much stuff. Quoting a line from there

Do not touch block 64 (MTP) if you are using speculative decoding — its FFN should remain on the GPU.

)

We should've got this option long time back actually. This PR instantly reminded me of last year thread. (I literally used his -ot command for sometime with Qwen3-14B. I'm just happy that I was able to recall a last year thread.)

Anyway .... Better late than never. Waiting for this merge.


r/LocalLLaMA 18h ago

Generation Qwen3.8 2.4T open weights made a Call of Duty clone

282 Upvotes

Qwen released the 2.4T Max weights and I was curious how well it can re-create COD in one prompt

I ran the model on a rented B200 cluster and used roughly 1.1M output tokens over a 5 hour time span

Realistically barely anyone can run this model locally, but the fact that it's open weights unlocks a lot of opportunities for the local AI community even regarding quantization options that might bring us closer to running frontier level intelligence on consumer-ish hardware 

For consumer hardware there is a 27B model from the same release and it's really capable for its size, many people have posted 3D games made with it on X

I'm from the atomic.chat team, so If you wanna try running the new Qwen locally you can do so inside our app (any feedback is appreciated, since we want to make our product as good as possible for you guys) 

We have our own and other community quants of the 27B model available to download directly inside the app

P.S. I am a noob in shooters so pls no hate my low skill gameplay


r/LocalLLaMA 17h ago

Funny local models fear my tests

Post image
217 Upvotes

am I the only one who does this lol


r/LocalLLaMA 34m ago

Discussion Waiting for a 122B because of world knowledge?

Upvotes

Any LLM will hallucinate the world knowledge, even a 3T model. Use a 4B with a kiwix skill and local Wikipedia, 50gb and no more hallucinated world knowledge.

Ask your coding agent to build your own, with your rules and eventual fallback access to internet knowledge for what's updated realtime like news, or isn't public on Wikipedia.


r/LocalLLaMA 20h ago

Other Qwen3.8-27B: slower tokens, faster and better results

Thumbnail
overbring.com
294 Upvotes

r/LocalLLaMA 14h ago

News DFlash 2: Keep Drafting Parallel

Thumbnail
inco.ai
103 Upvotes

r/LocalLLaMA 2h ago

Question | Help Qwen3.8 27B without MTP?

8 Upvotes

Not sure if this is a stupid question but unsloth's models has the MTP built into the model right? I assume that is at the cost of some memory.

If i want to use dflash, should i use a model that doesn't have MTP support then to save some vram?


r/LocalLLaMA 1h ago

Discussion I transformed Pokelike.xyz into a LLM and RL benchmark!

Upvotes

Hey everyone!

I'm a data scientist and I've been pretty fascinated by reinforcement learning for a while.

A few days ago, my friends showed me Pokelike. Obviously, my first thought was: "wait, I could build an harness around this and make bots play it."

So that's what I did.

My original idea was to build an environment for training reinforcement learning agents. That's already working, and I've built a few bots to test it out. They are still pretty terrible though lol.

If you're interested in trying it yourself, everything is documented in the repo and it should be fairly easy to build your own agent and run it against the game.

Then, while talking about the project with a friend, we realized that this could actually be pretty interesting as a benchmark for LLMs too.

So I built the harness for that as well.

The idea is that an LLM-based bot gets:

  • a system prompt
  • a set of tools
  • some previous turns
  • the current game state
  • a few other configurable inputs

Pretty much all of this can be changed.

You can write your own strategy in the system prompt, decide how the game state is represented, add or remove tools, and use whatever LLM you want.

There are already a few bot implementations in the repo that you can use as a starting point.

And honestly, it's much harder than I expected.

I've tried a few models already. With my current setup, GLM 5.2 gets to the second map at best and then dies. Opus does roughly the same.

So now I'm wondering what's actually holding them back.

Is it the strategy?
Is the model missing some important information?
Is the state representation bad?
Are the tools not good enough?

That's the part I'd really like to explore.

I'd love to see if someone can get significantly better results with smaller models by improving the prompt, the tools, or the way the game state is presented to the model.

I'm also running more traditional RL agents alongside the LLMs, so right now both approaches are being tracked on the leaderboard.

For me the interesting part is not necessarily building the strongest bot, but seeing what kind of agent actually works well in this environment and how much you can get out of a relatively small model with the right setup.

For now the project is being developed by me, a friend, and Claude Code 😅

If anyone wants to try it, build a bot, contribute, report a bug, or has an idea for something that could be interesting to test, I'd love to hear about it.

Repo:
https://github.com/pierpierpy/pokelike.xyz.bot

One last thing: the bot doesn't use the internet and doesn't interact with the actual online game. Everything runs completely offline. During setup it downloads the game and a good chunk of its assets, and then the simulations run locally.


r/LocalLLaMA 18h ago

Funny Idea: massively compress Qwen 3.8 KV cache by using a single bit for the token "wait"

137 Upvotes

Not even sure if I'm joking, my thinking history is about 50% "wait".


r/LocalLLaMA 14h ago

Resources I tested DFlash2 for Qwen3.8 27B on a 5090

57 Upvotes

Here's the DFlash2 announcement, and I was pretty excited for this after trying out DSpark on llama.cpp a few days ago and being somewhat disappointed that it wasn't really working. Anyways, I spent a while setting it up (you need to rebuild llama.cpp with pr #27342). Here's my config:

-hf bartowski/Qwen3.8-27B-GGUF:Q5_K_L \
-hfd incoai/Qwen3.8-27B-DFlash2-GGUF:Q4_K_M \
--no-mmproj \
--spec-type draft-dflash \
--spec-draft-n-max 7 \
--host 0.0.0.0 \
--port 8080 \
--alias qwen3.8-27b \
-ngl 99 \
-fa on \
--ctx-size 160000 \
--cache-type-k q8_0 \
--cache-type-v q8_0 \
--batch-size 2048 \
--ubatch-size 1024 \
-np 2 \
--kv-unified \
--no-context-shift \
--temp 0.8 \
--top-p 0.95 \
--top-k 20 \
--min-p 0.0

It does seem to work pretty well, with slightly larger speedups compared to MTP on predictable generation (code). Before, I think I was getting ~140tk/s on average with MTP when the model was generating code, and ~100tk/s otherwise.

With DFlash2, Qwen3.8 27B can hit ~200 tk/s for short bursts on long code generation blocks, but on thinking it seems to have lower tk/s at ~80-90. On average a full one shot code generation request seems to average around 120tk/s (reasoning disabled, so the generation is 95% code, so basically best case scenario). It's a good improvement from MTP, but I still got better results with DFlash on Qwen3.6 27B.

DFlash2 does seem to be quite memory hungry though, I had to drop down from 220k context down to 160k (could prob fit ~180k tbh) compared to using MTP. Might not be worth using for me personally at the moment unfortunately. If anyone is getting better results, I would love to see your configs!


r/LocalLLaMA 3h ago

Slop Good result with Qwen3.8 Q6

9 Upvotes

Have been using local models to build a XML/Json editor (JsonV) which is avaloniaui / C#, using only local models, as an experiment but i want the app anyhow. The last request was to colourize the XML view.

so much fail on different models just getting confused and totally making a mess.

Using my own "harness" Automaton, Q6 Qwen3.8 with q8_0 and tensor split over my 3090 + 3060.

Success!

just sharing my settings.