2026-09-24 · 5 min read

Best Consumer Local AI Build of September 2026: Dual RTX 3090 or 4090 Running Qwen 3.8 27B at 3.5 bpw

September 2026 is a remarkable moment for local artificial intelligence. A consumer workstation built around two RTX 3090 cards, or two RTX 4090 cards, can now run a 27-billion-parameter model with a 256k token context window entirely offline. The key enabler is the Qwen 3.8 27B GSQ-RCO GGUF release, a quantized checkpoint that reaches 3.5 bits per weight while matching the accuracy of the original base model. This article explains the hardware choices, the quantization science behind GSQ and RCO, and the exact llama.cpp configuration needed to reproduce the result at home.

Why Two RTX 3090s Remain the Smartest Choice

Both the RTX 3090 and the RTX 4090 ship with 24 GB of VRAM, and that capacity, not raw compute, is what limits local inference. Two cards give you 48 GB of usable memory, which is the sweet spot for a 27B model plus a very large key-value cache. The 4090 is roughly twice as fast in token generation and noticeably quicker during prompt processing, but it costs far more per gigabyte. For most enthusiasts, a pair of used 3090s delivers the best balance of price, memory and reliability. If your budget allows, mixing one 4090 with one 3090 also works, though the slower card sets the pace for tensor-parallel workloads. Whichever pair you choose, make sure your power supply can deliver at least 850 watts and that your motherboard exposes two PCIe x16 slots with adequate airflow between them.

GSQ and RCO: How 3.5 Bits Match the Base Model

The Qwen 3.8 27B GSQ-RCO GGUF checkpoint comes from the Distributed Algorithms and Systems Lab and combines two complementary techniques. Gumbel-Softmax Quantization (GSQ) is a post-training scalar quantization method that jointly learns the per-coordinate grid assignments and the per-group scales through a Gumbel-Softmax relaxation. Instead of rounding every weight to the same grid, GSQ searches for the best assignment per coordinate, which closes most of the gap between scalar and vector quantization at two to three bits while remaining deployable in standard scalar formats such as GGUF. Riemannian Constrained Optimization (RCO) then assigns one of K quantization types to each of the N tensors under a total size budget. The budget constraint is reformulated as a smooth Riemannian manifold in logit space, which permits gradient-based optimization directly on the task loss while enforcing the budget exactly, without constraint-specific hyperparameter tuning.

Task average versus average bit width plot for Qwen 3.8 27B GSQ-RCO

The practical consequence is visible in the published task-average versus average-bit-width plot: at 3.5 bpw the GSQ-RCO build tracks the unquantized base model closely and clearly outperforms three-bit Unsloth dynamic quants at the same footprint. Perplexity stays low, and downstream reasoning, coding and multilingual benchmarks remain stable.

KV Cache, Q8 Precision and a Full 256k Context

A 256k context window is memory-hungry, but 48 GB is enough when the weights are small. At 3.5 bpw the model occupies roughly 12 to 14 GB, leaving more than 30 GB for activations and the KV cache. Quantizing the cache to Q8 keeps long-context reasoning coherent while halving its footprint compared with FP16. To reach the full 262,144 tokens you must split the model across both GPUs with tensor parallelism and offload every layer, including the cache, to the GPUs. If you run short of VRAM, drop the cache to Q4_0 as a fallback, but expect a measurable loss of coherence beyond 100k tokens.

Recommended settings for a dual-GPU build
ComponentRecommended settingWhy it matters
GPUs2 x RTX 3090 or 2 x RTX 409048 GB of total VRAM for weights and cache
ModelQwen 3.8 27B GSQ-RCO GGUF at 3.5 bpwBase-model accuracy at a low memory cost
KV cacheQ8_0Coherent reasoning over long contexts
Context length262,144 tokensFull 256k window across both GPUs
GPU offloadAll layers on GPU, tensor split 1.0 / 1.0Even load distribution between the cards
← Scroll right to see more →

Hosting Locally with llama.cpp

Because GSQ-RCO checkpoints are ordinary GGUF files, no custom fork is required. Download the latest llama.cpp build, fetch the quantized model from the link below, and launch the server with tensor splitting, full GPU offload and a Q8 cache. Set the context length to 262144 and enable flash attention. If your build supports multi-token prediction, turn it on: it can substantially raise generation throughput on dual-GPU systems. Watch VRAM during the first load; if allocation fails, confirm that the cache is quantized and that no other process is holding memory.

Practical Tuning Notes

For maximum fidelity, the Unsloth UD Q4 build remains a strong alternative, but its perplexity is higher than the GSQ-RCO 3.5 bpw release, so the latter is the better default when you want the largest context at the lowest memory cost. Keep your drivers current, pin the process to performance mode, and monitor temperatures, since two 3090s under sustained load produce serious heat. With careful tuning, this build delivers near-datacenter quality inference from a desk-side machine.

Let's work together

Do you need more info, help with your project, or to develop an idea?

Whether it's an easy question, a quick doubt, or just a 5-minute chat, send me a message—it costs nothing and I'm always ready to help. I love discussing a problem to understand it, getting creative with solutions, and focusing on simple, reliable, and straightforward ideas that we can actuate quickly.

Contact me →

Switch Topic

Choose a specialized topic to explore: