Qwen3.8-27B Hardware Requirements: RAM, VRAM & GGUF

Compare more models: Can You Run It at Home? lists every Kingy verdict by machine type, from a 16GB laptop to a 512GB Mac Studio.

Related Kingy decision guides

• How to Build a Private Local Coding Agent with Qwen3.8-27B
• Which Qwen3.8-27B GGUF Should You Download? Q2–Q8 Quantization Guide
• Can You Run Kimi K3 Locally? The Brutal Hardware Math Behind Its 2.8T Open Weights

Testing disclosure: This began as a source-audited launch-day hardware guide. Kingy later tested the linked Qwen3.8-27B and RTX 4090 24GB configuration; that observed result is shown in the verdict box above and documented in Local Lab. We have not independently benchmarked every hardware tier in the tables. Official specifications, repository file sizes and hardware specifications are treated as confirmed facts. Launch-day community measurements are labelled as such. Recommendations and memory-headroom figures are editorial judgments.

You can run Qwen3.8-27B on a laptop. You can also make a 27-billion-parameter model crawl across a mixture of laptop VRAM and system RAM at four tokens per second and call that “running.” Those are not the same achievement.

Choose the file and context before buying hardware. A 24GB device is a candidate for a four-bit build with limited headroom; 32GB is a more forgiving starting point, and 48–64GB leaves room for larger quants, vision and other applications. NVIDIA Blackwell serving and an ordinary GGUF use different kernels and checkpoints, so a fast result for one cannot establish the speed of the other.

If you already own a 12GB or 16GB GPU, try the model before buying anything. If you are shopping specifically for Qwen3.8-27B, do not buy a 16GB computer merely because a two- or three-bit file can be squeezed into it.

Qwen3.8-27B local hardware requirements at a glance

What Qwen3.8-27B actually is

Qwen3.8-27B is a dense, open-weight vision-language model: all 27 billion language parameters participate in generation, unlike a mixture-of-experts model that activates only a subset.

The official Qwen model card lists 64 language layers, a 262,144-token native context window, optional extension to one million tokens, native image and video understanding, thinking and non-thinking modes, and a trained multi-token-prediction head. It uses a hybrid layout: 48 Gated DeltaNet layers and 16 full-attention layers. The model is released under Apache 2.0.

For benchmark methodology and model comparisons, see Kingy.ai’s launch-day Qwen3.8-27B analysis.

The official Hugging Face checkpoint (Qwen/Qwen3.8-27B, revision 1d4bf0f) is BF16 and contains about 55.6GB of weights. That is why quantization—the process of storing weights at lower precision—is what lets it fit laptop-sized memory. Local does not have to mean compressed: those BF16 weights fit on a 128GB or larger unified-memory machine, though slowly.

The exact memory ladder

The following file sizes were read from Unsloth repository revision 4ca720788d1e on October 17, 2026. Sizes are decimal GB. The practical-memory bands are editorial planning allowances for modest context, runtime and the operating system, not measured minima or quality rankings. The current catalogue contains dynamic UD- variants; do not silently substitute them for an older standard file used in a retained test.

The separate BF16 vision projector is 0.931GB. Optional MTP files, cache and working buffers add further allocations. In this pinned October 17 table, the 17.56GB Q4 XL figure is only the weight payload; the November 12 download is 17.66GB.

Check Qwen3.8-27B on your hardware. Compare calculated memory fit for five NVIDIA and Apple Silicon setups, then adjust context and runtime for your computer. Open Qwen3.8-27B requirements →

The 262K context trap

The advertised context window is a capability, not a sensible default.

SGLang documents 16 full-attention layers with four KV heads at head dimension 256. Calculating K and V at two bytes per BF16 value gives 65,536 bytes per token. The table uses binary memory units: for 8,192 tokens this is 0.5GiB, or 0.25GiB with one-byte FP8 cache. These are attention-cache calculations, before Gated DeltaNet state and other allocations. Current geometry and pool guidance

These estimates exclude Gated DeltaNet state, vision and runtime workspaces. Parallel requests also need separate cache. Start at 8K or 16K, then increase context after the model runs reliably. A 24GB device that holds Q4 at 8K may fail at the full native window.

