Homelable generates interactive network diagrams for self-hosted infrastructure, mapping devices via one-click network scans and importing data from Proxmox, Zigbee, or Z-Wave for live status monitoring.

https://github.com/Pouzor/homelable https://x.com/tom_doerr/status/2075853458033222069

NVIDIA might just have solved the biggest tradeoff in LLMs.

Every LLM makes you pick between speed and quality. Autoregressive models like GPT give you quality, but they're slow, because they generate one token at a time.

Diffusion models do the opposite. They generate whole blocks in parallel, so they're fast, but that speed has always come at the cost of quality.

Before we get to NVIDIA's fix, it's worth understanding why diffusion falls behind in the first place.

A diffusion LLM starts with a block of masked tokens and unmasks them over a few passes. On every pass, it reads all the text written so far and predicts the masked tokens in that block together.

So the same network is doing two very different jobs at once. It has to understand the context that's already there while also guessing at tokens that don't exist yet.

That's one set of weights pulled in two directions, so it never gets good at either.

TwoTower fixes this by not forcing one network to do both. It clones a pretrained autoregressive model into two towers.

The first is a frozen context tower that reads everything written so far, exactly like the original did. It's never trained, so the model's intelligence stays perfectly intact.

The second is a trainable denoiser tower that fills in each new block of tokens in parallel. To stay on track, it constantly cross-attends back to the context tower.

Here's where it gets clever. The two connect layer by layer, so denoiser layer 5 talks to context layer 5, and so on.

That gives the denoiser the backbone's full multi-scale understanding, not just a final summary of it.

The results:

↳ 2.42x higher generation throughput
↳ Keeps 98.7% of the original model's quality
↳ Built on a 30B hybrid Mamba-Transformer MoE backbone
↳ Trained on just ~2.1T tokens, a fraction of the 25T used to pretrain the original

That last number is the real story. Nothing here was trained from scratch.

It's an adaptation you bolt onto an autoregressive model you already have, and it turns slow one-token-at-a-time decoding into fast parallel block generation, cheaply.

So if you're shipping anything latency-sensitive, this is a blueprint worth studying. You no longer have to choose between the model you trust and the speed you need.

Weights, code, and recipe are all open-sourced.

Link to the paper: https://arxiv.org/pdf/2606.26493

That said, if you want to go deeper, I wrote a detailed article that explains LLM inference from first principles, step by step.

The article is quoted below.

|￣￣￣￣￣￣￣￣￣￣￣￣￣ |
!Push To Production On Friday|
|＿＿＿＿＿＿ ＿＿＿＿＿＿＿|
\ (•◡•) /
\ /
——
| |
|_ |_

Managing X when we reach AGI and have space datacenters https://x.com/boneGPT/status/2075974845918023776

The open-source library of CSS motion effects, Kinetics, now contains 99 motion effects.

You can copy CSS to the clipboard or the prompt so it's easy to replicate in your AI tool.

https://kinetics.colorion.co/ https://x.com/csaba_kissi/status/2075845852849942695

Open-source meeting bot API for Google Meet, Teams, and Zoom with real-time transcription

https://github.com/Vexa-ai/vexa https://x.com/tom_doerr/status/2075579273688047630