VRAMNeeded

Meta · VRAM requirements

Llama 3.1 70B VRAM requirements: can you run it locally?

  • Parameters70.6B
  • Context128K
  • 4-bit file42.5 GB
  • Checked2026-10-23

Quick answer

At the popular 4-bit Q4_K_M quantization, Llama 3.1 70B's weights are 42.5 GB, and an 8K-token context adds about 2.7 GB of KV cache, so plan for roughly 45 GB plus your engine's overhead.[4][3] That is more than any single 24 GB or 32 GB consumer GPU. It fits (tightly) on 48 GB of VRAM, such as two 24 GB cards or one 48 GB card, comfortably on an 80 GB A100 or H100, or on a Mac with 64 GB or more of unified memory. Unquantized BF16 weights need about 141 GB.[2]

Llama 3.1 70B is Meta's mid-size open-weight model, released on July 23, 2024, with a 128K-token context window and grouped-query attention (GQA).[1] Hugging Face lists 70,553,706,496 parameters in BF16.[2] Because it is a dense model, every one of those parameters has to sit in memory while it runs.

Memory needed at each quantization

Quantization stores each weight in fewer bits. Smaller files fit on smaller GPUs, at some cost in quality, and the cost grows as you go below about 4 bits. File sizes below are the actual GGUF downloads on Hugging Face (1 GB = 1,000,000,000 bytes).[4]

QuantizationWeights
BF16 (original)141.1 GB
Q8_075.0 GB
Q6_K57.9 GB
Q5_K_M49.9 GB
Q4_K_M Ollama default42.5 GB
IQ4_XS37.9 GB
Q3_K_M34.3 GB
Q2_K26.4 GB
IQ2_XS21.1 GB
IQ1_M16.8 GB

Ollama's default llama3.1:70b download is 43 GB, the same size Ollama lists for its 70b-instruct-q4_K_M tag. Its q8_0 tag is 75 GB and fp16 is 141 GB.[5]

Context length adds memory (the KV cache)

On top of the weights, the engine keeps a key/value cache for every token in the conversation. From the model's config.json (80 layers, 8 KV heads, head size 128),[3] an FP16 cache takes 2 × 80 × 8 × 128 × 2 bytes = 327,680 bytes per token:

ContextKV cache (FP16)
4,096 tokens1.34 GB
8,192 tokens2.68 GB
32,768 tokens10.74 GB
131,072 tokens42.95 GB

So the full 128K context needs about as much memory again as the 4-bit weights. Most people run 8K–32K. Some engines can quantize the cache to shrink it.

Which GPUs and Macs it fits on

Each cell compares the weights plus an 8K-token KV cache with the device's memory.[6][7][8][9][10][11][12][13]

DeviceQ8_077.7 GBQ6_K60.6 GBQ5_K_M52.6 GBQ4_K_M45.2 GBQ3_K_M37.0 GBQ2_K29.1 GBIQ2_XS23.8 GB
RTX 309024 GBNoNoNoNoNoNoTight
RTX 409024 GBNoNoNoNoNoNoTight
RTX 509032 GBNoNoNoNoNoTightFits
2x RTX 3090 / 409048 GBNoNoNoTightFitsFitsFits
RTX 6000 Ada48 GBNoNoNoTightFitsFitsFits
A10080 GBTightFitsFitsFitsFitsFitsFits
H100 (PCIe/SXM)80 GBTightFitsFitsFitsFitsFitsFits
Mac64 GB unifiedNoTightFitsFitsFitsFitsFits
Mac128 GB unifiedFitsFitsFitsFitsFitsFitsFits
Mac Studio256 GB unifiedFitsFitsFitsFitsFitsFitsFits

Column headers show weights + 8,192-token KV cache.

How to read it: "Fits" means weights + 8K cache use under 90% of memory. "Tight" means 90–100%: it may load, but the engine's own working memory or a longer context can push it over. "No" means it won't fit on the GPU alone. The 90% line is our own rule of thumb, not a vendor figure. On a Mac, macOS also needs some of the unified memory, so treat Mac rows as optimistic.

How to run it

The easiest way is Ollama. ollama run llama3.1:70b pulls the 43 GB Q4_K_M build.[5] For a smaller or larger quant, use a specific tag such as llama3.1:70b-instruct-q3_K_M (34 GB) or llama3.1:70b-instruct-q8_0 (75 GB).[5] With llama.cpp or LM Studio, download the matching GGUF file instead.[4]

If the model is bigger than your VRAM, these tools can keep some layers in system RAM, but every token then has to wait on the slower memory, so expect much lower speed.

Rent a GPU for this model

If you don't own 48 GB of VRAM, renting is the cheapest way to try it. On-demand prices listed on Runpod's pricing page:[14]

GPU (Runpod (on-demand, as listed))VRAMPrice
RTX A600048 GB$0.59/hr
A4048 GB$0.59/hr
RTX 6000 Ada48 GB$0.99/hr
L40S48 GB$1.09/hr
A100 PCIe80 GB$1.79/hr
H100 PCIe80 GB$2.89/hr

Prices checked on 2026-10-23. They change often, so confirm on the provider's page. A 48 GB card runs Q4_K_M tightly; 80 GB gives room for longer context or Q5/Q6.

SponsoredRent a GPU for this model

Where to rent or buy

Rent a GPU

Links coming soon.

Buy a GPU or Mac

Links coming soon.

Some links here may become affiliate links. How we make money. They never change the numbers on this page.

Frequently asked questions

Can I run Llama 3.1 70B on an RTX 4090 or RTX 3090?

Not fully on the GPU at 4-bit. The Q4_K_M weights are 42.5 GB and these cards have 24 GB.[4][7][6] Only 2-bit and lower quants (21.1 GB for IQ2_XS, 16.8 GB for IQ1_M) come close, with a large quality trade-off. The usual options are two 24 GB cards, offloading part of the model to system RAM, or renting a 48 GB GPU.

How much VRAM does Llama 3.1 70B need for the full 128K context?

At FP16, the KV cache for 131,072 tokens is about 42.9 GB, on top of the weights.[3] With Q4_K_M weights (42.5 GB), that's about 85.5 GB before engine overhead, which is more than a single 80 GB GPU.

Is the Ollama download the same as Q4_K_M?

Ollama's default llama3.1:70b tag is 43 GB, the same size it lists for 70b-instruct-q4_K_M.[5]

Can a Mac run Llama 3.1 70B?

Yes, if it has enough unified memory. Apple sells MacBook Pro and Mac Studio models with 64 GB and 128 GB, and Mac Studio with up to 512 GB.[12][13] A 64 GB Mac can hold the 42.5 GB Q4_K_M file plus a moderate context. A 128 GB Mac can run Q8_0 (75 GB).

How we calculated

  • Weights are the exact file sizes on Hugging Face, with multi-part files added together.[4] BF16 is the parameter count × 2 bytes.[2]
  • KV cache is calculated from config.json. We assume an FP16 cache.[3] Meta's own repo is gated, so we read an identical public copy of the config.
  • Device memory is from NVIDIA and Apple spec pages. We compare in decimal GB, which slightly understates GPU capacity, so the results lean conservative.
  • Not included: engine working buffers, the OS and display, and vision or other add-ons. These vary by engine and settings, so leave headroom.

Sources

All sources checked on .

  1. Meta, Llama 3.1 model card (release date, sizes, context, GQA). https://github.com/meta-llama/llama-models/blob/main/models/llama3_1/MODEL_CARD.md
  2. Hugging Face, meta-llama/Llama-3.1-70B-Instruct (parameter count, BF16). https://huggingface.co/meta-llama/Llama-3.1-70B-Instruct
  3. Hugging Face, config.json (public copy of the gated Meta config). https://huggingface.co/unsloth/Meta-Llama-3.1-70B-Instruct/blob/main/config.json
  4. Hugging Face, bartowski/Meta-Llama-3.1-70B-Instruct-GGUF file list. https://huggingface.co/bartowski/Meta-Llama-3.1-70B-Instruct-GGUF/tree/main
  5. Ollama, llama3.1 tags. https://ollama.com/library/llama3.1/tags
  6. NVIDIA, GeForce RTX 3090 specs (24 GB). https://www.nvidia.com/en-us/geforce/graphics-cards/30-series/rtx-3090-3090ti/
  7. NVIDIA, GeForce RTX 4090 specs (24 GB). https://www.nvidia.com/en-us/geforce/graphics-cards/40-series/rtx-4090/
  8. NVIDIA, GeForce RTX 5090 specs (32 GB). https://www.nvidia.com/en-us/geforce/graphics-cards/50-series/rtx-5090/
  9. NVIDIA, RTX 6000 Ada Generation (48 GB). https://www.nvidia.com/en-us/products/workstations/rtx-6000/
  10. NVIDIA, A100 (80 GB). https://www.nvidia.com/en-us/data-center/a100/
  11. NVIDIA, H100 (80 GB). https://www.nvidia.com/en-us/data-center/h100/
  12. Apple, MacBook Pro tech specs (up to 128 GB unified memory). https://www.apple.com/macbook-pro/specs/
  13. Apple, Mac Studio tech specs (up to 512 GB unified memory). https://www.apple.com/mac-studio/specs/
  14. Runpod, GPU pricing. https://www.runpod.io/pricing

Last checked: