Vision-languageDense27.78B params262K max context

Qwen3.8 27B (VLM) VRAM Requirements: How Many GPUs & What It Costs

Qwen3.8 27B (VLM) needs 27.8 GB of VRAM for its weights at FP8 (E4M3) — 28.9 GB once a KV cache is loaded. Below is the full breakdown: which GPUs fit, how many you need, what it serves, and what it costs per million tokens. Every figure comes from tokcalc's open-source capacity model.

Weights (FP8 (E4M3))
27.8 GB
28.9 GB with KV cache
Fits on 1 GPU?
Yes
A100 40GB SXM4 or larger
Cheapest config
$0.0511
4× RTX 3080 10GB / 1M tokens
Fastest config
8423
tok/s on 1× Cerebras CS-3 (WSE-3)
VRAM requirement by quantization
Weight footprint = params × bytes per param. The “with KV cache” column adds one request at 4K context.
QuantizationWeightsWith KV cacheSmallest single GPU
FP1655.6 GB56.6 GBMac M3 Max (64GB) (64 GB)
FP8 (E4M3)recommended27.8 GB28.9 GBV100 SXM2 32GB (32 GB)
AWQ 4-bit15.3 GB16.4 GBA10G 24GB (24 GB)
Which GPU should you use?
Reference workload: 8K context, 8 concurrent users, continuous batching, FP8 (E4M3). Ranked by fitting first, then by tokens per dollar-hour.
GPUGPUsTotal VRAMDecode tok/sAggregate tok/sCost / 1M tokens
RTX 3080 10GB4×40 GB90.694353$0.0511
RTX 4080 16GB4×64 GB85.564107$0.0812
RTX 5090 32GB2×64 GB106.92566$0.1083
RTX 3090 24GB2×48 GB55.841281$0.1084
RTX A4000 16GB4×64 GB53.462566$0.1299
RTX 4090 24GB2×48 GB60.141443$0.1540
T4 16GB4×64 GB38.181166$0.1905
V100 SXM2 32GB2×64 GB53.701289$0.2155
A10G 24GB2×48 GB35.80859.1$0.2328
AMD MI300X 192GB1×192 GB186.02232$0.3111
TPU v6e Trillium (32GB)2×64 GB48.861173$0.3790
A100 40GB SXM41×40 GB54.40652.8$0.3830

RTX 3080 10GB has no NVLink, so 4-way tensor parallelism runs over PCIe. tokcalc applies a flat 0.85× multi-GPU efficiency factor for this, which is realistic for NVLink-equipped datacenter cards but optimistic for PCIe scale-out — treat the throughput and cost figures for this configuration as an upper bound, and measure before committing.

How concurrency changes with context length
On 4× RTX 3080 10GB at FP8 (E4M3). KV cache scales linearly with context, so long contexts cut the number of users you can serve from the same GPUs.
ContextConcurrent usersKV per requestFits?
4K291.07 GB✓ fits
8K172.15 GB✓ fits
33K58.59 GB✓ fits
66K217.18 GB✓ fits
131K134.36 GB✓ fits
Frequently asked questions

Can Qwen3.8 27B (VLM) run on a single GPU?

Yes. At FP8 (E4M3) the model needs 28.9 GB of VRAM, so it fits on a single A100 40GB SXM4 or anything with more VRAM. At full FP16 it needs 56.6 GB, which fits on one Mac M3 Max (64GB) or larger.

How many GPUs does Qwen3.8 27B (VLM) need?

At FP8 (E4M3) with 8,192-token context and 8 concurrent users, the cheapest configuration that fits is 4× RTX 3080 10GB (40 GB total VRAM). $0.0511 per 1M output tokens.

How fast can Qwen3.8 27B (VLM) be served?

On 1× Cerebras CS-3 (WSE-3) at FP8 (E4M3), the aggregate throughput is 8423 tokens/sec with continuous batching. That hardware has no published rental price, so its cost per million tokens is not comparable.

How much VRAM does Qwen3.8 27B (VLM) need?

Weights alone: 55.6 GB at FP16, 27.8 GB at FP8 (E4M3). Add KV cache for your context length and concurrency — every concurrent request at 8,192 tokens costs extra VRAM, so budget headroom above the weight figure.

Should I run Qwen3.8 27B (VLM) in FP8 or FP16?

FP8 halves the weight footprint (56 GB → 28 GB) and is faster than FP16 on Hopper and Blackwell, where it has native kernels. FP16 remains the reference quality bar; FP8 loses a small amount of accuracy in exchange for roughly doubling the batch size you can serve per GPU.

Is it cheaper to self-host Qwen3.8 27B (VLM) than to call an API?

At 4× RTX 3080 10GB the marginal cost is $0.0511 per 1M output tokens, before you add idle capacity, ops staff, or egress. That is typically cheaper than frontier API pricing at sustained volume, but API calls win when your load is bursty or too small to keep a GPU busy. The Build vs Buy tab on tokcalc prices this against a specific provider for you.

Try Qwen3.8 27B (VLM) with your own context and concurrency

The calculator uses the exact same formulas as this page — change the workload and watch every number update.

Open in calculator

Qwen3.8 27B (VLM) on specific GPUs

Qwen3.8 27B (VLM) on RTX 5090 32GBQwen3.8 27B (VLM) on AMD MI300X 192GBQwen3.8 27B (VLM) on A100 40GB SXM4Qwen3.8 27B (VLM) on AMD MI325X 288GBQwen3.8 27B (VLM) on A100 80GB SXM4Qwen3.8 27B (VLM) on Intel Gaudi 3 128GBQwen3.8 27B (VLM) on H100 SXM5 80GBQwen3.8 27B (VLM) on B200 SXM 192GB
Model architecture
The numbers behind the KV-cache and throughput math.
Total parameters27.78B
Active parameters per token27.78B
ArchitectureDense
Attention layoutHybrid: 16 full + 48 linear
Transformer layers64
Hidden dimension5120
Attention heads24 query / 4 KV (GQA)
Head dimension256
Vocabulary size248,320
Max context (catalog)262K
KV cache per token @ 8K64.0 KB
Fixed recurrent state154.6 MB per request
Native checkpoint size55.56 GB
Native weight formatbfloat16
Licenseapache-2.0

linear-attention layers keep a fixed recurrent state instead of a growing key/value cache.

Limitations of these numbers
Where the source does not fully establish the values above. Some of the figures hold only under conditions that may not apply to you.
  • •Checkpoint carries 1 multi-token-prediction head layer (~370M of 27.78B) — a draft head, not part of the per-token decode path, so it is not counted as active parameters. Weight bytes, parameter count and attention layout are exact.