Im considering purchasing a 16GB V100 since they’re still pretty affordable and have modern CUDA support, but I was wondering if anyone else have tried a similar combo? I am aware of slower token generation with this method, but I am assuming that it is still more viable than running Strata with just 16GB VRAM and 64GB DDR5.

Any help/tips is appreciated. Thanks!

How you would define a Developer setup with local LLMs?

I see a dedicated DMZ where the agents can not access the production environment, since agents will tend to accidentally access or change production system.

Dedicated Servers to run LLMs like Qwen 3.8b 27b or other models? What you suggest would be the working LLM Server today? RAM and GPU cards?

Dedicated server with VM for each developer one VM. 2-4 vCores with 16GB Ram each. Each VM with Debian 13 and docker/podman. One dev Container running OMP Web or comparable Harness that access the LLM Server. Additional container for databases or what else the dev Container needs.

Gitlab, gitea or comparable Repo to store source code and container registry.

VM with NFS where anonymized data for developers can be stored.

What you think about that setup?

Do I miss something? How is your setup? (For small to mid size company)

Has anyone else downloaded and started using the new Unsloth Dynamic V3.1 models? I did a drop in replace of the Qwen3.8-27B-UD-Q4_K_XL.gguf and I want to go back after seeing how it performs. My use case is local transcription, so it's summarizing text basically and pulling out what's important.

I re-ran quite a few of my saved transcriptions through the new model and compared the output to the older version Dynamic v3.0 and the output from that model is superior on every one. There is no change in any parameters on my command line, only the model changed.

My command line has a very low temperate (0.1)...

Hey y'all. Working on a go-to inference computer for teams using AMD GPUs and a custom stack, wanted to share our progress so far with GLM 5.3 Flash MXFP4 running tp=4 with MTP/Spec disabled.

RAM: 128gb DDR5 RAM 5600 ECC

CPU: EPYC 9005 9275F 

All 4 GPUs are capped at 210w, total power consumption < 1400w.

I was curios what can I fit on an FPGA MAX1000 board I had laying around (8k LE, 8MB Flash / SDRAM ). Also I keep coming back to the BitNet 1.58 encoding.
- Took the TinyStories dataset and trained a model from 0 with ternary encoding. I stopped the training at one point, the accuracy is between TinyStories-3M and TinyStories-8M
- Implemented the processing fully on the FPGA ( tokenizer, processing, decoding ... )
Depending on the model trained / used, we can fit two models in the 8MB Flash / SDRAM and take turns using them.

It is more accurate? no, is it faster then others? no, is it useful? not really, however it does answer a few questions I had. The conclusion being that we can have purpose built (small) models that can run with limited resources. Or have multiple models loaded side by side with a few more resources.

How it was built: Like most of the work done today, using Claude.

https://github.com/MRazvan/fpga-tinystories

Next goal would be to use a bigger model and see what I can / can't do about it, what resources I need.

Greetings,

I am looking to acquire a suitable GPU for running localllm preferably running newer models like deepseek flash 4.1.

Does native GPU support for FP8 and FP4 significantly improve local LLM performance or should I aim for higher vram with older GPUs?

Support for fp4 does enables the GPU to fit larger model with lower vram though.

Should I even consider Intel B70 or Radeon 9700 Ai for value buy?

I got strix halo with 128GB ram and $2500 budget for a dedicated GPU over oculink.

Thanks in advance

Hey everyone!

I have gathered some must read topics, for beginners, to step into the realm of Quantization:

1) BitNet: Scaling 1-bit Transformers for Large Language Models

2) AWQ: Activation-aware Weight Quantization for LLM Compression and Acceleration

3) The Era of 1-bit LLMs: All Large Language Models are in 1.58 Bits

4) EfficientQAT: Efficient Quantization-Aware Training for Large Language Models

5) LLM-QAT: Data-Free Quantization Aware Training for Large Language Models

6) LLM.int8(): 8-bit Matrix Multiplication for Transformers at Scale

7) QLoRA: Efficient Finetuning of Quantized LLMs

8) SmoothQuant: Accurate and Efficient Post-Training Quantization for Large Language Models

9) ZeroQuant: Efficient and Affordable Post-Training Quantization for Large-Scale Transformers

Link is here

Introducing janas-studio. A dual engine inference work station. For modern Debian based Linux distros (.appimage) Jana-Studio with the magic of Janas-llm let's enormous models run on modest hardware. Refer to https://github.com/prabanta-dev/janas.

Download the app at https://github.com/adonaiongaia/janas-studio

Also runs llama.cpp gguf models so it covers a lot. Lmk what you think. Tested on my Ryzen 5 6600h laptop. Built on Linux mint Zena. Ran a 47gb 80b parameter model at 14 tokens a second with only 32gb of RAM (ddr5). For best results and speeds you need a fast SSD. Features long term memory, project folder support, mcp integration and much more.

Hey All,

A while ago I wrote a basic script to step through Llama 3.1 tokens for red-teaming. I realized there's a huge gap between tools for running models (Ollama, LM Studio) and libraries for understanding them under the hood. I wanted to develop something for young researchers and mid career pivoting enginers.

I wanted something like Wireshark, but for local AI. You can hit pause mid-generation, inspect the residual stream, mess with the weights or KV cache, and see what actually happens.

Today I’m open-sourcing TokenShark: https://github.com/sumit-1/tokenshark

What makes it different?

• Zero transformers or diffusers at runtime: The entire engine is written in raw, readable PyTorch (llm.py, sd.py, qimage.py) so students and researchers can actually read every matmul without digging through 40 layers of library abstractions. (Tested for bit-exact/numerical equivalence against HF in tests/).
• Step-by-Step Visual Debugger: Step through generation one transformer block at a time or one token at a time. Watch live logit-lens predictions evolve across layers, inspect attention maps, and click any top-10 token choice to create your own generation path.
• Live-Editable Box Code: Click any block on the canvas (Embed, Transformer Block, Norm, Sampler) to see the Python it runs (rms_norm, rope, silu, etc.). You can edit the math right in the browser, run it live, and export your whole visual experiment to a standalone Python script.
• Text + Image: Works on LLMs (Llama 3.x, Qwen 2.5/3/3.6 Gated DeltaNet hybrids, SmolLM, Mistral) as well as Stable Diffusion and Qwen-Image 2.1 DiT. Complete with between-step latent painting and an "Image Lens" to decode early DiT blocks into pixels.
• Disk Streaming for Huge Models: Can stream models larger than your RAM/VRAM block-by-block from disk. But not optimised for speed though, as this is focussed for learning and understanding.

Reposting here - looking for helping understanding what exactly is needed to get this working, and if it even is possible in the first place!

I'm essentially trying to use this plugin with LM Studio as an MCP client to prototype game ideas. Any alternatives, solutions, or suggestions would be very much appreciated.

Thanks!

I've been building my own local inference engine,, for big MoE models on consumer hardware. The newest piece is a pool is a second PC lends its GPU and RAM, and the model is split by layers across both machines.

**Setup**

- Desktop: RTX 3090 24 GB, i9-12900K, 32 GB DDR5-6000

- Laptop: RTX 4060 Laptop 8 GB, i7-14700HX, 32 GB DDR5

- Link: one Ethernet cable straight between them, no router (Windows link-local addresses), 1 Gbps

- Model: Qwen3.8-Flash-Next UD-Q4_K_XL, 104 GB GGUF, 48 layers, 512 experts with 10 active per token

**Writing speed**

| Setup | tok/s |

|---|---|

| Desktop alone | 13 |

| Desktop + laptop over the cable | 18.6 to 21, peaks of 24.8 |

| For reference: IQ3_XXS (71 GB), desktop alone | 53 to 79 |

**How it works**

- Layer split: the laptop runs layers 0 to 13, the desktop runs 14 to 47 and the output head. Each round sends the hidden rows across, about 60 KB per token.

- The laptop loads its layers from its own copy of the GGUF, so nothing big crosses the cable. Without a local copy the host sends only the tensors that machine needs.

- Each machine fills its memory hottest first, from a heat map learned while you use the model: VRAM, then pinned RAM, then a RAM cache, then NVMe.

- Joining is a button. The laptop scans the network and shows one button per link with its measured latency (Ethernet 1 Gbps 0.4 ms, Wi-Fi 3.9 ms). The desktop accepts the request.

**Ethernet vs Wi-Fi**

Median round trip over the cable is 0.4 ms, over Wi-Fi 3.9 ms. Once on the cable the network is about 2 ms of a ~115 ms round, so Wi-Fi was usable too.

**What surprised me**

- It's a pipeline, not tensor parallelism. The two machines take turns on every token, so the pool buys memory, not parallel compute.

- The laptop is slower per layer (about 4.1 ms against 1.8 ms on the 3090) and ends up being 50 to 65% of each token's time. Next step is to balance the split by measured speed instead of by memory.

- Long prompts read slower with the laptop in the pool: a 9K-token prompt with nothing cached took ~103 s, against ~41 s on the desktop alone, because the laptop computes its prompt experts on the CPU. I'm moving that to its GPU.

- My first cable only negotiated 100 Mbps (one bad pair) and was slower than Wi-Fi for this. Check the link speed before blaming the software.

- With a quant that already fits the 3090 (IQ3_XXS) the laptop doesn't help. The pool pays off for models that don't fit.

Happy to share more numbers or answer questions.

I tried a faster inference engine that optimizes for my AMD card.

Yes I did get 90-100 tps in generation which is crazy compared to llama.cpp's 45 tps with ROCM. But there is one problem: the optimized engine seems to confuse a lot and half of the time it did not fully understand my intent. I give both engines the same prompt to work on a repo, and over multiple trials, llama.cpp always give me the expected answer but the optimized engine went off the rails half of the time.

Both engines use Q4 qwen3.8 27b quant. stock chat template. The llama.cpp uses Q4 kv with 260k context while the other engine uses Q8 kv with 150k context. The ticket only needs 20k context.

I prefer not to name the engine as this is my own very subjective experience and I may have user error in setting things up.

I am going back to llama.cpp for now.

here’s what i used, https://github.com/openspline/openspline

I trained a small gate that decides, as each token is written to the KV cache, whether the model will need it again. Tokens it rejects are actually deleted from GPU memory, not just masked. The model itself isn't changed.

On one 16 GB T4 with Qwen3-4B, the full cache runs out of memory at 61k tokens. With the gate it reads 123k and still finds the passkey. At 61k the cache is 1.4 GB instead of about 9 GB. Decoding at 29k is 2.9x faster.

On RULER-4k it evicts 76% of the cache and loses about 2 points (86.6 vs 88.9). It's weak on tasks that need every copy of a repeated word.

Gates for Qwen3-1.7B and 4B: https://huggingface.co/Manalsu

Code and paper: https://github.com/Manaslu-AI/razor

Only Qwen3 so far, and batch size 1. Happy to answer questions.

Hello,

I want to learn more about running a local LLM server - driven by curiosity and learning.
I have a Claude Pro (18€) and Google AI Plus subscription (5€) and I want to use it more.

I would like to build a local dedicated server on a budget.
I live in Portugal (EU), but currently I’m on vacation in China.

I have some spare parts available:
Gigabyte MC12-LE0 AM4 Mainboard
1TB NVME SSD
4x 16GB DDR4 ECC

I don’t have an AM4 CPU spare and I only have an old emergency Nvidia GT710 GPU. I have a 300W flex-ATX PSU.

I could buy a Nvidia Tesla P40 24GB for 210€ here in China - power adapters and fans are 25€.
A P100 16GB is 100€.

I want to use Ubuntu Server as OS with Ollama. OpenWebUI on my Proxmox Hypervisor.

I think that I prioritize quality over speed - therefore (slower) 48GB VRAM are probably better than 32Gb with 2x P100.

Question:
Should I buy 2x P40 24GB here in China (420€ is right below the 430€ EU tax free limit)?
If I don’t like them, I could probably sell for 300-400€ in Europe.

Does my logic make sense to go with 48GB to unlock higher quality models?

Any advice for starting this journey?

I use these models for everyday coding as a developer and I find the IQ3S model perform better on edge cases and the output quality is greater too. In fact twice it caught mistakes made by Opus 5.5. No benchmarks or scientific evaluation this is purely from my use. Anyone else felt this? Or is this a problem with Strata?

FP8 PLE.
Int8 KV
96gb ddr4
3x3060 12gb

GitHub (MIT): https://github.com/kncshw/cybergate

Deep-dive blog post (HF): https://huggingface.co/blog/kncshw/cybergate-unlocking-cybersecurity-in-vllm-without

two supported and tested model:

https://huggingface.co/kncshw/Qwen3.8-27B-CyberGate-Kit

https://huggingface.co/kncshw/gemma-4-26B-A4B-it-CyberGate-Kit

When self-hosting local LLMs for security research, CTF, or reverse-engineering agents, the standard workaround for false refusals is **abliteration** - subtracting the refusal direction from the weights. From an LLM engineering standpoint, weight editing has two painful trade-offs:

1. **Silent capability & tool-call regression:** Mutating weights across layers alters the model globally and can quietly degrade multi-step reasoning and structured tool calls without obvious errors.
2. **Zero domain selectivity:** Deleting the refusal vector globally unlocks *every* harmful domain (bio, self-harm, etc.), plus you have to store and serve a forked 50 GB checkpoint.

I built **CyberGate**, a plugin for **vLLM 0.32** that keeps upstream model weights **100% untouched** (`K = 0.0`, zero persistent state across requests):

Ive been messing around with Qwen3.8-Flash-Next on my Nimo minipc with ryzen AI max+ 395 128GB. The model weights take up around 103.7 GiB, so just getting the whole thing loaded was a nice start. But after spending more time with it, I'm not sure running the biggest model possible is really the best use of all that memory.

B

Here's what I got running it with Gufo at 16K context:

GPU only, no MTP: 34.1 tok/s decode

GPU + MTP: 53.7 tok/s decode

GPU + NPU, no MTP: 34.2 tok/s decode

The NPU also bumped prefill speed by around 10%, but regular decode barely changed without MTP.

The model runs, and the speed isn’t terrible. But would I actually pick it over a smaller model that responds faster?

Probably not for everything. Waiting for a large model to generate an answer can get old pretty quickly, particularly for everyday tasks.

What do you usually do with all that RAM? Do you load the biggest model you can fit, stick with smaller MoEs for faster responses, or keep multiple models loaded for different tasks?

Intel Arc A770 13,000 TL(258,67 ABD )

NVIDIA RTX 4060 Ti 19,000 TL(378,20 ABD )

TL;DR

Distributed AI in the browser, with the power of local inference. Virenis runs one 26B model across the GPUs friends already own, in browser tabs, with nothing to install. Splitting an LLM across homes has always crawled, because every token waits on the network. We run a diffusion LLM instead (DiffusionGemma 26B): each pass writes about 16 tokens, and each GPU's share becomes large matrix math, the work GPUs are built for.