Worked memory budget: The pinned October 17 Unsloth UD-Q4_K_XL file is 16.353 GiB. Using F16 attention cache and Qwen’s published geometry, add 0.5 GiB at 8,192 tokens or 2 GiB at 32,768: 16.853 GiB and 18.353 GiB respectively, before recurrent state, runtime buffers, OS and other overhead. Two simultaneous 32K sequences need 4 GiB of attention cache. A 16 GiB discrete GPU is therefore a different budget from a 16 GB unified-memory Mac, whose OS shares that total. Actual placement and overhead depend on the runtime. For the November 12 replacement, 17,659,407,264 bytes ÷ 2³⁰ gives 16.447 GiB of weights. Adding the same attention-cache estimates gives 16.947 GiB at 8K or 18.447 GiB at 32K, before the other allocations above. These are calculations, not observed fit results. Download the dated November 3 memory budget, which retains its older file.

Before choosing a large context, check the GGUF’s declared training context locally, then confirm the runtime’s actual allocation in its settings or startup log. Training context, allocated context and KV-cache precision are separate inputs; the header does not establish how much memory your run will use.

Can an ordinary laptop run it?

A launch-day community test on an RTX 5070 Ti laptop used 12GB of VRAM, 32GB of system RAM, the 17.9GB dynamic Q4 (Kingy could not confirm the exact file or runtime), an 8K context, Q8 cache and automatic CPU/GPU offload. It produced approximately 3.26 tokens per second on a longer answer and 4.42–4.53 tokens per second on short factual and coding responses. Prompt processing was reported at 20–27 tokens per second.

That is legitimate local inference. It is also a patience-first experience. The GPU held about 11GB while the remaining weights ran from system memory. Treat it as evidence that a 12GB laptop can participate, not as evidence that 12GB is the right buying target.

NVIDIA’s official laptop specifications list 12GB for the RTX 5070 Ti Laptop GPU, 16GB for the RTX 5080 Laptop GPU and 24GB for the RTX 5090 Laptop GPU. The practical split is straightforward:

• 12GB: Q4 requires offload; three-bit is more self-contained but lower quality.
• 16GB: a three-bit build can fit more cleanly; the best Q4 files still spill beyond VRAM once overhead is counted.
• 24GB: Q4 is practical, Q5 is a tight fit, and Blackwell-native NVFP4 becomes possible with the right runtime.

Laptop names hide power limits. Capacity decides whether the model fits; wattage and cooling decide how fast it stays.

Desktop RTX 5090 versus RTX 5090 laptop

These are not the same local-AI product.

The desktop RTX 5090 has 32GB of GDDR7 and 1,792GB/s bandwidth. The laptop GPU has 24GB and 896GB/s; its speed varies with thermal and power limits.

The desktop card holds Q6 with useful context. Q8 at 29–31.5GB is uncomfortable on a 32GB card once cache and runtime overhead arrive.

The current SGLang cookbook names separate RadixArk and NVIDIA NVFP4 exports and reports a v0.5.19 serving/quality sweep. Its NVIDIA export is about 21.9GB on disk; the BF16-head RadixArk variant is larger. The current Unsloth NVFP4 repository totals 23.42GB of safetensors, while the official FP8 repository totals 30.87GB. These are different artifacts, not a universal 16.5GB NVFP4 download or a proven runtime-memory requirement.

NVIDIA’s US page lists the RTX 5090 at $1,999; the marketplace capture shows both an Add to Cart label and Out of Stock, so it does not establish an available purchase. Treat this as a manufacturer listing, not a current street-price quote. Check the exact seller and stock.

Mac mini: capacity first, bandwidth second

Apple’s current lineup is M6 and M5 Pro. The M6 mini offers up to 32GB unified memory; its 24GB/32GB options list 170GB/s bandwidth. M5 Pro lists 307GB/s and offers 48GB or 64GB configurations. Current Apple specifications

This answers the M6 question by capacity, not by inventing a token rate. Kingy has not measured Qwen3.8-27B on an M6 mini for this guide. A higher chip number does not supply more memory: a 16GB M6 remains a tighter host than a 48GB older Pro.

Existing M4 machines remain relevant. Apple’s archived 2024 specifications list 120GB/s for M4 and 273GB/s for M4 Pro. Keep a suitable machine you own and test the exact file before replacing it. The earlier $2,499 M4 Pro quote is superseded as buying advice; use the current configurator for the memory, storage, country and tax treatment you will buy. We have not verified a new configured dollar price.

Mac Studio: faster, quieter and easy to overbuy

The current Studio uses M5 Max or M5 Ultra. Apple lists 460GB/s for the base M5 Max and 614GB/s for the 40-core-GPU option; M5 Ultra lists 1.2TB/s. These are hardware specifications, not measured model generation rates. Current Studio specifications

