LocalLLM Rigs

Local LLM rigs compared: the best hardware for running models at home

This site compares hardware for running open-weight models locally: Apple silicon Macs, AMD Strix Halo mini PCs and discrete-GPU desktops, judged on the specs that decide what fits and how fast it runs. Every pick is researched from manufacturer data, retailer listings and independent benchmarks, then compared on the same criteria: how many parameters fit, how fast tokens come out, and what that costs.

Buyer’s guide

The best mini PCs for local AI

Memory sets your ceiling: 16GB runs 8B models, 64GB reaches 70B at 4-bit, and 128GB Strix Halo or GB10 boxes take larger open-weight models.

Read more →

Top picks

Editor’s Choice
Apple Mac Studio (M3 Ultra)

Up to 512GB of unified memory for very large local LLMs on one desk

  • 512GB memory fits huge quantized models
  • 80-core GPU speeds token generation
  • 120Gb/s Thunderbolt 5 for Mac clustering
  • No CUDA: some AI tools unsupported
  • Prompt processing trails high-end NVIDIA GPUs
★★★★★ 4.6
Runner-up
Apple Mac mini (M4 Pro, 64GB)

64GB unified memory for 70B-class local models in a desk-sized box

  • 64GB shared memory fits 70B-class quants
  • Small chassis runs quietly on a desk
  • Front USB-C for quick drive swaps
  • No CUDA, so fewer fine-tuning tools
  • Prompt processing slower than Nvidia GPUs
★★★★★ 4.5
Apple Mac Studio (M4 Max)

Up to 128GB unified memory in a 7.7-inch box for large local models

  • 128GB unified memory loads large models
  • 7.7-inch square fits under monitors
  • Quiet cooling during long inference runs
  • No CUDA: some AI tools unsupported
  • Memory fixed at purchase, no upgrades
★★★★★ 4.5 $3,399.00
GMKtec EVO-X2 (Ryzen AI Max+ 395, 128GB)

128GB unified memory to run 70B-class models locally

  • 128GB shared memory: fits 70B models
  • 120W mode for long inference runs
  • Two M.2 slots for model libraries
  • Soldered memory: cannot upgrade beyond 128GB
  • LPDDR5X: fewer tokens/sec than RTX VRAM
★★★★★ 4.5 $3,499.99
Best Value
Minisforum MS-S1 Max

Ryzen AI Max+ 395 mini PC with dual 10GbE and a PCIe x16 slot for LLM clusters

  • 64GB shared memory sidesteps VRAM limits
  • Dual 10GbE for multi-unit clustering
  • PCIe x16 slot for add-in cards
  • 235B Q4 needs two units
  • Soldered LPDDR5x: no memory upgrades
★★★★★ 4.4 $2,599.00
NVIDIA DGX Spark

128GB unified memory and a 4TB SSD for running large open-weight LLMs on your desk

  • 128GB memory: larger models fit
  • 4TB SSD stores many models
  • 6-year seller warranty included
  • Upgrade voids NVIDIA's original warranty
  • Slower tokens than high-end discrete GPUs
★★★★★ 4.3 $8,699.99
Editor's Choice
Acer Veriton GN100

128GB unified memory and 20 cores for running large local models at your desk

  • 128GB shared memory fits larger models
  • 20 cores handle data-prep workloads
  • Up to 4TB SSD for models
  • Upgrade voids Acer's original warranty
  • Apps need manual install and setup
★★★★★ 4.2 $6,699.99
Apple Mac mini (M4, 16GB)

A 5x5-inch M4 box with 16GB unified memory for small local models

  • 16GB unified memory runs small models
  • 5x5-inch footprint fits beside monitors
  • Thunderbolt: fast external model storage
  • 16GB rules out larger models
  • Memory can't be upgraded later
★★★★★ 4.2

Prices as of Nov 16, 2026; they may have changed since.

Top reviews

  1. 1
    Review Acer Veriton GN100
    4.2
  2. 2
    Review Apple Mac mini (M4, 16GB)
    4.2
  3. 3
    Review Apple Mac mini (M4 Pro, 64GB)
    4.5
  4. 4
    Review Apple Mac Studio (M3 Ultra)
    4.6
  5. 5
    Review Apple Mac Studio (M4 Max)
    4.5

Browse by category

Latest reviews

Guides & articles

Size the rig to the model, not the spec sheet

Start with the open-weight models you actually plan to run, then work backwards to hardware. Parameter count and quantization level set the memory floor. If the weights don't fit, nothing else on the spec sheet matters.

