6× NVIDIA CMP 170HX GPUs running at nearly 250W EACH — ~1,500W total, 98–99% GPU utilization, yet staying at just 61–65°C! 🔥 The secret? Custom 3D-printed cooling shrouds I designed for 9733 blower fans. I now make them for other CMP 170HX owners too! 🛒 Available on my Etsy store — link in bio. #CMP170HX #3DPrinting #LocalAI partypailsto.etsy.com/listin…

6x CMP 170HX. ~250W each. ~1,500W total. 98-99% GPU utilization. 61-65°C. Damn, I love it when the numbers sit there flat and boring. That's with my custom 3D-printed shrouds for 9733 blower fans. A blower only does its job when the air is forced through the heatsink instead of leaking around it, and that's exactly what the shroud is for. If you're building with 170HX cards, the shrouds are on my Etsy shop. Check that your fan is a 9733 blower before you order. If you're not running 170HXs, ignore the pitch and enjoy the numbers.

Holy crap, a 125B model on a 16 GB GPU with only 8 GB of system RAM? This one is wild. The dev behind Lean-QwenFlash claims Qwen3.8-Flash-Next, a 125B MoE with 512 experts, runs at around 20 tok/s with the full 262k context on 16 GB of VRAM and 8 GB of RAM. The trick is direct NVMe SSD offloading. Per the README, experts that aren't cached get streamed straight off the SSD to the GPU, and all the expert math stays on the GPU. Most setups for this model want 48 to 64 GB of RAM just to hold the experts, so damn. What the README reports on an RTX 4090 with 8 GB RAM and a 4-bit KV cache: - 8k context: 28 to 33 tok/s on prose, 19 to 22 on code - 100k context: 20.8 tok/s decode, 1,536 tok/s prefill - 262k context: 20.0 tok/s decode, 1,627 tok/s prefill - RTX 3080 Laptop 16 GB at 100k: about 18 to 21 tok/s, using 19 to 24 GB of system RAM The video is a screen recording of the chat UI answering a jet engine prompt. It ends on a 32.9 tok/s decode readout for 228 tokens, with RTX 4090 and 8 GiB RAM cap labelled on screen. How to try it, OpenAI-compatible server included: git clone github.com/MaxDevv/lean-qwen… python compile_local.py python download_http.py --model-dir ./model python qwen_server.py --model ./model --store ./store/qwen.bin --ram-gb 8 --cache 262144 --port 30000 Honest caveat: needs Linux, a fast NVMe SSD, CUDA 12.4+ and about 85 GB of downloads plus a 47 GB packed store. 12 GB and 8 GB GPUs are untested. #LocalAI Bookmark this for later. MaxDevv/lean-qwenflash

I gave a CMP 170HX mining GPU and two RTX 5090s the same 15,000 images to generate. The 5090 is faster, but the 170HX is more efficient. Same model, same settings (Qwen-Image 2.1, int8, 25 steps, 1 MP): • CMP 170HX: 9.1 s per image, 207 W, 0.53 Wh per image • RTX 5090: 5.2 s per image, 399 W, 0.58 Wh per image That's about 10% less energy per image on a card people call e-waste. All three cards together make roughly 41 images per minute, and the full run takes about 18 hours. Fairness notes: the 170HX runs a fine-tune of the same architecture, my 5090s are power-limited to 455 W, and times are medians of the last 200 images. The screenshot is my live dashboard. Every tile is a real image. Would you put a 170HX in your AI rig?

Buying a used GPU? Run this before the return window closes. Holy crap, I wish more people knew about memtest_vulkan. It's a free, open-source tool that stress tests your card's video memory, and VRAM faults are the sneaky kind of problem a used card can hide. What the README says: • Written in Vulkan compute, so it's cross-platform: Windows, plus Linux on x86_64 and AARCH64 • Needs a driver that supports Vulkan 1.1, which most graphics drivers already include • On Windows, just double-click the .exe. No install, no admin rights • Start it, wait at least 6 minutes, hit Ctrl+C. Errors are shown immediately • The 6 minutes is on purpose: some errors only show up once the card is hot • If it reports errors, the PC has hardware problems On Linux, run ./memtest_vulkan from a terminal, not by double-clicking it. Caveat: a clean run is a good sign, not a guarantee. Per the README, rare near-the-limit errors can take 2-3 hours of runtime to catch. Bookmark this for later. GpuZelenograd/memtest_vulkan