The earlier M4 Max/M3 Ultra table described the 2025 hardware. Those machines can remain useful, but they are no longer this guide’s current retail lineup. The old $2,499 base-Studio quote is superseded. Compare the exact current Studio configuration; no new price or measured Mac speed is claimed here.

Windows and Linux GPU recommendations

NVIDIA’s official RTX 30-series and RTX 40-series specifications confirm 24GB on the RTX 3090 and RTX 4090, 16GB on the RTX 4070 Ti Super and optional 16GB on the RTX 4060 Ti. Here is what that capacity buys:

If you own a 24GB 3090 or 4090, keep it. If buying used, test the card and account for power, case space and warranty.

Multiple GPUs add memory only when the runtime splits the model; PCIe traffic, heat and complexity remain.

AMD and CPU-only: viable, but mind the software path

AMD’s Ryzen AI Max+ 395, better known as Strix Halo, is the most interesting alternative to Apple’s unified-memory approach. AMD specifies up to 128GB of LPDDR5X-8000 memory and 256GB/s bandwidth on its Ryzen AI Halo platform.

A launch-day 128GB Strix Halo community benchmark reported 10.5 generated tokens per second for dynamic Q5 (Kingy could not confirm the exact file or runtime) at fresh context and 9.4 at 32K; Q8 produced 7.5 and 6.9 respectively. It is usable, but not RTX 5090-fast.

Discrete 16GB AMD GPUs face the same fit problem as NVIDIA cards. A 24GB Radeon can hold Q4/Q5, but verify ROCm or Vulkan support for the exact operating system.

CPU-only is a fallback. A 32GB PC can run Q3/Q4 with discipline; 64GB is safer. SSD offload may prevent a load failure but is far slower than RAM. Speed depends heavily on memory bandwidth and CPU features, so there is no honest universal token rate.

The five configurations I would choose

Cheapest machine that can load it

Whatever 16GB or 12GB-GPU computer you own, using two or three bits or Q4 with CPU offload. This is an experiment, not a buying recommendation.

Cheapest configuration Kingy.ai recommends

A 24GB discrete GPU running dynamic Q4 at 8K is a candidate, including an RTX 3090/4090 or RTX 5090 laptop. A 24GB unified-memory Mac shares its memory with the OS and applications; check free memory and consider a smaller quant if Q4 does not fit.

New Mac shortlist

For a new Mac, compare an M6 mini with 32GB against an M5 Pro mini with 48GB or 64GB. Choose on configured cost, memory left for other applications and a verified runtime path. An existing 48GB M4 Pro remains a useful test candidate; a newer badge alone does not justify replacing it.

Best-value NVIDIA system

An existing or carefully purchased used RTX 3090 24GB system. It is slower than a 4090/5090, but capacity matters more than gaming-generation prestige.

Fastest sensible single-GPU build

A desktop RTX 5090 with substantial host RAM is an optimized serving candidate. Pair the exact NVFP4 export with its documented runtime. Use a current Q4/Q6 GGUF when a simpler llama.cpp workflow matters more. The historical 200+ tok/s report came from the SGLang team; Kingy has not confirmed its checkpoint, MTP or batch settings, so treat it as one configuration’s result, not the expected speed of every 5090 build.

How to run Qwen3.8-27B locally

Easiest route on macOS and Windows: Unsloth Desktop

The current Unsloth guide documents Desktop and llama.cpp routes. Use the 27B instructions and repository; files for other Qwen sizes have different requirements. Start with a short text task, 8,192 context tokens and one session; record the app/runtime version and exact quant before changing settings.

1. Download Unsloth Desktop from the official Unsloth site.
2. Search for unsloth/Qwen3.8-27B-GGUF.
3. Start with UD-Q4_K_XL on 24GB+ systems or UD-Q3_K_XL if memory is tight; reserve at least 25GB of free disk for Q4 plus its vision projector and working room.
4. Set context to 8,192 tokens for the first run.
5. Leave thinking enabled for difficult coding or reasoning; disable it for short direct answers.
6. Confirm GPU or Metal acceleration, then increase context while watching memory. Do not jump directly to 262K.

The official Qwen sampling settings are temperature 1.0/top-p 0.95 for thinking and temperature 0.7/top-p 0.8 for non-thinking. Unsloth can set these automatically.

Linux or advanced users: llama.cpp text-only route

The commands below adapt the 27B download and llama-cli pattern in the current Unsloth guide, with an 8K first-run context. Use a llama.cpp build that supports this model and quant; record its commit and backend. Kingy’s RTX 4090 test used commit 6d05498 with CUDA. These commands were source-checked, not executed as a new Kingy inference test.