Most people running models at home use Q4_K_M, a 4-bit quantization that keeps quality close to the original while cutting size by roughly three-quarters versus FP16. At that level the numbers are simple to remember:

Model size Q4_K_M (weights only) Q8_0 (approx.) FP16 (approx.) Typical local use
8B ~5 GB ~8.5 GB ~16 GB Chat, autocomplete, quick coding help
32B ~20 GB ~34 GB ~64 GB Serious coding assistants, reasoning, drafting
70B ~40–43 GB ~75 GB ~140 GB Near-frontier chat, complex analysis

These figures cover weights only. Every token in the context window also needs room in the KV cache, and that grows linearly with context length. A long context window adds several GB, and on a 70B model it can pass 10 GB. So a 32B model at ~20 GB fits a 24 GB GPU for everyday chat, but not once you ask it to read a large codebase. It loads, then runs out of room or falls back to slower system RAM.

Budget headroom, not an exact fit

Plan for weights + KV cache + 15–20% spare. On Apple silicon and Strix Halo, the OS and other apps share the same unified memory pool, so the whole figure is never available to the model. A 64 GB machine is a comfortable 70B Q4_K_M home. A 48 GB one is a squeeze.

Where the platforms split

8B–32B covers most home use. Coding assistants and everyday chat run well in that range, and nearly every rig in this comparison handles it. A 24 GB discrete GPU, a 32 GB-plus Mac or a Strix Halo box will all load a 32B model at Q4_K_M with sensible context. At this size you're choosing on speed, noise and price, not on whether the model fits.

70B and larger is where the field divides. At roughly 40–43 GB before context, a 70B model won't fit on a single 24 GB card. You'd need two GPUs or have to offload layers to system RAM, which slows generation sharply. The large unified memory pools of higher-memory Macs and 128 GB Strix Halo systems hold it in one piece. Above 70B, such as 100B-plus mixture-of-experts models, only the largest unified memory configurations stay in play.

So the first question is "what's the biggest model I'll run every week?", not "what's fastest?" Buy the memory capacity that answers it, then compare speed among the rigs that pass.

The mistake most buyers make: capacity without bandwidth

A spec sheet that says "128 GB unified memory" tells you a 70B model will load. It doesn't tell you whether it will run fast enough to hold a conversation. That second question is answered by memory bandwidth, and it's where many first-time buyers get caught out.

During generation, the chip streams essentially the entire set of weights from memory for every token it produces. That gives you a simple rule of thumb: memory bandwidth ÷ model size in memory ≈ the ceiling on tokens per second (tok/s). Real-world speeds land below that ceiling, never above it.

Model at Q4_K_M (approx. size) Strix Halo (~256 GB/s) M3 Ultra (~819 GB/s) RTX 4090 (~1,008 GB/s, 24 GB)
8B (~5 GB) ~50 tok/s ceiling ~160 tok/s ceiling ~200 tok/s ceiling
32B (~20 GB) ~13 tok/s ceiling ~40 tok/s ceiling ~50 tok/s ceiling
70B (~40 GB) ~6 tok/s ceiling ~20 tok/s ceiling Doesn't fit in 24 GB

That 70B row is the decision point. On Strix Halo, a 40 GB 70B model tops out around 6 tok/s, and real output lands below that, which feels sluggish for back-and-forth chat. An M3 Ultra's ceiling for the same file is about 20 tok/s, and roughly 15–20 tok/s in practice is comfortable. Both machines have the capacity. Only one has the bandwidth to make 70B pleasant to use. Strix Halo is far better suited to 32B-class models, where its ~13 tok/s ceiling is still workable for chat.

The other half: prefill

Bandwidth governs output. Prompt processing (prefill) works differently. Reading your input is compute-bound, because the chip handles all the prompt tokens in parallel rather than streaming weights once per token. NVIDIA GPUs have far more raw compute for this step. As a result, Macs and Strix Halo show a noticeably longer time to first token (TTFT) when the prompt is long, even when their tok/s figures look respectable.

For short chat prompts you'll barely notice the gap. If you paste in a 30-page contract or a large chunk of a repository, the wait before the first word appears can rival the time spent generating a short answer.

Pro tip

Work out which way your traffic flows. If your typical session is long documents or codebases in, short answers out, prefill speed matters as much as tok/s. That favours a discrete NVIDIA GPU, provided the model fits in its VRAM. If you mostly chat or generate long outputs from short prompts, prioritise bandwidth and unified memory capacity instead.