#comparison

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.

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.

The framing most posts use — 'Ollama is easier, llama.cpp is faster' — is from 2024. In 2026 the real question is whether you're running one model for yourself or serving many. Here's the honest decision rule, including where vLLM and SGLang have eaten Ollama's edge.

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.

Replicate, fal.ai, Midjourney, and OpenAI compared for cloud image generation. The billing models differ more than the models do — per-second, per-image, subscription, and token-bundled each win for different usage patterns. Here's the decision tree.

Cloud video generation has the widest price range in AI media — $0.13 to $3.20 per clip. Runway, fal.ai, Pika, and Sora compared on pricing models, quality, and content control, with a decision tree for which provider wins for which use case.

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.

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.

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.

We ran the same two 8B models on both cards with byte-identical weights and identical settings. The RX 7900 XT is ~3.9x faster — consistently across both architectures. Here's the full 2x2, what it actually tells you, and where we got the framing wrong the first time.