Damn, a new Apache 2.0 open model just dropped and it's going straight at agentic coding. Nanbeige4.3-33B: 33B parameters, 512K context, built for coding agents and tool use. It's the "teacher" for a smaller 3B distill they've announced. Lab-reported scores vs Qwen3.8-27B (from the model card): • Terminal-Bench 2.1: 80.9 vs 73.0 • DeepSWE: 65.5 vs 42.5 • Toolathlon-Verified: 70.4 vs 68.5 • SWE-Bench Pro: 60.3 vs 61.7 (Qwen wins this one) Why it matters for local rigs: • Open weights you can self-host, no API meter • Runs with Transformers, SGLang or vLLM • Chat template supports tool calls and toggleable thinking Try it: grab the weights from Hugging Face, serve with vLLM, point your agent at the endpoint. Caveats: every benchmark above is self-reported by the lab. At full precision 33B won't fit a single 24GB card, so you'll want a quant, and community quants are still early. Test it on your own repo before you switch. This is insane for an open ~30B. Bookmark this for later. huggingface.co/Nanbeige/Nanb…

Real talk, local AI builders. You've got ~$1,000 for GPUs. What are you buying? A) One used 24GB card B) Two used 16GB cards C) Four or more cheap 8-12GB cards D) Something weird (unlocked mining cards, old server GPUs) Why this is a damn hard call: • One big card = simplest setup, no model splitting, usually the lowest power draw • Multiple cards = more total VRAM per dollar, but you need slots, a serious PSU, cooling and enough PCIe lanes • llama.cpp and vLLM can split a model across cards, so pooled VRAM works, but one card is always less hassle Drop your pick and the model you're trying to run. I want to see who's got the wildest answer. 👇

This is absolutely nuts: a 27B model on ONE 24GB RTX 3090, served with vLLM, 150k context, OpenAI-compatible API. HyperQwen is an open-source (Apache 2.0) patch series on a pinned vLLM plus a model-prep pipeline for Qwen3.8-27B. The README's numbers on a 3090 at 250 W: • 127 tok/s single-stream • ~1,035 tok/s aggregate at 64 concurrent requests • 381 tok/s when the answer quotes its own prompt Where it shines: • Coding assistants applying edits • RAG front-ends and document rewrites • A private API backend for your own agents Try it: • git clone the repo, cp .env.example .env • docker compose --profile single up -d (or --profile batch for many users) • Set a VLLM_API_KEY before exposing the port Caveats: the 381 figure only happens when output repeats the input. Normal chat is the 127 mode. First start pulls a 9.5 GB image and requantizes ~20 GB of weights. The README says it has only been run on 3090 and 3080 cards so far. Holy crap, software alone. Bookmark this for later. github.com/syv-ai/HyperQwen

Holy crap, Google just dropped Genie 4 and it's a real-time interactive world model 🌐 You type a prompt and you're walking around inside a world. A WASD keyboard overlay shows you steering it live, and you can keep typing to change the scene on the fly: add a shooting star, drop a piano in the snow, or have giant alien tentacles tear up the city behind a moped. It generates ambient sound and character speech too, not just pixels. The part that matters for us: they showed 16 simulated robot arms pipetting in a grid, then a real arm doing the same task in a lab. Practicing robots in a generated world is the real endgame here. Their own disclaimer says the clips are for illustrative purposes and shortened, and there are no resolution or frame rate numbers, so I'm waiting to see how it runs outside a demo.

