All Posts
39 articles, newest first.
Long Context on a 32GB Mac: Four Local LLMs, Measured to 128K
Four local models measured at 4K to 128K context on one Apple M5 32GB. Two of them are the same size; at 64K one runs 3.3x faster on half the memory. At 128K a 12B model holds the window in the same memory as a 3B one, and faster. The difference is sliding-window attention.
Cloud GPU Pricing Compared: RunPod vs Vast.ai vs Lambda (2026)
The three platforms don't just charge different rates — they sell compute in three different shapes. RunPod posts a flat rate in two tiers, Vast.ai's price is a distribution rather than a number, and Lambda quotes per GPU but sells by the configuration. Here's how that structure decides your bill, plus a July 2026 snapshot and a worked 24-hour H100 example.
Fix Common ComfyUI Installation and Out-of-Memory Errors
A 2026-current troubleshooting guide for ComfyUI's two most common headaches: install failures (torch/CUDA mismatches, failed custom nodes) and CUDA out-of-memory crashes. Includes copy-paste fixes, and why the once-standard --lowvram flag is mostly a no-op on setups where Dynamic VRAM is actually running — plus how to check whether yours is.
How to Run DeepSeek Locally with Ollama
A step-by-step 2026 guide to running DeepSeek-R1 locally with Ollama: install, pull a model, and chat in about ten minutes. Includes a registry-checked download-size table with VRAM guidance, the distilled-vs-full caveat most guides skip, model management, the local API, and troubleshooting.
How to Build a Local LLM Server with Ollama and Open WebUI
A complete, copy-pasteable guide to running a private ChatGPT-style assistant on your own machine with Ollama and Open WebUI. Covers honest hardware sizing, install steps for macOS/Windows/Linux, the Docker setup, the port binding most guides get wrong, and the networking fix that trips everyone up.
ComfyUI Workflows Explained: Load, Run, and Customize
A practical, end-to-end guide to ComfyUI workflows built around three verbs: load a workflow JSON, run the node graph, and customize it. Covers the three ways to load, the missing-custom-nodes wall that stops most downloaded workflows, and when you'd need API format.
Fix "SSL: CERTIFICATE_VERIFY_FAILED" in Python requests
The SSL: CERTIFICATE_VERIFY_FAILED error in Python requests almost always means your CA bundle can't trust the server's certificate. Here's a cause-first decision tree: identify the cause with one openssl command, then apply the right fix — updating certifi, the macOS certificate script, environment variables, truststore, or a corporate root — without ever turning verification off.
What Is Quantization? Running Big Models on Less VRAM
Quantization is what shrinks a 70B model from 140 GB to ~43 GB — enough for two consumer cards or a big-memory Mac, not one 24 GB GPU. Here's what it actually does, the memory math including the KV cache everyone forgets, how to read GGUF labels like Q4_K_M, and which quant level to pick for your VRAM.
Postgres vs SQLite for Small Apps in 2026
In 2026 the SQLite-vs-Postgres question flipped: it's no longer whether SQLite is production-ready, but whether your app actually has the concurrent-write volume that needs Postgres. A pragmatic decision guide with current versions, the single-writer trade-off, 2026 tooling (Litestream, Turso), a real cost table, and a migration trigger based on evidence rather than anticipation.
Pinecone vs pgvector vs Qdrant: Vector Databases Compared
Two axes decide this — where your data already lives, and how much infrastructure you want to run. A structural comparison of pgvector, Pinecone, and Qdrant, including why Pinecone never used HNSW, why two 2026 benchmarks disagree by 1.6–3x under identical stated conditions, and what actually separates the three.
The Best Local LLMs You Can Actually Run on 16GB and 32GB RAM (2026)
Local LLMs are free to download, so the real cost is RAM. Here's the arithmetic that decides what fits — about 0.6–0.65 GB per billion parameters, plus overhead, plus the KV cache — and a spec-checked shortlist of models that clear the 16GB and 32GB bars.
LLM API Pricing Compared: GPT vs Claude vs Gemini vs Open Models (2026)
A vendor-neutral 2026 guide to what actually decides your LLM bill: output rates, not headline input prices, and the five levers — caching, batch, length tiers, service tiers, and prompt design — that move the invoice more than switching vendors. Ends with a dated price snapshot, a worked cost example, and a pick-by-use-case verdict.
VPRM: A Critical Read of Verifiable Process Reward Models
Seven places where the VPRM paper's abstract, prose, and citations do not line up with its own tables — including two coherence numbers that cannot both be right.
Running TRELLIS.2 on a Mac (3/3): The Optimizations That Actually Won
The optimizations that survived measurement: load time cut 5x, mesh extraction 67x, and a sixth twist that overturned my own conclusion about MPS attention.
QLoRA Explained: Fine-Tuning Big LLMs on a Single GPU
QLoRA finetunes a frozen 4-bit base model into 16-bit LoRA adapters, dropping the memory to adapt a 65B model from over 780 GB to under 48 GB — one GPU instead of a cluster, with no reported quality loss. Here's how NF4, double quantization, and paged optimizers make 4-bit training work, and what the paper proves versus infers.
OpenClaw: Set Up a Self-Hosted AI Assistant (Beginner Guide)
OpenClaw is an open-source, self-hosted AI assistant you run on your own machine and talk to through chat apps like Telegram and WhatsApp. This beginner guide walks through prerequisites, install, onboarding, connecting a WhatsApp channel, picking a model, and the safety basics for a tool that runs real shell commands.
Mixtral and Mixture-of-Experts, Explained
Mixtral 8x7B holds ~47B parameters but activates only ~13B per token, matching or beating Llama 2 70B and GPT-3.5 on most metrics at a fraction of the active compute. A walkthrough of how sparse mixture-of-experts works, what the benchmarks show, and the surprising finding that expert assignment appears to align more with syntax than with domain.
RLVR Explained: Verifiable Rewards and Where They Break Down
Most RLVR explainers stop at "it works." This one adds the three published results that complicate it — pass@k, spurious rewards, and what DeepSeek-R1 actually shipped.
Running TRELLIS.2 on a Mac (2/3): Five Bottlenecks I Guessed Wrong
Five confident guesses about where the Apple Silicon port was slow — and how honest measurement killed every one, plus the profiling methodology that made the numbers trustworthy.
Ollama vs LM Studio vs llama.cpp: The Best Way to Run LLMs Locally
Ollama, LM Studio, and llama.cpp aren't really rivals — two of them wrap the third, so token speed is nearly identical. The real choice is interface and control. Here's a side-by-side comparison and a clear pick for each kind of user.
How to Set Up a Python Virtual Environment with uv
uv replaces venv, pip, and virtualenv with one fast Rust binary. This guide walks through installing uv, creating a virtual environment with uv venv, installing packages, and when to move up to uv's project workflow.
What People Are Actually Building with Claude Fable 5 (and What It Teaches)
A tour of five real things people shipped with Claude Fable 5 in its first weeks: a browser-based procedural 3D world built ~99% autonomously, and four single-prompt UI pieces from a 550-project community gallery. Plus what the corpus teaches about one-shot prompting, verification tooling, cost, and hype.
Running TRELLIS.2 on a Mac (1/3): Porting a CUDA-Only Image-to-3D Model to Apple Silicon
How I got Microsoft's CUDA-only image-to-3D model (TRELLIS.2) to run on Apple Silicon: an idempotent patcher, swapping the CUDA kernels out one by one, and the first generation.
Claude vs ChatGPT vs Gemini for Coding in 2026
By mid-2026 all three frontier models write good code — the real choice is workflow fit, not raw capability. This vendor-neutral comparison pins exact 2026 versions, prices, and benchmarks for Claude Opus 4.8, GPT-5.5, and Gemini 3.1 Pro, then gives a clear 'pick X if you're Y' verdict with the benchmark-contamination caveat built in.
Is GitHub Copilot Worth It in 2026? (vs the Free Alternatives)
GitHub Copilot's June 1, 2026 switch to token-metered AI Credits changed what your $10 buys. A 2026 re-evaluation of Copilot's paid and free tiers against Continue.dev, Cline, Aider, Windsurf, Cursor, and Tabnine — plus why Gemini's free tier is now dead — with a clear pick-for-whom verdict.
How to Install ComfyUI: A Beginner Step-by-Step Guide
A beginner-friendly, first-try install guide for ComfyUI — the free, open-source node interface for Stable Diffusion and Flux. Covers the one-click Desktop installer, the Windows Portable build, and a manual git install, plus hardware requirements and fixes for the errors beginners hit.
LoRA Explained: Low-Rank Adaptation for Cheap Fine-Tuning
LoRA freezes a pretrained model's weights and trains a tiny pair of low-rank matrices to represent the update instead. On GPT-3 175B it trains ~10,000x fewer parameters and matches full fine-tuning quality, and because the update merges back into the weights it adds zero inference latency.
One Session with Claude Fable 5 Un-Stuck My Abandoned Three.js Game
My son-inspired Three.js endless runner sat abandoned for nine months: no physics, horror-movie visuals, no real gameplay. One session with Claude Fable 5 produced 48 commits and solved exactly the systems that had me stuck — then export controls took the model offline that same day.
Running Qwen-Image on an Apple Silicon Mac: Low-VRAM Setup and Real Performance
A first-person field report on running Qwen-Image-2512, a 20B text-to-image model, on an M5 MacBook Pro with 32 GB of unified memory. It covers the memory math that forces quantization, a working ComfyUI/GGUF setup, the settings that matter, and the honest speed trade-offs.
Claude Sonnet 5: Near-Opus Agents at Sonnet Prices — With a Tokenizer Catch
Claude Sonnet 5 delivers near-Opus performance for coding and agents at $3/$15 — but a new tokenizer means the real cost math depends on which model you're coming from. Opus 4.8 users get a clean 40% saving; Sonnet 4.6 users on English-heavy workloads may effectively pay ~40% more after the intro pricing ends August 31.
Claude Fable 5 Is Back: What the 19-Day Shutdown Changed
Claude Fable 5 returned on July 1 after a 19-day, government-ordered global shutdown — and it came back changed. A new cybersecurity classifier now silently reroutes flagged requests to Claude Opus 4.8, and included subscription access ends July 7. Here's what changed, who gets access on what terms, and what the outage teaches about treating frontier models as single-vendor infrastructure.
Ollama vs vLLM vs LM Studio: Local LLM Runtimes in 2026
Ollama, vLLM, and LM Studio aren't really competitors — they live on different layers of the local LLM stack. The choice comes down to one number: how many requests hit your model at once. Here's a decision-first breakdown with the 2026 versions, tradeoffs, and a clear pick for each use case.
Cursor vs GitHub Copilot vs Windsurf: Which AI Coding Tool in 2026?
Windsurf is now Devin Desktop after Cognition's acquisition — here's how the three leading AI coding tools compare in 2026. A verified price-and-feature table for Cursor, GitHub Copilot, and Devin Desktop, plus a clear pick for each kind of developer.
KV Cache Explained: Why LLM Inference Slows Down
LLM generation slows down on long contexts because of one data structure: the KV cache. It grows linearly with every token and must be re-read in full on each decode step, making decode memory-bandwidth bound. Here is the formula, the real numbers, and how GQA, MLA, PagedAttention, and prefix caching fight back.
How LoRA Fine-Tuning Works (and When to Use It)
LoRA freezes a model's pretrained weights and trains a tiny low-rank update instead, cutting trainable parameters by ~10,000x and GPU memory by ~3x. This explainer covers how the mechanism works, what QLoRA and the variants add, and an honest, research-backed framework for when LoRA wins and when full fine-tuning still beats it.
What Is RAG? Retrieval-Augmented Generation Explained
Retrieval-Augmented Generation (RAG) grounds an LLM's answers in information it pulls from an external knowledge source at query time, instead of relying on frozen training data. Here's what RAG is, how the indexing and retrieval pipelines actually work, and when to choose it over fine-tuning or long-context.
uv vs pip vs Poetry: Python Package Managers in 2026
uv, pip, and Poetry each solve a different problem in 2026. Here is the benchmark-backed case for defaulting to uv on new projects, keeping pip as the universal baseline, and reaching for Poetry when you publish libraries — plus a skimmable decision guide and migration notes.
How to Self-Host n8n with Docker Compose on a VPS
A 2026 production guide to self-hosting n8n on a VPS with Docker Compose: official images, PostgreSQL, external task runners, automatic HTTPS via Caddy, and a backup routine that protects your encryption key. Updated for the n8n 2.0 hardening release and the March 2026 RCE disclosures.
How Speculative Decoding Speeds Up LLM Inference
Speculative decoding makes LLM inference 2-3x faster by letting a small draft model guess ahead and a large model verify the guesses in one parallel pass. A rejection-sampling step keeps the output mathematically identical to the slow path. Here's how it works, why it's lossless, and where it stops helping.