Can my PC run AI?

Can I run Qwen3 Coder Next 80B-A3B locally? Requirements and speed

Qwen3 Coder Next 80B-A3B needs about 49 GB at 4-bit compression with an 8,192-token conversation (about 6,000 words): more than any single gaming graphics card holds. It runs entirely on 96 GB of graphics memory (two or more cards, a workstation card, or a Ryzen AI Max+ 395 with 128 GB), and on one gaming card with the rest in system memory, much more slowly. Of the PCs below, the least powerful that runs it well is an RTX 4060 with 32 GB of DDR5: 35–56 tokens/s at 2-bit.

Check your PC

A second, different card shares the model with the first.

Choosing one fills in the memory it usually has.

Settings, System, About: “Installed RAM”.

Task Manager, Performance, Memory: “Speed”.

Memory it needs

The model’s weights plus the conversation it is holding, at each compression. For it to run at full speed, all of it has to fit in the graphics card’s memory with about 1.2 GB to spare. Slow although it should fit? See where it is really running. Which compression to download.

CompressionWeights8,192 tokens32,768 tokens131,072 tokens
16-bit (BF16)159 GB160 GB160 GB163 GB
8-bit (Q8_0)85 GB85 GB85 GB88 GB
6-bit (Q6_K)65 GB66 GB66 GB69 GB
5-bit (Q5_K_M)56 GB57 GB57 GB60 GB
4-bit (Q4_K_M)48 GB49 GB49 GB52 GB
3-bit (Q3_K_M)39 GB39 GB40 GB42 GB
2-bit (Q2_K)30 GB30 GB31 GB33 GB

How fast it runs on common PCs

With an 8,192-token conversation, at the best compression that fits each PC. Writing speed is how fast an answer appears; most people read at about 5 to 8 tokens a second.

PCRuns?WritesHow
Raspberry Pi 5, 8 GB, microSDToo slow to use0.02–0.03 tokens/s2-bit (Q2_K), partly read from the drive as it runs
Mini PC, Intel N100, 16 GB DDR5-4800 (one channel)Too slow to use0.76–1.2 tokens/s2-bit (Q2_K), partly read from the drive as it runs
Laptop, Core i5-8250U, 8 GB DDR4-2400, SATA SSDToo slow to use0.09–0.14 tokens/s2-bit (Q2_K), partly read from the drive as it runs
Laptop, Ryzen 7 7840HS with Radeon 780M, 32 GB DDR5-5600Runs slowly5.9–9.4 tokens/s2-bit (Q2_K), partly read from the drive as it runs
Laptop, Core Ultra 7 258V with Arc 140V, 32 GB LPDDR5X-8533Runs slowly5.7–9.2 tokens/s2-bit (Q2_K), partly read from the drive as it runs
Desktop, no graphics card, 32 GB DDR5-5600Runs slowly5.6–9.0 tokens/s2-bit (Q2_K), partly read from the drive as it runs
RTX 4060 8 GB, 32 GB DDR5-5600Runs fast35–56 tokens/s2-bit (Q2_K), graphics card and system memory
RTX 3060 12 GB, 32 GB DDR4-3200Runs fast25–41 tokens/s2-bit (Q2_K), graphics card and system memory
RTX 5060 Ti 16 GB, 32 GB DDR5-6000Runs fast35–57 tokens/s3-bit (Q3_K_M), graphics card and system memory
RX 9070 XT 16 GB, 32 GB DDR5-6000Runs fast36–58 tokens/s3-bit (Q3_K_M), graphics card and system memory
RTX 5070 Ti 16 GB, 64 GB DDR5-6000Runs fast28–45 tokens/s4-bit (Q4_K_M), graphics card and system memory
RTX 3090 24 GB, 64 GB DDR4-3600Runs fast22–36 tokens/s4-bit (Q4_K_M), graphics card and system memory
RX 7900 XTX 24 GB, 64 GB DDR5-6000Runs fast35–56 tokens/s4-bit (Q4_K_M), graphics card and system memory
RTX 4090 24 GB, 64 GB DDR5-6000Runs fast35–56 tokens/s4-bit (Q4_K_M), graphics card and system memory
RTX 5090 32 GB, 96 GB DDR5-6000Runs fast48–77 tokens/s4-bit (Q4_K_M), graphics card and system memory
RTX 5090 and RTX 3090 (56 GB), 128 GB DDR5-6000Runs fast160–260 tokens/s4-bit (Q4_K_M), on the graphics card
Two RTX 3090 (48 GB), 128 GB DDR4-3200Runs fast150–245 tokens/s3-bit (Q3_K_M), on the graphics card
Mac mini, M4 Pro, 64 GBRuns fast72–115 tokens/s3-bit (Q3_K_M), in the graphics share of its memory
Ryzen AI Max+ 395, 128 GBRuns fast40–64 tokens/s8-bit (Q8_0), in the graphics share of its memory
NVIDIA DGX Spark, 128 GBRuns fast44–70 tokens/s8-bit (Q8_0), in the graphics share of its memory
Mac Studio, M3 Ultra, 512 GBRuns fast66–105 tokens/s8-bit (Q8_0), in the graphics share of its memory
RTX PRO 6000 96 GB, 512 GB DDR5-6400 in 8 channelsRuns fast145–230 tokens/s8-bit (Q8_0), on the graphics card
Server, EPYC 9755, no graphics card, 1,536 GB DDR5-6400 in 12 channelsRuns fast91–145 tokens/s4-bit (Q4_K_M), on the processor, in system memory
Server: RTX PRO 6000 96 GB, 1,536 GB DDR5-6400 in 12 channelsRuns fast145–230 tokens/s8-bit (Q8_0), on the graphics card
Data-centre server: eight H100 80 GB (640 GB)Runs fast150–240 tokens/s8-bit (Q8_0), on the graphics card

About Qwen3 Coder Next 80B-A3B

Made byQwen (Alibaba)
ReleasedJanuary 2026
Parameters79.7 billion, 3 billion per token
Longest conversation262,144 tokens
Good forCoding and agents and tools
LicenceApache 2.0

From its page on Hugging Face, read on 8 November 2026. LM Studio, Ollama and Jan load it from GGUF files such as unsloth/Qwen3-Coder-Next-GGUF. Bottleneck is not connected with Qwen (Alibaba).

How it is worked out

Writing an answer is limited by memory rather than arithmetic: for every word-piece (token) a model writes, the computer reads every weight that token uses once. So the speed is how fast the memory holding the model can be read, divided by how much is read for each token: the model’s weights at the chosen compression, plus the conversation so far. How much of its memory speed each graphics card reaches is measured, not assumed: it comes from the card’s own result in llama.cpp’s benchmark, which LM Studio, Ollama and Jan are built on. A model that does not fit in the graphics card’s memory spills into system memory, five to fifteen times slower, and one that does not fit in memory at all can be read from the drive as it runs, slower again; the estimate counts each part at its own speed, and a processor with few threads cannot use all of fast memory. Graphics built into a processor use system memory, at its speed. Reading a prompt is limited by arithmetic, so it follows the measured prompt speed.

Already running Qwen3 Coder Next 80B-A3B? See if it runs at full speed

A model that is slower than it should be is nearly always partly on the processor rather than all on the graphics card, which is several times slower — and Ollama does that without a word when something else holds the card’s memory. Bottleneck’s free app checks a model run with Ollama, LM Studio, llama.cpp, KoboldCpp or Jan: where it really runs, how fast it writes, and what your PC should manage with it. Nothing leaves your PC. Or check and fix it by hand.

It reads your parts too: the graphics card and how much memory it really has free, how much system memory is installed, the speed it runs at and in how many channels. Memory left in one channel, or below its rated speed, halves how fast a model runs from it, and Bottleneck says so. Its AI models screen then lists what runs on this PC.

The free version shows where a model runs and how fast, with no time limit and no account. Pro, $9 once, explains why it is slower than it could be and how to fix it. Compare the versions