Plasmient Labs

Code that runs is proof
no marketing page can fake.

The labs are small, reproducible, open. The flagship measures the exact gap the company is about — on a single GPU, in one command. Everything here is honest about what works today versus what's still a spec.

python measure.py --workload memory --gpu 0

The mapexplore the stack →

The Frontier Stack

The whole tree, not just the seed. Eight layers stand between nanoGPT and a Claude / Cursor / Grok-class product — architecture, scaling, alignment, serving, RAG, agents, cluster — and every one can be built from open models and tools. An interactive map of where each layer hides the GPU gap the company is about.

DeepSeek-V3vLLMRAGMoEopen-source frontier

the centerpiece →The roofline: the one diagram the company rests onTwo ceilings — compute and memory — and one number, arithmetic intensity, that decides which you hit. Every other lab is a point on this chart, and utilization is the one axis it doesn’t have. Drag the probe across three GPUs.the endgame · layer 00 →Observability: the layer that measures the other sevenThe bottom of the stack, and the reason the site exists. The signature idea — the vertical trace: one timeline where kernel, op, model, and cluster line up, so you can point at a green 100% bar and read the real reason it was busy. The generalized “your GPU is lying” gauge, and the product’s verdict. Two interactive pieces.worked example →Inside a coding agent: the request lifecycleWhat actually crosses the wire when you ask Claude Code to fix a bug — stateless resend, prefix caching, and the client-side tool loop people mistake for server RAG. Two animations.landscape →The model-API landscape: four providers, one shapeClaude, OpenAI, Gemini, and xAI expose the same core and split on state, tool execution, and per-call billing — with Cursor as a harness on top and a full open-source mirror underneath. Two interactive maps.deep dive · layer 02 →Modern architecture: the 2017 block, upgradedRoPE, RMSNorm, SwiGLU, grouped-query / latent attention, mixture-of-experts — the diff between nanoGPT and DeepSeek-V3, and why nearly every upgrade is a memory story. Three interactive pieces.deep dive · layer 03 →Scaling: one model across a thousand GPUsData, tensor, pipeline, and expert parallelism — the four ways a model is split across a cluster, the collective traffic each one taxes you, and the pipeline bubble where a GPU sits idle at 100%. MFU is usually under half. Two interactive pieces.deep dive · layer 04 →Alignment: the RL loop that runs two GPUs at onceSFT, reward models, RLHF and DPO — and the sharpest thesis example on the site: RL training oscillates between memory-bound generation and compute-bound updates, spends most of its clock starved, and reads a flat 100% the whole time. Two interactive pieces.deep dive · layer 05 →Inference & serving: where the GPU lies loudestPrefill vs decode, continuous batching, PagedAttention, and speculative decoding — the layer where nvidia-smi reads 100% while goodput is half of peak. The product thesis, animated. Two live gauges.deep dive · layer 06 →RAG: retrieval, and where the GPU actually isEmbed, search, rerank, augment, generate — and the surprise that the famous part (vector search) is cheap CPU bandwidth while the real GPU bill hides in the ballooned context handed to the generator. Drag a query through embedding space. Two interactive pieces.

Code Walks

Guided read-throughs of real codebases — read, don't run. We trace how real ML and GPU systems work end to end: the actual code, explained line by line, with full references. Proof we can pick up any system and explain it.

Walk 01read now →

micrograd

The 154 lines that are the seed of every deep-learning framework. Autograd, backprop, and the training loop — explained line by line.

autogradbackpropKarpathy

Walk 02read now →

nanoGPT

The same training loop, now training a real GPT. Embeddings, the attention block, and the one function — estimate_mfu — where the whole thesis is hiding in Karpathy's own code.

transformerattentionMFU

Walk 02·Aread now →

Attention, from the paper

A deep-dive companion to Walk 02: the two figures of “Attention Is All You Need”, made interactive. Drag the query, sweep every token, and watch “it” resolve to “cat” — reading the real softmax weights off the page.

attentionmulti-headinteractive

Walk 03read now →

a CUDA matmul

The same math in CUDA, written twelve ways: from 1.3% of peak to 93%, same correct answer, all pinning nvidia-smi at 100%. This is the thesis, in code.

CUDAkernelsroofline

Walk 04read now →

FlashAttention

The attention block from Walk 02, made memory-aware. It does MORE arithmetic and runs several× faster — because attention was never compute-bound. The thesis, in the LLM era's most famous kernel.

attentionkernelsIO-aware

The repositories

Measurement code that makes the thesis real — run it on your own GPU.

★ plasmient/utilization-truth

building

The thesis, executable. Runs matmul / memory / launch-bound workloads and prints the gap between what nvidia-smi reports and the fraction of peak you actually achieve.

NVMLCUDA eventsroofline

plasmient/gpu-observability-landscape

building

An annotated map of ~98 repos across the six layers of the GPU-observability stack — and the gap none of them fill.

awesome-list6 layers

plasmient/vertical-trace

spec

The signature idea as a spec plus a minimal prototype: join two adjacent layers (op-level + device counters) on one timeline.

CUPTIDCGMcorrelation

plasmient/labs

index

The index of everything here — what runs today, what is roadmap, and how each piece maps to the thesis.