en

GPU Buying Guide for Local AI

Compare graphics cards for local AI by VRAM, bandwidth, backend, power and price per GiB. Benchmarks count only under equal conditions. No upload.

This calculator gives a non-binding, model-based estimate and is not financial, tax or legal advice. More in the disclaimer
  • Bangladesh
  • Brazil
  • Bulgaria
  • China
  • Egypt
  • Euro area
  • France
  • Germany
  • India
  • Indonesia
  • Italy
  • Japan
  • Kenya
  • Malaysia
  • Mexico
  • Netherlands
  • Nigeria
  • Pakistan
  • Poland
  • Portugal
  • Russia
  • South Korea
  • Spain
  • Sweden
  • Taiwan
  • Thailand
  • Türkiye
  • Ukraine
  • United Kingdom
  • United States
  • Vietnam
GPU candidates as CSV: name; VRAM; bandwidth GB/s; backends; power W; price; currency; shipping; source
Benchmarks as CSV: GPU name; tokens/s; metric tg/pp; model; quantization; context; backend; source
Backend your software needs
  • No specific one
  • CUDA
  • ROCm
  • Vulkan
  • Metal
  • SYCL
Workload: total model parameters (billions)
Workload: bits per weight (quantization, e.g. 4.5)
Workload: context in tokens
Workload: layers with KV cache (model card)
Workload: KV heads (model card)
Workload: dimension per head (model card)
Workload: bits per KV element
  • 16 (FP16/BF16)
  • 8
  • 4
Runtime buffer and reserve per GPU (GiB, assumption)
Read VRAM sizes in GB as GiB (usual labelling)
Currency (rows without one and electricity price)
  • ¤
  • USD
  • EUR
  • GBP
  • JPY
  • CHF
  • CAD
  • AUD
  • CNY
  • INR
  • KRW
  • BRL
  • MXN
  • SEK
  • PLN
  • TRY
  • SGD
Decimal mark in the CSV
  • Detect automatically
  • Comma (12,50)
  • Point (12.50)
Electricity price per kWh (empty = no energy cost)
Hours under load per day
Market or seller country (free text)
Prices as of, e.g. date (free text)

Result

No valid candidates yet
Fit in VRAM (✓ fits · ✗ does not fit · ? unconfirmed)
Workload incomplete: enter parameters and bits per weight
Total memory needed
Workload incomplete: enter parameters and bits per weight
Calculation: weights + KV cache + buffer
No specific backend required
Required backend per candidate
0
Valid candidates
No candidate with a price
Lowest price per GiB of VRAM (per currency)
No candidate with a price
Currency comparison
0
Candidates without a price
No comparable benchmarks
Benchmark groups (ranked only within a group)
0
Benchmarks without a rank (incomplete conditions)
0
Candidates without a benchmark (stays unknown)
Not specified
Calculation of energy cost per year
None
Invalid candidate lines
None
Invalid benchmark lines
No CSV pasted
Detected CSV separator
Only your values and sources, no built-in GPU table
Origin of the technical data
Not specified
Market
Not specified
Prices as of
✓ fits or per source · ~ stated without a source · ✗ does not fit or not supported · ? unknown · ≠ benchmark conditions incomplete, no rank · ≥ shipping unknown, minimum
Signs in the table
line;name;vram_gib;fit;bandwidth_gb_s;backends;power_w;price_total;currency;shipping_unknown;price_per_gib;rank_in_currency;source line;gpu;tokens_per_s;metric;model;quant;context;backend;group;rank_in_group;source
Report as CSV to copy (semicolon, decimal point)

GPU candidates compared

GPU candidates compared
LineGPUVRAMFitBandwidth (datasheet)BackendsRequired backendPower (datasheet)Energy per yearTotal pricePrice per GiB of VRAM (rank per currency)Price per GB/sBenchmark (measured, group rank/count)Source
Is my file uploaded?

No. Everything runs in your browser - your file never leaves your device. How this is verifiable

No upload100% local
Your content stays with youno third-party access
Hosted in GermanyGlobal Content Delivery
Independently auditedTLS A+ · HTTP headers A+

For local AI the first question is the graphics memory (VRAM, video random access memory) of the GPU (graphics processing unit): the model has to fit with its weights, the KV cache (a store for the attention keys and values) and a runtime buffer. The fit check uses the same calculation as the check for local language models: 8 billion parameters at 4.5 bits are 4.19 GiB of weights, 32 layers with 8 KV heads, head dimension 128 and a context of 8192 tokens in FP16 give 1.00 GiB of KV cache, together with a 1 GiB buffer 6.19 GiB. If a part is missing, the requirement is shown with "≥" and a card only counts as too small when the known parts alone do not fit.

Datasheet values and benchmarks are kept apart. VRAM, memory bandwidth in GB/s and power draw in watts are theoretical figures; tokens per second (tok/s) only come from benchmarks you enter, with the metric (tg = text generation, pp = prompt processing), model, quantization, context and backend. Ranking happens only within a group with exactly the same conditions: 40 and 55 tok/s with the same model, Q4_K_M, 8192 tokens and Vulkan form G1, while a run with CUDA sits in a group of its own. No speed is ever estimated from bandwidth.

Price only affects calculable figures: price per GiB of VRAM with a rank per currency, price per GB/s of bandwidth and, for ranked benchmarks, price per tok/s. Example: 16 GB for 450 EUR is 28.13 EUR per GiB, 24 GB for 900 EUR is 37.50 EUR per GiB. Currencies are never mixed, and unknown shipping turns the value into a minimum. Backends such as CUDA, ROCm, Vulkan, Metal or SYCL are programming interfaces through which AI software uses the GPU; an entry with a source counts as documented, one without a source as unconfirmed, and a backend that is not listed stays unknown.

Free, no account - calculate as often as you like; your inputs stay on your device.

Specifications

Specifications
Input formatsForm inputs (no file)
ProcessingLocally in your browser (JavaScript)
File uploadNone

In 3 steps

  1. Paste the GPU candidates with VRAM, bandwidth, backends, power, price and source as CSV.
  2. Enter the workload: parameters, bits per weight, context, model card values and buffer, plus the backend you need.
  3. Add your own or documented benchmarks with metric, model, quantization, context and backend.
  4. Compare fit, backend profile, price per GiB and the benchmark groups in the table and copy the report as CSV.

Limitations: The guide knows no products and gives no purchase recommendation or guarantee: it only calculates with your values. There is no tokens/s forecast, no bottleneck percentage and no overall score. The fit check covers one GPU without offloading to system memory; drivers, cooling, noise, form factor and power supply are not checked. Prices are as of your entry, without exchange rates.

FAQ

Why does the tool not estimate tokens per second from bandwidth?

Because the real speed depends on model, quantization, context, backend, driver and software. A forecast from the datasheet would look precise but be invented. That is why the table shows only measured values with their conditions; if a benchmark is missing, it shows "?".

Why do some benchmarks get no rank?

A rank only exists between benchmarks with the same metric, model, quantization, context and backend. If one of these is missing, the table shows "≠" instead of a rank and the benchmark counts as unranked. Different conditions end up in separate groups.

What do ✓, ~, ✗ and ? mean in the table?

For fit, ✓ means fits by calculation, ✗ does not fit and ? unconfirmed. For backends, ✓ means supported per source, ~ stated without a source, ✗ stated as not supported (entry with a minus, such as -CUDA) and ? unknown. A backend that is not listed is never treated as "no".

Why does "16 GB" of VRAM count as 16 GiB?

Graphics memory is organised in binary sizes but is usually labelled "GB", just like system memory. The switch therefore reads such values as GiB (2³⁰ bytes). Turn it off if your source really means decimal gigabytes; the table then shows the converted GiB value.

GPU Buying Guide for Local AI: free and without an account?

Yes. Using it is free and needs no account: you can calculate as often as you like, and your inputs stay on your device.

Related tools

LLM VRAM Calculator · RAM and SSD Price per GB · Local AI vs Cloud · PC Upgrade and PSU Planner · Energy Cost Calculator