Stop guessing if a model fits your GPU. The napkin math takes 10 seconds. Weights ≈ parameters × bits per weight ÷ 8 • 8B at 4-bit ≈ 4GB • 32B at 4-bit ≈ 16GB • 70B at 4-bit ≈ 35GB • 70B at 8-bit ≈ 70GB • 70B at 16-bit ≈ 140GB Damn, that's why 16-bit 70B is a data-center problem and 4-bit is a home-lab problem. But weights are only part of the bill: • KV cache grows with context length, so long context eats several more GB • CUDA and runtime overhead take a chunk • Real Q4_K_M files come out a bit bigger than the raw 4-bit math because some tensors stay at higher precision Safe rule of thumb: take the file size, add 10-20% headroom, then add KV cache for the context you actually use. That's why a 70B at 4-bit won't fit on one 24GB card, but two 24GB cards give you 48GB to split it across. Caveat: MoE models only activate some experts per token, but you still need all the weights in memory (or offloaded). Do the math before you buy the card.

Holy crap, someone made ComfyUI wires look like an actual professional cable bundle and I can't stop watching this. You know that spaghetti mess of wires in a big ComfyUI graph? This extension zip ties them into one clean ribbon. Hold Z, drag a line across the wires, and boom, seven wires get bundled into a tidy braid with little zip ties. Then you drag the ties around and the whole bundle bends with them. This is insane for a graph that looks like a plate of noodles. What it does, straight from the README: - Hold Z and drag across wires to tie them together - Drag a tie to move it, Shift-drag to rotate it in 15 degree steps - Right-click a tie to change colour or remove it - Ties get a random cable-tie colour, or you can set them to match the wires - Ties are saved in the workflow itself, so they save, load and undo with the graph - No new nodes and no Python dependencies, it's one frontend file How to try it: comfy node install comfyui-zip-ties Or search for Zip Ties in ComfyUI-Manager. Manual install: cd ComfyUI/custom_nodes git clone github.com/safzanpirani/comf… Honest caveat: wires that pass through native reroutes can't be tied, and the README says it was tested on ComfyUI 0.42.0 with frontend 1.57.1. The creator calls it just for fun, but damn, it's a satisfying one. MIT licensed. #ComfyUI Bookmark this for later. safzanpirani/comfyui-zip-ties

PCIe x1 is supposed to kill LLM inference. I ran a 262K-token context across two CMP 170HX cards on PCIe Gen2 x1 and it didn't. The setup: • 2× unlocked CMP 170HX • Both GPUs on PCIe Gen2 x1 links • Qwen3.8-Flash-Next-W4A16-FP8PLE in vLLM 0.29.0, pipeline parallel 2, MTP 3 The numbers: • 186.93 output tokens/sec at 8 concurrent requests • 4,770 input tokens/sec on a cold 262K prefill • 121,035 effective input tokens/sec with a warm cached prefix • Prefix caching cut time to first token by up to 25x • Tool calling and long-context retrieval passed • No OOMs, CUDA errors, NCCL errors or deadlocks Why it works: once the model sits in VRAM, the slow link barely matters, because the GPUs aren't constantly shuffling weights over it. Cheap cards can do real serving. How far do you think this scales?

Holy crap, this fixes the thing every agent-plus-notes setup gets wrong: finding the right file. QMD is a free, MIT-licensed, on-device search engine for your markdown notes, meeting transcripts, docs and knowledge bases. It's built to be called by agents. What the README says: • Hybrid search: BM25 keywords + vector semantic search + LLM re-ranking • Everything runs locally through node-llama-cpp with GGUF models • Default models are tiny: ~300MB embeddings, ~640MB reranker, ~1.1GB query expansion • Has --json output and an MCP server, so Claude Code or any MCP client can query your notes • You can attach context to each collection so results make more sense to the LLM How to try it: npm install -g @tobilu/qmd qmd collection add ~/notes --name notes qmd embed qmd query "how did I fix that CUDA error" Caveat: first run downloads the GGUF models from Hugging Face, and if you swap the embedding model you have to re-run qmd embed. Your local rig can quietly run your whole second brain. Bookmark this for later. tobi/qmd