pip install -U "huggingface_hub[cli]"

hf download unsloth/Qwen3.8-27B-GGUF \
  --local-dir Qwen3.8-27B-GGUF \
  --include "*UD-Q4_K_XL*" --revision 4ca720788d1e01f1bff70c033e0d0028fd02e502

./llama-cli \
  --model Qwen3.8-27B-GGUF/Qwen3.8-27B-UD-Q4_K_XL.gguf \
  --ctx-size 8192 \
  --temp 1.0 \
  --top-p 0.95 \
  --top-k 20 \
  --min-p 0.0

This is the text-only starting point. Local image input also requires the roughly 0.93GB mmproj file and a multimodal-capable frontend such as llama.cpp’s current multimodal tooling. Do not assume the vision projector is bundled with the language GGUF.

Thinking is on by default. Compatible API clients disable it by passing enable_thinking: false through the model’s chat-template options. Because client syntax varies, use the current Qwen or runtime documentation rather than adding /no_think from an older Qwen release.

NVIDIA Blackwell: optimized NVFP4 route

Runtime support is artifact-specific. Unsloth currently documents its NVFP4 export for vLLM and expressly says SGLang is not supported for that export. SGLang’s own cookbook instead names its RadixArk/NVIDIA exports. Do not cross those recipes. This is the minimal command for the Unsloth path; use the linked guide for its version and hardware requirements:

vllm serve unsloth/Qwen3.8-27B-NVFP4

MTP can add memory and requires a compatible draft/head and runtime build. SGLang’s current recipe has explicit cache-pool and speculative-decoding pins; its v0.5.19 sweep did not remeasure throughput. Keep launch-day speed reports dated and use the complete current recipe for your exact export. A recipe update is not a new Kingy speed measurement.

A useful first test

Use a task that reveals both speed and competence:

Write a Python command-line program that scans a folder of Markdown files, reports broken relative links, includes unit tests, and explains how to run it. Do not use third-party packages.

Record time to first token, generation speed, memory use, quantization and context. A naked “52 tok/s” is not a benchmark.

What speed feels usable?

For a single interactive user, this is a reasonable editorial scale:

• Below 3 tok/s: running, but unpleasant.
• 3–8 tok/s: usable with patience.
• 8–20 tok/s: comfortable chat and coding.
• 20–50 tok/s: fast.
• Above 50 tok/s: extremely responsive.

These are judgments, not standards. Thinking mode can spend many tokens before the final answer, and long prompts make time to first token important.

Launch evidence spans 3–4.5 tok/s on a 12GB laptop with offload, 7–10.5 on Strix Halo and SGLang’s reported 200+ on an optimized RTX 5090. These are configuration results, not a clean GPU league table.

Privacy, heat and the cost argument

Local inference keeps data on hardware you control—provided the frontend, tools and extensions are also local.

The trade is operational: laptops get hot, a desktop 5090 can draw hundreds of watts, and Macs trade NVIDIA-class speed for quiet efficiency. APIs avoid maintenance and upfront hardware cost.

Local makes financial sense when hardware is already owned, privacy has value, usage is sustained or offline access matters. It is not automatically cheaper for occasional questions.

Who should run it locally?

Run it locally for private documents, offline coding or a controllable agent endpoint. Use an API for high concurrency, minimal setup or occasional access, and check which precision the provider serves; an API is not automatically the full BF16 model. A hybrid approach often works best.

Final buying verdict

For a machine you own, try the smallest useful quant with short context and check the result before spending. For a new Mac, shortlist M6 32GB or M5 Pro 48–64GB; for an existing NVIDIA system, 24GB is a practical Q4 starting point. Higher-memory Studio and Blackwell serving configurations need a workload and verified runtime that justify their cost.

Use the dated file table and the current repository metadata to calculate the weight payload, add cache and working memory, then inspect the linked Local Lab observation or run your own bounded task. A successful result for the retained RTX 4090 artifact (Unsloth Qwen3.8-27B-Q4_K_M.gguf at revision f1bfb12, llama.cpp 6d05498) does not certify an M6, a new UD quant, or a different runtime.

The most important specification is not “27B.” It is the amount and bandwidth of memory left after the model loads.

FAQ

What about an 8GB, 12GB or 16GB GPU?

