Local LLM Hardware Checker & PC RAM/VRAM Compatibility Tester
Test if your PC, Mac, or workstation can run open-weights models (Gemma 4, DeepSeek V4.1, Llama 4 Maverick, Qwen 3) locally. Calculates exact GPU VRAM fit, system RAM offload layers, and token generation speed.
Quick Hardware Profiles
Hardware Configuration
Model & Context Target
Runtime Execution Plan
HYBRID ACCEPTABLE--n-gpu-layers 25Dragging the context slider re-calculates the dynamic KV cache footprint in real-time. As the context expands, the KV cache eats into available VRAM, pushing transformer layers out into system RAM, resulting in significant throughput drops (the "PCIe cliff").
Need to check a specific GitHub repo or Hugging Face model?
Paste any repository URL to automatically calculate exact minimum and recommended VRAM, RAM, and GPU requirements.
Need More VRAM? Deploy On-Demand Cloud GPUs
Bypass local memory limits. Spin up an RTX 4090 or A100 80GB in under 60 seconds with per-minute billing.
Instant cloud GPUs with 1-click vLLM, Ollama, and PyTorch templates. RTX 4090 to 8x H100.
Decentralized GPU marketplace with aggressive per-hour rates for consumer & datacenter cards.
High-speed networked enterprise clusters with low latency and dedicated NVMe storage.
Rates verified weekly. Transparent disclosure: We may receive an affiliate commission from partner signups at no extra cost to you.
Engineering Deep-Dive: Memory Architecture for Local LLM Inference
Running open-weights foundation models locally via runtimes such as llama.cpp, Ollama, vLLM, and ExLlamaV3 requires precise sizing across three distinct hardware memory pools: static parameter storage, dynamic attention KV-caches, and CUDA runtime execution buffers.
How do you calculate if your PC hardware can run a local LLM without Out-Of-Memory errors?
| Model Architecture (Sept 2026) | Weight (Q4_K_M) | Min VRAM (Full GPU) | Min RAM (Offload) | Optimal Target Hardware |
|---|---|---|---|---|
| Microsoft Phi-4 Mini (3.8B) | 2.4 GB | 4 – 6 GB | 8 GB | RTX 3050 (6GB) / GTX 1660 / Mac M2 8GB |
| Qwen 3 (8.1B) / Granite 4.1 (8.3B) | 4.9 GB | 8 GB | 16 GB | RTX 4060 (8GB) / RTX 3060 (12GB) / Mac M3 16GB |
| Gemma 4 (12.4B Dense) | 7.8 GB | 12 GB | 24 – 32 GB | RTX 4070 (12GB) / Mac Mini M4 24GB |
| Nemotron 3.5 Lightning (105B MoE, 12B Active) | 61.0 GB | 64 GB (2x RTX 4090) | 96 – 128 GB | Mac Studio M2/M4 Max (64GB–96GB) / Dual RTX 3090 |
| DeepSeek V4.1 Flash (236B MoE, 24B Active) | 98.5 GB (IQ3_XS) | 112 GB | 128 – 192 GB | Apple Mac Studio M2 Ultra (128GB–192GB) / 4x RTX 3090 |
| Llama 4 Maverick (401B MoE, 17B Active) | 168.0 GB (IQ3_XS) | 192 GB | 256 GB | Apple Mac Studio Ultra 192GB UMA / 8x H100 Cluster |
What is the token generation speed penalty of offloading layers from GPU VRAM to System RAM?
# Deterministic Layer Offload & Bandwidth Formula
$ llama-cli -m model-q4_k_m.gguf -ngl [GPU_LAYERS] -c 16384 -b 512
• Static Weight (GB): [Total Parameters × Bits Per Weight / 8]
• KV-Cache Size (GB): 2 × N_layers × n_kv_heads × d_head × L_context × Precision Bytes
• GPU Layer Quota: N_gpu = floor((VRAM_avail - M_kv - CUDA_overhead) / Weight_per_Layer)
• Effective Throughput: Speed ≈ Min(Bandwidth_GDDR, Bandwidth_PCIe × (N_layers / N_cpu_layers))
| Architecture Type | Memory Bus | Theoretical Bandwidth | Latency / Transfer Penalty | Effective Speed (32B Model) |
|---|---|---|---|---|
| Pure Dedicated GPU | GDDR6X / GDDR7 | 504 – 1,792 GB/s | Zero PCIe bus transfer overhead | 45 – 75 tok/s |
| Hybrid GPU + RAM Offload | PCIe 4.0/5.0 + DDR5 | 32 – 64 GB/s bus | Sequential bus synchronization stall | 4 – 9 tok/s (-80%) |
| Pure CPU Inference | Dual-Channel DDR5 | 55 – 85 GB/s | Limited memory channels per core | 2 – 5 tok/s (-92%) |
| Apple Silicon Unified (UMA) | Unified LPDDR5X | 150 – 800 GB/s | Zero-copy unified memory pool | 22 – 40 tok/s (Near-GPU) |
Frequently Asked Questions
How do you calculate if your PC hardware can run a local LLM without Out-Of-Memory errors?
Determining if a local PC can run modern open-weights foundation models requires calculating static weight footprints and dynamic Key-Value (KV) cache buffers. Model weights quantized at 4-bit (Q4_K_M) require approximately 0.56 GB of memory per billion parameters. A 12B model like Gemma 4 requires ~7.8 GB of VRAM for static weights plus ~1.2 GB for a 16K context KV-cache, fitting inside a 12GB RTX 4070. When total memory exceeds dedicated VRAM, runtimes like llama.cpp offload overflow layers to DDR4 or DDR5 system RAM.
What is the token generation speed penalty of offloading layers from GPU VRAM to System RAM?
Full GPU execution streams weights and attention activations through high-speed GDDR6X or GDDR7 memory buses operating between 504 and 1,792 GB/s. When layers are offloaded to system RAM, intermediate transformer activation tensors must traverse the PCIe 4.0/5.0 bus (32 to 64 GB/s) while CPU cores process layers against DDR5 channels (55 to 85 GB/s). This memory throughput bottleneck reduces autoregressive token generation speeds by 75% to 90%, typically dropping throughput from 45+ tok/s down to 4 to 8 tok/s.
How does Apple Silicon Unified Memory compare to PC NVIDIA GPUs for local LLM inference?
Apple Silicon (M2/M3/M4 Max and Ultra) employs Unified Memory Architecture (UMA) where CPU, GPU cores, and the Neural Engine access a shared LPDDR5X memory pool without a discrete PCIe transfer bus. While individual NVIDIA RTX GPUs offer higher raw memory bandwidth (up to 1,008 GB/s on RTX 4090), Apple Silicon systems with 64GB, 96GB, or 192GB can load large 105B or 236B MoE models entirely into memory without triggering layer offloading slowdowns.
Which quantization format should I choose: Q4_K_M, IQ3_XS, or Q8_0?
For 95% of consumer hardware setups, Q4_K_M (4.5 bits per weight) is the community standard, preserving 99% of dense model reasoning fidelity while reducing weight footprint by 68% compared to FP16. For massive MoE architectures such as DeepSeek V4.1 Flash (236B) or Llama 4 Maverick (401B), IQ3_XS (3.2 bits per weight) enables fitting within 64GB–96GB memory pools. Q8_0 provides near-lossless precision for sensitive code generation but doubles memory consumption.