Qwen_Qwen3-Next-80B-A3B-Thinking GGUF size and VRAM requirements

License: apache-2.0 ⬇ 14,689 ❤ 15
Parameters79.67B
Context262,144

bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF is a very large reasoning-focused model with 79.67 billion parameters, built on the qwen3next architecture. It is released under the apache-2.0 license and has been downloaded 14,689 times.

To run bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF locally at a 4,096-token context, its quantized versions need between 5.53 GB (GGUF, lowest quality) and 84.09 GB (Q8_0, highest quality) of memory, weights plus KV cache and a system margin included.

For most users the best balance is GGUF, needing about 5.53 GB. That means bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF fits entirely in the VRAM of a 6 GB GPU or larger, running fully on the GPU.

→ Guide: How much VRAM do you need?

GGUF file size and memory by quantization

Compare real GGUF weight sizes, estimated KV cache and total memory for Q4, Q5, Q8 and every quantization published in this repository.

Quant.Bits QualityWeights KVTotal Speed~Verdict
GGUF 0.05 Very low 0.43 GB 4.31 GB 5.53 GB 939.8 t/s Fits in VRAM
IQ1_S 1.67 Very low 15.44 GB 4.31 GB 20.55 GB 3.2 t/s Offload
IQ1_M 1.74 Very low 16.11 GB 4.31 GB 21.22 GB 3.1 t/s Offload
IQ2_XXS 1.94 Very low 17.97 GB 4.31 GB 23.08 GB 2.8 t/s Offload
IQ2_XS 2.23 Very low 20.69 GB 4.31 GB 25.8 GB Insufficient
IQ2_S 2.35 Very low 21.76 GB 4.31 GB 26.87 GB Insufficient
IQ2_M 2.62 Low 24.31 GB 4.31 GB 29.41 GB Insufficient
Q2_K 2.83 Low 26.23 GB 4.31 GB 31.34 GB Insufficient
Q2_K_L 2.86 Low 26.52 GB 4.31 GB 31.62 GB Insufficient
IQ3_XXS 3.19 Low 29.55 GB 4.31 GB 34.65 GB Insufficient
IQ3_XS 3.32 Fair 30.76 GB 4.31 GB 35.87 GB Insufficient
Q3_K_S 3.5 Fair 32.47 GB 4.31 GB 37.58 GB Insufficient
IQ3_M 3.68 Fair 34.13 GB 4.31 GB 39.23 GB Insufficient
Q3_K_M 3.68 Fair 34.14 GB 4.31 GB 39.25 GB Insufficient
Q3_K_L 3.84 Fair 35.6 GB 4.31 GB 40.71 GB Insufficient
Q3_K_XL 3.87 Fair 35.86 GB 4.31 GB 40.96 GB Insufficient
IQ4_XS 4.3 Good 39.91 GB 4.31 GB 45.01 GB Insufficient
IQ4_NL 4.55 Good 42.2 GB 4.31 GB 47.31 GB Insufficient
Q4_0 4.63 Good 42.93 GB 4.31 GB 48.04 GB Insufficient
Q4_K_S 4.71 Good 43.71 GB 4.31 GB 48.81 GB Insufficient
Q4_K_M 4.89 Good 45.38 GB 4.31 GB 50.49 GB Insufficient
Q4_K_L 4.92 Good 45.6 GB 4.31 GB 50.7 GB Insufficient
Q4_1 5.04 Very good 46.78 GB 4.31 GB 51.88 GB Insufficient
Q5_K_S 5.54 Very good 51.38 GB 4.31 GB 56.49 GB Insufficient
Q5_K_M 5.72 Very good 53.07 GB 4.31 GB 58.17 GB Insufficient
Q5_K_L 5.74 Very good 53.25 GB 4.31 GB 58.35 GB Insufficient
Q6_K 6.61 Excellent 61.27 GB 4.31 GB 66.38 GB Insufficient
Q6_K_L 6.62 Excellent 61.41 GB 4.31 GB 66.52 GB Insufficient
Q8_0 8.52 Excellent 78.99 GB 4.31 GB 84.09 GB Insufficient

KV cache estimated (architecture unavailable). Speed is a rough estimate bounded by memory bandwidth.

Frequently asked questions

How much VRAM do you need to run bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF?

You need about 5.53 GB of VRAM to run bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF entirely on the GPU using the GGUF quantization (at a 4,096-token context). Smaller quantizations lower the requirement at the cost of quality.

Can I run bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF on an 8 GB GPU?

Yes. With 8 GB of VRAM you can run bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF fully on the GPU using GGUF (about 5.53 GB).

Can I run bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF on a 16 GB GPU?

Yes. With 16 GB of VRAM you can run bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF fully on the GPU using GGUF (about 5.53 GB).

Can I run bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF on a 24 GB GPU?

Yes. With 24 GB of VRAM you can run bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF fully on the GPU using IQ2_XXS (about 23.08 GB).

What is the best quantization for bartowski/Qwen_Qwen3-Next-80B-A3B-Thinking-GGUF?

If memory allows, higher bits-per-weight means better quality. A common sweet spot is a Q4_K_M or Q5_K_M quantization, which keeps most of the quality while roughly halving the memory versus 8-bit. Pick the highest quantization that still fits in your VRAM.