Qwen3.8-27B on Hugging Face: the official repo, what's inside, and how to download it

Qwen3.8 27B is on Hugging Face at Qwen/Qwen3.8-27B, published by the Qwe​n org on August 14, 2026 under the Apache 2.0 license. The repo holds 55.6 GB of BF16 safetensors across 18 shards, plus the tokenizer, chat template, and config that go with it — free to download, free to use commercially, and no per-token fee. Two things trip people up: the official repo ships safetensors only, while the GGUF quantizations people run on consumer GPUs live in separate community repos; and lookalike repos appeared before release, so only the Qwe​n org's copy is real. This article is the download walkthrough: what is in the repo, the three ways to grab it, and how to verify you got the genuine weights.

The fast facts, checked August 15, 2026

• Repo — Qwen/Qwen3.8-27B on Hugging Face, publisher the Qwe​n org; mirrored at Qwen/Qwen3.8-27B on ModelScope.

• Released — weights went live August 14, 2026; timezone-bracketed coverage also cites August 13, and pre-release articles from the week before reported them as pending.

• License — Apache 2.0: download, modify, and redistribute, commercial use included.

• Size — 55.57 GB of safetensors across 18 shards (2.1–3.99 GB each); the repo page rounds the total to 55.6 GB.

• Model — 27B dense parameters (28B when you count the vision encoder), 64 layers, hidden size 5,120, vocabulary 248,320.

• Attention — hybrid: 48 Gated DeltaNet (linear-attention) layers against 16 full Gated Attention layers, with multi-token prediction trained — the 3:1 split is why 262,144 tokens of native context run on a 27B.

• Context — 262,144 tokens natively, extendable to 1,000,000 via YaRN RoPE scaling.

• Input — native image and video alongside text; returns text.

• Signal — 91,917 downloads on the model card's rolling 30-day counter, checked August 15, 2026.

Every figure above comes from the Hugging Face model page, repo tree, and config for Qwen3.8 27B, read August 15, 2026. The benchmark claims on the card (SWE-bench Pro 61.7, LiveCodeBench v6 90.3, OSWorld-Verified 84.3) are Ali​baba-reported; as of today no independent lab has reproduced them.

Why download it: the local-versus-API question

Open weights are the one category of model where the marginal cost of running a token is whatever your electricity costs. No license fee, no per-token price, no rate limit, and nothing leaves your machine. Qwen3.8 27B is Apache 2.0, so that freedom is permanent: Ali​baba cannot pull the weights, re-license them, or bill you for them.

The trade is hardware and setup. The full BF16 weights want an 80 GB-class GPU at native precision, and 55.6 GB is a serious download. If you want to evaluate the model before committing to that, the API route is faster: Qwen3.8 27B is served on OrcaRouter at Qwe​n's $0.33 per million input and $2.40 per million output tokens, passed through with no markup — and OrcaRouter also carries a rate-limited free tier for the same model, so a zero-cost smoke test needs no download at all. But the API is a convenience, not a dependency — the weights are the product, and they are free.

What is actually in the repo

The repo is not just weights. It is a complete runnable package: 18 shards plus the metadata files that Transformers, vLLM, and SGLang need. Walking it top to bottom:

• model-00001-of-00018.safetensors … model-00018-of-00018.safetensors — the weights, 2.1–3.99 GB per shard, 55.57 GB total.

• model.safetensors.index.json — maps every tensor to its shard; this is what a loader reads first.

• config.json — the architecture: 64 layers, hidden size 5,120, vocabulary 248,320, and the Gated DeltaNet / Gated Attention layout.

• tokenizer.json (12.8 MB), tokenizer_config.json, vocab.json (6.72 MB), merges.txt (3.35 MB) — the tokenizer.

• chat_template.jinja — the chat template, including the thinking block; llama.cpp needs it passed as a jinja template or the model answers you in thought tags.

• preprocessor_config.json and video_preprocessor_config.json — image and video preprocessing.

• crc32.txt — per-shard checksums; verify a download against this and a corrupt transfer stops being a mystery.

• README.md (the 65 kB model card), LICENSE (Apache 2.0), generation_config.json, .gitattributes (marks the weight files as Git LFS).

One consequence of this layout matters for the fake-repo problem below. A genuine copy of this repo is heavy and complete. A placeholder repo with "Qwen3.8" in the name and nothing but a README is not a download that failed — it is a different, empty repository.

How to download it — three ways

Method one, huggingface-cli, is the cleanest path. The model is public, so no login is required; this pulls all 18 shards plus the metadata into a folder:

huggingface-cli download Qwen/Qwen3.8-27B --local-dir Qwen3.8-27B

For a 55.6 GB transfer, the hf_transfer backend is worth installing — it parallelizes the download and usually cuts the time sharply:

pip install hf_transfer

HF_HUB_ENABLE_HF_TRANSFER=1 huggingface-cli download Qwen/Qwen3.8-27B --local-dir Qwen3.8-27B

Method two, git clone, gets you the repo as a working copy with history. Requires Git LFS:

git lfs install

git clone https://huggingface.co/Qwen/Qwen3.8-27B

Method three, the browser — open the Files tab and download shards individually. Only sane when you need one file (say, just config.json to inspect the architecture). For the full repo it is 18 manual downloads plus a checksum check; use a CLI.

Which files you should actually download

The official repo is BF16 safetensors — full precision, 55.6 GB — the right artifact if you have an 80 GB-class GPU, or want to quantize down yourself later. There is no official GGUF. The GGUF builds people actually run on consumer cards are community releases: Hugging Face lists 303 quantized models built from this base (checked August 15, 2026), and the ones runbooks point to are the unsloth and lmstudio-community builds. The rough ladder:

• BF16 safetensors — 55.6 GB, needs an 80 GB-class GPU at native precision.

• GGUF Q8_0 — roughly 29 GB, fits a 48 GB card.

• GGUF Q4_K_M — roughly 17 GB, the standard 24 GB-card choice.

• GGUF 2-bit — roughly 9 GB, squeezes onto 12 GB cards with visible quality loss.

If you want vision from a GGUF build you also need the separate mmproj file for the vision encoder, documented on each community card. For the full quantization-and-runtime breakdown — including the llama.cpp chat-template caveat — our runbook on running Qwen3.8 27B locally has the details.

How to tell the real repo from the fakes

Before the weights dropped, Hugging Face search was full of "Qwen3.8" repos with no weight files — placeholder cards and forks parked to catch people searching early. Some are still up. The verification checklist:

• Check the publisher, not the name. The genuine repo is under the Qwe​n org: Qwen/Qwen3.8-27B. A repo named Qwen3.8 27B under any other account is not the official release, however professional it looks.

• Use the official collection. Qwe​n maintains huggingface.co/collections/Qwen/qwen38; every repo in it is theirs.

• Check the license field. The real card says Apache 2.0.

• Check the size and shape. The real repo has 18 safetensors shards totalling roughly 55.6 GB, a crc32.txt checksum file, and a 65 kB README. Zero weight files means an empty repo, not a broken download.

• Treat download count as a signal, not proof. The genuine repo passed 91,000 downloads within a day, which tells you where everyone else is pointing. But a fake can be downloaded too; the publisher is the guarantee.

After the download, verify integrity: check each shard's CRC32 against crc32.txt, or load the model with Transformers and confirm the state dict loads without warnings. That catches both a corrupt transfer and a repackaged wrong model.

When downloading is the wrong move

Downloading 55.6 GB is not the right call for everyone, and the honest version of this article says so plainly.

You just want to evaluate the model. The API route is faster — a structured test costs cents and takes minutes, not a download and an afternoon of setup.

You have no GPU near 80 GB. The BF16 download is the wrong artifact for you. Pick a GGUF quant or the API.

You need verified benchmarks. Every headline figure for Qwen3.8 27B is Ali​baba-reported as of August 15, 2026. If your decision depends on numbers an independent lab has reproduced, wait for them — the weights will still be here.

You are building on a days-old model. The weights shipped August 14. OrcaRouter's model page, read today, shows a 33.3% error rate over the trailing seven days and p50 first-token latency of 225 ms — a brand-new model under early load, so treat early telemetry as provisional. Self-hosters should pin the commit they downloaded and keep a fallback; API users should keep a failover rule as the same insurance.

You want a support contract. Apache 2.0 is permissive, but a license is not an SLA. If your workload needs vendor support, the hosted API route is the safer seat.

The bottom line

The real Qwen3.8 27B is on Hugging Face at Qwen/Qwen3.8-27B, Apache 2.0, released August 14, 2026, 55.6 GB of BF16 safetensors in 18 shards. Download it with huggingface-cli or git clone, verify the publisher is the Qwe​n org, and you hold a state-of-the-art open-weights 27B that no one can take away or bill you for. If that is more commitment than your use case needs, the same model is a few cents away through the API. The weights are the thing, though — and they are free.