Qwen 3.8 27B locally: Ollama installation and VRAM

#The verdict in 30 seconds

Qwen 3.8 27B installs with one command: “ollama run qwen3.8:27b”. The default package (Q4_K_M) takes up 18 GB and requires a 24 GB graphics card—RTX 3090, 4090, 5090—or a Mac Apple Silicon with at least 32 GB of unified memory for comfortable use. Below that, the model still runs, but some layers spill over to the CPU and throughput collapses.

What it is

A dense model with 27 billion parameters, native vision-language support (images and videos), 262,144-token context, under the Apache 2.0 license—so it can be used commercially without restrictive clauses.

The realistic prerequisite

24 GB of VRAM or 32 GB of unified memory for the Q4_K_M version. 30 GB of files and ~40 GB of VRAM for Q8, 56 GB for BF16.

The command

ollama pull qwen3.8:27b puis ollama run qwen3.8:27b. Sur Mac, préférez le tag -mlx, optimisé Metal.

The #1 trap

The advertised context is 256k, but Ollama applies a much smaller default window and truncates without warning. You need to set num_ctx manually.

Pitfall No. 2

“Thinking” mode is enabled by default and consumes many tokens before responding. Locally, lower reasoning_effort or disable it for simple tasks.

#What Qwen 3.8 27B really is

Unlike the Mixture-of-Experts trend, Qwen3.8-27B is a dense model: all 27 billion parameters are activated for every token. That makes its memory usage predictable—no pleasant surprises in throughput, no unpleasant surprises in VRAM—and it also explains its lower local throughput than a comparably sized MoE.

Architecture

64 layers organized into 16 blocks of “3 × (Gated DeltaNet → FFN) followed by 1 × (Gated Attention → FFN).” A hybrid attention design: most layers use memory-efficient linear attention, interspersed with true attention layers for precision.

Terms

Native vision-language: still images, documents, scientific diagrams, and videos. This is not an adapter bolted on afterward.

Context

262,144 tokens natively, extendable to 1,000,000 via YaRN—but only on vLLM, SGLang, or TokenSpeed, not through Ollama.

License

Apache 2.0. Commercial use permitted, no user threshold as with Llama, and no use clause as with Gemma.

Special feature

The model is trained with Multi-Token Prediction (MTP)—hence the Ollama “mtp” tags, which speed up generation on engines that know how to use them.

#The hardware you need, tag by tag

The Ollama library publishes twelve variants. Download size is not the VRAM required: you also need to add the KV cache, which grows with context length, and the vision encoder. Allow 15 to 25% of headroom above the file size.

For throughput, our estimates for a dense 27B in Q4 are around 14 tokens/second on a mid-range configuration and 22 tokens/second on recent high-end hardware. These are calculated estimates, not measurements: the “thinking” mode enabled by default can also double the perceived time before the first response line.

#Install Qwen 3.8 27B with Ollama

1. 01
   Update Ollama

   The hybrid layers and vision parser of Qwen 3.8 require a recent version of Ollama. A version older than August 2026 will return an architecture error or a misleading “model not found.” Reinstall from the official site, or rerun the installation script on Linux.
2. 02
   Download the model

   18 GB are transferred: make sure there is room on the system drive, where Ollama stores its blobs. The pull can resume if the connection drops.
3. 03
   Start a first exchange

   The first response is slower while the weights are loaded into memory. If startup takes more than a minute, that indicates an overflow onto the processor.
4. 04
   Check where the model is running

   The ollama ps command displays the GPU/CPU split. Until you see 100% GPU, every token is expensive — drop down one quantization level or reduce the context.

# 1. Récupérer le modèle (18 Go)
ollama pull qwen3.8:27b

# 2. Discuter avec
ollama run qwen3.8:27b

# 3. Vérifier la répartition GPU / CPU
ollama ps

#On Mac Apple Silicon: choose the MLX variant

Ollama publishes an MLX build compiled for Apple's Metal engine. At the same file size (18 GB), it makes better use of unified memory and delivers noticeably higher throughput than generic GGUF on M3, M4, and later chips.

# Build MLX (Metal) — recommandé sur M1/M2/M3/M4
ollama run qwen3.8:27b-mlx

# Mac 64 Go et plus : qualité supérieure
ollama run qwen3.8:27b-mxfp8

16 GB Mac

Insufficient. macOS only makes about 70% of unified memory available to the GPU: the model swaps and becomes unusable.

Mac 24 GB

It just fits with a short context and no other demanding application open. Acceptable for testing, frustrating in everyday use.

32 GB Mac

The real entry point: the model fits, leaving room for the KV cache and the system.

Mac 64 GB and up

Comfortable, and lets you run in mxfp8 or work with long documents.

#The 256k context trap

This is the mistake almost all first-time users make. The model advertises 262,144 tokens, but Ollama applies a much shorter context window by default: beyond that limit, the beginning of your document is simply cut off, with no error message. The model confidently answers about text it has not seen in full.

