Can your GPU run Qwopus 3.8 27B Flash?
An RTX 5080 runs Qwopus 3.8 27B Flash only by giving up quality. Q4_K_M, the rung most people download, wants 17.1 GiB at 4K and 18.9 GiB at 32K against the 15.2 GiB a 16 GB card hands a process, so it misses at every context length rather than only at long ones. What fits is Q3_K_M, and only under 8K context. Twenty four of the 125 cards in our catalogue are 16 GB and every one of them pays that same price.
An RTX 3090 from 2020 runs it at 32K with the vision tower loaded. 22.9 GiB usable against the 20.6 that needs, and @ItsmeAjayKV measured the base model at 40 tok/s on one under llama.cpp. The second hand 3090 our buying guide still calls the rational purchase is the cheapest sensible way to run this model. The current generation 16 GB cards are not in the running for it at all.
32K is the default, not the ceiling, and the difference is the KV cache. Every total on this page uses an fp16 KV cache, which is the honest default because it is what you get without asking. Quantize the cache and the same 24 GB card goes a long way further:
| RTX 3090, Q4_K_M | Longest context that fits |
|---|---|
| fp16 KV, the default here | 65,536 |
| q8_0 KV | 131,072 |
| q5_1 KV | 262,144, the model's native maximum |
@JakeKAllDay pushed that further than anyone we have seen: 240,000 tokens at 75.29 tok/s on a 3090 Ti power capped to 350 W, using his own 4.5 bpw quant and a fork with 8 bit keys and a roughly 3 bit value cache, peaking at 23 GB. That is a custom quant and a custom build of llama.cpp, so it is a ceiling for the card rather than something you get from a stock install, and he documents every number against a logged run. The reason it fits is in this model's shape: only 16 of its 64 layers hold a KV cache at all, which is the same fact that makes the totals above smaller than a 27B usually implies.
The sizing itself is already solved, because the weights are Qwen 3.8 27B's weights. What is left is the files most people never add up.
What Qwopus 3.8 27B Flash actually is
Jackrong/Qwopus3.8-27B-Flash-GGUF is a community fine-tune, not a lab release. It went up on 4 September 2026 and had 22,128 downloads and 122 likes two days later.
The author's own card frontmatter names the base: Qwen/Qwen3.8-27B. The training data is a multi stage mix and Jackrong has not fully disclosed it. His card describes roughly 1.5 million teacher model SFT examples cut to the best 10%, plus agent trajectory data and, in his words, reconstructed trace data derived from closed models such as Claude and GPT, with the detail held back until the dataset is cleaned up for release. The same author does publish Claude-opus-4.6-TraceInversion-9000x and Claude-opus-4.7-TraceInversion-5000x, and names both on the earlier Qwopus 3.6 v2 cards. That is where the name comes from, Qwen plus Opus.
Adoption is why this one is worth sizing. Qwopus spans 717 repositories on Hugging Face, and in the thirty days to 6 September 2026 they pulled 4.48 million downloads between them. Jackrong published 48 of those. The rest are other people's quantisations, merges and mirrors, which is what a model looks like when a community has adopted it rather than bookmarked it.
None of that changes the arithmetic. A fine-tune carries the same tensors in the same shapes as the model it came from, so it occupies the same memory. What changes is the file the publisher hands you, and that is the part worth reading carefully.
Every file in the repo, and what it costs
Sizes read from the Hugging Face API on 6 September 2026. Totals are computed by our engine for one GPU, fp16 KV cache, llama.cpp, and include the KV cache and runtime overhead rather than just the weights.
| Quant | File, GB | 8K ctx | 32K ctx | 128K ctx | 32K + vision |
|---|---|---|---|---|---|
| BF16 | 54.66 | ||||
| Q8_0 | 29.05 | 29.0 | 30.5 | 36.7 | 32.3 |
| Q6_K | 22.43 | 22.7 | 24.2 | 30.4 | 26.0 |
| Q5_K_M | 19.54 | 20.0 | 21.5 | 27.6 | 23.2 |
| Q5_K_S | 18.97 | ||||
| Q4_K_M | 16.81 | 17.4 | 18.9 | 25.0 | 20.6 |
| Q4_K_S | 15.83 | ||||
| IQ4_XS | 15.42 | ||||
| Q3_K_L | 14.56 | ||||
| Q3_K_M | 13.50 | 14.2 | 15.8 | 21.9 | 17.5 |
| Q3_K_S | 12.26 | ||||
| Q2_K | 10.86 | 11.7 | 13.3 | 19.4 | 15.0 |
| mmproj-F32 | 1.84 |
Totals in GiB. File sizes in decimal GB, as Hugging Face reports them.
The 16 GB wall is sharp on this model, and shortening the context does not get you over it. Q4_K_M is 17.1 GiB at 4K, 17.4 at 8K and 18.9 at 32K, against the 15.2 GiB a 16 GB card offers, so the rung misses at every context length rather than only at long ones. That is 24 of the 125 cards we carry: the RTX 5080, the 5070 Ti, the 4080 and 4080 Super, the 4060 Ti 16GB, the 9070 XT, the 7800 XT and seventeen others. Q3_K_M does get a 16 GB card in at 14.2 GiB, but only under 8K context, because the same rung reaches 15.8 GiB at 32K and misses again. Q2_K clears it at 13.3 GiB, and a 27B at two bits is a different model in practice.
The 1.84 GB nobody counts
mmproj-F32.gguf is the multimodal projector, the piece that turns image tokens into something the language model can read. It is a separate download and a separate load, it is not folded into any of the twelve quant files, and it is stored at F32, so it does not shrink when you drop to Q4.
That means the vision column above is not a rounding difference. At Q4_K_M and 32K context:
| Total | Cards that fit | Smallest class | |
|---|---|---|---|
| Text only | 18.91 GiB | 50 of 125 | 20 GB |
| With vision | 20.62 GiB | 48 of 125 | 24 GB |
The two cards that fall out are the RTX 4000 Ada and the Radeon RX 7900 XT, both 20 GB, both offering 19.0 GiB usable. They run this model perfectly well as a text model and cannot load its vision tower.
One detail explains the size. Jackrong ships the projector at F32. unsloth's build of the base model ships the same component at BF16, 931,146,432 bytes, almost exactly half. That is also why our own calculator note for Qwen 3.8 27B quotes 0.93 GB: it is describing unsloth's projector, not this repo's. Borrowing the smaller one brings the vision total to 19.8 GiB, which still does not fit a 20 GB card, so the verdict holds either way. It just holds for a duller reason.
This is the kind of thing that produces a confusing evening. The model loads, it answers, then it fails the moment an image arrives, and the file that caused it was never in the number anyone quoted. If you are on a 20 GB card and you want the vision path, the honest options are Q3_K_M with vision at 17.5 GiB, or a shorter context.
Every filename says MTP, and that is a speed feature
All twelve GGUF files are named Qwopus3.8-27B-Flash-MTP-<quant>.gguf. MTP is multi token prediction, the model's own draft head, and it is the cheap half of speculative decoding. It ships in the file, and it is not Jackrong's addition: mtp_num_hidden_layers sits in Qwen 3.8 27B's own config.json, and @analogalok's baseline on the base model was already running it.
What Jackrong claims is not the head but the hit rate. His card reports weighted MTP draft acceptance of 80.7% against 66.1% for the base, and 9.347 tok/s decoder throughput against 8.284, which he puts at 12.8% faster. He also gives the flag he ran it under, --spec-type draft-mtp. Those are his measurements, not ours.
The acceptance claim is the one figure somebody has now checked, and it did not hold. @witcheer ran both models on an RTX 5090 and measured draft acceptance at 0.76 for Qwopus against 0.77 for the base with thinking off, which is the same number either way and marginally better on the base. Jackrong reports a 14.6 point gap in Qwopus favour. Same run puts both models at 61 tok/s plain and 109 to 145 with the head, so the head is worth roughly 2x on this card and it is worth that on both.
What it is worth is measurable on the base model, where we have runs from named testers. These are Qwen 3.8 27B runs, not Qwopus runs. We have not run Qwopus and are not presenting anyone's number as ours.
| Tester | Hardware | Baseline | With speculative decoding | Gain |
|---|---|---|---|---|
| @ViC305 | 1x DGX Spark | 12.37 tok/s | 24.51 | 1.98x |
| @fahdmirza | 1x A100, SGLang | 28.9 | 59.1 | 2.05x |
| @analogalok | 1x RTX 4090 | 60 on plain MTP | 87 with DFlash 2, the top of his own table against the 90 in his headline | 1.45x |
| @filicroval | 1x DGX Spark | 12.34 | 57.11 whole request | 4.63x |
The spread is wide because the runs are not the same experiment. @analogalok's baseline was already using MTP, so his 1.45x is DFlash 2 on top of the feature Qwopus ships, while @ViC305 and @fahdmirza measured against no speculation at all. The honest summary is that across the four runs below this base gains between 1.45x and 4.63x from speculative decoding depending on where you start, and our wider corpus holds a 4.71x, and Qwopus hands you the starting point in the box. We wrote up the full picture in DFlash 2 speculative decoding, and the per card numbers live in Qwen 3.8 27B speed.
Why these are the base model's numbers
The parameter count settles it. The Qwopus base reports 27,781,427,952 parameters, and the architecture under text_config is 64 layers, 4 KV heads, head dim 256, hidden size 5120, 262,144 max context, with full attention on every fourth layer, so 16 of the 64. That is the geometry our catalogue already carries for Qwen 3.8 27B, and carried for Qwen 3.6 27B and Qwen 3.5 27B before it. The Qwen 27B line has held its shape across three generations.
The file sizes agree in a way that is more interesting than it first looks:
| Quant | Qwopus | Our measured Qwen 3.8 27B | Difference |
|---|---|---|---|
| BF16 | 54.66 | 54.66 | 0.0% |
| Q8_0 | 29.05 | 29.05 | 0.0% |
| Q6_K | 22.43 | 21.98 | +2.0% |
| Q5_K_M | 19.54 | 19.77 | -1.2% |
| Q4_K_M | 16.81 | 16.46 | +2.1% |
| Q3_K_M | 13.50 | 13.15 | +2.7% |
The two near lossless rungs land within 6 KB of each other and the gap widens as the bits come off. Neither column is wrong. BF16 and Q8_0 leave a quantiser almost no decisions to make, so two people converting the same architecture land on the same bytes. A K-quant is not a bit width, it is a plan for which tensors get which precision, and two publishers making that plan differently produce files that differ by a couple of percent while both being correct. That is the whole argument in mixed precision quantization, showing up in a file anyone can download and check.
Our Qwen 3.8 27B figures come from unsloth's builds and Jackrong quantised his own. The pattern in that last column is not random: unsloth ships BF16 and Q8_0 plain, and everything below them as Dynamic builds, UD-Q4_K_M, UD-Q5_K_M, UD-Q3_K_XL. The rungs that match are exactly the ones where nobody applied a per tensor plan. The rungs that diverge are the ones where two people applied different plans, and in the Q3 row they are not even the same rung name. Both files are real.
What Jackrong claims, and what is confirmed
Start with this model's own card, because it does not claim what people assume a fine-tune claims. Jackrong puts Qwopus 3.8 27B Flash at 91.28% on a 2,500 question MMLU-Pro set against 92.73% for the Qwen 3.8 base, and sells the difference as a trade: slightly less accuracy for 12.8% faster decoding and an 80.7% draft acceptance rate. It is tuned to be quick, not clever.
The older cards in the family carry the strong numbers. On the Qwopus3.6-27B-Coder-MTP card, Jackrong reports 87.43% MMLU-Pro and 75.25% SWE-bench Verified for the v2 base, and 67.0% SWE-bench Verified for the Coder with thinking off.
Those are the author's own figures and nobody has reproduced them on the benchmarks he ran. A 75.25% SWE-bench Verified score from a 27B dense model would place it level with or above the frontier labs, which is a claim that deserves a third party run before anyone repeats it as fact.
Somebody has now measured the trade-off on a different benchmark, and it costs far more than Jackrong says. @witcheer ran Qwopus 3.8 27B Flash against the Qwen 3.8 27B base on his own RTX 5090, GPQA-diamond, thinking on, greedy, 198 questions:
| Score | Tokens per correct answer | Wall time | |
|---|---|---|---|
| Qwopus 3.8 27B Flash | 70.7% | 4,229 | 2.7 hours |
| Qwen 3.8 27B base | 79.3% | 7,740 | 5.5 hours |
On the 125 questions both answer correctly the base thinks 2.08x longer, so the tune buys half the tokens and half the wall time for 8.6 points. Jackrong's own card puts the cost at 1.45 points on MMLU-Pro. These are different benchmarks and neither confirms nor refutes the other, but the direction is the same and the price on this one is six times larger. His words for what the tune learned: it stops early, and on the hardest questions it sometimes stops before it is done.
The hardware question does not depend on it. Whatever the model scores, it occupies the memory calculated above, because that is a property of the tensors and not of the training.
Check your own card
The base model is in the calculator with measured file sizes, a measured speed corpus and an NVFP4 rung added this week, so the fastest way to size your own configuration is to run it rather than read a table built for somebody else's context length.
- What LLM can I run? takes your card and lists what fits.
- The homepage calculator goes the other way: pick Qwen 3.8 27B, set your quant and context, and read the total.
- Tokens per second estimates decode speed for your card, against our corpus of measured runs from named testers.
Add about 1.7 GiB to whatever those tools report if you intend to use the vision path, because the projector is not part of the model entry.
One thing to expect: the calculator carries unsloth's file sizes for Qwen 3.8 27B, which run about 2% smaller than Jackrong's, so it reports 18.6 GiB at Q4_K_M and 32K where the table above says 18.9. Both are real files. If you are near a limit, size on the larger one.
Related reading: Qwen 3.8 VRAM requirements for the wider family, and Qwen 3.8 Flash Next on NVFP4 for the 180B sibling that runs on a single DGX Spark.
FAQ
Is Qwopus 3.8 27B Flash the same size as Qwen 3.8 27B?
Yes, within a rounding error at the top of the ladder. Both report 27,781,427,952 parameters, and the BF16 and Q8_0 files agree to two decimal places at 54.66 GB and 29.05 GB, differing by about 6 KB of header metadata. The K-quants differ by up to 2.7%, because Jackrong quantised his own files while our Qwen 3.8 27B figures come from unsloth's Dynamic builds, and two quantisers make different per tensor choices. Both sets of files are correct.
How much VRAM does Qwopus 3.8 27B Flash need?
At Q4_K_M with 32K context, 18.9 GiB including KV cache and overhead, which needs a 20 GB card or larger. With the vision projector loaded it is 20.6 GiB, which needs 24 GB. Q8_0 at the same context is 30.5 GiB and needs a 32 GB card.
Will Qwopus 3.8 27B Flash run on a 16 GB GPU?
Not at Q4_K_M, and not at any context length. A 16 GB card offers roughly 15.2 GiB usable, and Q4_K_M is 17.1 GiB even at 4K, rising to 18.9 GiB at 32K. Q3_K_M does fit, at 14.2 GiB, but only if you stay under 8K context, because it reaches 15.8 GiB at 32K. Q2_K clears it at 13.3 GiB and a 27B at two bits per weight is a meaningfully different model. A 20 GB card is the floor for Q4_K_M and 24 GB is the floor once the vision projector loads.
What is the mmproj file in the Qwopus repo?
mmproj-F32.gguf is the multimodal projector, 1.84 GB, which converts image tokens into the language model's input space. It is a separate download and a separate load, it is stored at F32 so it does not shrink with the quant you pick, and it is not included in any of the twelve quant file sizes. Skip it and you have a text only model.
What does MTP mean in the Qwopus filenames?
Multi token prediction, the model's built in draft head for speculative decoding. Every GGUF in the repo carries it. On the same base architecture, named testers measured speculative decoding gains between 1.45x and 4.63x depending on the baseline they started from.
Is Qwopus 3.8 27B Flash better than Qwen 3.8 27B?
Not on reasoning, and the independent number is worse than the author's. Jackrong puts Qwopus at 91.28% on a 2,500 question MMLU-Pro set against 92.73% for the base, giving up 1.45 points for 12.8% faster decoding. @witcheer measured both on GPQA-diamond on an RTX 5090 and got 70.7% against 79.3%, an 8.6 point gap, in exchange for half the tokens and half the wall time. Different benchmarks, same direction, six times the price. What you are buying is a model that stops thinking early. And on the same run, an indentation defect: 150 of 164 HumanEval answers put one space before every code line, which flattens nested blocks and drops one-shot Python to 26.8 against the base's 94.5. Check your own output formatting before trusting it for code. On hardware the two are interchangeable: same parameter count, same architecture, same memory.
What is Qwopus trained on?
Jackrong describes about 1.5 million teacher model SFT examples filtered to the best 10%, plus agent trajectory data and reconstructed trace data from closed models such as Claude and GPT. He has not disclosed the dataset for this release. The two datasets he does publish, Claude-opus-4.6-TraceInversion-9000x and Claude-opus-4.7-TraceInversion-5000x, are named on the earlier Qwopus 3.6 v2 cards. The repository is listed under an Apache 2.0 licence.