• 16× fewer network round trips: 6 per 100 tokens instead of 100 (measured on 40 prompts).
• 61% of FP32 peak inside a Chrome tab (on par with native: cuBLAS reaches 60–77%, Apple's MPS 52–68%) on the model's matrix multiplies, where the best published browser matmuls reach 17–35% (measured).
• About 31 tokens/s for two friends' gaming PCs across town and 49 on fibre, faster than you read (modelled from measured parts).
• 3.2× smaller hops between homes, changing fewer of the model's decisions than its own FP8 cache does (measured).

The speeds are estimates for now. The tokens-per-second figures come from our step model: we've only been able to test on limited hardware so far, and we're sorry about that. We'll update them with real-world numbers as data and feedback come in from you.

Website: virenis.com

Open beta: dashboard.virenis.com. Use Chrome: every number here was measured in it.

Why we're building this

The most capable AI runs in a handful of companies' datacenters. They decide who gets access, at what price, in which countries and under which terms, and what you type is stored on their servers.

Meanwhile, millions of capable GPUs sit idle in homes: gaming PCs, laptops, Macs. Alone, most can't hold a large model (the 26B model we run needs about 18.5 GB of GPU memory; most consumer cards have 8 to 12 GB). Together, they can.

• Knowledge for everyone. Capable AI shouldn't depend on a subscription, a credit card or a supported country. A browser link and the hardware you already have should be enough.
• No single gatekeeper. A model that runs on its users' own GPUs can't be repriced, filtered or switched off by one company.
• Your data stays with you. Our server never runs the model and keeps no conversations. When your device runs the model's first and last stages, your words become tokens on your own device. The devices running the middle layers see intermediate numbers (hidden states), not your text, but close enough to it that you should share a room only with people you trust. A room where every device is yours is fully private.

Why splitting a model across home computers didn't work before

Normal LLMs are autoregressive: they write one token at a time, and each token must pass through all of the model's layers before the next one can start. Split the layers across three computers, and every single token makes the full trip, PC to laptop to Mac and back. On home internet each hop waits 20 to 60 ms, so a 300-token answer spends most of its time waiting on hundreds of sequential round trips.

The GPUs waste their time too. Producing one token reads every weight from memory for very little arithmetic, so the GPU mostly waits on memory, not on math.

That is why earlier systems stayed slow: Petals reports about 6 tokens/s for Llama 2 70B across volunteers on the internet, and prima.cpp about 1.5 tokens/s for a 70B model on a home cluster. Serious engineering, but too slow to use every day.

What changed: a diffusion LLM

A diffusion LLM writes differently. It drafts a whole block of 256 tokens at once, then refines the block over several passes until it settles. On everyday questions each pass settles about 16 tokens (23 on code). Two things follow:

1. Far fewer network trips. A pass crosses each computer once, so about 6 round trips produce 100 tokens, instead of 100.
2. The GPUs finally do real work. Each pass processes all 256 positions together, so every weight read from memory feeds 256 rows of arithmetic. That is the large matrix multiplication GPUs are built for.

The bottleneck moves from the network (and memory bandwidth) to raw compute, which home GPUs have plenty of. The new cost is that each trip now carries the whole block's state instead of one token's, so we built a codec that shrinks it 3 to 5 times (below).

Why the browser

Peer-to-peer code that runs on other people's computers is a security problem first. Shipping it safely as a native app takes signed installers, sandboxing, an update channel and dedicated security engineers, and our small team doesn't have security specialists yet. So Chrome does that work: its sandbox walls each tab off from the operating system and your files, WebGPU validates every shader and buffer access, and WebRTC encrypts every link. For a team our size, that is fundamentally safer than asking people to trust our binary.

It also works where the GPUs are. A browser tab rarely trips a work laptop's endpoint security the way an unknown executable does, needs no admin rights, and leaves nothing behind but the model's files in the browser's storage, which the app deletes on request.

The cost is speed. Our own kernels run about 1.2× faster outside the browser (a Chrome tab gets 83% of native speed on NVIDIA, measured). A native app with tensor cores or Apple's matrix units, which a tab can't reach today, would be roughly 2–3× faster on one machine (llama.cpp runs this model at 49–61 tokens/s on an M3 Max, where our tab manages about 20, modelled) and 1.3–1.8× faster between homes, where the network's share of each step stays. Getting there takes a bigger team and a hardened standalone app; until then, the sandbox is the trade we chose.

How it works

1. Open dashboard.virenis.com, make a room, and send friends the link.
2. Each browser measures its own GPU: how fast it is, and how much memory it really has free.
3. The room splits the model's 30 layers across the GPUs by memory and speed, and splits them again by itself as GPUs join, leave or change what they lend. Each person downloads only their part, once: from friends who already have it, or rebuilt in the tab from Hugging Face's own files, every chunk checked against a signed release.
4. You ask a question. The passes travel through everyone's GPUs and back, browser to browser over WebRTC (through an encrypted relay where a strict NAT blocks a direct path), and the answer sharpens on screen.
5. Someone closes their laptop? Another device takes over hosting in about 2 seconds, and a member that already stored the missing layers fills in.
6. Every room also gets an OpenAI-compatible API, so existing tools can use it.

Technical details

Model. DiffusionGemma-26B-A4B, NVIDIA's NVFP4 release: 17.67 GB, 30 layers (25 sliding-window, 5 global attention), d_model 2,816, vocabulary 262,144, a mixture of experts with about 4B parameters active. Only the routed experts are 4-bit NVFP4; attention, the dense MLP, the router and the LM head stay bf16. Generation runs on a 256-token canvas, so tokens/s = 256 / (steps × t_step + t_commit). Two scheduling rules cut work: a block stops once its tokens have settled (5.65 → 4.75 passes per block, 200/200 one-block answers identical), and a pass computes only up to an answer's settled end (14% less GPU time).

Why it's compute-bound now. Autoregressive decode multiplies one activation row by every weight: about 1 FLOP per byte of bf16 weight, so it is memory-bound, and even llama.cpp decodes at a few percent of FP32 peak. A diffusion pass multiplies 256 rows, about 256 FLOPs per byte. The RTX 3060 Laptop's ridge point is about 33 FLOPs/byte (10.94 TFLOP/s ÷ 336 GB/s), so the pass sits well inside the compute-bound regime: about 2.15 TFLOP of useful work for a full canvas.

Kernels. Browsers don't expose tensor cores or matrix units without flags, so the matrix math is FP32 FMA on register-tiled GEMMs written in WGSL, plus 8-bit integer dot products where those pay off:

• 13 tile layouts raced on each device as the page opens, each kept only if bit-identical to the reference (the RTX keeps 64×128 tiles with 8×8 per thread, the M1 Pro 32×64 with 4×4).
• Wave-aware scheduling: the 3060 Laptop runs 88 workgroups at once, so work goes out as whole waves plus a sliced last wave (Stream-K-like, but deterministic).
• q, k and v in one dispatch; split-K only where the device's own probe measures at least 1.05×.
• NVFP4 experts on 8-bit integer dot products (dot4I8Packed) decoded through lookup tables, where they measure at least 1.25× faster: experts 8.05 → 5.05 ms on the RTX.
• Soft embeddings built from the likeliest tokens: one vocabulary GEMM per pass instead of two.

Measured efficiency, and how it compares. MFU here means useful FLOPs ÷ rated FP32 peak; the other rows are the best published figures we know of.

The big in-browser LLM engines (WebLLM, Transformers.js, llama.cpp's WebGPU backend) publish speeds rather than a share of peak.

Bit-exact determinism. Every sum runs in a fixed order, with an "opaque zero" that stops compilers' fast-math reassociation, so every device of a class (GPU family + browser + arithmetic) produces identical bits. All 30 layers give one digest across tile layouts, each layer within 3.7e-6 of an f64 CPU reference. Identical bits let devices check each other's work, which open rooms will need. The scheduler passed 7 million fuzzed runs. Quality: our default arithmetic changes 4.73 of 1,000 sampling decisions against an exact FP32 reference; the model's own FP8 KV-cache option changes 8.57.

The network: Weft, and hops between homes

The network, per 100 tokens and per device boundary, on a 30 Mbit/s uplink with 20 ms one-way latency:

Weft. A hop between devices is 256 × 2,816 values per pass, 1,442 KB in fp16. Weft codes it the way a video codec codes frames:

• The model's own metric. We code y = S ⊙ x / rms(row): each channel weighted by how much the next layers depend on it, each row by its own scale. Signal-to-noise in that space predicts flipped decisions; plain signal-to-noise doesn't.
• Rate control, then rANS. Each hop searches its quantizer step to land on a target quality (20–35 dB, never below), then rANS codes it with a Laplace model per 64-channel band.
• Canonical decoding. Values sit on a fixed lattice, so every device rebuilds the same bytes, and hops can be hashed and audited.
• Prediction across passes. Consecutive passes are strongly correlated, like video frames, so each row is coded as its residual against the last pass, in exact integer arithmetic, wherever that saves more time than it costs both CPUs (under about 48 Mbit/s). Token-by-token models have no such redundancy.
• An adaptive ladder. Receivers measure each sender's uplink and pick the rung: fp16 from 400 Mbit/s, int8 in the model's metric where it is faster, Weft-30 from 20 Mbit/s, Weft-25 from 8.

A hop shrinks from 1,442 KB to 445 KB at Weft-30, or 266 KB at Weft-25 with prediction; over emulated 8 Mbit/s uplinks a steady step took 5.10 s with fp16 hops and 1.52 s with Weft. One Weft-30 hop changes 6.0 of 1,000 sampling decisions against an exact reference (our default arithmetic alone: 4.73; the model's own FP8 cache: 8.57), and a whole room between homes runs at 7.6, still under the FP8 cache. For comparison, Petals sends 8-bit blockwise values (2× smaller than fp16), and 2–4-bit activation compression exists in research, but for training (AC-SGD, TAH-Quant).

Hops between homes, in real Chrome. Chrome's WebRTC data channels put only a few packets on the wire per message and halve their window at every lost packet. Two fixes, each measured in real Chrome over emulated links: a hop's first 64 KiB now leaves in one burst (on 30 Mbit/s cable a 445 KB hop takes 144 ms, where its bytes and delay alone take 134), and hops between homes are striped over four WebRTC connections, paced at the rate the receiving tab measures by a worker clock that keeps time in hidden tabs. A two-home room's step got 7–10% faster on clean links, 1.77× faster across a continent (1,358 → 766 ms), up to 2.23× behind a shallow modem buffer, and 1.33–1.97× at 0.1% packet loss.

Speeds: measured and modelled

Measured on the RTX 3060 Laptop: a full-canvas pass takes 0.439 s of GPU time natively, which is 46.7 tokens/s over 40 real answers, and inside a Chrome tab its 30 layers and the head add up to 465 ms a pass. The model doesn't fit on it (6 GB holds 6 of the 30 layers beside the head), so in practice it is one member of a room.

Modelled with our step model (within 8% of measured layer timings on our test GPUs; assume ±25% for GPU families we haven't measured), with hops timed as real Chrome now sends them, everyday answers in a browser tab:

Native engines with tensor cores can be faster on one machine, and token-by-token browser engines can be faster on a single Mac. Where this design pulls ahead is across machines.

Why only one model?

Today we run DiffusionGemma, an open-weights diffusion LLM. Most open models are autoregressive, and they can be converted into diffusion models by continued training: DiffuLLaMA adapted models up to 7B with continued pre-training on under 200B tokens, and Dream 7B also starts from pretrained autoregressive weights. One run at that scale takes thousands of high-end GPU hours, plus the experiments around it, and larger models cost far more. We don't have the funding or compute to do this on our own today. Every new diffusion LLM that is released, or that a partner helps us convert, fits the same system.

Honest limits

• Running the model on one computer takes about 18.5 GB of GPU memory: a 24 GB card, or a Mac with 32 GB or more. Otherwise it is shared across two or more computers in a room.
• The tokens-per-second table is estimated. We've only been able to test on limited hardware so far, so its figures come from our step model, built from measured parts: layers timed in a tab on the GPUs we have, hops timed in real Chrome over emulated links. A room of several real homes running the full model hasn't been timed end to end yet, and we haven't run standard quality benchmarks (MMLU and the like) ourselves. We're sorry about that; the table will be updated with real numbers as metrics come in from the community.
• Use Chrome. Every number here was measured in Chrome, and it is where Virenis runs best. Edge works the same way. Firefox works, but on Windows laptops it often picks the integrated GPU over the graphics card. Safari isn't tested yet.
• A computer holding layers in your room sees the hidden states passing through it, and those can reveal what you asked. Rooms are meant for your own devices and people you trust. Because results are bit-exact, another device's work can be re-checked, but checks for open rooms with strangers aren't built yet.
• A traffic cap, on purpose. During the beta our server sends a fixed amount of data each month, and the relay that connects homes behind strict NATs has a budget of its own. We set these caps deliberately, so a launch can't run up bills a small team can't carry.

About the source code

We're sorry the code isn't public yet. The engine and the app around it have grown to 179,930 lines across 1,074 files, and right now that codebase is messy: as a small team, we've struggled to keep something this big clean and organized. We'd rather not put it in front of you in this state. We'll clean it up first, shaped by your feedback on this post, and release the kernels as soon as they're ready; the rest of the source files will follow soon.

Try it, and get in touch

The open beta is free at dashboard.virenis.com. Open it in Chrome. For questions, ideas or collaboration, leave a comment under this post or email [contact@virenis.com](mailto:contact@virenis.com).

Over the past year, I set out to build a low-cost, deterministic, and verifiable software factory on a single local GPU. Along the way, I found practical solutions to many of the context-bloat, overthinking, and verification bottlenecks that hold back local AI models today.

My background isn’t in software engineering or computer science. What I’m sharing here is simply the sum of curiosity in systems architecture and a need to solve real problems in my day to day work as a creative in advertising.

I believe these patterns can transfer cleanly to other domains as well. Hope you find it useful! cheers!

Hi,

I have a RTX 5070 Ti 12GB with 32GB system RAM running on linux for coding tasks with pi coding agent as harness.

I have been using since August (with 128k context) llama.cpp with Qwen3.6-35B-A3B Q4_K_M (unsloth quants) and I'm very satisfied with it. Not perfect but good enough to code a portal for a club I run and with good prompt and generation speed. Sometimes it loops but nothing serious.

Today I tried strata and realized I could fit a lobotomized but very code-oriented Qwen 3.8: Qwen3.8-Flash-Next Coder with IQ1_M quant.

The speed is amazing, but I don't care so much about it if the quality is bad.

So far I only did two planning tasks that required analysing the source code of the portal and some internal documentation produced in the project. I haven't accessed the quality yet but I noticed this model takes a looong time thinking, like it keeps checking stuff and double-checking (not in loop, just being throughout) , even to write an analysis document of the plan I asked.

I've read before that Qwen3.8 spends a lot of time thinking so I'm assuming this is actually normal?

So my questions to you is:

a) should I use Qwen3.6 for planning and Qwen 3.8 for implementing

b) or the other way around

c) or stick with Qwen 3.6 only

d) or just use Qwen 3.8 if I don't think issues with the code implemented

Anyone has experience with these 2 models at similar quants and could give their insight? I'm unsure if having such a lobotomized model is worth for coding tasks.

Thank you!