#fundamentals

The open-weight text-to-speech landscape finally has a real default: Kokoro-82M for almost everything, XTTS-v2 for zero-shot voice cloning, F5-TTS for maximum quality, and Piper for edge. A practical pick-by-use-case guide — with the licensing catches that decide which you can actually ship.

The one number that decides your entire local-AI experience. A practical VRAM-to-model map with real measured numbers from the lab — what fits at each tier (6GB → 48GB+), what 'fits' actually means once you account for context, and the fastest way to answer it for your exact card.

Local isn't a privacy magic spell — it shifts which adversaries you're defending against. A concrete threat-model breakdown: what local protects you from, what it doesn't, and the five questions that decide whether your setup earns the word 'private.'

A five-stage path from 'what is local AI' to running a multi-GPU home lab — each stage a clear outcome with the exact articles and steps to get there. No prerequisites beyond a willingness to use a terminal once or twice.

The honest total-cost number everyone asks for and nobody publishes. Upfront hardware by tier, the real monthly electricity cost (measured, not guessed), the hidden costs nobody mentions, and the break-even point against a cloud API.

The honest version of a question everyone asks and most articles answer with a slogan. Four axes — cost, privacy, latency, capability — with where each side wins, where it's a wash, and the decision rule for your specific case.

Privacy is not a feature you can toggle on a cloud API — it's a property of where the computation happens. A threat-model breakdown of what 'private' actually requires, where cloud 'private' modes fall short, and what a genuinely private local setup looks like.

Every 'best local LLM' list ranks models by reputation and parameter count. None of them actually ran the models on consumer hardware and reported measured tok/s, VRAM, and quality scores. We did. Here are the models that genuinely run well on hardware you own — with the receipts.

A start-to-finish guide to running LLMs on your own hardware in 2026 — pick the right GPU, choose a backend, pick a quantization, and pick a runtime. Every recommendation is backed by measured benchmarks, not guesses. For beginners and builders.

In 2024, Q4_K_M meant 'noticeably broken.' In 2026 it's the practical default. We ran the Q4 vs Q6 vs Q8 sweep on Qwen3-Coder-30B — here's the measured quality delta, the VRAM math, and when you actually should step up.

Every model worth running locally in 2026 — Qwen3-30B-A3B, LFM2.5-8B-A1B, the GLM/Kimi frontier — is MoE. Here's what 'active parameters' actually means, why it's the reason these models fit on your card, and the measured 2.5× speed data behind it.

Every GPU roundup ranks the same NVIDIA cards. Almost none run the same model file on Arc, AMD, and NVIDIA and report the actual tok/s gap. We did. The cross-vendor gap is real. So is the price gap — and that flips the recommendation for budget buyers.

Every backend explainer describes CUDA, ROCm, Vulkan, and SYCL correctly and then tells you to 'pick what works on your card.' Almost none measure them on the same hardware. We did, across nine benchmark records. The backend gaps are large, vendor lock-in is real, and one documented failure is worth a thousand abstract paragraphs.

Every 'home AI lab' guide describes a single workstation. None describe running models across the machines you already own. Here's the four-node cross-vendor fleet we run — Intel Arc, dual AMD, AMD APU, dual NVIDIA — the routing pattern that ties it together, and what a fleet gets you that a single big box doesn't.

The local-vs-cloud question for AI image and video generation isn't 'which is better.' It's a cost, privacy, and volume calculation — and the answer is different from the one for text. Here's the framework, the break-even math, and where each side actually wins.

The 'Ollama is easier, llama.cpp is faster' framing is from 2024 and it was correct then. What it never came with was the actual measured gap on the same card with the same weights. Here's that gap — across four backend configurations on a single R9700, plus the one result that looks like an Ollama win and isn't.

Every 'how much power does local AI use' piece multiplies GPU TDP specs by hours and calls it a day. Almost nobody measures actual wall-power during inference. We measured a narrow slice — and the headline finding is that quantization barely moves power draw. The honest version of what we have, what we don't, and the rough cost math.

Forum threads answer 'is dual GPU worth it' with 'depends.' Our four-machine baseline (bm-013) gives the actual crossover: dual-12GB-NVIDIA tied single-32GB-AMD on a 27B model. Below ~18GB of model weight the second card idles; above, dual becomes mandatory or faster. The measured rule, with the trade-offs single-card buyers forget.

Every speculative decoding explainer calls it a 'free speedup.' Almost none measure the actual multiplier on consumer hardware or show the accept-rate curve across context lengths. Here's both — Qwen3.6-27B on the same R9700 with and without MTP, plus the long-context sweep that explains when the speedup holds and when it shrinks.

Cloud LLMs got good. So why are people still buying GPUs to run models at home? Four reasons — and where the cloud still wins.