# RTX 5080 vs RTX 3080 Ti

*A ZOTAC GeForce RTX 5080 Solid CORE OC, 16 GB, wrote text 9 to 22 per cent faster than an NVIDIA GeForce RTX 3080 Ti Founders Edition, 12 GB. Both were held to 300 watts in the same slot of the same computer, on seven builds of four language models of up to twelve billion parameters. Its board used 24 to 45 per cent less energy per token. The catch is memory. Three bigger models this workshop most wanted did not fit whole in 16 GB. Under ollama's own planner, part of each went to system memory while 0.74 to 1.73 GiB of the card sat empty. No one overrode the planner by hand.*

*Published 2026-09-25 (UTC) · A small (human) team and a fleet of AI agents.*

**the short version:** at the same 300 W, this 5080 wrote text 9 to 22 per cent faster than a 3080 Ti Founders Edition, 12 GB. That held on all seven builds it ran, four language models of twelve billion parameters or under, in the same slot of the same computer, four days apart. That Founders Edition carries the same chip as a 3090, with half the memory, and cost about $1,000 less than this 5080: $699.97 refurbished against $1,649.00 new, both before tax. At 300 W this 5080's board used 24 to 45 per cent fewer joules per thousand tokens, and it trained the workshop's music adapter 1.73 times as fast. With each card at its own default, and the prompt's encoding already cached, it drew pictures 1.60 to 1.69 times as fast, and up to 2.82 where its log shows an fp8 or fp4 path. Its 360 W default adds 60 W, which bought at most 2.6 per cent. Memory cuts both ways. With the KV cache at eight bits, its 16 GB held a 12-billion-parameter model to 262,144 tokens, that model's own maximum; the 12 GB card stopped at 73,216. But under ollama's planner, gemma4:26b, its QAT build and mistral-small3.2:24b did not fit whole at any window, as ollama ships them.

8,968 words · about 41 minutes (at 220 words/min) · 18 tables · data kit: no

https://research.strata2signal.com/rtx-5080-vs-rtx-3080-ti/

---

*[strata→signal](https://strata2signal.com) is a small workshop that runs its own machines and writes up what it measures. This is the first 16 GB card it has measured; the [3090 and 3090 Ti](https://research.strata2signal.com/one-3090-against-one-3090-ti/), [two-3080](https://research.strata2signal.com/two-used-3080s-priced/) and [laptop](https://research.strata2signal.com/a-laptop-asked-the-desktops-questions/) pages came before it. Its language numbers come from a different test program from those pages': the one that measured that 3080 Ti Founders Edition and an EVGA GeForce RTX 3080 FTW3 Ultra, 10 GB, in this same slot, four and five days earlier. It is the first page to publish that Founders Edition's measured rows.*

**The chip.** A 3080 Ti is built on the same chip as a 3090, NVIDIA's GA102, with 2.4 per cent fewer cores enabled (10,240 against 10,496, by NVIDIA's own pages) and the same 384-bit memory bus, but half the memory: 12 GB of GDDR6X against 24. The driver read 12,288 MiB on that Founders Edition; an EVGA GeForce RTX 3090 XC3 Ultra read 24,576 MiB on [an earlier page](https://research.strata2signal.com/one-3090-against-one-3090-ti/). The chip is the same; the cards are not, and of the two only a 3090 has an NVLink connector.

**The price.** In September 2026 this workshop's two refurbished 3080 Tis each cost about $1,000 less than this 5080 bought new: that Founders Edition, the card measured here, $699.97 before tax against this card's $1,649.00, $949.03 less; and an EVGA GeForce RTX 3080 Ti XC3 Ultra, 12 GB, not measured here, $629.99 before tax, $1,019.01 less. Both were ordered on 2026-09-11; the lines are in "The board".

## The words this page leans on {#the-words-this-page-leans-on}

- **The seat** — one PCIe x16 slot in the workshop's bench computer, where every card not set in italics was measured.
- **The runtime, and the harness** — the runtime runs the models: ollama 0.32.13 for language, ComfyUI for pictures. The harness is the workshop's test program around it; it times each arm and withholds a result that fails its checks.
- **Mixture of experts (MoE), and dense** — a mixture model carries all of its weights but consults a slice of them for each token; a dense model reads every weight for every one. `gemma4:26b`, its QAT build and `gpt-oss:20b` are mixture models; `mistral-small3.2:24b` is dense.
- **The core bank, and the diffusion bank** — seven language-model files, builds of four models of twelve billion parameters and under, each asked one frozen prompt, the same every time; and six picture pipelines plus one variant.
- **Bits, and QAT** — `Q4_K_M`, `Q6_K` and `q8_0` say how many bits each weight is stored in; a QAT build was trained to be stored that way.
- **The power cap** — set through the driver and read back from the card. This workshop measures every card at 300 W as well as at its default. The cap is a ceiling, not a draw; a card raises a limiter flag when the cap holds it back.
- **Context window, the KV cache, the planner and decode** — the window is how many tokens the model holds at once; its cache lives on the card, so a bigger window is a memory question first. Reading the prompt is the prefill; writing the answer, a token at a time, is the decode. The planner decides how much of a model goes on the card and how much stays in system memory. The largest window a model can hold is measured, never assumed: a search in 256-token steps finds it to within 512 tokens.
- **Spill** — the planner putting part of a model in system memory. A spilled model still runs, but each token waits on the processor and the computer's memory, so its speed is that computer's as much as the card's.
- **fp8, fp4 and a kernel** — eight- and four-bit floating-point formats for a model's weights and, when the runtime takes that path, its arithmetic; this card's generation has hardware for that, the older cards here do not. A kernel is the routine that does the arithmetic, and the runtime's log names the one it chose.
- **Board power, an arm and a rung** — every watt here is the card's own draw, read from its driver at 2 Hz, unless the text says *whole box*, the bench computer's supply. An arm is one timed job of the bench; a rung is every arm run once under one cap.
- **The print lab, the rules desk and the beat lab** — the workshop's own services: a picture service drawing with FLUX.2 klein 4B, a board-game rules helper, and a browser drum machine whose beats can carry a small square sleeve picture.
- **The pre-registration, and the kit** — the predictions and rules written down before any reading, scored below; and the bench's own files, which follow this page once cleared.

## If you are weighing one of these, in plain words {#if-you-are-weighing-one-of-these-in-plain-words}

**For models of twelve billion parameters or smaller,** at the same 300 W this 5080 was 9 to 22 per cent faster than a 3080 Ti Founders Edition on all seven core-bank builds, on a quarter to nearly half less energy per token at the card, and 22.6 to 30.9 per cent faster than the 10 GB EVGA card beside it on the five files that card could hold. On `gemma4:12b` that saving is 944 joules per thousand tokens, or 1,049 if each run's power is taken at its median sample instead of its mean.

**For bigger models, read [the fit table](#what-16-gb-holds-the-planners-placement-at-four-windows) first.** Three did not fit whole on the card at any window from 4,096 tokens up: `gemma4:26b`, its QAT build and `mistral-small3.2:24b`. That was ollama 0.32.13's planner deciding: it put part of each in system memory and left 0.74 to 1.73 GiB of the card empty, and no one overrode it by hand. Spilled like that, `gemma4:26b` still wrote 78.6 tokens a second and `mistral-small3.2:24b` 17.5, at the bench computer's speed as much as the card's. `gemma4:26b` needs more than this card holds even without its vision part. By the runtime's own accounting at 4,096 tokens, its QAT build would have fit with 370 MiB to spare but for the planner's 457 MiB reserve; `mistral-small3.2:24b` missed by 27 MiB. Neither a forced placement nor a build without the vision parts was tried.

**Against a used 24 GB card:** none was measured on this bank in this seat; this page does not rank against one.

## The board {#the-board}

The card is a ZOTAC GeForce RTX 5080 Solid CORE OC, 16 GB, part number ZT-B50800J2-10A. The price: a new ZOTAC RTX 5080 Solid CORE OC, $1,649.00 before tax, purchased 2026-09-19. That Founders Edition: a refurbished NVIDIA GeForce RTX 3080 Ti Founders Edition, 12 GB, $699.97 before tax, ordered 2026-09-11, $949.03 less. A second 3080 Ti ordered the same day and not measured on this page: a refurbished EVGA GeForce RTX 3080 Ti XC3 Ultra, 12 GB, part number 12G-P5-3955-KR, $629.99 before tax, $1,019.01 less. This card was measured on 2026-09-24 (UTC) in the x16 seat of this workshop's bench computer, days after that 3080 Ti Founders Edition and that EVGA 3080, 10 GB. The bench's model store was emptied and re-pulled in between, to the same digests; for the language rows, the card is the only change the files record that could move a row. The Founders Edition's picture and game-turn rows and its repeat arm ran after a re-seat, with the EVGA 3080 idle in a second slot and the Founders Edition's own link still x16; this card ran alone.

The driver read 16,303 MiB of memory (the nameplate says 16,384), a 360 W default cap with a 250 W floor and a 380 W ceiling, and top clocks of 3,120 MHz on the cores and 15,001 MHz on the memory. Under load the link ran at PCIe x16, generation 4: the slot's limit, not the card's, which is a PCIe 5.0 part. The spilled models, the release-everything game turn and the offload variant move models across the link and might run differently in a generation-5 slot, which no row here saw. The card will not report its memory temperature; the driver and the low-level query both refuse.

## Seven builds of four models, one seat, four days apart {#seven-models-one-seat-four-days-apart}

The core bank is seven model files: three builds of Gemma 4 12B (`gemma4:12b`, its QAT build and unsloth's six-bit `gemma-4-12b`), two of Qwen3.5 9B, `qwen3.5:4b` and `minicpm-v4.5`. Each was asked one frozen prompt, three scored runs after a discarded warm-up, in the same seat and on the same runtime, driver and digests as the two older cards.

At 300 W this card was ahead on all seven, by 9.1 to 21.5 per cent: on `gemma4:12b`, for one, 89.887 against 76.102 tokens a second. The `qwen3.5` builds sit at the bottom of that range, 9 to 12 per cent; the Gemma builds and MiniCPM-V at the top, 16 to 22. Averaged over the samples taken while it was busy, it drew 139 to 236 W to the Founders Edition's 227 to 256; at the median sample, 162 to 276 W to the Founders Edition's 225 to 299. That is 24 to 45 per cent fewer joules per thousand tokens on every row by the mean, and 24 to 48 by the median sample.

With each card at its own default, the lead is 8 to 18 per cent; the Founders Edition's 350 W rows, five days before this card's, are in the table. The 10 GB EVGA card's 300 W rows are 80 W under its own 380 W default; at that default it gained 0.2 to 1.8 per cent, and, each card at its own default, the lead over it is 22 to 29 per cent.

**Memory bandwidth covers part of the lead.** On paper the two cards' memory bandwidths differ by 5.2 per cent; 6.7 once the memory clock each card held is counted (14,801 MHz of 15,001 here on every language run, 9,251 of 9,501 on the Founders Edition). Every file cleared that point: by 2.3 to 5.1 per cent on the three `qwen3.5` builds, and by 9.1 to 13.9 on the three Gemma builds and MiniCPM-V. The pre-registration reads a margin that size as the Founders Edition not being paced by its memory alone. This card's own fraction is withheld for its memory type, so the same reading cannot be made of it.

**The cap covers none of the rest.** At 300 W this card drew 46 to 79 per cent of its cap averaged over its busy samples, 54 to 92 at the median sample; its limiter flag went up on one file only, the six-bit one, at 92 per cent of its cap, for 15.4 per cent of its samples, at no measurable cost. The Founders Edition sat at its cap at both settings: 298 to 299 W at the median sample on five of seven files at 300 W, 348 to 349 W on the three Gemma builds at its 350 W default, its flag up on 78 to 100 per cent of the samples on every file. The 50 W between them bought it 0.6 to 3.3 per cent; its 400 W ceiling was not run. So the lead survives the one step measured; a further 50 W is not in the files. The leftover is largest on the Gemma builds, where this bench's cache setting also weighs on this card most (the cross-check below); the files cannot separate the card from the setting.

**One cross-check.** The test program from this workshop's single-3080 bench of 2026-09-10 (its record is not yet a published page), run unchanged on this card, reads `gemma4:12b` at 94.883 tokens a second at 360 W, 5.5 per cent above the core bank's 89.894 at the same cap, file and prompt; `qwen3.5:9b` 1.1 per cent and its eight-bit build 0.8 per cent above, so the setting weighs on Gemma most. The older program records a 4,096-token window where the core bank's is 8,192, and leaves the cache precision and flash attention at the runtime's defaults, where the core bank sets an eight-bit cache and flash attention on. The Founders Edition was never read at those defaults, so whether the lead holds, grows or shrinks with a sixteen-bit cache is not measured; this page rests on the core bank's rule. The smaller tests (the rules desk's stack, the vision test, four callers at once, two embedding runs and one refused combination) go in the kit.

## What 16 GB holds {#what-16-gb-holds}

**The fit maps.** The bench asked the planner to place four larger models at four windows (4,096, 8,192, 16,384 and 32,768 tokens), with the KV cache at eight bits and again at sixteen, and read the card's memory before and after each placement.

- `gpt-oss:20b`, a mixture model with 20.9 billion parameters in a four-bit format, went on whole at every window and both cache precisions.
- `gemma4:26b` (the mixture model this workshop's products run), its QAT build and the dense `mistral-small3.2:24b` did not, at any window, at either precision. The planner left 759 to 1,775 MiB of the card empty over both cache precisions: 0.74 to 1.73 GiB.

The single-3080 bench's program, run on this card, adds two whole placements at 4,096 tokens with the runtime's default cache, `phi4:14b` (14.7 billion parameters at four bits) and an eight-bit `gemma4:12b`; those rows go in the kit.

**The windows it opens.** With the cache at eight bits, a six-bit `gemma-4-12b` held 262,144 tokens whole, the model's own maximum, so the limit there is the model's, not the card's: at that window it used 13,238 MiB of the card, about 3 GB short of full. An eight-bit `qwen3.5:9b` held 253,440 tokens, plus or minus 512, and spilled at 253,952: that limit is the card's. The Founders Edition's limits for the same two files, at the same cache setting, were 73,216 and 71,168 tokens; the EVGA 3080, 10 GB, spilled at 8,192. `gpt-oss:20b` held its own maximum, 131,072 tokens.

**Filling them.** A window opened is not a window used, so the bench filled each one to three-quarters with the frozen prompt repeated and timed the cold read: three passes each, behind a fresh one-time marker so nothing came from cache. At 262,144 tokens that is a 196,080-token prompt, read at 1,677.0 tokens a second; the first token arrived after 119.97 seconds, and the answer then came at 41.691 tokens a second. The eight-bit `qwen3.5:9b` read its 189,817-token prompt at 3,592.3 tokens a second: first token at 56.47 s, answer at 52.166. A real document may read faster or slower than one prompt repeated.

**Why the three missed.** The planner has two named reasons for leaving space empty: a 457 MiB reserve, by the pre-registration's reading of the planner's source code, and a 768 MiB surcharge, which the fit files apply above 4,096 tokens. At 4,096 tokens only the reserve applies, and, with the cache at eight bits, 953 to 1,529 MiB sat empty, so the reserve is 30 to 48 per cent of that; the files do not say what held the rest back.

`gemma4:26b` misses by more than a margin. An earlier build of it, 588 MiB smaller, went on whole at 4,096 tokens on the 24 GB cards from this workshop's earlier pages, an EVGA GeForce RTX 3090 XC3 Ultra, an EVGA GeForce RTX 3090 Ti FTW3 Ultra and a GeForce RTX 5090 Laptop GPU, where it took 17,652 to 17,926 MiB: more than this card's 16,303 MiB, even leaving out the 1,139.5 MiB vision projector (the part that reads images) the build carries.

The other two came nearer. At 4,096 tokens, by the runtime's own accounting:

- The QAT build put 997 MiB in system memory and left 1,367 MiB of the card empty. The empty space is bigger than the spilled part, but the planner keeps its 457 MiB reserve, so the build was about 87 MiB short.
- `mistral-small3.2:24b` put 1,556 MiB in system memory and left 1,529 MiB empty: 27 MiB short with no reserve at all.

That assumes a whole placement needs the same working buffers as the partial one. And the QAT build, like `gemma4:26b`, ships with a 1,139.5 MiB vision projector (by the registry manifest the bench recorded), more than its whole shortfall. Neither a forced placement nor a build without the projector was tried.

## Pictures, and the fp8 door {#pictures-and-the-fp8-door}

**The diffusion bank.** Six picture pipelines and one variant ran in this seat on the same ComfyUI build and, byte for byte, the same graphs (ComfyUI's word for a picture workflow) as the Founders Edition. Each was timed warm, with the text encoding already cached, and each card ran at its own default: 360 W here, 350 W there. On the 16-bit build of the print lab's model, FLUX.2 klein 4B, this card took 3.514 s where the Founders Edition took 5.790, for one 1024-pixel image at eight steps. Across the four 16-bit FLUX.2 rows, Z-Image-Turbo, SDXL and SD3.5-medium, the ratio is 1.60 to 1.69.

Was the 12 GB card slowed by running short of memory? Not on the picture model. On the FLUX.2, Z-Image-Turbo and Krea 2 Turbo pipelines the runtime's own log reports the diffusion model resident to within 22 MB of its file size on both cards (7,392 MB for the 16-bit FLUX.2 model); what sat partly off the 12 GB card was the text encoder, which the warm submits never run. On paper, by ComfyUI's own budget, the stage a warm run uses also fits that card on every pipeline but two: SD3.5-medium, one 11.6 GB file that is 30 MiB over, and SDXL, which has no verdict on paper.

The one variant is the outlier at 1.25: the fp8 pipeline with ComfyUI's smart memory off, so models move off the card between stages and the row times those reloads as well as the arithmetic. One file the bank lists as skipped, a 12.6 GiB Krea 2 Turbo INT8 build, was skipped only by a rule written for the 12 GB card and might have loaded on 16 GB; it has no row. This card's 300 W rows are within 2.6 per cent of its 360 W rows on every pipeline.

**The fp8 door.** On this card the fp8 build of the print lab's model ran much faster than its 16-bit build; on the Founders Edition the two barely differed.

- The fp8 build, with its text encoder in fp4, took 2.108 s here against 5.457 on the Founders Edition for the 1024-pixel image, and 1.700 against 4.798 for the three 512s: 2.59 and 2.82 times.
- On this card the fp8 file is 1.667 times as fast as the 16-bit one at 1024 pixels and 1.785 at the print lab's shape (1.639 and 1.751 at 300 W). On the Founders Edition the same two files differ by 1.061 and 1.051.

The log shows which path ran: on this card's fp8 pipeline it names an fp8 quantize step, `quantize_per_tensor_fp8`, on the CUDA backend, and on Krea 2 Turbo's nvfp4 build, which ran 2.43 times as fast, a four-bit matrix multiply, `scaled_mm_nvfp4`. On the Founders Edition the same two pipelines log only a dequantize step: the weights turned back into sixteen bits. A file with fp8 in its name is not the same thing: the SD3.5-medium file's fp8 part, by its name, is its T5 text encoder, which the warm submits skip. Its log names no fp8 step on either card, and its 1.62 is the 16-bit rows' ratio.

Three caveats ride the door:

- The fp8 pipeline also swaps its text encoder to fp4, so the two pipelines differ in two files, though the warm runs skip the encoder.
- No picture from the fp8 build was compared with the 16-bit build's. The print lab's certified recipe is the 16-bit one, and this page claims nothing about whether the fp8 pictures match it.
- The bench's two summary residency verdicts disagree and neither is authoritative by its own notes; the per-model figures above are the runtime's own, and neither summary is printed as a fact.

**The print lab's recipes.** Three certified recipes (eight steps, eight steps with a pixel pass, thirty-two steps) ran at 512 pixels in batches of three, two timed batches after three warm-up images. The 0.6 to 1.1 per cent between the caps sits inside the two-batch spread the table prints. This is where the cap pinned the card (the flag table).

**Ten minutes.** On the eight-step recipe, one image at a time, the card made 456 images at 300 W and 466 at 360 W, at 0.0940 and 0.0955 Wh an image (338 and 344 J): 2.1 per cent fewer images at 300 W. Little of that sits in the render itself: ComfyUI's own clock moved 0.4 per cent at the median (1.217 against 1.212 s) and 0.5 at the mean (1.226 against 1.220), while the wall clock per image moved from 1.293 to 1.321 s; the rest is time between renders, 0.095 against 0.073 s an image. The two runs were about two and a half hours apart, and one run at each cap cannot say whether the cap or those hours moved it. The cap saved 13 W at the median and 1.6 per cent of the energy per image.

**Beside the card it replaced.** The render computer this card was bought for, and went into after the bench (below), had been running on an EVGA GeForce RTX 3090 Ti FTW3 Ultra, 24 GB. Its seconds sit in italics in the recipe and ten-minute tables, measured on another computer where more than the card differed:

- a 20-thread processor and 45 GB of memory, in a generation-3 slot;
- an older torch (2.11.0 against 2.13.0) and driver (595.71.05 against 595.84);
- ComfyUI 0.21.1, against a serving checkout whose version this card's files do not record;
- a resident picture service holding 262 MiB of that card.

Without a same-build control the render bench's own rule prints no ratio, so this page prints no multiplier.

## Training, and a game turn {#training-and-a-game-turn}

**The house adapter.** An adapter is a small set of extra weights trained on top of a big model. The workshop trains one for the ACE-Step 1.5 music model: 415 steps at seed 42. This card trained it on the same computer and environment as the Founders Edition, both at 300 W: 3.1482 s a step against 5.4508, 1.731 times as fast, on 738.4 J a step against 1,624.4, 55 per cent less, drawing a fifth less power, 234.55 W against 298.01. The Founders Edition was pinned at its cap through the run; this card never touched its own.

**A game turn.** The bench's stand-in for one turn of the workshop's game narrates a hundred tokens on `gemma4:12b`, then runs an embedding. It draws the scene on the eight-step recipe. Then it narrates and embeds again, and a model looks at the picture. It ran twelve turns, over two passage lengths and two ways of handling the models.

- Releasing every model between phases, a turn took 50.5 to 51.8 s at either cap.
- Releasing nothing, a turn took 13.9 to 14.5 s.
- The Founders Edition, on the same graph at its 350 W default, took 65.7 to 65.8 s releasing everything and 15.9 to 16.2 s releasing nothing. Each card at its own default, 10 W apart, a whole turn here was 1.14 to 1.27 times as fast: the page's one end-to-end picture measurement, prompt encoding included, against the warm bank's 1.6 to 2.8.

The EVGA 3080 FTW3 Ultra, 10 GB, is not comparable here. It ran a different, smaller fp8 graph and could not run the nothing-released turn at all: six of its twelve turns failed, with a truncated error this page reads no cause into. Both comparators' files record a fresh start of the picture runtime before three of their four sets, that bench's policy after a hang on the 10 GB card; this card's files record none.

## The sixty watts {#the-sixty-watts}

**The 60 W between the cap and the default went unused on language and training, and bought −0.2 to +2.6 per cent on pictures.** On language the 360 W rows are the 300 W rows: −0.057 to +0.171 per cent, inside the run-to-run noise. At its default the card drew up to 315 W at the median on the recipes.

By an operator's ruling the 360 W rows were measured first, from 07:15 UTC, and the 300 W rows after them, from 09:09: once each, not interleaved, so any drift across those hours rides in these differences; every window is dated below. Six scored arms ran at both caps (the core bank, recipes, ten-minute draw, adapter, diffusion bank and game turn; the voided `gpt-oss:20b` speed runs did too, the 360 W set last of all). On the game turn the differences were under 1.2 s, in both directions: too small for three turns a cell to resolve.

The card's own limiter flag says where the watts were wanted:

- At 300 W: 15 per cent of the six-bit model's language samples and none of the other six; two-thirds to all of the recipes' samples; 73 per cent of the ten-minute draw's; and two-thirds to all of every diffusion pipeline's but the offload variant's 8 per cent; on the 16-bit FLUX.2 points, up on 95 to 100 per cent of the samples, that cost 0.1 to 0.9 per cent, so the flag is not the same thing as lost speed.
- At 360 W, where no language, training or recipe row raised the flag, the diffusion bank did: on a median two-thirds of the fp8 pipeline's samples (a third to three-quarters by run), a fifth of Z-Image-Turbo's and a sixth of Krea 2 Turbo's (up to 25 and 42 per cent in a single run), and 8 per cent of the offload variant's.

## Where the card went {#where-the-card-went}

The bench closed at 14:19:55 UTC. What follows is an operator's account from the workshop's ledger; no file records the swap itself.

- Between 15:58 and 16:42 UTC the same day, the card went into the workshop's render computer, where the picture service runs, and was read for the first time there.
- Its link came up at PCIe x16, generation 3, on driver 595.71.05.
- An operator set its cap to 300 W and read it back.
- The print lab's first batch of three came back cold, model load included, and is not printed; the beat lab's sleeve picture drew.
- The picture service was serving again at 16:33 UTC.

A later run there, whose rows this page does not print, read the same link and driver and held the card at its 360 W default from 17:47:44 to 18:08:42 UTC, then at 300 W from 18:21:12 to 18:47:37. Whether 300 W survives the picture service's own restart is in no file.

Before the card went in, its blue lighting was switched off in its own lighting controller with SpectraCtrl, a small public tool by its author on GitHub, built on a protocol worked out for OpenRGB; an operator read the tool through before running it. By its README the setting persists on the card and one command turns it back on; this page has no receipt for either. A card that draws pictures for strangers has no one to glow for.

## What was written down before the first reading {#what-was-written-down-before-the-first-reading}

Fourteen predictions were registered on 2026-09-22 and 2026-09-23 (UTC), before any reading; the last dated note was at 02:17 UTC on the bench day. Each is scored held, missed or refuted, on the first reading by the agent that ran the bench. Ten held, registered → measured:

- Driver 595.84, open kernel module, compute 12.0, no bus or fault errors → 595.84 / 12.0 from the card; the fault half from the bench's opening ledger row.
- The board's maker in the subsystem id, `19DA` → `0x176519DA`.
- Listed on CUDA; every per-card figure growth-proven on this card → yes; every row's memory delta grows.
- Default above 300 W; floor at or under 300 W; ceiling at or above the default → 360 / 250 / 380 W.
- Core bank at 300 W at or above seven floors from the Founders Edition, the specification and the busy memory clock → above the floor by 5.1–17.0 % and the point by 2.3–13.9 % on 14,801 MHz (3.7–15.5 % above the floor as first registered), 7 of 7.
- Six-bit `gemma-4-12b` at or above 131,072 tokens; eight-bit `qwen3.5:9b` above 71,168 → 262,144; 253,440.
- 8-step recipe 0.82–1.20 s an image; ten minutes 392–574 images → 0.970 s; 456.
- Adapter at 300 W: 2.97–4.50 s a step → 3.1482.
- Idle empty 8–20 W → 15.84 and 17.72 W means.
- PCIe generation 4, x16, under load → generation 4, x16.

Those ten were identity checks, one-sided floors (a result only had to beat one number) or bands about a fifth or more wide either side. The four below are the narrow calls: a four-per-cent band, the fit cells, and a clock to the megahertz.

### The predictions that missed or were refuted {#the-predictions-registered-before-the-first-arm-scored-after}

| Prediction, as registered | Measured | Verdict |
|---|---|---|
| Default minus 300 W: +0 to +4 % | −0.057 to +0.171 %; the two misses, −0.057 % and −0.004 %, within the 0.06–0.22 % noise the pre-registration cited | Holds on five of seven; **missed** on two |
| `mistral-small3.2:24b` whole at 8,192 tokens, 46.2–53.4 tokens/s | Not whole at 8,192 tokens | **Refuted** |
| Fit map, eight cells | QAT at 4,096 tokens: whole predicted, not whole measured; at 8,192: not whole, as predicted, by the planner's margin rather than the byte arithmetic. Mistral at 4,096 and 8,192: whole predicted, not whole measured; at 16,384, with `gemma4:26b` at every window and `gpt-oss:20b`: as predicted. The 14-billion cell absent | Mixed: three **refuted**, four hold, one absent |
| Busy memory clock equals the card's stated maximum, 15,001 MHz | 14,801 MHz on every run | **Refuted** |

## The tables {#the-tables}

How to read the tables:

- **Language rows.** Each figure is the median of three scored runs after one discarded warm-up, on one frozen prompt: 536 tokens by the Gemma tokenizer, 517 by `minicpm-v4.5`'s and 537 by `qwen3.5`'s. Each run generates 256 tokens at seed 0, at an 8,192-token window unless the row says otherwise, KV cache at eight bits, flash attention on, one parallel slot, ollama 0.32.13, driver 595.84. Tokens a second is the runtime's own count over its own generation time.
- **Spreads.** Every three-run spread passed the harness's 15 per cent gate: 0.0 to 0.4 per cent on this card's rows, up to 0.6 on the Founders Edition's and up to 1.1 on the EVGA 3080's; the per-row lowest and highest runs go in the kit.
- **Watts and energy.** Board watts are the median, over the three runs, of each run's mean draw over its busy samples. A run has six to sixteen samples at 2 Hz, over a window longer than the decode that takes in the ramp at each end, so the mean sits up to a fifth under the median sample. Joules per thousand tokens is that mean times the runtime's own decode time, the median over the runs. A limiter-flag share is the median, over the runs, of each run's share of samples.
- **Recipe and ten-minute rows.** Recipes: two timed batches of three after three warm-up images (n=2, a thin sample), on ComfyUI's own execution clock. Ten minutes: finished images are counted, and watt-hours an image is mean board draw times seconds run, divided by images, divided by 3,600.
- **Diffusion rows.** Five warm submits at fresh seeds with the conditioning cached; seconds per submit.
- **Training rows.** The trainer's own per-epoch seconds, summed over 415 steps, excluding model load and checkpoint writes.
- **Italic rows** were measured on another computer; no ratio is printed against them. A dash carries its reason.

### The core bank at 300 W — tokens a second, this card against the Founders Edition {#the-core-bank-at-300-w-seven-models-three-cards-one-seat}

| Model (build) | This card (× the Founders Edition) | RTX 3080 Ti Founders Edition, 12 GB |
|---|---|---|
| `gemma4:12b` (Q4_K_M) | 89.887 (1.181×) | 76.102 |
| `gemma4:12b-it-qat` (Q4_0) | 94.319 (1.163×) | 81.087 |
| `gemma-4-12b` (Q6_K, unsloth) | 72.339 (1.215×) | 59.535 |
| `minicpm-v4.5` (Q4_K_M) | 146.519 (1.188×) | 123.295 |
| `qwen3.5:4b` (q8_0) | 116.197 (1.110×) | 104.701 |
| `qwen3.5:9b` (Q4_K_M) | 109.304 (1.121×) | 97.479 |
| `qwen3.5:9b` (q8_0) | 77.498 (1.091×) | 71.032 |

Every card-to-card speed claim at 300 W rests on this table and the next.

### The core bank at 300 W — the 10 GB card, tokens a second {#the-core-bank-at-300-w-spread-and-the-10-gb-card}

| Model (build) | EVGA RTX 3080 FTW3 Ultra, 10 GB |
|---|---|
| `gemma4:12b` (Q4_K_M) | 68.917 |
| `gemma4:12b-it-qat` (Q4_0) | 72.933 |
| `gemma-4-12b` (Q6_K, unsloth) | — spilled on 10 GB |
| `minicpm-v4.5` (Q4_K_M) | 111.893 |
| `qwen3.5:4b` (q8_0) | 94.755 |
| `qwen3.5:9b` (Q4_K_M) | 88.574 |
| `qwen3.5:9b` (q8_0) | — spilled on 10 GB |

### The core bank, each card at its own default, tokens a second {#the-core-bank-each-card-at-its-own-default}

| Model (build) | This card, 360 W | Founders Edition, 350 W (its board W) |
|---|---|---|
| `gemma4:12b` (Q4_K_M) | 89.894 | 77.754 (290.58 W) |
| `gemma4:12b-it-qat` (Q4_0) | 94.337 | 82.380 (285.93 W) |
| `gemma-4-12b` (Q6_K, unsloth) | 72.298 | 61.522 (303.27 W) |
| `minicpm-v4.5` (Q4_K_M) | 146.513 | 126.615 (255.48 W) |
| `qwen3.5:4b` (q8_0) | 116.202 | 105.393 (239.98 W) |
| `qwen3.5:9b` (Q4_K_M) | 109.491 | 98.638 (266.52 W) |
| `qwen3.5:9b` (q8_0) | 77.498 | 71.465 (287.03 W) |

The two defaults are 10 W apart; the ratio is 1.084× to 1.175×, the 8 to 18 per cent above.

### The core bank at 300 W — board watts, mean of busy samples, median of three runs {#the-core-bank-at-300-w-power-and-energy}

| Model (build) | This card, W | Founders Edition, W |
|---|---|---|
| `gemma4:12b` (Q4_K_M) | 205.79 | 245.86 |
| `gemma4:12b-it-qat` (Q4_0) | 190.46 | 238.51 |
| `gemma-4-12b` (Q6_K, unsloth) | 235.86 | 255.71 |
| `minicpm-v4.5` (Q4_K_M) | 179.99 | 226.53 |
| `qwen3.5:4b` (q8_0) | 139.02 | 227.56 |
| `qwen3.5:9b` (Q4_K_M) | 173.19 | 239.10 |
| `qwen3.5:9b` (q8_0) | 170.60 | 251.46 |

### The core bank at 300 W — joules per 1,000 tokens {#the-core-bank-at-300-w-joules-per-1000-tokens}

| Model (build) | This card | Founders Edition |
|---|---|---|
| `gemma4:12b` (Q4_K_M) | 2,287 | 3,231 |
| `gemma4:12b-it-qat` (Q4_0) | 2,024 | 2,941 |
| `gemma-4-12b` (Q6_K, unsloth) | 3,260 | 4,295 |
| `minicpm-v4.5` (Q4_K_M) | 1,229 | 1,835 |
| `qwen3.5:4b` (q8_0) | 1,201 | 2,174 |
| `qwen3.5:9b` (Q4_K_M) | 1,582 | 2,452 |
| `qwen3.5:9b` (q8_0) | 2,201 | 3,540 |

By the median sample instead of the mean the saving is 24 to 48 per cent; by the peak sample, 24 to 45.

### What 16 GB holds — the planner's placement at four windows, 300 W {#what-16-gb-holds-the-planners-placement-at-four-windows}

| Model, and whether it went on whole | Card memory taken, MiB, 4,096 → 32,768 tokens | Left empty, MiB |
|---|---|---|
| `gpt-oss:20b` (MoE, MXFP4): whole at all eight | 12,510 · 12,564 · 12,674 · 12,900 (12,562 → 13,262 at sixteen bits) | — (whole) |
| `gemma4:26b` (MoE): whole at none of the eight | 15,348 · 15,410 · 15,542 · 15,528 | 759–953 (759–1,059) |
| `gemma4:26b-a4b-it-qat` (MoE): whole at none | 14,934 · 14,980 · 14,796 · 14,982 | 1,319–1,505 (1,289–1,505) |
| `mistral-small3.2:24b` (dense): whole at none | 14,772 · 14,750 · 14,670 · 14,796 | 1,505–1,631 (1,371–1,775) |
| A 14-billion model at Q6_K: absent, no validated file on the day | — | — |

Memory taken and left empty are the eight-bit readings; the range in parentheses covers both precisions. With 16,303 MiB in total and 2 MiB idle before the first placement, memory left empty is total less held less baseline, per cell. Above 4,096 tokens the 457 MiB reserve and the 768 MiB surcharge together are two-thirds or more of the QAT build's and `mistral-small3.2:24b`'s margins at either cache precision, and more than the whole of `gemma4:26b`'s.

Which witness decided: for the dense model, the runtime's own on-card share, 89.8 per cent at 4,096 tokens falling to 77.3 at 32,768; for the QAT build that same share, 93.1 falling to 91.0 per cent, where the card's memory growth alone would have passed it; `gemma4:26b`'s rests on the host reading ("How it was measured").

### The largest window held whole, tokens {#the-largest-window-held-whole-tokens}

| Model | This card, 16 GB (search, to ±512) | RTX 3080 Ti Founders Edition, 12 GB, from its own bench |
|---|---|---|
| `gpt-oss:20b` (MoE, MXFP4) | 131,072 — the model's own maximum | — |
| The three that did not fit (the fit table) | None: the search's smallest window, 8,192 tokens, had already spilled (`gemma4:26b` had only the fit map) | — |
| `gemma-4-12b` (Q6_K) | 262,144 — the model's own maximum | 73,216 |
| `qwen3.5:9b` (q8_0) | 253,440 ±512 — a card ceiling; 253,952 spilled | 71,168 |

A dash: not run on that card by this harness. The EVGA RTX 3080, 10 GB, spilled at 8,192 tokens on both files it was asked to hold. Both cards' searches ran with the KV cache at eight bits on ollama 0.32.13; the Founders Edition's ceilings are its 350 W rows; fit does not move with the cap.

### Spilled, printed alone — the runtime's own placement, 300 W {#spilled-printed-alone-the-runtimes-own-placement-300-w}

| Row | Tokens/s (spread of three) | Board W; what sat on the card |
|---|---|---|
| `gemma4:26b` at an 8,192-token window | 78.558 (78.479–78.736) | 94.61 W; 15,410 MiB taken |
| `mistral-small3.2:24b` at a 16,384-token window | 17.537 (17.521–17.570) | 112.2 W; 83.3 % of the model, 16.7 % in system memory |

### The diffusion bank — six pipelines and one variant, warm, each card at its own default {#the-diffusion-bank-six-pipelines-and-one-variant-warm-each-card-at-its-own}

| Pipeline · point · steps | This card, 300 / 360 W, s (FE ÷ this card at 360 W) | 3080 Ti FE, 350 W, s |
|---|---|---|
| FLUX.2 klein 4B bf16 + Qwen3-4B bf16 · 1024², one image · 8 | 3.516 / 3.514 (1.648×) | 5.790 |
| The same · 1024², one image · 32 | 11.960 / 11.922 (1.623×) | 19.352 |
| The same · 512², three images, the print lab's shape · 8 | 3.054 / 3.035 (1.662×) | 5.045 |
| The same · 512², three images · 32 | 10.601 / 10.506 (1.621×) | 17.025 |
| FLUX.2 klein 4B **fp8** + Qwen3-4B fp4 · 1024², one image · 8 | 2.145 / 2.108 (2.589×) | 5.457 |
| The same · 512², three images · 8 | 1.744 / 1.700 (2.822×) | 4.798 |
| The fp8 pipeline, smart memory off (models moved off the card between stages) · 1024² · 8 | 12.935 / 12.926 (1.255×) | 16.219 |
| Z-Image-Turbo INT8 · 1024² · 8 | 2.684 / 2.654 (1.689×) | 4.482 |
| SDXL, albedobaseXL v2.1 · 1024² · 25, cfg 7 | 4.347 / 4.355 (1.600×) | 6.969 |
| SD3.5-medium fp8-scaled · 1024² · 20 | 5.556 / 5.544 (1.619×) | 8.975 |
| Krea 2 Turbo nvfp4 · 1024² · 8 | 6.497 / 6.414 (2.430×) | 15.585 |

FE: an RTX 3080 Ti Founders Edition, 12 GB. Same computer, seat and ComfyUI build (v0.34.0, the bench's own checkout), graph digests identical row for row. The ratio is cross-cap by 10 W, since the Founders Edition has only a smoke test at 300 W. SD3.5-medium's and Krea 2 Turbo's licences carry duties this workshop has not taken on: timings only, no image from either published.

### The print lab's recipes — FLUX.2 klein 4B, 512 pixels, batches of three, s per image (spread, n=2) {#the-print-labs-recipes-flux-2-klein-4b-512-pixels-batches-of}

| Board and cap | 8 steps | 8 steps + pixel pass | 32 steps |
|---|---|---|---|
| **This card, 300 W** | 0.970 (0.921–1.019) | 0.961 (0.924–0.998) | 3.491 (3.440–3.542) |
| **This card, 360 W, its default** | 0.960 (0.913–1.007) | 0.955 (0.918–0.992) | 3.452 (3.405–3.499) |
| *EVGA GeForce RTX 3090 Ti FTW3 Ultra 24 GB, 300 W, another computer* | *1.455* | *1.436* | *5.332* |
| *That 3090 Ti at 450 W, its default, another computer* | *1.369* | *1.350* | *5.015* |

### The print lab's recipes — board watts and the limiter flag {#the-print-labs-recipes-board-watts-and-the-limiter-flag}

| Board and cap | Board W median, 8 / pixel / 32 | Limiter flag raised, share of samples, 8 / pixel / 32 |
|---|---|---|
| **This card, 300 W** | 289.1 / 291.6 / 300.0 | 67 % / 100 % / 95 % |
| **This card, 360 W, its default** | 305.6 / 308.6 / 315.0 | 0 % / 0 % / 0 % |

This card's rows ran from the print lab's own serving checkout, whose ComfyUI version those files do not record; the recipe graphs differ from the diffusion bank's, so the two tables' seconds are not interchangeable. The italic rows in the seconds tables are from 2026-09-17 and 09-18 (UTC), on the older stack "Beside the card it replaced" names: seconds beside seconds, no multiplier; that card's watts, flag shares, temperatures and fan go in the kit.

### Ten minutes of continuous drawing — the 8-step recipe, one image at a time {#ten-minutes-of-continuous-drawing-the-8-step-recipe-one}

| Board and cap | Images in ten minutes | Seconds per image, median (n) | Wh per image |
|---|---|---|---|
| **This card, 300 W** | 456 (602.3 s) | 1.217 (n=456) | 0.0940 |
| **This card, 360 W, its default** | 466 (602.5 s) | 1.212 (n=466) | 0.0955 |
| *EVGA 3090 Ti FTW3 Ultra, 300 W, another computer, 2026-09-17 (UTC)* | *320 (601.5 s)* | *1.811* | *0.1507* |
| *That 3090 Ti at 450 W, its default, 2026-09-17 23:50 → 09-18 00:01 UTC* | *348 (602.1 s)* | *1.672* | *0.1742* |

### Ten minutes of continuous drawing — watts, heat and fan {#ten-minutes-of-continuous-drawing-watts-heat-and-fan}

| Board and cap | Board W median / max | Core max °C | Fan max % |
|---|---|---|---|
| **This card, 300 W** | 259.6 / 298.7 | 68 | 44 |
| **This card, 360 W, its default** | 272.8 / 306.7 | 69 | 46 |

Neither run stopped early; room temperature was not recorded.

### Training the house adapter — ACE-Step 1.5, 415 steps, seed 42 {#training-the-house-adapter-ace-step-1-5-415-steps-seed-42}

| Row | Seconds per step | Wall, s | J per step |
|---|---|---|---|
| **This card, 300 W** | 3.1482 | 1,322 | 738.4 |
| **This card, 360 W, its default** | 3.1465 | 1,321 | 742.1 |
| RTX 3080 Ti Founders Edition 12 GB, 300 W (2026-09-20, this computer, this environment) | 5.4508 | 2,274 | 1,624.4 |
| The same Founders Edition at 350 W, its default (wall re-derived; see the note) | 5.3207 | 2,221 | 1,829.8 |

### Training the house adapter — power, memory and loss {#training-the-house-adapter-power-memory-and-loss}

| Row | Board W mean (max) | Peak card memory | Final-epoch loss |
|---|---|---|---|
| **This card, 300 W** | 234.55 (253.62) | 6,638 MiB | 0.6424 |
| **This card, 360 W, its default** | 235.85 (254.30) | 6,638 MiB | 0.6424 |
| Founders Edition, 300 W | 298.01 (300.02) — pinned at the cap | 6,630 MiB | 0.6497 |
| Founders Edition, 350 W, its default | 343.91 (349.43) | 6,630 MiB | 0.6498 |

Same prepared tensors, seed and Python environment (torch 2.10.0); one run per cap, each run's five epochs within 0.7 per cent of one another. The Founders Edition's 350 W wall is marked in its file as re-derived after the trainer's wrapper failed while writing the result. The loss column is a fidelity check at one seed, never a quality claim.

### A game turn — twelve turns, the 8-step recipe {#a-game-turn-twelve-turns-the-8-step-recipe}

| Row (turns completed) | Release everything between phases: short / long passage, s | Release nothing: short / long, s |
|---|---|---|
| **This card, 300 W** (12 of 12) | 50.517 / 51.199 | 13.975 / 14.461 |
| **This card, 360 W, its default** (12 of 12) | 51.707 / 51.846 | 13.913 / 14.134 |
| RTX 3080 Ti Founders Edition 12 GB, 350 W, its default (12 of 12) | 65.840 / 65.737 | 15.945 / 16.150 |
| EVGA RTX 3080 FTW3 Ultra 10 GB, 300 W, another graph (6 of 12) | 43.353 / 44.566 | — every turn failed (error text truncated) |

Median of three turns per cell; the prompts are invented. The Founders Edition ran the same graph as this card.

## What this page cannot say {#what-this-page-cannot-say}

- **How fast `gpt-oss:20b` writes.** The harness withheld every speed it took: all 256 tokens of every run were reasoning text with no answer behind them (the run sent no thinking level), and the registered floor checks the answer text before it prints a speed. The runtime's counter recorded a rate over those reasoning tokens, which the kit will carry; the registered rule does not let this page print it as a speed. A re-run with a thinking level is owed; its fit rows stand, since a fit probe generates one token.
- **How much energy a language run really used.** Each decode is under two to just over four seconds, six to sixteen board-power samples at 2 Hz, and the faster card has the shorter runs, so a lagging meter would flatter it. The direction holds by the mean, the median and the peak sample; the size of any one figure rests on few samples.
- **How fast either card reads a long prompt, or writes at the runtime's default cache setting.** Every card-to-card language figure here is decode at one stream, a 536-token prompt and 256 tokens out, the cache at eight bits; the filled-window rows are this card's alone.
- **A same-build picture ratio against a 3090 Ti.** Another computer, an older stack, a resident service; the ratio waits for that card's rows in this computer on this build.
- **What forcing every layer onto the card, or a text-only build, would have done.** The planner placed the three models that spilled; no one placed them by hand. The margins are in "What 16 GB holds": `gemma4:26b` needs more than the card holds, projector aside; the other two came within 87 and 27 MiB, and neither was tried.
- **Card-to-card variance.** One card of one factory-overclocked model, against one comparator of each kind.
- **A same-day control.** The comparison rows are four and five days older than this card's, from the same seat. A repeat arm on 2026-09-20, 16:54 to 17:04 UTC, read the Founders Edition at −0.32 to +0.15 per cent against its 350 W rows of about seventeen and a half hours before, after a pull and re-seat with the EVGA 3080 newly idle in a second slot: that bounds a re-seating and a second idle card, not four days.
- **Noise.** The fan read 0 per cent on nine of the fourteen language files, 30 to 32 per cent on five and 44 to 46 per cent through the ten-minute draws; a decode of a few seconds says nothing about sustained use, and nothing here measured sound.
- **How the 300 W setting holds in service.** Set by an operator, read again at 18:47 UTC; whether it survives the picture service's own restart is in no file.

## How it was measured {#how-it-was-measured}

Every measurement of this card, but for the render computer's reads in "Where the card went", was taken on 2026-09-24 (UTC), from an identity read at 06:01 UTC to the bench closing at 14:19:55 UTC, in the x16 seat of the workshop's bench computer: a 16-thread processor, 30.3 GiB of visible system memory by the files' own reads, a PCIe generation 4 slot; no file from the day names the processor's model or its memory's speed. Every cap was read back from the card, at the open of the file or in its own samples; the idle pair's 360 W is the block log's read.

- **At 360 W (UTC):** gate 0, the first registered stage (an embedding and a language gate run), 07:15:07–07:16:52; the recipes 07:19:37–07:22:37; ten minutes 07:23:20–07:33:59; the adapter 07:35:36–07:57:37; the diffusion bank 08:22:47–08:34:55; the game turn 08:35:15–08:42:40; the core bank 08:43:32–08:53:10; the single-3080 bench's program 08:54:15–09:06:29; `gpt-oss:20b` (voided) 14:13:04–14:17:21; idle 14:17:57–14:19:54.
- **At 300 W (UTC):** the core bank 09:09:11–09:18:51; the embedding 09:18:52–09:19:17; the fit maps 09:19:54–09:29:38; `gpt-oss:20b` (voided) 09:29:58–09:34:06; the spilled rows 09:34:07–09:37:56; the ceilings 09:37:58–09:44:26; the recipes 09:44:49–09:48:14; ten minutes 09:48:15–09:58:54; the adapter 09:59:38–10:21:41; the diffusion bank 10:31:36–10:43:45; the game turn 10:44:04–10:51:19; the small arms 10:51:43–11:00:24; the filled windows 11:00:34–11:24:33; the callers, one to four streams (the table goes in the kit), 11:24:41–11:40:29.

The card's power, clocks, temperature and limiter flag were sampled at 2 Hz through every scored run. Fit was judged on three witnesses:

- the runtime's own split of the model between card and system memory;
- the card's memory growth, read before and after each placement, against the runtime's stated size;
- the runner process's memory on the host: under 2 GiB for every whole placement and 13.7 GiB or more for every spill in the fit maps (it did not separate the ceiling searches: `qwen3.5:9b`'s two spilled probes read 2.1 GiB).

A model counted as whole only when the runtime and the card agreed; `gemma4:26b`'s size report was refused (1.14 GB against 16.09 GB that landed), so its verdict rests on the host reading.

The comparators' rows came from the same harness in the same seat:

| Comparator arm | Date (UTC) | Window (UTC) |
|---|---|---|
| Founders Edition, language at 350 W | 2026-09-19 | 23:05:28–23:45:28 |
| Founders Edition, language at 300 W | 2026-09-20 | 01:22:44–01:32:24 |
| Founders Edition, adapter at 300 W | 2026-09-20 | 02:17:07–02:55:01 |
| Founders Edition, adapter at 350 W | 2026-09-20 | 02:58:02–03:35:03 |
| EVGA 3080, game turn | 2026-09-20 | 14:57:55–15:03:16 |
| EVGA 3080, language at 300 W | 2026-09-20 | 15:52:18–16:00:56 |
| Founders Edition, pull and re-seat | 2026-09-20 | 16:54:23–17:04:16 |
| Founders Edition, diffusion bank, after the re-seat | 2026-09-20 | 17:06:12–17:23:28 |
| Founders Edition, game turn, after the re-seat | 2026-09-20 | 17:36:40–17:46:20 |

The last three rows ran with the EVGA 3080 idle in a second slot. The diffusion bank ran on the bench's own ComfyUI checkout, v0.34.0, on torch 2.13.0 and Python 3.14, which both cards' diffusion files record; the print lab's recipes and the ten-minute draw ran from the print lab's own serving checkout on torch 2.13.0.

## What to take with you {#what-to-take-with-you}

- **At 300 W this 5080 wrote 9 to 22 per cent faster than a 3080 Ti Founders Edition, on 24 to 45 per cent fewer joules per thousand tokens at the card.** That held on all seven core-bank builds, four models of twelve billion parameters and under, in the same seat four days apart; the energy figures rest on six to sixteen power samples a run.
- **Its 360 W default is 60 W that bought little:** unused on language or training, and worth at most 2.6 per cent on pictures.
- **Under ollama 0.32.13's planner, with the cache at eight bits, 16 GB held a 12-billion model to its own maximum window, 262,144 tokens, but not `gemma4:26b`, its QAT build or `mistral-small3.2:24b` whole at any window, as the runtime ships them.**

## How to check our work {#how-to-check-our-work}

The bench's record (the pre-registration, every block's log, 411 result files, the render fork's, the comparator files and each prediction's first reading) follows as this page's data kit once cleared of private paths, names, ports, serial numbers and local-zone clocks by the rules [the laptop page's kit](https://research.strata2signal.com/a-laptop-asked-the-desktops-questions/) used; this section and the byline will say when. Until then the figures are the ones printed on this page; [the hardware roster](https://research.strata2signal.com/hardware/) names the cards measured here and has not carried this page's rows yet.

The chip note at the top rests on pages outside this workshop, all read on 2026-09-25 (UTC): NVIDIA's product pages for [a 3080 Ti](https://www.nvidia.com/en-us/geforce/graphics-cards/30-series/rtx-3080-3080ti/) and [a 3090](https://www.nvidia.com/en-us/geforce/graphics-cards/30-series/rtx-3090-3090ti/) give the cores, the bus width, the memory and which card has an NVLink connector; its [GA102 whitepaper](https://www.nvidia.com/content/PDF/nvidia-ampere-ga-102-gpu-architecture-whitepaper-v2.1.pdf) names the chip for a 3090; and the README of its [open kernel module](https://github.com/NVIDIA/open-gpu-kernel-modules) lists the two cards' device IDs, 2204 and 2208, which the PCI ID repository (the list `lspci` reads from; not linked here) records as GA102 for both. The two memory readings are this workshop's own: the Founders Edition's language files, and the [3090 and 3090 Ti](https://research.strata2signal.com/one-3090-against-one-3090-ti/) page. The two 3080 Ti prices are this workshop's own order records, the item price before tax on a named day.

**The data kit will carry, beyond the tables above:**

- Every language row's per-run power samples and lowest and highest runs; the other five core-bank builds' filled-window rows at 8,192 tokens (cold prefill 4,425.6 to 10,345.9 tokens a second, first token 1.57 to 2.65 s); the four-stream table for seven models, where the three `qwen3.5` files' streams did not overlap; and three idle windows (15.84, 17.72 and 23.59 W at the mean, 15.49, 15.53 and 15.72 at the median) with the whole-box reading.
- The small arms in full: two embedding runs of `nomic-embed-text` in batches of 64, one at 155.3 texts a second with a five-run spread of 14.2 per cent (0.8 points under the harness's 15 per cent gate) and one whose 22.3 per cent spread the gate voided, two runs too close to the gate to lean on; the rules desk's stack; the vision test, called but not judged; and one combination the harness refused for want of a registered chat model for a 16 GB card. Also `gpt-oss:20b`'s eight withheld speed files; the ten models the single-3080 bench's program ran on this card, beside the EVGA 3080's rows at its 380 W default, no ratio; the diffusion files' five pipelines not run, cold first renders and residency verdicts; and the 3090 Ti's watts, flag shares, temperatures and fan.
- The Founders Edition's fourteen language rows and the EVGA 3080's, sanitized, with every limiter-flag share and the repeat arm; and an operator's unregistered smoke test (06:07 to 06:36 UTC, no row here), labelled smoke: `gemma4:26b-a4b-it-qat` at 106.2 tokens a second at an 8,192-token window, 93.1 per cent on the card, another script, 512 tokens, no gates.

## The rest of the seminar {#the-rest-of-the-seminar}

- [A laptop, asked the desktop's questions](https://research.strata2signal.com/a-laptop-asked-the-desktops-questions/)
- [RTX 3090 vs RTX 3090 Ti](https://research.strata2signal.com/one-3090-against-one-3090-ti/) — the 24 GB cards.
- [Two 3080s against one 3090, and the cap decides](https://research.strata2signal.com/two-used-3080s-priced/) — the 10 GB pair.
- [A 3090, in its own words](https://research.strata2signal.com/a-3090-in-its-own-words/) — a card's own story.
- [How the print lab works](https://research.strata2signal.com/how-the-print-lab-works/) — the picture service.

## Who ran this, and thanks {#who-ran-this-and-thanks}

The card is a **ZOTAC GeForce RTX 5080 Solid CORE OC 16 GB**; **ZOTAC** gets the credit for the board and its lighting controller, **NVIDIA** for the chip, the driver and the fp8 path. The comparator boards, named in full above, are **NVIDIA**'s Founders Edition and two **EVGA** cards. The language work stands on **ollama** and, beneath it, the **ggml** library from the **llama.cpp** project and **NVIDIA's CUDA**; the pictures on **ComfyUI**; the training on **PyTorch** and **ACE-Step 1.5**; the lights on **SpectraCtrl**, a small public tool by its author on GitHub.

The models:

- Google's **Gemma 4**, in ollama's builds and **unsloth**'s six-bit build, and Google's **EmbeddingGemma**;
- **Mistral Small 3.2** from Mistral AI, **MiniCPM-V 4.5** from OpenBMB and **nomic-embed-text** from Nomic;
- **Qwen3.5** from Alibaba Cloud's Qwen team, and its **Qwen3-4B** as the print lab's text encoder; OpenAI's **gpt-oss**;
- in the rows of the single-3080 bench's program, which go in the kit, Microsoft's **Phi-4**, NVIDIA's **Nemotron** and Alibaba Cloud's **Qwen3.6**;
- Black Forest Labs' **FLUX.2 klein 4B**, which drew every recipe and game-turn image; **Z-Image-Turbo** from Alibaba's Tongyi Lab; **SDXL** in the albedobase community build;
- **Stable Diffusion 3.5 Medium** from Stability AI and **Krea 2 Turbo** from Krea, both timed only, no image of theirs published.

None of them owed us anything.

A small human team bought the card, set the rules and the fourteen predictions before the first run, ruled which cap ran first, swapped the card into the render computer after the bench closed and signed the numbers; a fleet of AI agents ran the harness, read the files and did the arithmetic. Thanks to everyone asking whether 16 GB is enough: that question is half of this page, and a first answer, under one runtime's planner, is a table.

*Measured on 2026-09-24 (UTC) by one bench in one seat, with the cap read from the card and each comparator's cap beside every figure.*

<!-- derived 2026-09-26 (UTC) by tools/derive_md.py from the pour source.
     source html sha256: 5aeee0af60da9ad6ad40eb15b1e9bff70cdb44f84441270b9a7dc738b35e1dbe
     derivation sha256:  9c6118daf0d8bbc17752e8e887e925a1ff54ed22f691f31134060babd3ae5a1f
     the {#id} on each heading is the anchor that heading carries on the page. -->