Skip to content

VRAM reference

Qwen3 30B-A3B VRAM requirements

Fine-tuning Qwen3 30B-A3B takes about 20 GB of GPU memory with QLoRA, 64 GB with LoRA on 16-bit weights and 492 GB for full fine-tuning, at 2,048 tokens per sequence. Running it takes 62 GB in 16-bit or 18 GB in 4-bit with a 8K-token context. It is a mixture of experts: 3.3B of its 30.5B parameters work on each token, but all of them must be in memory.

By Will Schulz · Architecture and prices checked 15 November 2026 · Prices as of November 2026

Fine-tuning memory

At 2,048 tokens per sequence, batch 1, LoRA rank 16, gradient checkpointing on
MethodWeightsTraining stateActivationsTotalSmallest single GPU80 GB GPUs needed
QLoRA (4-bit base)17 GB0.2 GB3.1 GB20 GBRTX 3090 (24 GB)1
LoRA (16-bit base)61 GB0.2 GB3.1 GB64 GBA100 80GB (80 GB)1
Full fine-tuning61 GB427 GB3.1 GB492 GBNone7

On a 24 GB card such as the RTX 4090: QLoRA: yes, about 20 GB at 2K tokens, batch 1, rank 16; up to 2K-token sequences at batch 1, LoRA rank up to 128.

Inference memory

One sequence, fp16 KV cache
PrecisionWeightsKV cache at 8KTotalAt 128K contextSmallest single GPU
16-bit (BF16/FP16)61 GB0.8 GB62 GB74 GBA100 80GB (80 GB)
8-bit31 GB0.8 GB31 GB43 GBA100 40GB (40 GB)
4-bit17 GB0.8 GB18 GB30 GBRTX 3090 (24 GB)

Which GPUs fit Qwen3 30B-A3B

One GPU unless a count is shown. Follow a GPU's name for its maximum sequence length, batch size, LoRA rank and rental cost.

GPUQLoRALoRAFull fine-tuningRun, fp16Run, int8Run, int4
RTX 3090 24 GBYes3×23×3×2×Yes
RTX 4090 24 GBYes3×23×3×2×Yes
RTX 5090 32 GBYes3×18×3×2×Yes
L40S 48 GBYes2×12×2×YesYes
A100 40GB 40 GBYes2×14×2×YesYes
A100 80GB 80 GBYesYes7×YesYesYes
H100 SXM 80 GBYesYes7×YesYesYes
H200 141 GBYesYes4×YesYesYes
B200 180 GBYesYes4×YesYesYes

What's specific to Qwen3 30B-A3B

  • A mixture of experts: 128 experts per layer with 8 used per token, so it computes like a 3.3B model but every one of its 30.5B parameters must sit in memory.
  • Memory is sized by total parameters and speed by active ones: fine-tuning costs a little more than a 3B dense model per token, but needs the memory of a 30B one.
  • Only 4 KV heads, so its KV cache is small: 96 KB per token.
ArchitectureQwen3 30B-A3B
Parameters30.5B total, 3.3B active per token
Experts128 per layer, 8 used per token
Layers48
Hidden size2,048
Expert MLP width768
Attention heads / KV heads32 / 4 (head dim 128)
Vocabulary151,936 tokens
Context128K tokens (32K native)
LicenseApache 2.0
ReleasedApril 2025

Try other settings

Pre-filled for Qwen3 30B-A3B. Change the sequence length, batch, LoRA rank, context or GPU.

JobMemoryRTX 4090 (24 GB)Smallest single GPU
QLoRA (4-bit base)2K tokens × batch 1, rank 1620 GBFitsRTX 3090 (24 GB)
LoRA (16-bit base)2K tokens × batch 1, rank 1664 GB3 GPUsA100 80GB (80 GB)
Full fine-tuning2K tokens × batch 1492 GB23 GPUsNone: needs several
Inference, 16-bit (BF16/FP16)8K-token context × 1 sequence62 GB3 GPUsA100 80GB (80 GB)
Inference, 8-bit8K-token context × 1 sequence31 GB2 GPUsA100 40GB (40 GB)
Inference, 4-bit8K-token context × 1 sequence18 GBFitsRTX 3090 (24 GB)

A job fits when the estimate is within 90% of the card's memory. Training assumes gradient checkpointing and FlashAttention; multi-GPU counts assume the memory splits evenly (FSDP, ZeRO-3 or tensor parallelism).

How we estimate it

Every figure comes from the model's published architecture (layers, hidden size, attention and KV heads, vocabulary) rather than a rule of thumb, using the same functions as the calculator above. Sizes are in GB (10⁹ bytes).

  • Full fine-tuning: 16 bytes per parameter for mixed-precision Adam (bf16 weights and gradients, fp32 master weights and two moments), as in the ZeRO paper.
  • LoRA: frozen bf16 weights (2 bytes per parameter) plus 16 bytes per adapter parameter, rank 16 on every linear layer. For mixture-of-experts models, adapters go on attention only and the experts stay frozen.
  • QLoRA: NF4 weights with double quantisation (4.127 bits per parameter); embeddings and the output head stay in bf16, as bitsandbytes leaves them.
  • Activations: gradient checkpointing and FlashAttention. Each layer's bf16 input is kept, one layer is recomputed at a time, and the output logits take 8 bytes per vocabulary entry per token (fp32 values and gradients). Chunked cross-entropy, as in Unsloth or Liger kernels, cuts that last term.
  • Inference: 2, 1 or about 0.56 bytes per weight (4-bit with group-wise scales), plus an fp16 KV cache of 2 × layers × KV heads × head dim × 2 bytes per token; sliding-window layers only cache their window.
  • Fits means the estimate is within 90% of the card's listed memory; the rest covers the CUDA context, kernels and fragmentation. Multi-GPU counts assume memory splits evenly.

Frequently asked questions

Can I fine-tune Qwen3 30B-A3B on a 24 GB GPU?
On an RTX 3090 or 4090 (24 GB): QLoRA: yes, about 20 GB at 2K tokens, batch 1, rank 16; up to 2K-token sequences at batch 1, LoRA rank up to 128. LoRA: no, it needs about 64 GB at 2K tokens, more than the 24 GB available. Estimates use gradient checkpointing and leave 10% of memory free.
How much VRAM do you need to run Qwen3 30B-A3B?
About 62 GB in 16-bit and 18 GB in 4-bit, at 8K tokens of context. The smallest single GPU here for 4-bit is the RTX 3090 (24 GB); for 16-bit, the A100 80GB (80 GB).
How many GPUs does full fine-tuning Qwen3 30B-A3B take?
About 492 GB with mixed-precision Adam at 2K tokens, so at least 7 × 80 GB H100s with the training state sharded (FSDP or ZeRO-3). LoRA needs 64 GB and QLoRA 20 GB.
Why does Qwen3 30B-A3B need so much memory if only 3.3B parameters are active?
It is a mixture of experts: each token uses 8 of 128 experts per layer, but which ones changes token to token, so all 30.5B parameters stay in GPU memory. Speed follows the active parameters; memory follows the total. Our LoRA figures adapt attention only; adapting every expert at rank 16 adds about 14 GB of adapter training state.
How long a context can Qwen3 30B-A3B handle on an 80 GB GPU?
Its KV cache costs 13 GB at the full 128K tokens (fp16 cache). On one 80 GB GPU: 64K tokens with 16-bit weights, 128K tokens with 4-bit weights.

Terms used on this page: LoRA, QLoRA, KV cache, gradient checkpointing, quantization, mixture of experts. For any model size, use the fine-tuning VRAM calculator; for the method in depth, the Academy lesson Memory first: what hardware can train what.

Sources

  1. [1]Hugging Face. Qwen/Qwen3-30B-A3B config.json
  2. [2]Alibaba Qwen. Qwen/Qwen3-30B-A3B model card
  3. [3]Alibaba Qwen. Qwen3 Technical Report (arXiv:2505.09388)
  4. [4]Dettmers et al., 2023. QLoRA: Efficient Finetuning of Quantized LLMs (arXiv:2305.14314)
  5. [5]Hu et al., 2021. LoRA: Low-Rank Adaptation of Large Language Models (arXiv:2106.09685)
  6. [6]Rajbhandari et al., 2019. ZeRO: Memory Optimizations Toward Training Trillion Parameter Models (arXiv:1910.02054)
  7. [7]Korthikanti et al., 2022. Reducing Activation Recomputation in Large Transformer Models (arXiv:2205.05198)
  8. [8]Chen et al., 2016. Training Deep Nets with Sublinear Memory Cost (arXiv:1604.06174)

Architecture read from config.json and parameter count from the Hugging Face safetensors metadata on 15 November 2026.

Find out if you need to fine-tune at all.

Kojen's prompt tuning and model search run for real on your own test cases, on hosted models. Measure the cheaper levers before you rent a GPU.

Start training free