The Complete Qwen Guide: Every Model Explained (Qwen 3 & 3.5, 2026)

If you run open models locally, you will eventually run Qwen. Alibaba's family has quietly become the default recommendation for anyone with a consumer GPU — not because it wins one headline benchmark, but because it is the most complete open family available: sizes from a phone-friendly 0.8B up to frontier-class hundreds of billions, native vision, 201 languages, a genuine reasoning mode, one of the most permissive licenses in AI, and — crucially — a size that actually fits and runs fast on the hardware you own.

This is the complete guide to Qwen. We will trace the family from Qwen 2.5 through Qwen 3 to the current Qwen 3.5, explain every model size and which one belongs on your machine, decode the jargon (thinking mode, MoE, Gated DeltaNet, quantization), walk through running it in Ollama and LM Studio, and compare Qwen honestly against Llama, DeepSeek, and Gemma. Beginner-friendly, but detailed enough to be your Qwen reference.

Table of contents

• What Qwen is and why it matters
• The Qwen family tree
• Qwen 3 vs Qwen 3.5: what actually changed
• The Qwen 3.5 lineup, size by size
• Thinking mode explained
• Dense vs MoE: the architecture
• Multimodal: vision and 201 languages
• Context windows: 256K and beyond
• Benchmarks: how good is it really?
• Which Qwen should you run?
• Running Qwen locally
• Qwen for coding
• Qwen vs Llama vs DeepSeek vs Gemma
• Qwen vs the cloud giants (GPT, Claude, Gemini)
• The Apache 2.0 license advantage
• What to build with Qwen
• Capstone: a private multilingual document desk
• Fine-tuning Qwen
• The wider Qwen ecosystem
• Troubleshooting Qwen-specific quirks
• Frequently asked questions

What Qwen is and why it matters {#what-is-qwen}

Qwen (short for Tongyi Qianwen, and pronounced roughly "chwen") is the family of large language models developed by Alibaba Cloud. They are open-weight: Alibaba publishes the actual model files, and you can download, run, modify, and even commercialize them for free under the Apache 2.0 license. That combination — frontier-adjacent quality plus genuinely open licensing — is why Qwen has become the backbone of the local-AI world.

What sets Qwen apart from the other strong open families is completeness and fit. Meta's Llama is excellent but its open lineup skews toward larger sizes; Google's Gemma is superb at multimodal and small sizes; DeepSeek is the reasoning specialist. Qwen covers all of it — tiny models for phones, mid-size models that are the sweet spot for consumer GPUs, and giant MoE models for workstations — with strong reasoning, coding, multilingual ability, and vision across the range. When someone asks "what model should I run locally?", the honest answer for most hardware in 2026 is "a Qwen." The Hardware Analyzer will almost always put one at the top of your list.

Qwen also earns trust by being genuinely useful at small sizes. A DeepSeek R1 671B is astonishing but unrunnable at home; a Qwen 3.5 9B fits in 8 GB of VRAM and still reasons impressively. Local AI is the art of getting the most intelligence per gigabyte, and Qwen is exceptionally good at that trade — which is exactly what our who is winning the local LLM race analysis keeps finding.

It helps to know the context. Alibaba Cloud is one of the world's largest cloud providers, and it has invested heavily in making Qwen both excellent and genuinely open — a strategic choice that has paid off in mindshare. Where some labs release open weights reluctantly and with strings attached, Alibaba has shipped its mainline models under Apache 2.0 and iterated in the open, quarter after quarter. The result is a family that is not a stripped-down "community edition" of a better closed model, but the actual flagship line, released for anyone to run. That combination of quality, openness, and relentless cadence is why Qwen shows up at the top of so many recommendation lists — including, most of the time, the Hardware Analyzer's.

The Qwen family tree {#family-tree}

Qwen iterates fast. Understanding the lineage helps you read model names and know what is current.

Decoding a Qwen model name

Qwen names look cryptic until you know the pattern. Every part tells you something:

Qwen3.5 - 35B - A3B - Instruct
  │        │     │       │
  │        │     │       └── variant: Instruct (chat), Base (raw), Coder, VL (vision), Thinking
  │        │     └────────── Active params (MoE only): 3B run per token
  │        └──────────────── Total params: 35B stored in memory
  └───────────────────────── Generation: 3.5 (newer than 3, than 2.5)

• The generation — 2.5, 3, 3.5. Higher is newer and generally better; 3 has the most mature tooling today.
• Total parameters — the B number (8B, 27B, 35B). This sets memory need and, for dense models, capability.
• Active parameters — the A number (A3B, A10B). Present only on MoE models; it is how many parameters actually run per token, which sets speed. 35B-A3B = 35B in memory, 3B-speed.
• The variant — Instruct (the chat model you usually want), Base (un-tuned, for fine-tuning), Coder (programming), VL (vision-language), Thinking (reasoning-tuned).

So qwen3.5:35b in Ollama is the Qwen 3.5 35B-A3B Instruct MoE — 35B stored, 3B active, chat-tuned, with vision. Once you can read the name, the whole Model Library becomes legible at a glance.

Qwen 3 vs Qwen 3.5: what actually changed {#3-vs-35}

Both generations are excellent, and — importantly — Qwen 3 is still a first-class choice today, because tooling support for a new model generation takes time to mature. Here is the honest comparison.

Qwen 3 (April 2025) introduced the family's signature feature: a hybrid thinking mode you can toggle per message. It ships in clean, well-supported sizes — 8B, 14B, and 32B dense models, plus 30B-A3B and 235B-A22B MoE variants — with a 128K context and Apache 2.0 licensing. Every runner, quantizer, and fine-tuning tool supports it. It is the safe, boring-in-a-good-way default. Qwen 3.5 (rolled out February–March 2026) is a bigger architectural leap than the version number suggests:

• New architecture — a hybrid Gated DeltaNet + MoE design that delivers frontier performance at a fraction of the compute, with roughly three-quarters of attention being linear (which is why huge contexts stay affordable).
• Native multimodal vision across the range — these are not text-only models with a bolted-on adapter.
• ~256K context, extensible toward 1M on the larger tiers via YaRN.
• 201 languages — one of the widest multilingual footprints of any open model.
• A wider size ladder — 0.8B, 2B, 4B, 9B (dense), 27B (dense), 35B-A3B and 122B-A10B (MoE), up to a 397B-A17B flagship.

Practical advice: if you want zero friction right now, run Qwen 3 (qwen3:8b/14b/32b) — it is battle-tested and everything supports it. If you want the newest capabilities and longer context, and you are comfortable being a little closer to the cutting edge, run Qwen 3.5 (qwen3.5:9b/27b). Both are covered below. Our deep dive Qwen 3.5's native multimodal leap focuses on the new generation.

The Qwen 3.5 lineup, size by size {#lineup}

This is the heart of the guide: every current Qwen size, who it is for, and what it needs. Memory figures are approximate at Q4_K_M (the recommended default quantization).

Walking the ladder:

• Qwen 3.5 0.8B and 2B are the tiny tier — for phones, IoT, and embedded devices. The 0.8B fits in ~1 GB; the 2B in ~2.7 GB. They will not write your novel, but they handle on-device summarization, classification, and quick chat with almost no memory. Perfect for running an LLM on your phone.
• Qwen 3.5 4B is the laptop tier: ~3.4 GB, native vision, and 201 languages on any 6 GB GPU. A great everyday model for modest hardware and the best small models on low-end hardware.
• Qwen 3.5 9B is the standout. It scores 81.7% on GPQA Diamond — a hard science-reasoning benchmark — which outpaces some models more than ten times its size, while fitting in ~6.6 GB, comfortably on an 8 GB GPU. If you have a mainstream GPU, this is the model to try first.
• Qwen 3.5 27B (dense) is the best model that fits under 24 GB VRAM. At ~16.5 GB it lives happily on a single RTX 3090 or RTX 4090, leaving room for a big context — ideal for long-document analysis and multilingual work.
• Qwen 3.5 35B-A3B is a Mixture-of-Experts model: ~36B total parameters but only 3B active per token, so it runs at roughly the speed of a small model while carrying far more knowledge. At ~21.4 GB it fits a 24 GB card and outperforms most dense 70B models. (Use the official qwen3.5:35b Ollama tag — some third-party GGUFs mishandle its vision file.)
• Qwen 3.5 122B-A10B is the workstation tier — ~74 GB at Q4, needing two 24 GB+ GPUs, a single 80 GB card, or a 96 GB+ Mac Studio. Near-frontier quality for long-context enterprise work.
• Qwen 3.5 397B-A17B is the flagship, and honestly a reference model: even heavily quantized it needs ~125 GB, so it is a cloud/API tier rather than something you self-host. Alibaba lists it mainly as a cloud tag.

The takeaway: most people want the 9B or the 27B. Use the VRAM Calculator to confirm a size fits your exact card, or the Hardware Analyzer to have it pick for you.

Thinking mode explained {#thinking-mode}

Qwen's signature feature is hybrid thinking — the ability to switch, per message, between fast direct answers and slow, careful reasoning. It is the single most useful thing to understand about the family.

In practice, add /think to a message to make Qwen reason step-by-step before answering, or /no_think to force a fast, direct reply. Under the hood, "thinking" means the model generates a stretch of internal reasoning — a chain of thought — that it works through before committing to an answer. That reasoning costs time and tokens, but for hard problems it dramatically improves accuracy, in the same way you would solve a tricky puzzle on scratch paper rather than blurting the first thing that comes to mind.

The art is knowing when to spend it. "Reformat this list" needs no thinking; "find the bug in this function" or "solve this optimization problem" absolutely does. This is the same idea that powers DeepSeek R1 — reasoning models trade speed for correctness — but Qwen lets you flip it on and off, so one model serves both fast chat and hard reasoning. If the visible reasoning tokens annoy you in a UI, most front ends (including Open WebUI) can collapse them.

Dense vs MoE: the architecture {#architecture}

Two words you will keep seeing in Qwen names are dense and MoE. The difference decides how fast a model runs relative to its size.

A dense model uses all of its parameters for every token it generates. A 32B dense model does 32B parameters' worth of computation per token — powerful, but the whole thing must be loaded and active.

A Mixture-of-Experts (MoE) model is split into many small "expert" sub-networks, and a router sends each token to only a few of them. Qwen 3.5's 35B-A3B has ~36B total parameters but activates only ~3B per token (the "A3B" = "Active 3B"). So it stores 36B worth of knowledge but computes like a 3B model — giving you big-model quality at small-model speed. The catch is that all 36B must still fit in memory, even though only 3B run at once. That is why an MoE's VRAM need tracks its total size, but its speed tracks its active size.

Qwen 3.5 adds one more trick: Gated DeltaNet, a form of linear attention. In a classic transformer, the memory and compute of long context grow quadratically — double the context, quadruple the cost. Linear attention grows far more gently, which is why Qwen 3.5 can offer 256K–1M context without the memory exploding. Roughly three-quarters of its attention is linear, giving it long-context ability that would be impractical in a pure transformer. If you want the deeper theory, see MoE Models Explained and our primer on context windows.

Multimodal: vision and 201 languages {#multimodal}

Qwen 3.5 is natively multimodal — vision is built into the architecture, not added as a separate model. Feed it an image and it can describe the scene, read text (OCR), interpret a chart or table, reason about a diagram, or extract fields from a scanned document. This works from the 4B up, so even modest hardware gets a capable vision model. For prior generations, the dedicated Qwen-VL models (like Qwen 2.5 VL) provide the same capability and remain excellent OCR and document-parsing tools. See Multimodal LLMs (Vision + Text) for how to prompt vision models well.

The 201 languages matter more than they might sound. Most open models are strongest in English and a handful of major languages; Qwen's breadth makes it the default for multilingual work — translation, cross-lingual RAG, and serving users who write in languages the big Western labs under-serve. Combined with vision, a single mid-size Qwen handles an astonishing range: read a receipt in Thai, summarize a German PDF, answer a coding question, and draft an email — all locally.

Using vision is as simple as attaching an image. In Ollama, reference an image path in your prompt (What's the total on this invoice? ./invoice.png); in LM Studio or Open WebUI, click the attach button. From the API, pass the image in the images field of your message. The model can then extract structured data ("give me the line items as JSON"), answer questions about a chart, transcribe handwriting, or describe a photo — turning Qwen into a private document-scanning and image-analysis tool that never uploads your files anywhere.

Context windows: 256K and beyond {#context}

A context window is how much text a model can consider at once — your prompt, the conversation, and any documents, all counted in tokens (~¾ of a word each). Qwen 3 offers 128K tokens (~96,000 words); Qwen 3.5 offers ~256K natively, extensible toward 1M on the larger tiers.

That is genuinely useful, not just a spec-sheet number. 256K tokens is roughly a 350-page book — you can drop an entire codebase, a long contract, or a research corpus into context and ask about it directly. But remember the trade-off from the Ollama guide: context lives in memory, so a huge context uses VRAM the weights also need, and a longer prompt lengthens the initial "reading" pause (time to first token). The practical move is to set the context to what your task actually needs — big for document analysis, modest for chat — rather than maxing it out by reflex. For very large document sets, RAG (retrieving only the relevant chunks) is often smarter than stuffing everything into context. The full trade-offs are in Context Windows Explained.

A worked intuition: suppose you want Qwen to review a 200-page technical manual. At 128K context (Qwen 3) you might need to split it; at 256K (Qwen 3.5) the whole thing fits, so the model can cross-reference chapter 2 against chapter 9 in a single pass — the kind of holistic analysis chunked RAG struggles with. The cost is memory and a longer first-token wait while it reads all 200 pages. For a one-off deep review, that trade is worth it; for repeated questions over a giant library, indexing it once with RAG and retrieving on demand is faster and lighter. Qwen 3.5's linear attention softens the memory penalty either way, which is precisely what makes its long context practical rather than theoretical.

Benchmarks: how good is it really? {#benchmarks}

Benchmarks are imperfect, but they set expectations. The headline is that mid-size Qwen models now score in territory that belonged to giant models a year ago.

Two things to take from this. First, the 9B is genuinely special — an ~82% GPQA Diamond score in 6.6 GB of memory would have been science fiction not long ago, and it means real reasoning is now available to anyone with a mainstream GPU. Second, the 27B and 35B-A3B push into near-frontier territory while staying on a single 24 GB card, which is why they are the enthusiast favorites. For live, hardware-specific numbers rather than headline scores, the benchmarks page measures throughput per GPU, and the Compare tool puts two models' capability scores side by side. Always take vendor benchmarks with a grain of salt and test on your tasks — a point we make in who is winning the local LLM race.

Which Qwen should you run? {#which-qwen}

The decision comes down to your VRAM and your priorities. Here is the straight answer.

If you remember one thing: 9B for small machines, 27B for 24 GB cards, and prefer Qwen 3 today if you want maximum tool compatibility. Not sure your card fits a size? The Hardware Analyzer and Can I Run It? answer it precisely.

Running Qwen locally {#running}

Qwen runs in every local tool. The two easiest paths:

With Ollama (terminal/servers — see the Complete Ollama Bible):

# Qwen 3 (universally supported today)
ollama run qwen3:8b
ollama run qwen3:14b
ollama run qwen3:32b

# Qwen 3.5 (current generation)
ollama run qwen3.5:9b
ollama run qwen3.5:27b
ollama run qwen3.5:35b     # the 35B-A3B MoE (official tag bundles vision)

With LM Studio (GUI — see the Complete LM Studio Bible): open Discover, search "qwen", and download the largest size that shows a green "fits your machine" badge at Q4_K_M. On a Mac, prefer the MLX build for extra speed.

A few Qwen-specific running tips:

• Quantization: Q4_K_M is the default sweet spot. Step up to Q5/Q6 if you have spare VRAM; the quantization guide explains the trade-offs.
• Thinking mode: add /think for hard problems, /no_think for speed, as covered above.
• Context: raise num_ctx for document work, but watch VRAM. Qwen's linear attention makes long context cheaper than most, but it is not free.
• The 35B-A3B vision quirk: use the official Ollama qwen3.5:35b tag; some community GGUF imports fail because the separate vision file (mmproj) is not bundled.

Give it a chat UI with Open WebUI, and you have a private, multilingual, vision-capable assistant.

Qwen for coding {#coding}

Qwen has a dedicated coding line, Qwen-Coder, and it is one of the strongest open options for local programming assistance. The models are tuned on code and excel at completion, explanation, refactoring, test generation, and agentic coding tasks. Sizes range from an 8B that fits a small card to large MoE variants (80B-A3B, 480B-A35B) for workstations.

To use it as a local Copilot, run qwen3-coder in Ollama or LM Studio, start the local API server, and point Continue (VS Code) or Aider at it — your source code never leaves your machine. Give it a large context so it can see whole files, and prefer the biggest coder model that fits your VRAM. The full setup is in Local Coding Assistant Setup and Coding & Debugging Workflow, and the coding hub covers agentic setups. For serious local coding, Qwen-Coder plus a 24 GB card is a genuinely capable, entirely private pair.

Qwen vs Llama vs DeepSeek vs Gemma {#comparison}

The four families you will actually choose between, and where each wins.

Honestly, you do not have to choose just one — they are all free, and most people keep two or three around: a Qwen as the daily driver, a DeepSeek for hard reasoning, and a Gemma for the smallest devices. But if you install exactly one model family, make it Qwen. See the head-to-head DeepSeek R1 vs GPT-4o and Llama 4 review for more.

Qwen vs the cloud giants (GPT, Claude, Gemini) {#vs-cloud}

The question everyone asks: "is a local Qwen as good as ChatGPT?" The honest answer is nuanced, and it is more encouraging than you might expect.

On peak capability, the very largest closed models — the frontier GPT, Claude, and Gemini tiers — still lead, especially on the hardest reasoning, the longest agentic tasks, and the most obscure knowledge. If you need the single most capable model on Earth for a genuinely hard problem, a frontier cloud model is still ahead. There is no point pretending otherwise.

But that gap matters far less than it used to, for two reasons. First, most real tasks do not need frontier capability — drafting, summarizing, translating, coding help, document Q&A, and everyday reasoning are handled excellently by a Qwen 3.5 27B, which you can run on a single 24 GB card. Second, the things Qwen gives you that no cloud model can are often the deciding factors:

• Privacy. Your prompts never leave your machine. For confidential work — client data, medical notes, unreleased code, personal writing — that is not a nice-to-have, it is the whole ballgame. A frontier model you cannot legally or safely send your data to is worth less than a local model you can.
• Cost. After the hardware, every query is free. Heavy users save thousands versus per-token or per-seat pricing — the math is in the Cost Calculator and cloud vs local comparison.
• No limits, no lock-in, no deprecation. No rate caps, no surprise price changes, no model being retired out from under you. The weights are yours forever.
• Offline. It works on a plane, in a lab, in a bunker — anywhere, as covered in running LLMs offline.

The pragmatic setup many people land on: run Qwen locally for the 95% of work that is private or routine, and keep a cloud model in the same Open WebUI dropdown for the rare frontier task. You get privacy and economy by default, and peak capability on demand. For the broader picture of how close open models have come, see who is winning the local LLM race in 2026 and DeepSeek R1 vs GPT-4o.

The Apache 2.0 license advantage {#license}

Qwen's Apache 2.0 license is a quiet superpower, especially for anyone building a product. It means:

• Commercial use with no royalties or fees — ship it in a paid product, no strings.
• No attribution in outputs — your app need not say "Powered by Qwen."
• Modification and redistribution — fine-tune, distill, and adapt; the result is yours.
• No deprecation risk — the weights you download today work forever, regardless of Alibaba's future decisions.

This is a meaningful contrast with some other families that carry community-license conditions or usage caps. For a startup or enterprise, running Qwen locally means you own the capability instead of renting API access — the argument developed in why companies fine-tune open models instead of using an API and the open LLM licenses for business reference. Combined with local execution, it also keeps data on-premise, which matters for privacy and compliance.

What to build with Qwen {#use-cases}

Qwen's breadth means one family covers most of what people actually want from local AI. A few high-value use cases:

• A multilingual assistant. With 201 languages, Qwen is the go-to for translation, cross-lingual document work, and serving users in languages the Western labs under-serve. A mid-size Qwen switches between languages mid-conversation without breaking stride.
• A private document analyst. Point Qwen at your PDFs and contracts via RAG or its long context, and interrogate them in plain language — safely, since nothing leaves your machine. This is the backbone of privacy-safe document analysis.
• A reasoning engine for hard problems. Flip on thinking mode for math, logic, planning, and analysis where correctness beats speed.
• A coding partner. Qwen-Coder plus Continue or Aider gives you a private Copilot (Local Coding Assistant Setup).
• A vision tool. OCR receipts, parse scanned forms, read charts, and describe images — all locally with a multimodal Qwen (Multimodal LLMs).
• The brain of an agent. Qwen's tool-use ability makes it a solid core for autonomous agents that call functions and take actions.
• An everyday writing and productivity aid. Email, summaries, rewrites, brainstorming — the daily-driver stuff covered in Personal Productivity with LLMs.

The unifying theme is that a single, free, permissively-licensed family handles this entire range on hardware you already own — the essence of local LLM use cases for 2026.

Capstone: a private multilingual document desk {#capstone}

Let us assemble something that plays to Qwen's strengths — a document assistant that reads files in many languages and answers with citations, entirely offline.

1. Pick the model. On a 24 GB card, qwen3.5:27b is ideal — strong reasoning, native vision (so it reads scanned pages too), and long context for whole documents. On 8–12 GB, qwen3.5:9b or qwen3:14b works well. Pull it in Ollama. 2. Add a local embedding model for retrieval, keeping everything offline:

ollama pull qwen3.5:27b
ollama pull nomic-embed-text

3. Front it with Open WebUI. Install Open WebUI, set the embedding model, and create a Knowledge collection. Upload your documents — in any of Qwen's 201 languages. Because Qwen 3.5 is multimodal, scanned PDFs and images work too. 4. Tune the assistant. Create a custom model with a system prompt like: "You are a careful multilingual analyst. Answer only from the provided documents, quote the relevant passage in its original language, then explain in English. If it isn't there, say so." Set temperature to 0.2 and enable /think for complex questions. 5. Use it. Ask questions across your whole document set. Qwen retrieves the relevant passages, reasons over them, and answers with citations — translating and summarizing across languages as needed, without a single byte leaving your machine.

That is a genuinely capable, private, multilingual research desk built from free software and a free model. Swap in DeepSeek R1 for the hardest analytical questions, or scale the whole thing onto a home server for the household. From here you can grow it into a full local RAG pipeline or an agent.

Fine-tuning Qwen {#fine-tuning}

Because Qwen is open and permissively licensed, it is a favorite base for fine-tuning — teaching the model your domain, style, or task with your own data. The common approach is LoRA/QLoRA, which adapts a model cheaply (often on a single consumer GPU) rather than retraining it from scratch. Qwen's range of sizes helps here: fine-tune a small Qwen for a narrow task and it can outperform a much larger general model on that task, while running far faster.

The workflow: pick a base size that fits your GPU, prepare a dataset (see the Datasets explorer and Which Dataset Should I Use?), run a LoRA fine-tune, then convert the result to GGUF and run it in Ollama with a Modelfile ADAPTER. The beginner-friendly walkthrough is Fine-Tune Your First LLM in 1 Hour, with the deeper SFT/LoRA/DPO theory in Fine-Tuning with Datasets and our overview of how to fine-tune a local LLM. Fine-tuning is how a general Qwen becomes your model.

The wider Qwen ecosystem {#ecosystem}

Qwen is not just a set of chat models — it is an ecosystem, and understanding its edges helps you pick the right tool:

• Qwen (Instruct) — the general chat/reasoning models this guide centers on.
• Qwen-Coder — programming-tuned models, one of the strongest open coding options.
• Qwen-VL — vision-language models for OCR, document parsing, and image understanding (now largely folded into native 3.5 multimodality).
• Qwen embeddings — dedicated embedding models for RAG and semantic search; pair them with a chat Qwen for a fully-Qwen pipeline.
• Qwen Audio — models that understand speech and audio, for transcription and audio Q&A.

Beyond Alibaba's own releases, Qwen is one of the most-forked base models in open AI. A huge share of community fine-tunes, distillations, and specialized models are built on a Qwen base — including some DeepSeek R1 distills, which distilled R1's reasoning into Qwen backbones. When you browse the Datasets explorer or Hugging Face, you will constantly see "based on Qwen." That gravitational pull matters practically: it means broad tooling support, abundant quantizations, plentiful fine-tuning recipes, and a large community solving problems you might hit. Choosing Qwen is choosing the center of the open-model ecosystem, which is part of why it is such a safe default. Our state of local AI in 2026 traces how central the family has become.

Troubleshooting Qwen-specific quirks {#troubleshooting}

Frequently asked questions {#faq}

Is Qwen free to use commercially?

Yes — Qwen 3 and 3.5 are Apache 2.0 licensed, which permits commercial use with no fees or attribution requirements. Always confirm the license on the specific model card, but the mainline Qwen models are among the most business-friendly open weights available.

Which Qwen is best for a beginner?

qwen3:8b in Ollama or LM Studio — it is small, fast, universally supported, and genuinely capable. Move up to the 14B or 27B as your hardware allows. The Hardware Analyzer picks the right size for your machine.

Is Qwen better than Llama or Gemma?

For most local use in 2026, Qwen is the best all-rounder thanks to its size range, multilingual ability, native vision, and license. Gemma edges it on the very smallest multimodal sizes; DeepSeek edges it on the hardest reasoning. There is no universal winner — test on your tasks.

Does Qwen run on a Mac?

Yes, and well — Apple Silicon's unified memory suits it, and LM Studio offers faster MLX builds on Macs. A 32–64 GB Mac runs the 27B comfortably. See Best Mac for Local LLMs.

What is the difference between Qwen 3 and Qwen 3.5?

Qwen 3.5 is newer with a better architecture (Gated DeltaNet + MoE), native vision, longer context (256K–1M), and 201 languages. Qwen 3 is a little older but has broader, more mature tooling support today. For zero friction, run Qwen 3; for the latest capabilities, run Qwen 3.5.

Can Qwen see images?

Yes — Qwen 3.5 is natively multimodal from the 4B up, and prior-generation Qwen-VL models handle vision too. You can do OCR, chart reading, and document parsing locally. See Multimodal LLMs.

How much VRAM do I need for Qwen?

Roughly the model's active size in GB at Q4, plus context: ~6.6 GB for the 9B, ~16.5 GB for the 27B, ~21.4 GB for the 35B-A3B. The VRAM Calculator gives exact numbers per model and quant.

Is Qwen good for coding?

Yes — the dedicated qwen3-coder line is one of the best open coding models. Pair it with Continue or Aider via a local API server for a private coding assistant.

What does "A3B" or "A22B" mean in a Qwen name?

It is the number of active parameters in a Mixture-of-Experts model. 30B-A3B means 30B total parameters stored in memory, but only ~3B run per token — so it needs 30B of VRAM but runs at roughly 3B speed. See the architecture section.

Should I use the "Base" or "Instruct" version?

Almost always Instruct — it is tuned to follow instructions and chat. "Base" models are raw and mainly useful as a starting point for your own fine-tuning. Ollama and LM Studio default to the Instruct builds.

How often does Qwen release new models?

Frequently — Alibaba ships new sizes and generations several times a year, often in waves (small sizes following the flagship by weeks). The Model Library and our reports track the latest; set up new-model alerts if you want to be notified.

Can I run Qwen on just a CPU?

Yes, for the small sizes (0.8B–4B). A modern CPU handles a 2–4B Qwen at a readable pace; larger sizes really want a GPU. See running on laptops and low-power devices.

Is Qwen safe and trustworthy to run?

The weights run entirely on your hardware with no network calls, so there is no data exfiltration risk from inference itself — a key benefit of local models. As with any model, apply your own judgment to its outputs. For regulated settings, the on-premise, auditable deployment is exactly why organizations choose local Qwen; see private AI for business.

Verdict and where to go next

Qwen is the most complete open-model family in 2026, and for the majority of people running AI locally it is simply the right default. The 9B brings real reasoning to an 8 GB GPU; the 27B delivers near-frontier quality on a single 24 GB card; the whole range is multilingual, increasingly multimodal, and free to use commercially. Whether you run the battle-tested Qwen 3 or the cutting-edge Qwen 3.5, you are getting more capability per gigabyte than any other family reliably offers.

To put it to work:

• Run it: the Complete Ollama Bible (terminal) or Complete LM Studio Bible (GUI).
• Give it an interface: the Complete Open WebUI Guide.
• Compare the alternative: the Complete DeepSeek Guide for hard reasoning.
• Get the hardware: the Complete RTX 5090 Guide and Best GPU Buyer's Guide.

---

See every Qwen variant and its specs → Qwen on the Model Library Check which Qwen your machine can run → Hardware Analyzer Compare local Qwen costs to cloud APIs → Cost Calculator