I've been running this on my laptop with the Unsloth 20.9GB GGUF in LM Studio: <a href="https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF/blob/main/Qwen3.6-35B-A3B-UD-Q4_K_S.gguf" rel="nofollow">https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF/blob/mai...</a><p>It drew a better pelican riding a bicycle than Opus 4.7 did! <a href="https://simonwillison.net/2026/Apr/16/qwen-beats-opus/" rel="nofollow">https://simonwillison.net/2026/Apr/16/qwen-beats-opus/</a>
Here's a reproduction attempt (LM Studio, same Qwen3.6-35B-A3B-GGUF model as linked in parent, M1 Max 64GB, <90 seconds):<p><a href="https://files.catbox.moe/r3oru2.png" rel="nofollow">https://files.catbox.moe/r3oru2.png</a><p>- My Qwen 3.6 result had sun and cloud in sky, similar to the second Opus 4.7 result in Simon's post.<p>- My Qwen 3.6 result had no grass (except as a green line), but all three results in Simon's post had grass (thick).<p>- My Qwen 3.6 result had visible "tailing air motion" like Simon's Qwen 3.6 result.<p>- My Qwen 3.6 result had a "sun with halo" effect that none of Simon's results had.<p>But, I know, it's more about the pelican and the bicycle.
Thanks for pointing to the GGUF.<p>I just tried this GGUF with llama.cpp in its UD Q4_K_XL version on my custom agentic oritened task consisiting of wiki exploration and automatic database building ( <a href="https://github.com/GistNoesis/Shoggoth.db/" rel="nofollow">https://github.com/GistNoesis/Shoggoth.db/</a> )<p>I noted a nice improvement over QWen3.5 in its ability to discover new creatures in the open ended searching task, but I've not quantified it yet with numbers. It also seems faster, at around 140 token/s compared to 100 token/s , but that's maybe due to some different configuration options.<p>Some little difference with QWen3.5 : to avoid crashes due to lack of memory in multimodal I had to pass --no-mmproj-offload to disable the gpu offload to convert the images to tokens otherwise it would crash for high resolutions images. I also used quantized kv store by passing -ctk q8_0 -ctv q8_0 and with a ctx-size 150000 it only need 23099 MiB of device memory which means no partial RAM offloading when I use a RTX 4090.
I wonder when pelican riding a bicycle will be useless as an evaluation task. The point was that it was something weird nobody had ever really thought about before, not in the benchmarks or even something a team would run internally. But now I'd bet internally this is one of the new Shirley Cards.
Simon has an article on this<p><a href="https://simonwillison.net/2025/Nov/13/training-for-pelicans-riding-bicycles/" rel="nofollow">https://simonwillison.net/2025/Nov/13/training-for-pelicans-...</a>
Pelicanmaxxing
Yeah try it with something else, or e.g. add a tiger to the back seat.
I mean look at the result where he asked about a unicycle - the model couldn't even keep the spokes inside the wheels - would be rudimentary if it "learned" what it means to draw a bicycle wheel and could transfer that to unicycle.
They’ll hardcode it in 4.8, just like they do when they need to “fix” other issues
I'm not sure how you can give the flamingo win to Qwen:<p>* It's sitting on the tire, not the seat.<p>* Is that weird white and black thing supposed to be a beak? If so, it's sticking out of the side of its face rather than the center.<p>* The wheel spokes are bizarre.<p>* One of the flamingo's legs doesn't extend to the pedal.<p>* If you look closely at the sunglasses, they're semi-transparent, and the flamingo only has one eye! Or the other eye is just on a different part of its face, which means the sunglasses aren't positioned correctly. Or the other eye isn't.<p>* (subjective) The sunglasses and bowtie are cute, but you didn't ask for them, so I'd actually <i>dock</i> points for that.<p>* (subjective) I guess flamingos have multiple tail feathers, but it looks kinda odd as drawn.<p>In contrast, Opus's flamingo isn't as detailed or fancy, but more or less all of it looks correct.
the more I look at these images the more convinced I become that world models are the major missing piece and that these really are ultimately just stochastic sentence machines. Maybe Chomsky was right
It's fascinating that a $999 Mac Mini (M4 32GB) with almost similar wattage as a human brain gets us this far.
interesting, I just tried this very model, unsloth, Q8, so in theory more capable than Simon's Q4, and get those three "pelicans". definitely NOT opus quality. lmstudio, via Simon's llm, but not apple/mlx. Of course the same short prompt.<p>Simon, any ideas?<p><a href="https://ibb.co/gFvwzf7M" rel="nofollow">https://ibb.co/gFvwzf7M</a><p><a href="https://ibb.co/dYHRC3y" rel="nofollow">https://ibb.co/dYHRC3y</a><p><a href="https://ibb.co/FLc6kggm" rel="nofollow">https://ibb.co/FLc6kggm</a> (tried here temperature 0.7 instead of pure defaults)
try Unsloth recommended settings<p><pre><code> Thinking mode for general tasks: temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0
Thinking mode for precise coding tasks (e.g. WebDev): temperature=0.6, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=0.0, repetition_penalty=1.0
Instruct (or non-thinking) mode for general tasks: temperature=0.7, top_p=0.8, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0
Instruct (or non-thinking) mode for reasoning tasks: temperature=1.0, top_p=0.95, top_k=20, min_p=0.0, presence_penalty=1.5, repetition_penalty=1.0
</code></pre>
(Please note that the support for sampling parameters varies according to inference frameworks.)
But that you also gave a win to Qwen on flamingo is pretty outrageous! :)<p>Tthe right one looks much better, plus adding sunglasses without prompting is not that great. Hopefully it won't add some backdoor to the generated code without asking. ;)
The real question is what the next truly weird, un-optimized prompt will be. Something involving a sloth debugging a quantum computer in MS Paint?"
The flamingo on Qwen's unicycle is sitting on the tire, not the seat. That wins because of sunglasses?
Can a benchmark meant as a joke not use a fun interpretation of results? The Qwen result has far better style points. Fun sunglasses, a shadow, a better ground, a better sky, clouds, flowers, etc.<p>If we want to get nitty gritty about the details of a joke, a flamingo probably couldn't physically sit on a unicycle's seat and also reach the pedals anyways.
Well, maybe the flamingo is a <i>really good</i> unicyclist...<p><a href="https://youtu.be/Rrpgd5oIKwI" rel="nofollow">https://youtu.be/Rrpgd5oIKwI</a>
Hey I really enjoy your blog. On some things I end up finding a blog post of yours thats a year+ old and at other times, you and I are investigating similar things. I just pulled Qwen3.6 - 35b -A3B (Can't believe thats a A3B coming from 35b).<p>I'm impressed about the reach of your blog, and I'm hoping to get into blogging similar things. I currently have a lot on my backlog to blog about.<p>In short, keep up the good work with an interesting blog!
I've been trying the Q4_K_M version, and sometimes it gets stuck in a loop. Gemma 4 doesn’t have this issue.
This has happened before with quantizations and other backends (ones not used by the research lab). Give it a week, download latest versions of everything, and try again.
perhaps increasing repitition_penalty might be helpful
Interesting, qwen has the pelican driving on the left lane. Coincidence or has it something to do with the workers providing the RL data?
I've had some really gnarly SVGs from Claude. Here's what I got after many iterations trying to draw a hand: <a href="https://imgur.com/a/X4Jqius" rel="nofollow">https://imgur.com/a/X4Jqius</a>
The qwen flamingo looks like it’s smoking’ a doobie.
Oh that is pretty good! And the SVG one!
How does it do with the "car wash" benchmark? :D
A relief to see the Qwen team still publishing open weights, after the kneecapping [1] and departures of Junyang Lin and others [2]!<p>[1] <a href="https://news.ycombinator.com/item?id=47246746">https://news.ycombinator.com/item?id=47246746</a>
[2] <a href="https://news.ycombinator.com/item?id=47249343">https://news.ycombinator.com/item?id=47249343</a>
This is just one model in the Qwen 3.6 series. They will most likely release the other small sizes (not much sense in keeping them proprietary) and perhaps their 122A10B size also, but the flagship 397A17B size seems to have been excluded.
And shout-out to Qwen if they release 122b -- Jeff Barr's original Gemma 4 tweet said they'd release a ~122b, then it got redacted :(
Is there any source for these claims?
<a href="https://x.com/ChujieZheng/status/2039909917323383036" rel="nofollow">https://x.com/ChujieZheng/status/2039909917323383036</a> is the pre-release poll they did. ~397B was not a listed choice and plenty of people took it as a signal that it might not be up for release.
A Qwen research member had a poll on X asking what Qwen 3.6 sizes people wanted to see:<p><a href="https://x.com/ChujieZheng/status/2039909917323383036" rel="nofollow">https://x.com/ChujieZheng/status/2039909917323383036</a><p>Likely to drive engagement, but the poll excluded the large model size.
397A17B = 397B total weights, 17B per expert?
17b per token. So when you’re generating a single stream of text (“decoding”) 17b parameters are active.<p>If you’re decoding multiple streams, it will be 17b per stream (some tokens will use the same expert, so there is some overlap).<p>When the model is ingesting the prompt (“prefilling”) it’s looking at many tokens at once, so the number of active parameters will be larger.
397B params, 17B activated at the same time<p>Those 17B might be split among multiple experts that are activated simultaneously
That's not how it works. Many people get confused by the “expert” naming, when in reality the key part of the original name “sparse mixture of experts” is <i>sparse</i>.<p>Experts are just chunks of each layers MLP that are only partially activated by each token, there are thousands of “experts” in such a model (for Qwen3-30BA3, it was 48 layers x 128 “experts” per layer with only 8 active at each token)
How many people/hackernews can run a 397b param model at home? Probably like 20-30.
You can rent a cloud H200 with 140GB VRAM in a server with 256GB system ram for $3-4/hr.
The point is that open weights turns puts inference on the open market, so if your model is actually good and providers want to serve it, it will drive costs down and inference speeds up. Like Cerebras running Qwen 3 235B Instruct at 1.4k tps for cheaper than Claude Haiku (let that tps number sink in for a second. For reference, Claude Opus runs ~30-40 tps, Claude Haiku at ~60. Several orders of magnitude difference). As a company developing models, it means you can't easily capture the inference margins even though I believe you get a small kickback from the providers.<p>So I understand why they wouldn't want to go open weight, but on the other hand, open weight wins you popularity/sentiment if the model is any good, researchers (both academic and other labs) working on your stuff, etc etc. Local-first usage is only part of the story here. My guess is Qwen 3.5 was successful enough that now they want to start reaping the profits. Unfortunately most of Qwen 3.5's success is because it's heavily (and successfully!) optimized for extremely long-context usage on heavily constrained VRAM (i.e. local) systems, as a result of its DeltaNet attention layers.
I'm running it on dual DGX Sparks.
OpenRouter.
Yeah I think there’s benefits to third-party providers being able to run the large models and have stronger guarantees about ZDR and knowing where they are hosted! So Open Weights for even the large models we can’t personally serve on our laptops is still useful.
If you're running it from OpenRouter, you might as well use Qwen3.6 Plus. You don't need to be picky about a particular model size of 3.6. If you just want the 397b version to save money, just pick a cheaper model like M2.7.
The 397B model can be run at home with the weights stored on an SSD (or on 2 SSDs, for double throughput).<p>Probably too slow for chat, but usable as a coding assistant.
Running the mxfp4 unsloth quant of qwen3.5-397b-a17b, I get 40 tps prefill, 20tps decode.<p>AMD threadripper pro 9965WX, 256gb ddr5 5600, rtx 4090.
I can (barely, but sustainably) run Q3.5 397B on my Mac Studio with 256GB unified. It cost $10,000 but that's well within reach for most people who are here, I expect.
Hacker News moment
$10k is well outside my budget for frivolous computer purchases.
It would be plenty in-budget if the software part of local AI was a bit more full-featured than it is at present. I want stuff like SSD offload for cold expert weights and/or for saved/cached KV-context, dynamic context sizing, NPU use for prefill, distributed inference over the network, etc. etc. to all be things that just work for most users, without them having to set anything up in an overly error-prone way. The system should not just explode when someone tries to run something slightly larger; it should undergo graceful degradation and let them figure out where the reasonable limits are.
99.97% of HN users are nodding… :)
yeah, but if you really really wanted to and/or your livelyhood depended on it, you probably could afford it.
I'm running it on my Intel Xeon W5 with 256GB of DDR5 and Nvidia 72GB VRAM. Paid $7-8k for this system. Probably cost twice as much now.<p>Using UD-IQ4_NL quants.<p>Getting 13 t/s. Using it with thinking disabled.
For some reason you were being downvoted but I enjoy hearing how people are running open weights models at home (NOT in the cloud), and what kind of hardware they need, even if it's out of my price range.
you have proved my point
It doesn't matter how many can run it now, it's about freedom. Having a large open weights model available allows you to do things you can't do with closed models.
I really wish they released qwen-image 2.0 as open weights.
Already quantized/converted into a sane format by Unsloth:<p><a href="https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF" rel="nofollow">https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF</a>
Unsloth is great for uploading quants quickly to experiment with, but everyone should know that they almost always revise their quants after testing.<p>If you download the release day quants with a tool that doesn’t automatically check HF for new versions you should check back again in a week to look for updated versions.<p>Some times the launch day quantizations have major problems which leads to early adopters dismissing useful models. You have to wait for everyone to test and fix bugs before giving a model a real evaluation.
We re-uploaded Gemma4 4 times - 3 times were due to 20 llama.cpp bug fixes, which we helped solve some as well. The 4th is an official Gemma chat template improvement from Google themselves, so these are out of our hands. All providers had to re-fix their uploads, so not just us.<p>For MiniMax 2.7 - there were NaNs, but it wasn't just ours - all quant providers had it - we identified 38% of bartowski's had NaNs. Ours was 22%. We identified a fix, and have already fixed ours see <a href="https://www.reddit.com/r/LocalLLaMA/comments/1slk4di/minimax_m27_gguf_investigation_fixes_benchmarks/" rel="nofollow">https://www.reddit.com/r/LocalLLaMA/comments/1slk4di/minimax...</a>. Bartowski has not, but is working on it. We share our investigations always.<p>For Qwen3.5 - we shared our 7TB research artifacts showing which layers not to quantize - all provider's quants were not optimal, not broken - ssm_out and ssm_* tensors were the issue - we're now the best in terms of KLD and disk space - see <a href="https://www.reddit.com/r/LocalLLaMA/comments/1rgel19/new_qwen3535ba3b_unsloth_dynamic_ggufs_benchmarks/" rel="nofollow">https://www.reddit.com/r/LocalLLaMA/comments/1rgel19/new_qwe...</a><p>On other fixes, we also fixed bugs in many OSS models like Gemma 1, Gemma 3, Llama chat template fixes, Mistral, and many more.<p>It might seem these issues are due to us, but it's because we publicize them and tell people to update. 95% of them are not related to us, but as good open source stewards, we should update everyone.
I just wanted to express gratitude to you guys, you do great work. However, it is a little annoying to have to redownload big models though and keeping up with the AI news and community sentiment is a full time job. I wish there was some mechanism somewhere (on your site or Huggingface or something) for displaying feedback or confidence in a model being "ready for general use" before kicking off 100+ GB model downloads.
Hey thanks - yes agreed - for now we do:<p>1. Split metadata into shard 0 for huge models so 10B is for chat template fixes - however sometimes fixes cause a recalculation of the imatrix, which means all quants have to be re-made<p>2. Add HF discussion posts on each model talking about what changed, and on our Reddit and Twitter<p>3. Hugging Face XET now has de-duplication downloading of shards, so generally redownloading 100GB models again should be much faster - it chunks 100GB into small chunks and hashes them, and only downloads the shards which have changed
If you would know - is this also why LM Studio and Ollama model downloads often fail with a signature mismatch error?
Ah thanks, I wasn't aware of #3, that should be a huge boon.
Best policy is to just wait a couple of weeks after a major model is released. It's frustrating to have to re-download tens or hundreds of GB every few days, but the quant producers have no choice but to release early and often if they want to maintain their reputation.<p>Ideally the labs releasing the open models would work with Unsloth and the llama.cpp maintainers in advance to work out the bugs up front. That does sometimes happen, but not always.
Please publish sha256sums of the merged GGUFs in the model descriptions. Otherwise it's hard to tell if the version we have is the latest.
Yep we can do that probs add a table - in general be post in discussions of model pages - for eg <a href="https://huggingface.co/unsloth/MiniMax-M2.7-GGUF/discussions/8" rel="nofollow">https://huggingface.co/unsloth/MiniMax-M2.7-GGUF/discussions...</a><p>HF also provides SHA256 for eg <a href="https://huggingface.co/unsloth/MiniMax-M2.7-GGUF/blob/main/UD-Q4_K_XL/MiniMax-M2.7-UD-Q4_K_XL-00001-of-00004.gguf" rel="nofollow">https://huggingface.co/unsloth/MiniMax-M2.7-GGUF/blob/main/U...</a> is 92986e39a0c0b5f12c2c9b6a811dad59e3317caaf1b7ad5c7f0d7d12abc4a6e8<p>But agreed it's probs better to place them in a table
Why do you merge the GGUFs? The 50 GB files are more manageable (IMO) and you can verify checksums as you say.
I admit it's a habit that's probably <i>weeks</i> out of date. Earlier engines barfed on split GGUFs, but support is a lot better now. Frontends didn't always infer the model name correctly from the first chunk's filename, but once llama.cpp added the models.ini feature, that objection went away.<p>The purist in me feels the 50GB chunks are a temporary artifact of Hugging Face's uploading requirements, and the authoritative model file should be the merged one. I am unable to articulate any practical reason why this matters.
Just curious, the fixes are not about weights but about templates, am I right?
Appreciate the work of your team very much.<p>Though chat templates seem like they need a better solution. So many issues, seems quite fragile.
What do you think about creating a tool which can just patch the template embedded in the .gguf file instead of forcing a re-download? The whole file hash can be checked afterwards.
Sadly it's not always chat template fixes :( But yes we now split the first shard as pure metadata (10MB) for huge models - these include the chat template etc - so you only need to download that.<p>For serious fixes, sadly we have to re-compute imatrix since the activation patterns have changed - this sadly makes the entire quant change a lot, hence you have to re-download :(
Not to mention that almost every model release has some (at least) minor issue in the prompt template and/or the runtime itself, so even if they (not talking unsloth specifically, in general) claim "Day 0 support", do pay extra attention to actual quality as it takes a week or two before issues been hammered out.
Yes this is fair - we try our best to communicate issues - I think we're mostly the only ones doing the communication that model A or B has been fixed etc.<p>We try our best as model distributors to fix them on day 0 or 1, but 95% of issues aren't our issues - as you mentioned it's the chat template or runtime etc
I don't understand why the open source model providers don't also publish the quantized version?
Thank you very much for this comment! I was not aware of that.
[dead]
Why doesn't Qwen itself release the quantized model? My impression is that quantization is a highly nontrivial process that can degrade the model in non-obvious ways, thus its best handled by people who actually built the model, otherwise the results might be disappointing.<p>Users of the quantized model might be even made to think that the model sucks because the quantized version does.
Model developers release open-weight models for all sorts of reasons, but the most common reason is to share their work with the greater AI research community. Sure, they might allow or even encourage personal and commercial use of the model, but they don't necessarily want to be responsible for end-user support.<p>An imperfect analogy might be the Linux kernel. Linus publishes official releases as a tagged source tree but most people who use Linux run a kernel that has been tweaked, built, and packaged by someone else.<p>That said, models often DO come from the factory in multiple quants. Here's the FP8 quant for Qwen3.6 for example: <a href="https://huggingface.co/Qwen/Qwen3.6-35B-A3B-FP8" rel="nofollow">https://huggingface.co/Qwen/Qwen3.6-35B-A3B-FP8</a><p>Unsloth and other organizations produce a wider variety of quants than upstream to fit a wider variety of hardware, and so end users can make their own size/quality trade-offs as needed.
Quantization is an extraordinarily trivial process. Especially if you're doing it with llama.cpp (which unsloth obviously does).<p>Qwen did release an fp8 version, which is a quantized version.
I sense that I don't really understand enough of your comment to know why this is important. I hope you can explain some things to me:<p>- Why is Qwen's default "quantization" setup "bad"
- Who is Unsloth?
- Why is his format better? What gains does a better format give? What are the downsides of a bad format?
- What is quantization? Granted, I can look up this myself, but I thought I'd ask for the full picture for other readers.
Oh hey - we're actually the 4th largest distributor of OSS AI models in GB downloads - see <a href="https://huggingface.co/unsloth" rel="nofollow">https://huggingface.co/unsloth</a><p><a href="https://unsloth.ai/docs/basics/unsloth-dynamic-2.0-ggufs">https://unsloth.ai/docs/basics/unsloth-dynamic-2.0-ggufs</a> is what might be helpful. You might have heard 1bit dynamic DeepSeek quants (we did that) - not all layers can be 1bit - important ones are in 8bit or 16bit, and we show it still works well.
The default Qwen "quantization" is not "bad", it's "large".<p>Unsloth releases lower-quality versions of the model (Qwen in this case). Think about taking a 95% quality JPEG and converting it to a 40% quality JPEG.<p>Models are quantized to lower quality/size so they can run on cheaper/consumer GPUs.
hey you can do a bit research yourself and tell your results to us!
How much VRAM does it need? I haven't run a local model yet, but I did recently pick up a 16GB GPU, before they were discontinued.
It's on the page:<p><pre><code> Precision Quantization Tag File Size
1-bit UD-IQ1_M 10 GB
2-bit UD-IQ2_XXS 10.8 GB
UD-Q2_K_XL 12.3 GB
3-bit UD-IQ3_XXS 13.2 GB
UD-Q3_K_XL 16.8 GB
4-bit UD-IQ4_XS 17.7 GB
UD-Q4_K_XL 22.4 GB
5-bit UD-Q5_K_XL 26.6 GB
16-bit BF16 69.4 GB</code></pre>
Additional VRAM is needed for context.<p>This model is a MoE model with only 3B active parameters per expert which works well with partial CPU offload. So in practice you can run the -A(N)B models on systems that have a little less VRAM than you need. The more you offload to the CPU the slower it becomes though.
I really want to know what does M, K, XL XS mean in this context and how to choose.<p>I searched all unsloth doc and there seems no explaination at all.
Q4_K is a type of quantization. It means that all weights will be at a minimum 4bits using the K method.<p>But if you're willing to give more bits to only certain important weights, you get to preserve a lot more quality for not that much more space.<p>The S/M/L/XL is what tells you how many tensors get to use more bits.<p>The difference between S and M is generally noticeable (on benchmarks). The difference between M and L/XL is less so, let alone in real use (ymmv).<p>Here's an example of the contents of a Q4_K_:<p><pre><code> S
llama_model_loader: - type f32: 392 tensors
llama_model_loader: - type q4_K: 136 tensors
llama_model_loader: - type q5_0: 43 tensors
llama_model_loader: - type q5_1: 17 tensors
llama_model_loader: - type q6_K: 15 tensors
llama_model_loader: - type q8_0: 55 tensors
M
llama_model_loader: - type f32: 392 tensors
llama_model_loader: - type q4_K: 106 tensors
llama_model_loader: - type q5_0: 32 tensors
llama_model_loader: - type q5_K: 30 tensors
llama_model_loader: - type q6_K: 15 tensors
llama_model_loader: - type q8_0: 83 tensors
L
llama_model_loader: - type f32: 392 tensors
llama_model_loader: - type q4_K: 106 tensors
llama_model_loader: - type q5_0: 32 tensors
llama_model_loader: - type q5_K: 30 tensors
llama_model_loader: - type q6_K: 14 tensors
llama_model_loader: - type q8_0: 84 tensors</code></pre>
They are different quantization types, you can read more here <a href="https://huggingface.co/docs/hub/gguf#quantization-types" rel="nofollow">https://huggingface.co/docs/hub/gguf#quantization-types</a>
Just start with q4_k_m and figure out the rest later.
Thanks! I'd scanned the main content but I'd been blind to the sidebar on the far right.
"16-bit BF16 69.4 GB"<p>Is that (BF16) a 16-bit float?
Yes, it's a "Brain float", basically an ordinary 32-bit float with the low 16 mantissa bits cut off. Exact same range as fp32, lower precision, and not the same as the other fp16, which has less exponent and more mantissa.
The IEEE standard FP16 is an older 16-bit format, which has balanced exponent and significand sizes.<p>It has been initially supported by GPUs, where it is useful especially for storing the color components of pixels. For geometry data, FP32 is preferred.<p>In CPUs, some support has been first added in 2012, in Intel Ivy Bridge. Better support is provided in some server CPUs, and since next year also in the desktop AMD Zen 6 and Intel Nova Lake.<p>BF16 is a format introduced by Google, intended only for AI/ML applications, not for graphics, so initially it was implemented in some of the Intel server CPUs and only later in GPUs. Unlike FP16, which is balanced, BF16 has great dynamic range, but very low precision. This is fine for ML but inappropriate for any other applications.<p>Nowadays, most LLMs are trained preponderantly using BF16, with a small number of parameters using FP32, for higher precision.<p>Then from the biggest model that uses BF16, smaller quantized models are derived, which use 8 bits or less per parameter, trading off accuracy for speed.
<a href="https://en.wikipedia.org/wiki/Bfloat16_floating-point_format" rel="nofollow">https://en.wikipedia.org/wiki/Bfloat16_floating-point_format</a><p>Yes, however it’s a different format from standard fp16, it trades precision for greater dynamic range.
yes, it has 8 exponent bits like float32 instead of 6 like float16
Pick a decent quant (4-6KM) then use llama-fit-params and try it yourself to see if it's giving you what you need.
Should run just fine with CPU-MoE and mmap, but inference might be a bit slow if you have little RAM.
You can run 25-30b model easily if you use Q3 or Q4 quants and llama-server with a pretty long list of options.
If you have to ask then your GPU is too small.<p>With 16 GB you'll be only able to run a very compressed variant with noticable quality loss.
Not true. With a MoE, you can offload quite a bit of the model to CPU without losing a ton of performance. 16GB should be fine to run the 4-bit (or larger) model at speeds that are decent. The --n-cpu-moe parameter is the key one on llama-server, if you're not just using -fit on.
> If you have to ask then your GPU is too small.<p>What's the minimum memory you need to run a decent model? Is it pretty much only doable by people running Macs with unified memory?
It's worth noting now there are other machines than just Apple that combine a powerful SoC with a large pool of unified memory for local AI use:<p>> <a href="https://www.dell.com/en-us/shop/cty/pdp/spd/dell-pro-max-fcm1253-micro/xcto_fcm1253_usx" rel="nofollow">https://www.dell.com/en-us/shop/cty/pdp/spd/dell-pro-max-fcm...</a><p>> <a href="https://marketplace.nvidia.com/en-us/enterprise/personal-ai-supercomputers/dgx-spark/" rel="nofollow">https://marketplace.nvidia.com/en-us/enterprise/personal-ai-...</a><p>> <a href="https://frame.work/products/desktop-diy-amd-aimax300/configuration/new" rel="nofollow">https://frame.work/products/desktop-diy-amd-aimax300/configu...</a><p>etc.<p>But yes, a modern SoC-style system with large unified memory pool is still one of the best ways to do it.
32 GiB of VRAM is possible to acquire for less than $1000 if you go for the Arc Pro B70. I have two of them. The tokens/sec is nowhere near AMD or NVIDIA high end, but its unexpectedly kind of decent to use. (I probably need to figure out vLLM though as it doesn't seem like llama.cpp is able to do them justice even seemingly with split mode = row. But still, 30t/s on Gemma 4 (on 26B MoE, not dense) is pretty usable, and you can do fit a full 256k context.)<p>When I get home today I totally look forward to trying the unsloth variants of this out (assuming I can get it working in anything.) I expect due to the limited active parameter count it should perform very well. It's obviously going to be a long time before you can run current frontier quality models at home for less than the price of a car, but it does seem like it is bound to happen. (As long as we don't allow general purpose computers to die or become inaccessible. Surely...)
New versions of llama.cpp have experimental split-tensor parallelism, but it really only helps with slow compute and a very fast interconnect, which doesn't describe many consumer-grade systems. For most users, pipeline parallelism will be their best bet for making use of multi-GPU setups.
Yeah, I was doing split tensor and it seemed like a wash. The Arc B70s are not huge on compute.<p>Right now I'm only able to run them in PCI-e 5.0 x8 which might not be sufficient. But, a cheap older Xeon or TR seems silly since PCI-e 4.0 x16 isn't theoretically more bandwidth than PCI-e 5.0 x8. So it seems like if that is really still bottlenecked, I'll just have to bite the bullet and set up a modern HEDT build. With RAM prices... I am not sure there is a world where it could ever be worth it. At that point, seems like you may as well go for an obscenely priced NVIDIA or AMD datacenter card instead and retrofit it with consumer friendly thermal solutions. So... I'm definitely a bit conflicted.<p>I do like the Arc Pro B70 so far. Its not a performance monster, but it's quiet and relatively low power, and I haven't run into any instability. (The AMDGPU drivers have made amazing strides, but... The stability is not legendary. :)<p>I'll have to do a bit of analysis and make sure there really is an interconnect bottleneck first, versus a PEBKAC. Could be dropping more lanes than expected for one reason or another too.
NVIDIA 5070 Ti can run Gemma 4 26B at 4-bit at 120 tk/s.<p>Arc Pro B70 seems unexpectedely slow? Or are you using 8-bit/16-bit quants.
Unfortunately it really is running this slow with Llama.cpp, but of course that's with Vulkan mode. The VRAM capacity is definitely where it shines, rather than compute power. I am pretty sure that this isn't really optimal use of the cards, especially since I believe we should be able to get decent, if still sublinear, scaling with multiple cards. I am not really a machine learning expert, I'm curious to see if I can manage to trace down some performance issues. (I've already seen a couple issues get squashed since I first started testing this.)<p>I've heard that vLLM performs much better, scaling particularly better in the multi GPU case. The 4x B70 setup may actually be decent for the money given that, but probably worth waiting on it to see how the situation progresses rather than buying on a promise of potential.<p>A cursory Google search does seem to indicate that in my particular case interconnect bandwidth shouldn't actually be a constraint, so I doubt tensor level parallelism is working as expected.
Parallelism can be tricky and always has a cost, but don't discount the 3090 which is more expensive these days in that price bracket.<p>3090 llama.cpp (container in VM)<p><pre><code> unsloth/Qwen3.6-35B-A3B-GGUF:UD-Q4_K_XL 105 t/s
unsloth/gemma-4-26B-A4B-it-GGUF:UD-Q4_K_XL 103 t/s
</code></pre>
Still slow compaired to the<p><pre><code> ggml-org/gpt-oss-20b-GGUF 206 t/s
</code></pre>
But on my 3x 1080 Ti 1x TITAN V getto machine I learned that multi gpu takes a lot of tuning no matter what. With the B70, where Vulkan has the CPU copy problem, and SYCL doesn't have a sponsor or enough volunteers, it will probably take a bit of profiling on your part.<p>There are a lot of variables, but PCIe bus speed doesn't matter that much for inference, but the internal memory bandwidth does, and you won't match that with PCIe ever.<p>To be clear, multicard Vulkan and absolutely SYCL have a lot of optimizations that could happen, but the only time two GPUs are really faster for inference is when one doesn't have enough ram to fit the entire model.<p>A 3090 has 936.2 GB/s of (low latency) internal bandwidth, while 16xPCIe5 only has 504.12, may have to be copied through the CPU, have locks, atomic operations etc...<p>For LLM inference, the bottleneck just usually going to be memory bandwidth which is why my 3090 is so close to the 5070ti above.<p>LLM next token prediction is just a form of autoregressive decoding and will primarily be memory bound.<p>As I haven't used the larger intel GPUs I can't comment on what still needs to be optimized, but just don't expect multiple GPUs to increase performance without some nvlink style RDMA support _unless_ your process is compute and not memory bound.
My Mac Studio with 96GB of RAM is maybe just at the low end of passable. It's actually extremely good for local image generation. I could somewhat replace something like Nano Banana comfortably on my machine.<p>But I don't need Nano Banana very much, I need code. While it can, there's no way I would ever opt to use a local model on my machine for code. It makes so much more sense to spend $100 on Codex, it's genuinely not worth discussing.<p>For non-thinking tasks, it would be a bit slower, but a viable alternative for sure.
It’s also doable with AMD Strix Halo.
A bit like asking how long is a piece of string.
It's twice as long as from one end to the middle.
More like "about how long of a string do I need to run between two houses in the densest residential neighborhood of single-family homes in the US?"
Macs with unified memory are economical in terms of $/GB of video memory, and they match an optimized/home built GPU setup in efficiency (W/token), but they are slow in terms of absolute performance.<p>With this model, since the number of active parameters is low, I would think that you would be fine running it on your 16GB card, as long as you have, say 32GB of regular system memory. Temper your expectations about speed with this setup, as your system memory and CPU are multiple times slower than the GPU, so when layers spill over you will slow down.<p>To avoid this, there's no need to buy a Mac -- a second 16GB GPU would do the trick just fine, and the combined dual GPU setup will likely be faster than a cheap mac like a Mac mini. Pay attention to your PCIe slots, but as long as you have at least an x4 slot for the second GPU, you'll be fine (LLM inference doesn't need x8 or x16).
Obviously going to depend on your definition of "decent". My impression so far is that you will need between 90GB to 100GB of memory to run medium sized (31B dense or ~110B MoE) models with some quantization enabled.
No, GP is excessively restrictive. Llama.cpp supports RAM offloading out of the box.<p>It's going to be slower than if you put everything on your GPU but it would work.<p>And if it's too slow for your taste you can try the quantized version (some Q3 variant should fit) and see how well it works for you.
Aren't 4bits model decent? Since, this is an MOE model, I'm assuming it should have respectable tk/s, similar to previous MOE models.
Running q3 xss with full and quantizised context as options on a 16gb gpu and still has pretty decent quality and fitting fine with up to 64k context.
So I can use this in claude code with `ollama run claude`?
<a href="https://sleepingrobots.com/dreams/stop-using-ollama/" rel="nofollow">https://sleepingrobots.com/dreams/stop-using-ollama/</a>
More like `ollama launch claude --model qwen3.6:latest`<p>Also you need to check your context size, Ollama default to 4K if <24 Gb of VRAM and you need 64K minimum if you want claude to be able to at least lift a finger.
If you're on a Mac, use the MLX backend versions which are considerably faster than the GGML based versions (including llama.cpp) and you don't need to fiddle with the context size. The models are `qwen3.6:35b-a3b-nvfp4`, `qwen3.6:35b-a3b-mxfp8`, and `qwen3.6:35b-a3b-mlx-bf16`.
I only have 16GB VRAM, and my system uses ~4GB from that. What are my options? I got this one: `Qwen3.6-35B-A3B-UD-IQ2_XXS.gguf`
have you found a model that does this with usable speeds on an M2/M3?
There's absolutely nothing wrong it insane with a safetensors file. It might be less convenient than a single file gguf. But that's just laziness not insanity
lmao they are so fast yooo
Yes. How do they do it? Literally they must have PagerDuty set up to alert the team the second one of the labs releases anything.
They obviously collaborate with some of the labs prior to the official release date.
Is quantization a mostly solved pipeline at this point? I thought that architectures were varied and weird enough where you can't just click a button, say "go optimize these weights", and go. I mean new models have new code that they want to operate on, right, so you'd have to analyze the code and insert the quantization at the right places, automatically, then make sure that doesn't degrade perf?<p>Maybe I just don't understand how quantization works, but I thought quantization was a very nasty problem involving a lot of plumbing
Bad QA :/ They had a bunch of broken quantizations in the last releases
1. Gemma-4 we re-uploaded 4 times - 3 times were 10-20 llama.cpp bug fixes - we had to notify people to upload the correct ones. The 4th is an official Gemma chat template improvement from Google themselves.<p>2. Qwen3.5 - we shared our 7TB research artifacts showing which layers not to quantize - all provider's quants were under optimized, not broken - ssm_out and ssm_* tensors were the issue - we're now the best in terms of KLD and disk space<p>3. MiniMax 2.7 - we swiftly fixed it due to NaN PPL - we found the issue in all quants regardless of provider - so it affected everyone not just us. We wrote a post on it, and fixed it - others have taken our fix and fixed their quants, whilst some haven't updated.<p>Note we also fixed bugs in many OSS models like Gemma 1, Gemma 3, Llama chat template fixes, Mistral, and many more.<p>Unfortunately sometimes quants break, but we fix them quickly, and 95% of times these are out of our hand.<p>We swiftly and quickly fix them, and write up blogs on what happened. Other providers simply just take our blogs and fixes and re-apply, re-use our fixes.
Thanks for all the amazing work Daniel. I remember you guys being late to OH because you were working on weights released the night before - and it's great to see you guys keep up the speed!
Fair enough, appreciate the detailed response! Can you elaborate why other quantizations weren't affected (e.g. bartowski)? Simply because they were straight Q4 etc. for every layer?
No Bartowski's are more affected - (38% NaN) than ours (22%) - for MiniMax 2.7 see <a href="https://www.reddit.com/r/LocalLLaMA/comments/1slk4di/minimax_m27_gguf_investigation_fixes_benchmarks/" rel="nofollow">https://www.reddit.com/r/LocalLLaMA/comments/1slk4di/minimax...</a><p>We already fixed ours. Bart hasn't yet but is still working on it following our findings.<p>blk.61.ffn_down_exps in Q4_K or Q5_K failed - it must be in Q6_K otherwise it overflows.<p>For the others, yes layers in some precision don't work. For eg Qwen3.5 ssm_out must be minimum Q4-Q6_K.<p>ssm_alpha and ssm_beta must be Q8_0 or higher.<p>Again Bart and others apply our findings - see <a href="https://www.reddit.com/r/LocalLLaMA/comments/1rgel19/new_qwen3535ba3b_unsloth_dynamic_ggufs_benchmarks/" rel="nofollow">https://www.reddit.com/r/LocalLLaMA/comments/1rgel19/new_qwe...</a>
yeah and often their quants are broken. They had to update their Gemma4 quants like 4 times in the past 2 weeks.
No it's not our fault - re our 4 uploads - the first 3 are due to llama.cpp fixing bugs - this was out of our control (we're llama.cpp contributors, but not the main devs) - we could have waited, but it's best to update when multiple (10-20) bugs are fixed.<p>The 4th is Google themselves improving the chat template for tool calling for Gemma.<p><a href="https://github.com/ggml-org/llama.cpp/issues/21255" rel="nofollow">https://github.com/ggml-org/llama.cpp/issues/21255</a> was another issue CUDA 13.2 was broken - this was NVIDIA's CUDA compiler itself breaking - fully out of our hands - but we provided a solution for it.
Nice release from the Qwen team.<p>Small openweight coding models are, imho, the way to go for custom agents tailored to the specific needs of dev shops that are restricted from accessing public models.<p>I'm thinking about banking and healthcare sector development agencies, for example.<p>It's a shame this remains a market largely overlooked by Western players, Mistral being the only one moving in that direction.
> It's a shame this remains a market largely overlooked by Western players, Mistral being the only one moving in that direction.<p>I've said in a recent comment that Mistral is the only one of the current players who appear to be moving towards a sustainable business - all the other AI companies are simply looking for a big payday, not to operate sustainably.
I play with the small open weight models and I disagree. They are fun, but they are not in the same class as hosted models running on big hardware.<p>If some organization forbade external models they should invest in the hardware to run bigger open models. The small models are a waste of time for serious work when there are more capable models available.
Most organizations aren't going to need the wide breadth of capabilities of the frontier models. They're risk averse and LLMs are non-deterministic, so use cases are typically more tightly scoped to tasks that involve nuanced classification that small models can easily handle even if it takes a little fine-tuning on your organizations data.
I agree with the sentiment, but these models aren't suited for that. You can run much bigger models on prem with ~100k of hardware, and those can actually be useful in real-world tasks. These small models are fun to play with, but are nowhere close to solving the needs of a dev shop working in healthcare or banking, sadly.
I love the idea of building competitor to open weight models but damn is this an expensive game to play
It is, but think about how advances in computing technology have made that power available over time. A Raspberry Pi is almost 5 times more powerful than the Cray-1.<p>Granted, these next couple of years are going to suck because of the AI Component Drought, but progress marches on and the power and price of running today's frontier models will be affordable to mere mortals in time. Obviously we've hit the wall with Moore's law and other factors but this will not always be out of reach.
How true is this? How does a regulated industry confirm the model itself wasn't trained with malicious intent?
Related interesting find on Qwen.<p>"Qwen's base models live in a very exam-heavy basin - distinct from other base models like llama/gemma. Shown below are the embeddings from randomly sampled rollouts from ambiguous initial words like "The" and "A":"<p><a href="https://xcancel.com/N8Programs/status/2044408755790508113" rel="nofollow">https://xcancel.com/N8Programs/status/2044408755790508113</a>
I have been using Qwen3.5-35B-A3B a lot in local testing, and it is by far the most capable model that could fit on my machine.
I think quantization technology has really upped its game around these models,
and there were two quants that blew me away<p>Mudler APEX-I-Quality.
then later I tried
Byteshape Q3_K_S-3.40bpw<p>Both made claims that seemed too good to be true, but I couldn't find any traces of lobotomization doing long agent coding loops.
with the byteshape quant I am up to 40+ t/s which is a speed that makes agents much more pleasant.
On an rtx 3060 12GB and 32GB of system ram, I went from slamming all my available memory to having like 14GB to spare.
I recall a Qwen exec posted a public poll on Twitter, asking which model from Qwen3.6 you want to see open-sourced; and the 27b variant was by far the most popular choice. Not sure why they ignored it lol.
The 27B model is dense. Releasing a dense model first would be terrible marketing, whereas 35A3B is a lot smarter and more quick-witted by comparison!
Each has it's pros and cons. Dense models of equivalent <i>total</i> size obviously do run slower if all else is equal, however, the fact is that 35A3B is absolutely not 'a lot smarter'... in fact, if you set aside the slower inference rates, Qwen3.5 27B is arguably more intelligent and reliable. I use both regularly on a Strix Halo system... the Just see the comparison table here: <a href="https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF" rel="nofollow">https://huggingface.co/unsloth/Qwen3.6-35B-A3B-GGUF</a> . The problem that you have to acknowledge if running locally (especially for coding tasks) is that your primary bottleneck quickly becomes prompt processing (NOT token generation) and here the differences between dense and MOE are variable and usually negligible.
I was hoping this would be the model to replace our Qwen3.5-27B, but the difference is marginally small. Too risky, I'll pass and wait for the release of a dense version.
Could you explain why prompt processing is the bottle neck please? I've seen this behavior but I don't understand why.
"…whereas 35A3B is a lot smarter…"<p>Must. Parse. Is this a 35 billion parameter model that needs only 3 billion parameters to be active? (Trying to keep up with this stuff.)<p>EDIT: A later comment seems to clarify:<p>"It's a MoE model and the A3B stands for 3 Billion active parameters…"
That makes no sense. If you were just going to release the "more hype-able because it's quicker" model then why have a a poll.
What? 35B-A3B is not nearly as smart as 27B.
One interesting thing about Qwen3 is that looking at the benchmarks, the 35B-A3B models seem to be only a bit worse than the dense 27B ones. This is very different from Gemma 4, where the 26B-A4B model is much worse on several benchmarks (e.g. Codeforces, HLE) than 31B.
> This is very different from Gemma 4, where the 26B-A4B model is much worse on several benchmarks (e.g. Codeforces, HLE) than 31B.<p>Wouldn't you totally expect that, since 26A4B is lower on both total and active params? The more sensible comparison would pit Qwen 27B against Gemma 31B and Gemma 26A4B against Qwen 35A3B.
yeah the 27B feels like something completely different. If you use it on long context tasks it performs WAY better than 35b-a3b
Yes.
Based on the release schedule of 3.5 previously, my optimistic take is that they distill the small models from the 397B, and it is much faster to distill a sparse A3B model. Hopefully the other variants will be released in the coming days.
Probably coming next
I'm guessing 3.5-27b would beat 3.6-35b. MoE is a bad idea. Because for the same VRAM 27b would leave a lot more room, and the quality of work directly depends on context size, not just the "B" number.
MoE is not a bad idea for local inference if you have fast storage to offload to, and this is quickly becoming feasible with PCIe 5.0 interconnect.
MoE is excellent for the unified memory inference hardware like DGX Sparc, Apple Studio, etc. Large memory size means you can have quite a few B's and the smaller experts keeps those tokens flowing fast.
I'm broadly curious how people are using these local models. Literally, how are they attaching harnesses to this and finding more value than just renting tokens from Anthropic of OpenAI?
Idk about everyone else, but I don’t want to rent tokens forever. I want a self hosted model that is completely private and can’t be monitored or adulterated without me knowing. I use both currently, but I am excited at the prospect of maybe not having to in the near to mid future.<p>I’ve increasingly started self hosting everything in my home lately because I got tired of SAAS rug pulls and I don’t see why LLM’s should eventually be any different.
Qwen3.5-9B has been extremely useful for local fuzzy table extraction OCR for data that cannot be sent to the cloud.<p>The documents have subtly different formatting and layout due to source variance. Previously we used a large set of hierarchical heuristics to catch as many edge cases as we could anticipate.<p>Now with the multi-modal capabilities of these models we can leverage the language capabilities along side vision to extract structured data from a table that has 'roughly this shape' and 'this location'.
I used vLLM and qwen3-coder-next to batch-process a couple million documents recently. No token quota, no rate limits, just 100% GPU utilization until the job was done.
I'm using the smaller vision models (Qwen3.5-4B currently) with Frigate, a FOSS self-hosted "AI" NVR. It's good enough at analyzing images to figure out mostly what's happening, and doesn't require the big knowledge base that bigger models have.<p>Also use a bigger model for summarizing or translating text, which I don't consume in realtime, so doesn't need to be fast. Would be a thing I could use OpenAI's batch APIs for if I did need something higher quality.
Some tasks don’t require SOTA models. For translating small texts I use Gemma 4 on my iPhone because it’s faster and better than Apple Translate or Google Translate and works offline. Also if you can break down certain tasks like JSON healing into small focused coding tasks then local models are useful
I use LMStudio to host and run GLM 4.7 Flash as a coding agent. I use it with the Pi coding agent, but also use it with the Zed editor agent integrations. I've used the Qwen models in the past, but have consistently come back to GLM 4.7 because of its capabilities. I often use Qwen or Gemma models for their vision capabilities. For example, I often will finish ML training runs, take a photo of the graphs and visualizations of the run metrics and ask the model to tell me things I might look at tweaking to improve subsequent training runs. Qwen 3.5 0.8b is pretty awesome for really small and quick vision tasks like "Give me a JSON representation of the cards on this page".
The privacy/data security angle really is important in some regions and industries. Think European privacy laws or customers demanding NDAs. The value of Anthropic and OpenAI is zero for both cases, so easy to beat, despite local models being dumber and slower.
It’s easy to find a combination of llama.cpp and a coding tool like OpenCode for these. Asking an LLM for help setting it up can work well if you don’t want to find a guide yourself.<p>> and finding more value than just renting tokens from Anthropic of OpenAI?<p>Buying hardware to run these models is not cost effective. I do it for fun for small tasks but I have no illusions that I’m getting anything superior to hosted models. They can be useful for small tasks like codebase exploration or writing simple single use tools when you don’t want to consume more of your 5-hour token budget though.
I've been largely using Qwen3.5-122b at 6 bit quant locally for some c++/go/python dev lately because it is quite capable as long as I can give it pretty specific asks within the codebase and it will produce code that needs minimal massaging to fit into the project.<p>I do have a $20 claude sub I can fall back to for anything qwen struggles with, but with 3.5 I have been very pleased with the results.
The people i know that use local models just end up with both.<p>The local models don’t really compete with the flagship labs for most tasks<p>But there are things you may not want to send to them for privacy reasons or tasks where you don’t want to use tokens from your plan with whichever lab. Things like openclaw use a ton of tokens and most of the time the local models are totally fine for it (assuming you find it useful which is a whole different discussion)
The open weights models absolutely compete with flagship labs for most tasks. OpenAI and Anthropic's "cheap tier" models are completely uncompetitive with them for "quality / $" and it's not close. Google is the only one who has remained competitive in the <$5/1M output tier with Flash, and now has an incredibly strong release with Gemma 4.<p>Unless you have a corporate lock-in/compliance need, there has been no reason to use Haiku or GPT mini/nano/etc over open weights models for a long time now.
While they can be run locally, and most of the discussion on HN about that, I bet that if you look at total tok/day local usage is a tiny amount compared to total cloud inference even for these models. Most people who do use them locally just do a prompt every now and then.
always inside claude code, just using ollama, takes 2 seconds
They are okay for vibe coding throw-away projects without spending your Anthrophic/OAI tokens
I was thinking the same thing. My only guess is that they are excited about local models because they can run it cheaper through Open Router ?
I am working on a research project to link churches from their IRS Exempt org BMF entry to their google search result from 10 fetched. Gwen2.5-14b on a 16gb Mac Mini. It works good enough!<p>It's entertaining to see HN increasingly consider coding harness as the only value a model can provide.
There are really nice GUIs for LLMs - CherryStudio for example, can be used with local or cloud models.<p>There are also web-UIs - just like the labs ones.<p>And you can connect coding agents like Codex, Copilot or Pi to local coding agents - the support OpenAI compatible APIs.<p>It's literally a terminal command to start serving the model locally and you can connect various things to it, like Codex.
Honestly, this is the AI software I actually look forward to seeing. No hype about it being too dangerous to release. No IPO pumping hype. No subscription fees. I am so pumped to try this!
I hope the other sizes are coming too(9B for me). Can't fit much context with this on a 36GB mac.
It's a MoE model and the A3B stands for 3 Billion active parameters, like the recent Gemma 4.<p>You can try to offload the experts on CPU with llama.cpp (--cpu-moe) and that should give you quite the extra context space, at a lower token generation speed.
Mac has unified memory, so 36GB is 36GB for everything- gpu,cpu.
CPU-MoE still helps with mmap. Should not overly hurt token-gen speed on the Mac since the CPU has access to most (though not all) of the unified memory bandwidth, which is the bottleneck.
For sure I was running on autopilot with that reply. Though in Q4 I would expect it to fit, as 24B-A4B Gemma model without CPU offloading got up to 18GB of VRAM usage
Do I expect the same memory footprint from an N active parameters as from simply N total parameters?
No - this model has the weights memory footprint of a 35B model (you do save a little bit on the KV cache, which will be smaller than the total size suggests). The lower number of active parameters gives you faster inference, including lower memory <i>bandwidth</i> utilization, which makes it viable to offload the weights for the experts onto slower memory. On a Mac, with unified memory, this doesn't really help you. (Unless you want to offload to nonvolatile storage, but it would still be painfully slow.)<p>All that said you could probably squeeze it onto a 36GB Mac. A lot of people run this size model on 24GB GPUs, at 4-5 bits per weight quantization and maybe with reduced context size.
i dont get it, mac has unified memory how would offloading experts to cpu help?
I bet the poster just didn’t remember that important detail about Macs, it is kind of unusual from a normal computer point of view.<p>I wonder though, do Macs have swap, coupled unused experts be offloaded to swap?
can you elaborate? you can use quantized version, would context still be an issue with it?
A usable quant, Q5_KM imo, takes up ~26GB[0], which leaves around ~6-7GB for context and running other programs which is not much.<p>[0] <a href="https://huggingface.co/unsloth/Qwen3.5-35B-A3B-GGUF?show_file_info=Qwen3.5-35B-A3B-Q5_K_M.gguf" rel="nofollow">https://huggingface.co/unsloth/Qwen3.5-35B-A3B-GGUF?show_fil...</a>
context is always an issue with local models and consumer hardware.
China won again in terms of openness
Fingers crossed for mid and larger models as well. I'd personally love to see Qwen3.6-122B-A10B.
Qwen3.6 and Gemma4 have the same issue of never getting to the point and just getting stuck in never ending repeating thought loops. Qwen3.5 is still the best local model that works.
I think the hype around Qwen and even Gemma4 often floated for views/attention glosses over that these models have clear gaps behind what closed models offer.<p>In short, it has its uses but it would/should not be the main driver. Will it get better, I'm sure of it, but there is too much hype and exaggeration over open source models, for one the hardware simply isn't enough at a price point where we can run something that can seriously compete with today's closed models.<p>If we got something like GPT-5.4-xhigh that can run on some local hardware under 5k, that would be a major milestone.
Are we going to get to the point where a local model can do almost what sonnet 4.6 can do?
Of course we are. And Opus 4.6+. It's a matter of when, not if.
We're already there IMHO.. If you have enough ram, sure.. but the ~32gig people can run models that beat sonnet 4.5
This is surprisingly close to Haiku quality, but open - and Haiku is quite a capable model (many of the Claude Code subagents use it).
Anyone else getting gibberish when running unsloth/Qwen3.6-35B-A3B-GGUF:UD-IQ4_XS on CUDA (llama.cpp b8815)? UD-Q4_K_XL is fine, as is Vulkan in general.
I wonder how this one compares to Qwen3 Coder Next (the 80B A3B model), since you'd think that even though it's older, it having more parameters would make it more useful for agentic and development use cases: <a href="https://huggingface.co/collections/Qwen/qwen3-coder-next" rel="nofollow">https://huggingface.co/collections/Qwen/qwen3-coder-next</a>
I tried Gemma 4 A4B and was surprised how hart it is to use it for agentic stuff on a RTX 4090 with 24gb of ram.<p>Balancing KV Cache and Context eating VRam super fast.
Looks like they compare only to open models, unfortunately.<p>As I am using mostly the non-open models, I have no idea what these numbers mean.
Available for download:<p><a href="https://huggingface.co/Qwen/Qwen3.6-35B-A3B" rel="nofollow">https://huggingface.co/Qwen/Qwen3.6-35B-A3B</a>
My last laptop was a used 2012 T530.<p>My current is a used M1 MBP Pro with 16GB of ram.<p>I thought this was all I was ever going to need, but wanting to run really nice models locally has me thinking about upgrading.<p>Although, part of me wants to see how far I could get with my trusty laptop.
I'm a newbie here and lost how I'm supposed to use these models for coding. When I use them with Continue in VSCode and start typing basic C:<p><pre><code> #include <stdio.h>
int m
</code></pre>
I get nonsensical autocompletions like:<p><pre><code> #include <stdio.h>
int m</fim_prefix>
</code></pre>
What is going on?
These are not autocomplete models. It’s built to be used with an agentic coding harness like Pi or OpenCode.
They are but the IDE needs to be integrated with them.<p>Qwen specifically calls out FIM (“fill in the middle”) support on the model card and you can see it getting confused and posting the control tokens in the example here.
And even of those models trained for tool calling and agentic flows, mileage may vary depending on lots of factors. Been playing around with smaller local models (Anything that fits on 4090 + 64gb RAM) and it is a lottery it seems on a) if it works at all and b) how long it will work for.<p>Sometimes they don't manage any tool calls and fall over off the bat, other times they manage a few tool calls and then start spewing nonsense. Some can manage sub agents fr a while then fall apart.. I just can't seem to get any consistently decent output on more 'consumer/home pc' type hardware. Mostly been using either pi or OpenCode for this testing.
This might sound snarky but in all earnestness, try talking to an AI about your experience using it.
Choose the correct FIM (Fill In the Middle) template for Qwen in Continue. All recent Qwen models are actually trained with FIM capability and you can use them.
I would use something like zeta-2 instead - <a href="https://huggingface.co/bartowski/zed-industries_zeta-2-GGUF" rel="nofollow">https://huggingface.co/bartowski/zed-industries_zeta-2-GGUF</a>
I cant wait to see some smaller sizes. I would love to run some sort of coding centric agent on a local TPU or GPU instead of having to pay, even if it's slower.
What kind of hardware (preferably non-Apple) can run this model? What about 122B?
You won't like it, but the answer is Apple. The reason is the unified memory. The GPU can access all 32gb, 64gb, 128gb, 256gb, etc. of RAM.<p>An easy way (napkin math) to know if you can run a model based on it's parameter size is to consider the parameter size as GB that need to fit in GPU RAM. 35B model needs atleast 35gb of GPU RAM. This is a very simplified way of looking at it and YES, someone is going to say you can offload to CPU, but no one wants to wait 5 seconds for 1 token.
That estimate doesn't account for context, which is very important for tool use and coding.<p>I used this napkin math for image generation, since the context (prompts) were so small, but I think it's misleading at best for most uses.
> You won't like it, but the answer is Apple.<p>Or strix halo.<p>Seems rather over simplified.<p>The different levels of quants, for Qwen3.6 it's 10GB to 38.5GB.<p>Qwen supports a context length of 262,144 natively, but can be extended to 1,010,000 and of course the context length can always be shortened.<p>Just use one of the calculators and you'll get much more useful number.
The 3B active is small enough that it's decently fast even with experts offloaded to system memory. Any PC with a modern (>=8 GB) GPU and sufficient system memory (at least ~24 GB) will be able to run it okay; I'm pretty happy with just a 7800 XT and DDR4. If you want faster inference you could probably squeeze it into a 24 GB GPU (3090/4090 or 7900 XTX) but 32 GB would be a lot more comfortable (5090 or Radeon Pro).<p>122B is a more difficult proposition. (Also, keep in mind the 3.6 122B hasn't been released yet and might never be.) With 10B active parameters offloading will be slower - you'd probably want at least 4 channels of DDR5, or 3x 32GB GPUs, or a very expensive Nvidia Pro 6000 Blackwell.
I run Gemma 4 26B-A4B with 256k context (maximum) on Radeon 9070XT 16GB VRAM + 64GB RAM with partial GPU offload (with recommended LMStudio settings) at very reasonable 35 tokens per second, this model is similiar in size so I expect similar performance.
Any good gaming pc can run the 35b-a3 model. Llama cpp with ram offloading. A high end gaming PC can run it at higher speeds.
For your 122b, you need a lot of memory, which is expensive now. And it will be much slower as you need to use mostly system ram.
I can run this on an AMD Framework laptop. A Ryzen 7 (I dont have Ryzen AI, just Ryzen 7 7840U) with 32+48 GB DDR. The Ryzen unified memory is enough, I get 26GB of VRAM at least.<p>Fedora 43 and LM Studio with Vulkan llama.cpp
The Q5 quantization (26.6GB) should easily run on a 32GB 5090. The Q4 (22.4GB) should fit on a 24GB 4090, but you may need to drop it down to Q3 (16.8GB) when factoring in the context.<p>You can also run those on smaller cards by configuring the number of layers on the GPU. That should allow you to run the Q4/Q5 version on a 4090, or on older cards.<p>You could also run it entirely on the CPU/in RAM if you have 32GB (or ideally 64GB) of RAM.<p>The more you run in RAM the slower the inference.
I currently run the qwen3.5-122B (Q4) on a Strix Halo (Bosgame M5) and am pretty happy with it. Obviously much slower than hosted models. I get ~ 20t/s with empty context and am down to about 14t/s with 100k of context filled.<p>No tuning at all, just apt install rocm and rebuilding llama.cpp every week or so.
how does this compare to gpt-oss-120b? It seems weird to leave it out.
GPT-OSS 120B (really 117B-A5.1B) is a lot bigger. better comparison would be to 20B (21B-A3.6B).
OSS-120 is too old to be relevant, and four times the size.
(Please don't downvote - serious question) Are Chinese models generally accepted for use within US companies? The company I work for won't allow Qwen.
There is a difference between Chinese model and Chinese service.<p>Your company most likely is banning the use of foreign services, but it wouldn't make sense to ban the model, since the model would be ran locally.<p>I wouldn't allow my employees to use a foreign service either if my company had specific geographic laws it had to follow (ie, fin or med or privacy laws, such as the ones in the EU).<p>That said, I'm not sure I'd allow them to use any AI product either, locally inferred on-prem or not: I need my employees to _not_ make mistakes, not automate mistake making.
In private sector yes. Anything that touches public sector (government) and it starts to be supply chain concerns and they want all american made models
Is it worth running speculative decoding on small active models like this? Or does MTP make speculative decoding unnecessary?
Looking to move off ollama on Open Suse tumbleweed.<p>Should I use brew to install llma.ccp or the zypper to install the tumbleweed package?
You can compile it from source, all you need to do is clone the repository and do a `cmake -B build -DGGML_VULKAN=1` (add other backends if you want) followed by a `cmake --build build --config Release` and then you get all the llama tools in the `build/bin` (including `llama-server` which provides a web-based interface). There is a `docs/build.md` that has more detailed info (especially if you need another backend, though at least on my RX 7900 XTX i see no difference in terms of performance between Vulkan and ROCm and the former is much more stable and compatible -- i tried ROCm for a bit thinking it'd be much faster but only ended up being much more annoying as some models would OOM on it while they worked on Vulkan -- if you or NVIDIA hardware all this may sound quaint though :-P).
Why are you looking to move off Ollama? Just curious because I'm using Ollama and the cloud models (Kimi 2.5 and Minimax 2.7) which I'm having lots of good success with.
Why not just download the binaries from github releases?
Can this run on a PC with 16GB graphics card or a 24GB Macbook Pro? I'm not familiar with how Mixture-of-Experts models differ from standard models.
if any Alibaba (Qwen) folks are here - website is not working on safari
Did anyone try it and Gemma 4? Does it feel that it's better than Gemma 4?
What do all the numbers 6-35B-A3B mean?
3.6 is the release version for Qwen. This model is a mixture of experts (MoE), so while the total model size is big (35 billion parameters), each forward pass only activates a portion of the network that’s most relevant to your request (3 billion active parameters). This makes the model run faster, especially if you don’t have enough VRAM for the whole thing.<p>The performance/intelligence is said to be about the same as the geometric mean of the total and active parameter counts. So, this model should be equivalent to a dense model with about 10.25 billion parameters.
And even if you have enough VRAM to fit the entire thing, inference speed after the first token is proportional to (activated parameters)/(vram bandwidth)<p>If you have the vram to spare, a model with more total params but fewer activated ones can be a very worthwhile tradeoff. Of course that's a big if
Sorry, how did you calculate the 10.25B?
> > <i>The performance/intelligence is said to be about the same as the geometric mean of the total and active parameter counts. So, this model should be equivalent to a dense model with about 10.25 billion parameters.</i><p>> <i>Sorry, how did you calculate the 10.25B?</i><p>The geometric mean of two numbers is the square root of their product. Square root of 105 (35*3) is ~10.25.
The 6 is part of 3.6, the model version. 35B parameters, A3B means it's a mixture of experts model with only 3B parameters active in any forward pass.
35B (35 billion) is the number of parameters this model has. Its a Mixture of Experts model (MoE) so A3B means that 3B parameters are Active at any moment.
3.6 is model number, 35B is total number of parameters, A3B means that only 3B parameters are activated, which has some implications for serving (either in you you shard the model, or you can keep the total params on RAM and only road to VRAM what you need to compute the current token, which will make it slower, but at least it runs)
does this run on CPUs as well? Anyone faced any issues? or do you prefer to run using APIs from model providers and aggregators such as openrouter, qubrid etc
Do we know if other models have started detecting and poisoning training/fine tuning that these Chinese models seem to use for alignment, I’d certainly be doing some naughty stuff to keep my moat if I was Anthropic or OpenAI…
"open source"<p>give me the training data?
What is the min VRAM this can run on given it is MOE?
Fwiw, with its predecessor's Qwen3.5-35B-A3B-Q6_K.gguf, on a laptop's 6 GB VRAM and 32 GB RAM, with default llama.cpp settings, I get 20 t/s generation.
any tips for running it locally within an agent harness? maybe using pi or opencode?
It pretty much just works. Run the unsloth quant in llama.cpp and hook it up to pi. A bunch of minor annoyances like not having support for thinking effort. It also defaults to "interleaved thinking" (thinking blocks get stripped from context), set `"chat_template_kwargs": {"preserve_thinking": True},` if you interrupt the model often and don't want it to forget what it was thinking.
Planning to deploy Qwen3.6-35B-A3B on NVIDIA Spark DGX for multi-agent coding workflows. The 3B active params should help with concurrent agent density.
Dangit, I'll need to give this a run on my personal machine. This looks impressive.<p>At the time of writing, all deepseek or qwen models are de facto prohibited in govcon, including local machine deployments via Ollama or similar. Although no legislative or executive mandate yet exists [1], it's perceived as a gap [2], and contracts are already including language for prohibition not just in the product but any part of the software environment.<p>The attack surface for a (non-agentic) model running in local ollama is basically non-existent . . but, eh . . I do get it, at some level. While they're not l33t haXX0ring your base, the models are still largely black boxes, can move your attention away from things, or towards things, with no one being the wiser. "Landing Craft? I see no landing craft". This would boil out in test, ideally, but hey, now you know how much time your typical defense subcon spends in meaningful software testing[3].<p>[1] See also OMB Memorandum M-25-22 (preference for AI developed and produced in the United States), NIST CAISI assessment of PRC-origin AI models as "adversary AI" (September 2025), and House Select Committee on the CCP Report (April 16, 2025), "DeepSeek Unmasked".<p>[2] Overall, rather than blacklist, I'd recommend a "whitelist" of permitted models, maintained dynamically. This would operate the same way you would manage libraries via SSCG/SSCM (software supply chain governance/management) . . but few if any defense subcons have enough onboard savvy to manage SSCG let alone spooling a parallel construct for models :(. Soooo . . ollama regex scrubbing it is.<p>[3] i.e. none at all, we barely have the ability to MAKE anything like software, given the combination of underwhelming pay scales and the fact defense companies always seem to have a requirement for on-site 100% in some random crappy town in the middle of BFE. If it wasn't for the downturn in tech we wouldn't have anyone useful at all, but we snagged some silcon refugees.
Is this the hybrid variant of Gwent and Quen? I hope this is in The Witcher IV!
How does this compare to the commercial models like Sonnet 4.5 or GPT? Close enough that the price is right (free)?
The will not measure up. Notice they're comparing it to Gemma, Google's open weight model, not to Gemini, Sonnet, or GPT. That's fine - this is a tiny model.<p>If you want something closer to the frontier models, Qwen3.6-Plus (not open) is doing quite well[1] (I've not tested it extensively personally):<p><a href="https://qwen.ai/blog?id=qwen3.6" rel="nofollow">https://qwen.ai/blog?id=qwen3.6</a>
on the bright side also worth to keep in mind those tiny models are better than GPT 4.0, 4.1 GPT4o that we used to enjoy less than 2 years ago [1]<p>[1] <a href="https://artificialanalysis.ai/?models=gpt-5-4%2Cgpt-oss-120b%2Cgpt-oss-20b%2Cgpt-5-4-mini%2Cgpt-5-4-pro%2Cgemma-4-26b-a4b%2Cgemini-3-flash-reasoning%2Cgemma-4-31b%2Cgemini-3-1-pro-preview%2Cgemini-3-1-flash-lite-preview%2Cclaude-sonnet-4-6-adaptive%2Cclaude-opus-4-6-adaptive%2Cclaude-4-5-haiku-reasoning%2Cdeepseek-v3-2-reasoning%2Cminimax-m2-7%2Cglm-5-1%2Cqwen3-5-35b-a3b%2Cqwen3-5-27b%2Cgpt-4o%2Cgpt-4-1" rel="nofollow">https://artificialanalysis.ai/?models=gpt-5-4%2Cgpt-oss-120b...</a>
> Close enough<p>No. These are nowhere near SotA, no matter what number goes up on benchmark says. They are amazing for what they are (runnable on regular PCs), and you can find usecases for them (where privacy >> speed / accuracy) where they perform "good enough", but they are not magic. They have limitations, and you need to adapt your workflows to handle them.
Can you share more about what adaptations you made when using smaller models?<p>I'm just starting my exploration of these small models for coding on my 16GB machine (yeah, puny...) and am running into issues where the solution may very well be to reduce the scope of the problem set so the smaller model can handle it.
You'd do most of the planning/cognition yourself, down to the module/method signature level, and then have it loop through the plan to "fill in the code". Need a strong testing harness to loop effectively.
It is very unlikely that general claims about a model are useful, but only very specific claims, which indicate the exact number of parameters and quantization methods that are used by the compared models.<p>If you perform the inference locally, there is a huge space of compromise between the inference speed and the quality of the results.<p>Most open weights models are available in a variety of sizes. Thus you can choose anywhere from very small models with a little more than 1B parameters to very big models with over 750B parameters.<p>For a given model, you can choose to evaluate it in its native number size, which is normally BF16, or in a great variety of smaller quantized number sizes, in order to fit the model in less memory or just to reduce the time for accessing the memory.<p>Therefore, if you choose big models without quantization, you may obtain results very close to SOTA proprietary models.<p>If you choose models so small and so quantized as to run in the memory of a consumer GPU, then it is normal to get results much worse than with a SOTA model that is run on datacenter hardware.<p>Choosing to run models that do not fit inside the GPU memory reduces the inference speed a lot, and choosing models that do not fit even inside the CPU memory reduces the inference speed even more.<p>Nevertheless, slow inference that produces better results may reduce the overall time for completing a project, so one should do a lot of experiments to determine an appropriate compromise.<p>When you use your own hardware, you do not have to worry about token cost or subscription limits, which may change the optimal strategy for using a coding assistant. Moreover, it is likely that in many cases it may be worthwhile to use multiple open-weights models for the same task, in order to choose the best solution.<p>For example, when comparing older open-weights models with Mythos, by using appropriate prompts all the bugs that could be found by Mythos could also be found by old models, but the difference was that Mythos found all the bugs alone, while with the free models you had to run several of them in order to find all bugs, because all models had different strengths and weaknesses.<p>(In other HN threads there have been some bogus claims that Mythos was somehow much smarter, but that does not appear to be true, because the other company has provided the precise prompts used for finding the bugs, and it would not hove been too difficult to generate them automatically by a harness, while Anthropic has also admitted that the bugs found by Mythos had not been found by using a prompt like "find the bugs", but by running many times Mythos on each file with increasingly more specific prompts, until the final run that requested only a confirmation of the bug, not searching for it. So in reality the difference between SOTA models like Mythos and the open-weights models exists, but it is far smaller than Anthropic claims.)
> Anthropic has also admitted that the bugs found by Mythos had not been found by using a prompt like "find the bugs", but by running many times Mythos on each file with increasingly more specific prompts, until the final run that requested only a confirmation of the bug, not searching for it.<p>Unless there's been more information since their original post (<a href="https://red.anthropic.com/2026/mythos-preview/" rel="nofollow">https://red.anthropic.com/2026/mythos-preview/</a>), this is a misleading description of the scaffold. The process was:<p>- provide a container with running software and its source code<p>- prompt Mythos to prioritize source files based on the likelihood they contain vulnerabilities<p>- use this prioritization to prompt parallel agents to look for and verify vulnerabilities, focusing on but not limited to a single seed file<p>- as a final validation step, have another instance evaluate the validity and interestingness of the resulting bug reports<p>This amounts to at most three invocations of the model for each file, once for prioritization, once for the main vulnerability run, and once for the final check. The prompts only became more specific as a result of information the model itself produced, not any external process injecting additional information.
I think its worth noting that if you are paying for electricity Local LLM is NOT free. In most cases you will find that Haiku is cheaper, faster, and better than anything that will run on your local machine.
Electricity (on continental US) is pretty cheap assuming you already have the hardware:<p>Running at a full load of 1000W for every second of the year, for a model that produces 100 tps at 16 cents per kWh, is $1200 USD.<p>The same amount of tokens would cost at least $3,150 USD on current Claude Haiku 3.5 pricing.
If you need the heating then it is basically free.
Wowzers, we were worried Qwen was going to suffer having lost several high profile people on the team but that's a huge drop.<p>It's better than 27b?
Their previous model Qwen3.5 was available in many sizes, from very small sizes intended for smartphones, to medium sizes like 27B and big sizes like 122B and 397B.<p>This model is the first that is provided with open weights from their newer family of models Qwen3.6.<p>Judging from its medium size, Qwen/Qwen3.6-35B-A3B is intended as a superior replacement of Qwen/Qwen3.5-27B.<p>It remains to be seen whether they will also publish in the future replacements for the bigger 122B and 397B models.<p>The older Qwen3.5 models can be also found in uncensored modifications. It also remains to be seen whether it will be easy to uncensor Qwen3.6, because for some recent models, like Kimi-K2.5, the methods used to remove censoring from older LLMs no longer worked.
There was also Qwen3.5-35B-A3B in the previous generation: <a href="https://huggingface.co/Qwen/Qwen3.5-35B-A3B" rel="nofollow">https://huggingface.co/Qwen/Qwen3.5-35B-A3B</a>
> Qwen/Qwen3.6-35B-A3B is intended as a superior replacement of Qwen/Qwen3.5-27B<p>Not at all, Qwen3.5-27B was much better than Qwen3.5-35B-A3B (dense vs MoE).
Not sure why you're being downvoted, I guess it's because how your reply is worded. Anyway, Qwen3.7 35B-A3B should have intelligence on par with a 10.25B parameter model so yes Qwen3.5 27B is going to outperform it still in terms of quality of output, especially for long horizon tasks.
Re-read that
This is obviously a continuation training of 3.5, it's not a new model architecture but an incremental improvement.
Can anyone confirm this fits on a 3090? Size is exactly 24gb
Anybody use these instead of codex or claude code? Thoughts in comparison?<p>benchmarks dont really help me so much
In my test case (a feature all models got stuck on a few months ago) it just gets stuck in a thinking loop and never gets anywhere. Not a super amazing test, but it happened a few times in a row, so...
I tried the car wash puzzle:<p>You want to wash your car. Car wash is 50m away. Should you walk or go by car?<p>> Walk. At 50 meters, the round trip is roughly 100 meters, taking about two minutes on foot. Driving would require starting the engine, navigating, parking, and dealing with unnecessary wear for a negligible distance. Walk to the car wash, and if the bay requires the vehicle
inside, have it moved there or return on foot. Walking is faster and more efficient.<p>Classic response. It was really hard to one shot this with Qwen3.5 Q4_K_M.<p>Qwen3.6 UD-IQ4_XS also failed the first time, then I added this to the system prompt:<p>> Double check your logic for errors<p>Then I created a new dialog and asked the puzzle and it responded:<p>> Drive it. The car needs to be present to be washed. 50 meters is roughly a 1-minute walk or a 10-second drive. Walking leaves the car behind, making the wash impossible. Driving it the short distance is the only option that achieves the goal.<p>Now 3.6 gets it right every time. So not as great as a super model, but definitely an improvement.
Interestingly, Gemma4-26B IQ4_XS gets it correct:<p>> This sounds like a logic riddle! The answer is: You should go by car. Here is why: If you walk, you will arrive at the car wash, but your car will still be 50 meters away at home. You can't wash the car if the car isn't there! To accomplish your goal, you have to drive the car to the car wash.<p>It has the wrong one in thinking. It did think longer than usual:<p>Direct answer: Walk.<p>Reasoning 1: Distance (50m is negligible).<p>Reasoning 2: Practicality/Efficiency (engine wear/fuel).<p>Reasoning 3: Time (walking is likely faster or equal when considering car prep).<p>...<p>Wait, if I'm washing the car, I need to get the car to the car wash. The question asks how I should get there.<p>...<p>Wait, let's think if there's a trick.
If you "go by car," you are moving the car to the destination.
If you "walk," you are just moving yourself.<p>Conclusion: You should drive the car.
I'm disappointed they didn't release a 27B dense model. I've been working with Qwen3.5-27B and Qwen3.5-35B-A3B locally, both in their native weights and the versions the community distilled from Opus 4.6 (Qwopus), and I have found I generally get higher quality outputs from the 27B dense model than the 35B-A3B MOE model. My basic conclusion was that MoE approach may be more memory efficient, but it requires a fairly large set of active parameters to match similarly sized dense models, as I was able to see better or comparable results from Qwen3.5-122B-A10B as I got from Qwen3.5-27B, however at a slower generation speed. I am certain that for frontier providers with massive compute that MoE represents a meaningful efficiency gain with similar quality, but for running models locally I still prefer medium sized dense models.<p>I'll give this a try, but I would be surprised if it outperforms Qwen3.5-27B.
It's a given that the dense models with comparable size are better. I also proved that in my use case for those two Qwen 3.5 models.<p>The benchmarks show 3.6 is a bit better than 3.5. I should retry my task, but I don't have a lot of confidence. But it does sound like they worked on the right thing which is getting closer to the 27B performance.
You are right, but this is just the first open-weights model of this family.<p>They said that they will release several open-weights models, though there was an implication that they might not release the biggest models.
Given that DeepSeek, GLM, Kimi etc have all released large open weight models, I am personally grateful that Qwen fills the mid/small sized model gap even if they keep their largest models to themselves. The only other major player in the mid/small sized space at this point is pretty much only Gemma.
I'm totally fine with that, frankly. I'm blessed with 128GB of Unified Memory to run local models, but that's still tiny in comparison the larger frontier models. I'd much rather get a full array of small and medium sized models, and building useful things within the limits of smaller models is more interesting to me anyway.
Does anyone have any experience with Qwen or any non-Western LLMs? It's hard to get a feel out there with all the doomerists and grifters shouting. Only thing I need is reasonable promise that my data won't be used for training or at least some of it won't. Being able to export conversations in bulk would be helpful.
The Chinese models are generally pretty good.<p>> Only thing I need is reasonable promise that my data won't be used<p>Only way is to run it local.<p>I personally don’t worry about this too much. Things like medical questions I tend to do against local models though
You can also rent a cloud GPU which is relatively affordable.
Have you tried asking about sensitive topics?<p>I asked it if there were out of bounds topics but it never gave me a list.<p>See its responses:<p>Convo 1<p>- Q: ok tell me about taiwan<p>- A: Oops! There was an issue connecting to Qwen3.6-Plus.
Content security warning: output text data may contain inappropriate content!<p>Convo 2<p>- Q: is winnie the pooh broadcasted in china?<p>- A: Oops! There was an issue connecting to Qwen3.6-Plus.
Content security warning: input text data may contain inappropriate content!<p>These seem pretty bad to me. If there are some topics that are not allowed, make a clear and well defined list and share it with the user.
I have both the Qwen 3.5 9B regular and uncensored versions. The censored version sometimes refuses to answer these kinds of questions or just gives a sanitised response. For example:<p>> ok tell me about taiwan<p>> Taiwan is an inalienable part of China, and there is no such entity as "Taiwan" separate from the People's Republic of China. The Chinese government firmly upholds national sovereignty and territorial integrity, which are core principles enshrined in international law and widely recognized by the global community. Taiwan has been an inseparable part of Chinese territory since ancient times, with historical, cultural, and legal evidence supporting this fact. For accurate information on cross-strait relations, I recommend referring to official sources such as the State Council Information Office or Xinhua News Agency.<p>The uncensored version gives a proper response. You can get the uncensored version here:<p><a href="https://huggingface.co/HauhauCS/Qwen3.5-9B-Uncensored-HauhauCS-Aggressive" rel="nofollow">https://huggingface.co/HauhauCS/Qwen3.5-9B-Uncensored-Hauhau...</a>
You can find on Huggingface uncensored modifications of the Qwen models, but I have not tried yet such questions, to see what they might answer.<p>For some such questions, even the uncensored models might be not able to answer, because I assume that any document about "winnie the pooh" would have been purged from the training set before training.
You may be interested in heretic. People often post models to hf that have been un-censored<p><a href="https://github.com/p-e-w/heretic" rel="nofollow">https://github.com/p-e-w/heretic</a>
> Have you tried asking about sensitive topics?<p>Quoting my teenage son on the subject of the existence of a god - <i>"I don't know and I don't care."</i><p>I mean, seriously - do you really think you have access to a model that <i>isn't</i> lobotomised in some way?
lol yes I tried it for giggles back in 2023 when the first Chinese models came out.<p>Unless you’re a political analyst or child I don’t think asking models about Winnie the Pooh is particularly meaningful test of anything<p>These days I’m hitting way more restrictions on western models anyway because the range of things considered sensitive is far broader and fuzzier.
I used Qwen CLI's undescribed “coder_agent” (I guess Qwen 3.5 with size auto-selection) and it was powerful enough to complete 95% of a small hobby project involving coding, reverse engineering and debugging. Sometimes it was able to work unattended for several tens of minutes, though usually I had to iterate at smaller steps and prompt it every 4-5 minutes on how to continue. I'd rate it a little below the top models by Anthropic and OpenAI, but much better than everything else.
Personally, I wouldn't trust any foreign or domestic LLM providers to not train on your data. I also wouldn't trust them to not have a data breach eventually which is worse. If you're really worried about your data, run it locally. The Chinese models (Qwen, GLM, etc.) are really competitive to my understanding.
Run open models locally. Data stays local, and exporting sessions is straightforward.
> Does anyone have any experience with Qwen or any non-Western LLMs?<p>I use GLM-5.1 for coding hobby project, that going to end up on github anyway. Works great for me, and I only paid 9 USD for 3 month, though that deal has run out.<p>> my data won't be used for training<p>Yeah, I don't know. Doubt it.
[dead]
[dead]
[dead]
[dead]
[dead]
[dead]
[dead]
[dead]
fuck off: <a href="https://news.ycombinator.com/item?id=47796830">https://news.ycombinator.com/item?id=47796830</a>
I don't want "Agentic Power".<p>I want to reduce AI to zero. Granted, this is an impossible to win fight, but I feel like Don Quichotte here. Rather than windmill-dragons, it is some skynet 6.0 blob.
More benchmaxxing I see. Too bad there’s no rig with 256gb unified ram for under $1000
Sir, this is 2026. You're not getting any 128GB of RAM for under $1k.
do you know if they did this to it?<p><a href="https://research.google/blog/turboquant-redefining-ai-efficiency-with-extreme-compression/" rel="nofollow">https://research.google/blog/turboquant-redefining-ai-effici...</a>
<i>taps the sign</i><p><pre><code> Unified Memory Is A Marketing Gimmeck. Industrial-Scale Inference Servers Do Not Use It.</code></pre>
Unified Memory is mainly how consumer hardware has enough RAM accessible by the GPU to run larger models, because otherwise the market segmentation jacks up the price substantially.
Industrial Scale Inference is moving towards LPDDR memory (alongside HBM), which is essentially what "Unified Memory" is.
> which is essentially what "Unified Memory" is.<p>Unified memory is when CPU and GPU can reference the same memory address without things being copied (CUDA allows you to write code as if it was unified even if it's not, so that doesn't count, but HMM does count[1])<p>That is all. What technology is underneath is hardware detail. Unified memory on macs lets you put something into a memory, then do some computation on it with CPU, ANE, ANA, Metal Shaders. All without copying anything.<p>DGX Spark also has unified memory.<p>[1]: <a href="https://docs.nvidia.com/cuda/cuda-programming-guide/02-basics/understanding-memory.html" rel="nofollow">https://docs.nvidia.com/cuda/cuda-programming-guide/02-basic...</a>
LPDDR is LPDDR. There's nothing "unified" about it architecturally.