None can keep the current 17.66GB Dynamic Q4 XL weight file wholly in VRAM. A smaller quant or CPU offload changes that calculation, but also changes the quality and speed you need to check. Count system RAM and transfer costs separately; an 8GB GPU plus 32GB RAM does not behave like a 40GB GPU. Start with one short task on hardware you own and inspect actual allocations before buying.

Can Qwen3.8-27B run on a 16GB laptop?

A lower-bit file may load, or a discrete GPU may offload weights into system RAM. At the November 12 repository revision, UD-Q2_K_XL and UD-Q3_K_XL are about 9.95GB and 13.15GB before cache, runtime and the OS. A 16GB machine is an experiment, not a Q4 buying recommendation.

How much RAM does Qwen3.8-27B need?

The current Dynamic Q4_K_M and Q4_K_XL examples are about 16.56GB and 17.66GB of weights at the November 12 revision. The October 17 size table above remains a historical snapshot. Practical memory must also cover context, runtime and the OS. Treat 24GB as a short-context trial, 32GB as a more forgiving starting point, and 48–64GB as extra headroom rather than a measured universal requirement.

Can a Mac mini run Qwen3.8-27B?

A 24GB mini is a capacity candidate for a short-context Q4 trial; 32GB leaves more room. The current choices are M6 and M5 Pro. We have not measured M6 inference for this guide, so confirm runtime support and inspect actual memory pressure.

Which Mac mini should I buy?

Compare M6 at 32GB with M5 Pro at 48GB or 64GB. Use memory headroom, current configured cost and a supported runtime to choose. The older M4 Pro remains worth testing if you already own it.

Is a Mac Studio overkill?

A 64GB M5 Max Studio is a higher-bandwidth candidate with more room for Q8, vision and other work. It is not necessary merely to try Qwen3.8-27B, and this guide does not establish a measured Studio speed advantage.

Can an RTX 3090 or RTX 4090 run it?

In a separate cloud test, Kingy measured a 47.7 tok/s mean for short requests on an RTX 4090 at an 8,192-token allocation. The owned desktop’s 49.1 tok/s figure is a different synthetic decode profile, described above. Q5 is a tight fit on 24GB; context and vision need additional memory.

Does it need an RTX 5090?

No. The 5090 is the speed choice. Its 32GB VRAM and Blackwell NVFP4 support enable far faster optimized serving.

Can the RTX 5090 laptop GPU run it?

Yes. Its 24GB GDDR7 is well suited to Q4/Q5 and potentially supported NVFP4 deployments. It is not equivalent to the 32GB desktop card.

What is the best quantization for 24GB VRAM?

Start by evaluating a named Q4 file at 8K context. At the November 12 revision, UD-Q4_K_XL is 17.66GB, UD-Q5_K_M is 19.87GB and UD-Q6_K is 21.98GB before cache and runtime. Extra precision consumes headroom and needs a task-quality check rather than an automatic upgrade.

Can I use the full 262K context locally?

Only with substantial spare memory and a compatible runtime. At exactly 262,144 tokens, the calculated attention KV cache alone is 16GiB with BF16 or 8GiB with FP8 for one sequence, before other state and runtime allocations. Start with 8K and measure actual allocation.

Can it analyze images locally?

Yes. It is natively multimodal, but GGUF users must also load the approximately 0.93GB vision projector and use a compatible multimodal runtime.

Is local inference cheaper than an API?

It can be if you already own the hardware or use it heavily. For occasional queries, an API is usually cheaper than buying a dedicated machine.

Can I fine-tune it on the same hardware?

Not on most inference-minimum configurations. Unsloth’s general 27B guidance estimates an absolute minimum around 22GB VRAM for four-bit QLoRA and 64GB for 16-bit LoRA, before longer sequences, vision data or larger batches. Treat those as lower bounds; inference fitting is not evidence that training will fit.

Sources and methodology

Navigation and evidence-link update, October 18, 2026: Added direct hardware/quantization jumps, exposed the RTX 4090 result link with its separate-run caveat, and added a local coding-agent next step. Existing hardware values, filenames and historical measurement dates remain unchanged.

October 17 maintenance: Updated current quant filenames and sizes, separated NVFP4 exports/runtime support, corrected cache units, added the M6/M5 Mac lineup and removed stale configured-price recommendations. Historical Kingy and community results remain tied to their original tests.

Original source ledger: August 14, 2026, 10:35–11:08 PDT. Full editorial review and current repository, hardware-specification and runtime checks: October 17, 2026. The historical table below retains its original capture dates; the current file table and Mac sections supersede its old shopping prices and file-size observations. No new hardware inference test was run.