LLM VRAM calculator: can my GPU run it?

Memory needed by model size and quantization, and a speed estimate.

0GB of GPU memory needed

    Which GPUs hold it, and how fast they could write

    Weights = parameters × bits per weight ÷ 8. KV cache = 2 × layers × KV heads × head size × context × bytes × chats. Bits per weight are llama.cpp's measured figures. The speed is a ceiling for one chat: memory bandwidth ÷ size of the weights, since each new token reads every weight once; real speed is lower. GB here means 1024³ bytes, the way GPU memory is sold. The runtime allowance covers buffers and the framework and varies by software.

    Prices and limits checked on October 26, 2026 on each provider's own page. See the numbers and sources

    The numbers behind this tool

    Read on October 26, 2026 from each provider's own page. Prices are US dollars per million tokens, standard tier.

    ModelParametersLayersKV headsHead sizeContextSource
    Qwen3 8B 8.19B36812840,960huggingface.co
    Qwen3 14B 14.77B40812840,960huggingface.co
    Qwen3 32B 32.76B64812840,960huggingface.co
    Qwen3 30B-A3B (MoE)
    3.3B active per token
    30.53B48412840,960huggingface.co
    Qwen3 235B-A22B (MoE)
    22B active per token
    235.09B94412840,960huggingface.co
    gpt-oss-20b (MoE)
    3.6B active per token
    20.91B24864131,072huggingface.co
    gpt-oss-120b (MoE)
    5.1B active per token
    116.83B36864131,072huggingface.co
    Qwen2.5 7B Instruct 7.62B28412832,768huggingface.co
    Qwen2.5 Coder 32B Instruct 32.76B64812832,768huggingface.co
    Qwen2.5 72B Instruct 72.71B80812832,768huggingface.co
    Mistral 7B Instruct v0.3 7.25B32812832,768huggingface.co
    Mistral Small 24B Instruct 23.57B40812832,768huggingface.co
    Phi-4 14.66B401012816,384huggingface.co
    DeepSeek-R1 Distill Qwen 14B 14.77B488128131,072huggingface.co
    DeepSeek-R1 Distill Llama 70B 70.55B808128131,072huggingface.co

    GPUs

    GPUMemoryBandwidthSource
    NVIDIA GeForce RTX 3060 12GB12 GBnot published by the makernvidia.com
    NVIDIA GeForce RTX 4060 Ti 16GB16 GBnot published by the makernvidia.com
    NVIDIA GeForce RTX 309024 GBnot published by the makernvidia.com
    NVIDIA GeForce RTX 409024 GBnot published by the makernvidia.com
    NVIDIA GeForce RTX 509032 GB1,792 GB/snvidia.com
    NVIDIA RTX 6000 Ada Generation48 GBnot published by the makernvidia.com
    NVIDIA A100 80GB PCIe80 GB1,935 GB/snvidia.com
    NVIDIA A100 80GB SXM80 GB2,039 GB/snvidia.com
    NVIDIA H100 SXM80 GB3,350 GB/snvidia.com
    NVIDIA H100 NVL94 GB3,900 GB/snvidia.com
    Apple M3 Max (14-core CPU, 30-core GPU)96 GB300 GB/ssupport.apple.com
    Apple M3 Max (16-core CPU, 40-core GPU)128 GB400 GB/ssupport.apple.com
    Apple M4 Max (14-core CPU, 32-core GPU)36 GB410 GB/ssupport.apple.com
    Apple M4 Max (16-core CPU, 40-core GPU)128 GB546 GB/ssupport.apple.com
    Apple M5 Max (32-core GPU)36 GB460 GB/sapple.com
    Apple M5 Max (18-core CPU, 40-core GPU)128 GB614 GB/sapple.com
    • Bits per weight: llama.cpp's measured table (measured on meta-llama/Llama-3.1-8B), github.com. Apple memory is the largest option for that chip and is shared with the system.

    How it works

    Running a model locally needs memory for three things: the weights, the KV cache that holds the conversation, and the software itself. The calculator works out each one.

    • Weights = parameters × bits per weight ÷ 8. Bits per weight for each quantization come from llama.cpp’s own measurements.
    • KV cache = 2 × layers × KV heads × head size × context length × bytes per value × chats running at once. Layers, KV heads and head size come from each model’s official configuration file. For gpt-oss, half the layers use a 128-token sliding window, and the calculator counts them that way.
    • Runtime: an allowance you can change, because it depends on the software you use.

    The speed estimate

    When a model writes, each new token reads every active weight from memory once, so memory bandwidth sets a ceiling: bandwidth ÷ size of the active weights. Mixture-of-experts models such as gpt-oss and Qwen3-30B-A3B read only their active experts per token, which is why they can be fast for their size. Real speed is lower than the ceiling. Where a GPU maker does not publish bandwidth, the tool says so rather than estimating it.