# Dans une session interactive
/set parameter num_ctx 32768

# Ou via un Modelfile réutilisable
cat > Modelfile <<'EOF'
FROM qwen3.8:27b
PARAMETER num_ctx 32768
PARAMETER temperature 1.0
PARAMETER top_p 0.95
PARAMETER top_k 20
EOF
ollama create qwen38-long -f Modelfile

As for the advertised million tokens: it relies on a YaRN extension, configured in the model's configuration file, and is supported only by vLLM, SGLang, or TokenSpeed. There is currently no way to access it from Ollama.

#Thinking mode and sampling parameters

Qwen 3.8 thinks before answering: it produces a reasoning block between « think » tags, followed by the final answer. This is enabled by default, and it explains most of the perceived latency. On engines that support it, the depth is controlled with reasoning_effort — xhigh by default, followed by medium and low.

Short local tasks

Set reasoning_effort to low or medium: for rewriting or extraction, extended reasoning does not change quality and triples the wait time.

Agentic tasks

Keep xhigh. Alibaba notes that reducing the effort leads to insufficient analysis, and therefore retries—the gain per turn is canceled out by failures.

Responses that get stuck in a loop

Increase presence_penalty (between 0 and 2). Above 1.5, the model starts mixing languages.

Output polluted by reasoning

If your application displays reasoning tags, it is not separating reasoning_content from the final content. Disable reasoning for this use case instead of filtering the text afterward.

#Analyze an image or document

Vision is native: screenshots, whiteboard photos, technical diagrams, scanned pages. On the command line, just provide the file path in the prompt; through the API, images are passed as base64 in the field provided by Ollama.

ollama run qwen3.8:27b
>>> Décris ce schéma et liste les valeurs lisibles ./schema.png

#What the reported scores are worth

The claimed leap over Qwen 3.6–27B, the same-size model from the previous generation, is substantial — especially for agentic coding and computer use. Here are the figures published by Alibaba, keeping in mind that they have not been independently reproduced.

What to take away for local use: the gains are concentrated in long, tool-driven tasks — operating a terminal, fixing a repository, and chaining steps without going off track. In a simple conversation or summary, the difference from the previous generation will be far less noticeable than these figures suggest.

#Should you move on from Qwen 3.6, Gemma 4, or gpt-oss?

You are on Qwen 3.6-27B

Yes, the update is worth it: same memory footprint, same permissive license, clear gains in coding and agentic tasks. Keep the old tag while you validate your prompts; the outputs change in style.

You're on Gemma 4 26B

Qwen 3.8 retains the edge in coding and agentic capabilities; in terms of licensing, both are now Apache 2.0, with Gemma having become permissive in April 2026. Gemma 4 (MoE 26B-A4B, multimodal) often remains more natural in conversational French and is faster to start.

You're running gpt-oss-20b

Two philosophies: gpt-oss is lighter and faster, Qwen 3.8 sees images, handles a much longer context, and targets long-running tasks. Choose based on the available VRAM.

You're mainly looking to code

A specialized 30B code model in MoE remains faster for autocompletion. Qwen 3.8 27B makes sense when the agent needs to read, plan, and modify multiple files.

You have less than 24 GB

Don't force it. A 12-14B model in Q4 will give you a better experience than a 27B model that spills over onto the CPU.

#Troubleshooting

“model not found” on pull

Ollama is too old to know about this repository, or the tag is misspelled—it is “qwen3.8:27b,” with a dot, not a hyphen. Update Ollama and then run it again.

Architecture error during loading

Same cause: the hybrid layers of Qwen 3.8 are supported only by recent engine versions.

Very slow generation (less than 5 tokens/s)

The model spills into RAM. Check with ollama ps: if the split is not 100% GPU, reduce num_ctx, close other GPU applications, or switch to a smaller model.

Responses that ignore the beginning of the document

Context is silently truncated. Set num_ctx to match the actual size of your input, or split the document.

The model “thinks” forever

reasoning_effort is too high for the task. Lower it to medium or low, or disable reasoning for simple tasks.

The image is ignored

The file path must be accessible from the Ollama process, and the vision parser requires an up-to-date version. Test with a simple local image before blaming the model.

Not enough disk space

Between blobs and the cache, plan for twice the advertised size during installation. A pull interrupted by a full disk leaves fragments: ollama rm then pull again.

#Go further

This guide assumes a working Ollama installation and a deliberate quantization choice. These pages provide additional coverage:

Install Ollama

The prerequisite if the engine is not yet set up on Windows, macOS, or Linux—and the update, required for Qwen 3.8.

Choose your quantization

To make informed choices between Q4, Q8, and BF16: what each step costs in memory and delivers in quality.

Qwen 3.8: the open-weights timeline

Where the confusion between the Max in the API and the open 27B comes from, and what was actually announced when.

Which LLM for 24 GB of VRAM

The comparison of models that fit on a 24 GB card, if you're still deciding between Qwen 3.8 27B and a lighter alternative.