Holy shit, your old RTX 30-series card might be hiding half its tensor speed. An open-source Linux kernel module called gpu-unlock flips the FP16/BF16 instruction rate on GA102, GA103, GA104 and GA106 cards to the full "professional" rate. It runs before the NVIDIA driver loads, so there's no patched driver to babysit. The README's numbers on a 3090 Ti (8192³ GEMM, FP32 accumulate, 450 W): • BF16: 87.5 → 157.4 TFLOPS • FP16: 87.5 → 118.4 TFLOPS • TF32: 42.6 → 82.6 TFLOPS Why local builders should care: • LLM prefill gains of +14–36% in user reports • Diffusion and FlashAttention speed up too • Decode stays about the same (memory-bound) • Reports found outputs bit-identical before/after How to try it: • git clone, then make install • Add gpu_unlock.targets=all to your kernel command line • Reboot, then check journalctl -k -b | grep gpu_unlock Caveats: it writes GPU registers, so keep a fallback boot entry. Gains shrink under low power caps (+25% on 225 W cards). Damn, free speed from a kernel module. Bookmark this for later. github.com/Zagitta/gpu-unloc…

Holy crap, a 96GB RTX 5090 might actually be coming 🔥 Reportedly, card-mod shops in China are already testing it and getting ready for batch shipments. These are the same shops that turned the RTX 4090 into a 48GB card, and now they've set their sights on the 5090. The rumored recipe: take the GB202 core off a stock 5090 and move it onto a custom dual-slot blower PCB with 96GB of GDDR7. That's triple the 32GB on the normal card, aimed squarely at AI inference and compute servers. Why local AI people should care: VRAM is the real limit for running big models at home. 96GB on one card could mean 70B-class models at high quality, or huge context windows, without splitting across multiple GPUs. The dual-slot blower design also means you could pack several into a rack. The caveat: this is still a rumor. No confirmed specs, pricing, or availability yet, and modded cards come with no warranty and uncertain driver behavior. But damn, if it ships, the whole used-GPU market gets shaken up.

DeepSeek has reportedly released an open-source inference framework for its own models. Why local builders should care: inference speed on your own hardware comes from the software stack as much as the model. Faster engines mean: • more tokens per second on the same GPU • bigger models fitting on cheaper cards • less reason to pay per token

Heads up for anyone planning a GPU build: memory prices may jump next year. Reports say Samsung has sold out its 2027 high-bandwidth memory, with HBM prices expected to rise sharply and ordinary DRAM up as well. Why it matters: the AI boom competes for the same memory your next GPU or RAM kit needs. If a rig is on your list, price it now. Used cards with plenty of VRAM are where I'd look first.

Nvidia ships consumer cards with tensor math throttled in software. Now people are posting real before and after numbers: 4070 Ti SUPER: 158.5 → 309.1 TFLOP/s (via @CommonFoundry1) Worth asking: what else is locked on the card you already own?

Models keep disappearing from Hugging Face, and local AI folks are noticing. If you depend on a model, it can vanish: taken down, gated, or replaced. What I do: 1. Download the weights you actually use, not just the link 2. Keep the exact quantization and settings that worked for you 3. Store a copy on a separate drive Cloud APIs can change or disappear overnight. Local only stays local if you keep the files. Own your compute. Own your weights.

Common Foundry (@CommonFoundry1) reports a ~1.95x tensor speedup on an RTX 4070 Ti SUPER: 158.54 → 309.08 TFLOP/s, FP8→FP32 matched GEMM Same GPU, same binary, same 240 W cap. I've seen the same kind of unlock on my own 3080. xitter.cf/CommonFoundry1/status/…

Due to major hype on Grok Bot, I tried it for few real world tasks. For example, Managing my Etsy shop: I linked the Etsy shop, gave access to my shipping platform so it had shopping data. Sent the 3d files so it knows the product weight. I asked it to do analysis for my product. And it told me it doesn’t know my shipping cost. It doesn’t know my product weight. It told me to provide these information. For those who have used a normal coding agents like Claude/codex/deepseek, you know if you have provided access to relevant platform , it will just automatically go pull your data. Instead Grok Bot just acts it has no previous context. I guess Grok bot is aimed at normie who doesn’t use agentic workflow. For those who AI heavy users, you’re not missing much. It is just an Openclaw/hermes minus extensive setup/maintenance tax . It underperforms compare what you can do with Claude/codex