# The same eighteen pictures, card by card — the data kit's tables file

*Published 2026-09-26 (UTC) beside the page of the same name, as the data kit's first drop. This file holds every table the page does not print, verbatim from the page's last full draft, each under its own heading with the conditions that qualify it. Rows across cards are **same software, different computer** unless a heading says otherwise. The raw files these tables come from (`grid.json`, `sustained.json`, the traces, the logs, the render bench's own files) follow once cleared and once the kit's `reduce.py --check` passes on every one; the page's "How to check our work" says when. Lines that differ from the draft they were copied from are marked "(edited on the fold)"; notes added on a fold are marked "(Added on the fold.)"; what the page moved here on a later fold is marked "(Moved from the page.)" and keeps its figures verbatim.*

## Who ran where, every card this page and its second test touched


Nine cards, four computers, two tests. The grid is this page's main test; the render bench is the print lab's ten-minute recipe test.

| Card | Computer | Test | Settings run |
|---|---|---|---|
| NVIDIA RTX PRO 6000 Blackwell Workstation Edition 96 GB | Workstation computer | Grid | 600 W (stock) and 300 W |
| ZOTAC GeForce RTX 5080 Solid CORE OC 16 GB | i9 computer | Grid | 360 W (stock) and 300 W |
| NVIDIA GeForce RTX 5090 Laptop GPU 24 GB | Laptop | Grid | 138 to 150 W, Dynamic Boost |
| NVIDIA GeForce RTX 3080 Ti Founders Edition 12 GB | Bench computer, the next day | Grid | 350 W (stock) and 300 W |
| ZOTAC GeForce RTX 5080 Solid CORE OC 16 GB | Bench computer | Render bench | 360 W (stock) and 300 W |
| EVGA GeForce RTX 3090 Ti FTW3 Ultra 24 GB | Bench computer | Render bench | 300 W; recipes also at 450 W |
| ZOTAC GeForce RTX 3090 Ti AMP Extreme Holo 24 GB | Bench computer | Render bench | 300 W and 450 W (stock) |
| EVGA GeForce RTX 3090 Ti FTW3 Ultra 24 GB | i9 computer, a week earlier | Render bench, old build | 300, 350, 400 and 450 W |
| EVGA GeForce RTX 3090 XC3 Ultra 24 GB | i9 computer, a week earlier | Render bench, old build | 250 and 350 W |
| Gigabyte GeForce RTX 3080 10 GB and EVGA GeForce RTX 3080 FTW3 Ultra 10 GB, as a pair | i9 computer, a week earlier | Render bench, old build | 250 W |
| NVIDIA GeForce RTX 5090 Laptop GPU 24 GB | Laptop, three days earlier | Render bench, its own build | 95 W fixed, and boost |

The 5080 was in two computers that day: its render-bench rows ran in the bench computer (07:19 to 09:59Z) before its grid ran in the i9 computer (from 17:47Z). The 3080 Ti ran the grid on 2026-09-25 in the bench computer's x16 slot with a second board, an EVGA GeForce RTX 3080 Ti XC3 Ultra 12 GB, held idle in the chipset x4 slot directly below it. The EVGA 3090 Ti has run the render bench but not the grid.


## The four computers

The evidence for the label: four processors, three drivers, three link generations, four sizes of system memory (ComfyUI's own startup line, "total RAM", whose MB are MiB; paged weights live there). (System memory added on the fold.)

| Computer | Processor | Driver | System memory, MiB | Link to the card under load |
|---|---|---|---:|---|
| The workstation computer | AMD EPYC 7532, 64 threads | 595.84 | 126,353 | PCIe x16, generation 4 |
| The i9 computer | Intel Core i9-10850K, 20 threads | 595.71.05 | 47,041 | PCIe x16, generation 3 (the processor's limit) |
| The laptop | Intel Core Ultra 9 290HX Plus, 24 threads | 595.91.07 | 62,699 | PCIe x8, generation 5 |
| The bench computer | AMD Ryzen 7 3700X, 16 threads | 595.84 | 30,990 | PCIe x16, generation 4 |


## The grid's cell tables

Medians of three timed pictures after a warm-up, batch 1, on ComfyUI's own clock; a dash means fewer than four power samples. Rows across cards are **same software, different computer**. Stock is 600 W on the workstation card, 360 W on the 5080 and 350 W on the 3080 Ti; the laptop's enforced limit read 138.11 to 150.0 W across the cells. The 3080 Ti's Z-Image-Turbo and FLUX.1 [dev] cells are paged (1). The three timed pictures of a cell spread 0.03 to 3.8 per cent on 84 of the 87 cells with a median; the three wider, 4.6, 8.4 and 13.6 per cent, are all at 1024×1024. (Moved from the page.)

### FLUX.2 [klein] 4B, bf16, at stock {#flux-2-klein-4b-bf16-at-stock}

**Seconds per picture**

| Card and steps | 512×512 | 1024×1024 | 2048×1280 |
|---|---:|---:|---:|
| Workstation card, 8 steps | 0.586 | 1.506 | 3.860 |
| Workstation card, 32 steps | 1.546 | 4.368 | 12.474 |
| 5080, 8 steps | 1.237 | 3.593 | 9.617 |
| 5080, 32 steps | 3.707 | 12.023 | 33.456 |
| Laptop, 8 steps | 1.484 | 4.501 | 12.565 |
| Laptop, 32 steps | 5.069 | 16.011 | 46.384 |
| 3080 Ti, 8 steps | 2.190 | 5.725 | 14.847 |
| 3080 Ti, 32 steps | 6.279 | 19.004 | 52.795 |

**Joules per picture**

| Card and steps | 512×512 | 1024×1024 | 2048×1280 |
|---|---:|---:|---:|
| Workstation card, 8 steps | — | — | 2,096 |
| Workstation card, 32 steps | — | 2,493 | 7,148 |
| 5080, 8 steps | — | 937 | 2,736 |
| 5080, 32 steps | 1,076 | 3,542 | 10,237 |
| Laptop, 8 steps | — | 622 | 1,838 |
| Laptop, 32 steps | 744 | 2,407 | 6,865 |
| 3080 Ti, 8 steps | 683 | 1,750 | 4,932 |
| 3080 Ti, 32 steps | 2,117 | 6,422 | 18,190 |

### Z-Image-Turbo, bf16, at stock {#z-image-turbo-bf16-at-stock}

**Seconds per picture**

| Card and steps | 512×512 | 1024×1024 | 2048×1280 |
|---|---:|---:|---:|
| Workstation card, 8 steps | 0.668 | 1.993 | 5.744 |
| Workstation card, 32 steps | 1.905 | 6.718 | 20.109 |
| 5080, 8 steps | 2.018 | 5.650 | 14.911 |
| 5080, 32 steps | 5.267 | 18.570 | 54.161 |
| Laptop, 8 steps | 1.613 | 6.436 | 19.684 |
| Laptop, 32 steps | 6.071 | 24.240 | 75.537 |
| 3080 Ti, 8 steps, paged | 3.069 | 8.604 | 23.022 |
| 3080 Ti, 32 steps, paged | 8.747 | 30.289 | 85.428 |

**Joules per picture**

| Card and steps | 512×512 | 1024×1024 | 2048×1280 |
|---|---:|---:|---:|
| Workstation card, 8 steps | — | — | 2,916 |
| Workstation card, 32 steps | — | 3,644 | 11,686 |
| 5080, 8 steps | 405 | 1,484 | 4,394 |
| 5080, 32 steps | 1,397 | 5,623 | 16,893 |
| Laptop, 8 steps | — | 950 | 2,839 |
| Laptop, 32 steps | 875 | 3,601 | 11,167 |
| 3080 Ti, 8 steps, paged | 899 | 2,851 | 7,684 |
| 3080 Ti, 32 steps, paged | 2,860 | 10,425 | 29,500 |

### FLUX.1 [dev], fp8 storage, bf16 math, at stock {#flux-1-dev-fp8-storage-bf16-math-at-stock}

**Seconds per picture**

| Card and steps | 512×512 | 1024×1024 | 2048×1280 |
|---|---:|---:|---:|
| Workstation card, 8 steps | 1.119 | 2.758 | 7.295 |
| Workstation card, 32 steps | 3.574 | 9.601 | 26.194 |
| 5080, 8 steps | 2.408 | 7.033 | 19.195 |
| 5080, 32 steps | 8.222 | 25.689 | 72.198 |
| Laptop, 8 steps | 3.019 | 9.777 | 27.711 |
| Laptop, 32 steps | 11.306 | 37.231 | Over 90 s |
| 3080 Ti, 8 steps, paged | 3.863 | 10.857 | 28.867 |
| 3080 Ti, 32 steps, paged | 13.211 | 39.809 | Over 90 s |

**Joules per picture**

| Card and steps | 512×512 | 1024×1024 | 2048×1280 |
|---|---:|---:|---:|
| Workstation card, 8 steps | — | 1,504 | 4,098 |
| Workstation card, 32 steps | 2,134 | 5,620 | 15,324 |
| 5080, 8 steps | 710 | 2,310 | 6,387 |
| 5080, 32 steps | 2,532 | 8,841 | 24,934 |
| Laptop, 8 steps | 465 | 1,442 | 4,062 |
| Laptop, 32 steps | 1,713 | 5,547 | No figure |
| 3080 Ti, 8 steps, paged | 1,351 | 3,708 | 9,847 |
| 3080 Ti, 32 steps, paged | 4,495 | 13,761 | No figure |

Over 90 s: the laptop's warm-up was stopped at 92.885 s at step 28 of 32, the 3080 Ti's at 93.45 s at step 27 of 32; 0 of 3 timed renders ran on either.

### The 2048×1280 cells with the desktop cards at 300 W {#the-2048-1280-cells-at-300-w}

**Seconds per picture**

| Card and steps | FLUX.2 [klein] 4B | Z-Image-Turbo | FLUX.1 [dev] |
|---|---:|---:|---:|
| Workstation card, 8 steps | 5.957 | 9.036 | 11.697 |
| Workstation card, 32 steps | 20.872 | 33.729 | 43.646 |
| 5080, 8 steps | 9.612 | 15.003 | 19.817 |
| 5080, 32 steps | 33.829 | 54.626 | 74.933 |
| 3080 Ti, 8 steps | 15.042 | 23.661, paged | 29.770, paged |
| 3080 Ti, 32 steps | 54.502 | 88.218, paged | Skipped |

**Joules per picture**

| Card and steps | FLUX.2 [klein] 4B | Z-Image-Turbo | FLUX.1 [dev] |
|---|---:|---:|---:|
| Workstation card, 8 steps | 1,631 | 2,657 | 3,377 |
| Workstation card, 32 steps | 6,202 | 9,977 | 12,941 |
| 5080, 8 steps | 2,623 | 4,276 | 5,715 |
| 5080, 32 steps | 9,776 | 16,068 | 22,292 |
| 3080 Ti, 8 steps | 4,388 | 6,911, paged | 8,673, paged |
| 3080 Ti, 32 steps | 16,191 | 26,199, paged | Skipped |

**Mean board draw of the 2048×1280 cells, W** (each cell's figure is the median over its timed pictures of the picture's mean draw; the page's finding 5 reads its draw ranges from these rows). (Added on the fold, read from `row.mean_w` in each card's `grid.json` files.)

| Card and steps, at stock | FLUX.2 [klein] 4B | Z-Image-Turbo | FLUX.1 [dev] |
|---|---:|---:|---:|
| Workstation card, 8 steps | 556.6 | 509.7 | 549.9 |
| Workstation card, 32 steps | 565.5 | 581.2 | 585.2 |
| 5080, 8 steps | 288.5 | 296.9 | 330.9 |
| 5080, 32 steps | 306.4 | 311.5 | 344.1 |
| Laptop, 8 steps | 144.7 | 142.6 | 146.8 |
| Laptop, 32 steps | 147.2 | 147.3 | No figure |
| 3080 Ti, 8 steps | 330.5 | 331.6, paged | 341.4, paged |
| 3080 Ti, 32 steps | 344.8 | 344.7, paged | No figure |

| Card and steps, at 300 W | FLUX.2 [klein] 4B | Z-Image-Turbo | FLUX.1 [dev] |
|---|---:|---:|---:|
| Workstation card, 8 steps | 272.4 | 294.0 | 287.1 |
| Workstation card, 32 steps | 297.0 | 296.2 | 296.3 |
| 5080, 8 steps | 271.8 | 282.9 | 286.5 |
| 5080, 32 steps | 288.7 | 293.7 | 296.7 |
| 3080 Ti, 8 steps | 291.1 | 293.2, paged | 293.2, paged |
| 3080 Ti, 32 steps | 297.0 | 297.0, paged | Skipped |


### Seconds per sampling step, every size, at stock {#seconds-per-sampling-step-every-size-at-stock}

**FLUX.2 [klein] 4B**

| Card | 512×512 | 1024×1024 | 2048×1280 |
|---|---:|---:|---:|
| Workstation card | 0.0400 | 0.1193 | 0.3589 |
| 5080 | 0.1029 | 0.3513 | 0.9933 |
| Laptop | 0.1494 | 0.4796 | 1.4091 |
| 3080 Ti | 0.1704 | 0.5533 | 1.5812 |

**Z-Image-Turbo**

| Card | 512×512 | 1024×1024 | 2048×1280 |
|---|---:|---:|---:|
| Workstation card | 0.0515 | 0.1969 | 0.5985 |
| 5080 | 0.1354 | 0.5383 | 1.6354 |
| Laptop | 0.1857 | 0.7418 | 2.3272 |
| 3080 Ti, paged at every size | 0.2366 | 0.9035 | 2.6002 |

**FLUX.1 [dev]**

| Card | 512×512 | 1024×1024 | 2048×1280 |
|---|---:|---:|---:|
| Workstation card | 0.1023 | 0.2851 | 0.7875 |
| 5080 | 0.2422 | 0.7773 | 2.2085 |
| Laptop | 0.3453 | 1.1439 | No figure |
| 3080 Ti, paged at every size | 0.3895 | 1.2063 | No figure |

it/s is one divided by the seconds; ComfyUI's console bar, which times only the sampler's last interval, differs from it by up to 6 per cent on 32-step renders and 29 on 8-step ones at stock (edited on the fold: 22 was the three-card figure; the 3080 Ti's klein 2048×1280 8-step cell reads 28.6 per cent).


### Peak board memory at 2048×1280, 32 steps, stock {#peak-board-memory-at-2048-1280-32-steps-stock}

| Card | FLUX.2 [klein] 4B, MiB | Z-Image-Turbo, MiB | FLUX.1 [dev], MiB | The card's total, MiB |
|---|---:|---:|---:|---:|
| Workstation card | 22,978 | 27,306 | 24,036 | 97,887 |
| 5080 | 15,836 | 15,812 | 15,838 | 16,303 |
| Laptop | 22,625 | 22,409 | 23,683 | 24,463 |
| 3080 Ti | 11,700 | 11,868 | 11,766 | 12,288 |

From `row.vram_peak_mib`, all processes included; the laptop's and the 3080 Ti's FLUX.1 [dev] figures are from their 8-step cells. The 16 GB card peaked within 465 to 851 MiB of its ceiling on every cell (15,452 to 15,838 of 16,303 MiB) and the 12 GB card within 388 to 650 MiB (11,638 to 11,900 of 12,288): ComfyUI fills a card to its budget, so those peaks are the budget; the footprint is the 96 GB card's row.

**The 16 GB card's moves (finding 1's residency note).** The ZOTAC GeForce RTX 5080 Solid CORE OC 16 GB held every transformer whole through the steps but kept its text encoder mostly off the card during them (as low as 4,864 of klein's 7,671 MB, 256 of Z-Image-Turbo's, 1,152 of FLUX.1 [dev]'s 4,777) and moved part of the transformer over its generation-3 link around each encode and decode (Z-Image-Turbo's: 5,344 MB before the sampler, 7,616 after, at 2048×1280); that sits in its fixed cost and ten-minute count, not its per-step figure. (Added on the fold.)

**The 12 GB card's residency detail (finding 1's note).** On the NVIDIA GeForce RTX 3080 Ti Founders Edition 12 GB the rest of the graph left the card before the transformer did: during the steps klein's text encoder fell to 960 of its 7,671 MB, Z-Image-Turbo's to 0 of 7,671, FLUX.1 [dev]'s to 0 of 4,777, and all three decoders to 0. At 300 W the same two models paged the same way: inside the sampler's span at 2048×1280, Z-Image-Turbo's transformer sat at 8,064 to 9,664 MB of its 11,738 staged and FLUX.1 [dev]'s at 8,704 to 9,376 of 11,350. (Moved from the page.)


## The change table of finding 5: what 300 W costs, cell by cell

Within one card, stock against 300 W on the same 2048×1280 cells, same computer, software and prompts: no label. From `row.exec_s` and `row.joules_per_image` in each card's two `grid.json` files; the seconds and joules themselves are in The tables.

| Cell, 2048×1280 | Workstation card, time | Workstation card, J | 5080, time | 5080, J | 3080 Ti, time | 3080 Ti, J |
|---|---:|---:|---:|---:|---:|---:|
| FLUX.2 [klein] 4B, 8 steps | +54 % | −22 % | −0.1 % | −4 % | +1.3 % | −11 % |
| FLUX.2 [klein] 4B, 32 steps | +67 % | −13 % | +1.1 % | −5 % | +3.2 % | −11 % |
| Z-Image-Turbo, 8 steps | +57 % | −9 % | +0.6 % | −3 % | +2.8 % | −10 % |
| Z-Image-Turbo, 32 steps | +68 % | −15 % | +0.9 % | −5 % | +3.3 % | −11 % |
| FLUX.1 [dev], 8 steps | +60 % | −18 % | +3.2 % | −11 % | +3.1 % | −12 % |
| FLUX.1 [dev], 32 steps | +67 % | −16 % | +3.8 % | −11 % | Skipped | Skipped |

The 3080 Ti's Z-Image-Turbo and FLUX.1 [dev] cells are paged at both settings (68.7 per cent of the transformer resident at 2048×1280 on Z-Image-Turbo at stock and at 300 W; 76.1 and 76.7 per cent on FLUX.1 [dev]); the ratios are within one card and allowed, and the label travels with them. (Added on the fold.)


## The size table of finding 6: per-step cost, 2048×1280 against 1024×1024

Before the first picture, the bench registered that the per-step cost would rise 2.5 to 4.5 times from 1024×1024 to 2048×1280 on every model: these models cut a picture into patches called tokens, 2048×1280 has 2.5 times as many, and attention, which compares every token with every other, grows faster than the token count. Measured, from the per-step figures at stock:

| Per-step cost, 2048×1280 ÷ 1024×1024, at stock | FLUX.2 [klein] 4B | Z-Image-Turbo | FLUX.1 [dev] |
|---|---:|---:|---:|
| Workstation card | 3.01× | 3.04× | 2.76× |
| 5080 | 2.83× | 3.04× | 2.84× |
| Laptop | 2.94× | 3.14× | No figure |
| 3080 Ti | 2.86× | 2.88×, paged at both sizes | No figure |

All nine whole pairs with a figure fall between 2.76 and 3.14; the 3080 Ti's paged Z-Image-Turbo pair (2.88×) is printed under its label and read against no band (edited on the fold). The registered band ran from linear in pixels (2.5×) to most of the way to quadratic (6.25×); the measured values sit near its linear end, so attention adds a tenth to a quarter over linear here, not a doubling: a 2048×1280 step costs about three 1024×1024 steps, not two and a half, on all nine whole pairs with a figure (edited on the fold).


### The print lab's recipes in the bench computer, 300 W {#the-print-labs-recipes-in-the-bench-computer-300-w}

Batches of three at 512×512. The per-batch column, where the text encoder ran fresh on every card, is the like-for-like one; the median covers two batches on the 5080 (one with a cached encoder) and six on each 3090 Ti.

**8-step recipe**

| Card | Seconds per batch of 3, fresh encoder | Seconds per picture, median | Mean board W |
|---|---:|---:|---:|
| ZOTAC RTX 5080 | 3.057 | 0.970 | 276.2 |
| EVGA RTX 3090 Ti | 4.410 | 1.469 | 285.7 |
| ZOTAC RTX 3090 Ti | 4.528 | 1.512 | 269.1 |

**32-step recipe**

| Card | Seconds per batch of 3, fresh encoder | Seconds per picture, median | Mean board W |
|---|---:|---:|---:|
| ZOTAC RTX 5080 | 10.626 | 3.491 | 289.3 |
| EVGA RTX 3090 Ti | 15.500 | 5.166 | 293.1 |
| ZOTAC RTX 3090 Ti | 16.028 | 5.366 | 277.3 |


### Ten minutes on the 8-step recipe, every card on this site {#ten-minutes-on-the-8-step-recipe-every-card-on-this-site}

Only rows in one group may be set in a ratio with each other. The builds: **old**, ComfyUI 0.21.1 (`292814c3`), torch 2.11.0+cu128, driver 595.71.05; **the laptop's own**, ComfyUI 0.21.1 (`26515acd`), torch 2.12.1+cu130, driver 595.91.07; **new**, ComfyUI 0.34.0 (`3216c62e`), torch 2.13.0+cu130, driver 595.84.

**In the bench computer, new build, 2026-09-24** (the 5080's 360 W rows at 07:19 to 07:34Z).

| Card and cap | Pictures | Seconds per picture | Mean board W | J per picture |
|---|---:|---:|---:|---:|
| ZOTAC RTX 5080, 300 W | 456 | 1.217 | 256.1 | 338.3 |
| ZOTAC RTX 5080, 360 W (stock) | 466 | 1.212 | 265.9 | 343.8 |
| EVGA RTX 3090 Ti, 300 W | 322 | 1.771 | 282.3 | 528.0 |
| ZOTAC RTX 3090 Ti, 300 W | 305 | 1.873 | 268.2 | 528.9 |
| ZOTAC RTX 3090 Ti, 450 W (stock) | 341 | 1.645 | 369.9 | 652.9 |

**In the i9 computer, old build, 2026-09-17 to 18.** The 3080 pair's rows are one run with both cards drawing at once.

| Card and cap | Pictures | Seconds per picture | Mean board W | J per picture |
|---|---:|---:|---:|---:|
| EVGA RTX 3090 Ti, 300 W | 320 | 1.811 | 288.6 | 542.5 |
| EVGA RTX 3090 Ti, 350 W | 331 | 1.715 | 324.9 | 590.3 |
| EVGA RTX 3090 Ti, 400 W | 347 | 1.676 | 360.2 | 623.4 |
| EVGA RTX 3090 Ti, 450 W (stock) | 348 | 1.672 | 362.5 | 627.2 |
| EVGA RTX 3090 XC3 Ultra, 250 W | 269 | 2.156 | 243.6 | 543.9 |
| EVGA RTX 3090 XC3 Ultra, 350 W (stock) | 311 | 1.886 | 328.0 | 634.5 |
| Gigabyte RTX 3080 10 GB, x16 slot, 250 W, pair run | 158 | 3.737 | 224.3 | 853.5 |
| EVGA RTX 3080 FTW3 Ultra 10 GB, x4 slot, 250 W, pair run | 84 | 7.053 | 163.8 | 1,175.0 |

**On the laptop, its own build, 2026-09-21.**

| Card and setting | Pictures | Seconds per picture | Mean board W | J per picture |
|---|---:|---:|---:|---:|
| RTX 5090 Laptop GPU, 95 W fixed | 294 | 1.958 | 93.2 | 190.5 |
| RTX 5090 Laptop GPU, boost, 150 W | 378 | 1.521 | 143.4 | 227.8 |

The NVIDIA GeForce RTX 3080 Ti Founders Edition 12 GB has run the grid and not this instrument; the EVGA 3090 Ti the reverse.


**What the computer and the build moved, on one card** (the page's note on the old-build rows above, kept beside them). A week earlier the EVGA 3090 Ti had run the same recipes at the same caps in the i9 computer on the old build. Per step at 300 W: 0.1615 s there against 0.1540 here, 4.6 per cent faster; at 450 W, 0.1519 against 0.1440, 5.2 per cent. Over ten minutes at 300 W, 320 pictures became 322 (0.6 per cent) and 542.5 J a picture became 528.0. That prices everything that changed at once at 0.6 to 5.2 per cent on this recipe for an Ampere card; no Blackwell card has this measurement yet.


## What 300 watts buys, card by card (the render bench)

**From here the page switches instruments.** On the workstation card, 300 W makes a different card; on a 5080 or a 3080 Ti, nearly the same card. The render bench asks the same question at more settings (the 8-step recipe, ten minutes). Its rows come from a different instrument on three software builds, so they are compared within each card only; the rows and the builds are in the last table of The tables, and their energy never shares a column with the grid's joules. What the extra watts bought:

| Card and computer | From cap to stock | More pictures in ten minutes | More energy per picture |
|---|---|---:|---:|
| EVGA 3090 Ti, i9 computer | 300 to 450 W | +8.8 % | +15.6 % |
| ZOTAC 3090 Ti, bench computer | 300 to 450 W | +11.8 % | +23.5 % |
| 5080, bench computer | 300 to 360 W | +2.2 % | +1.6 % |
| EVGA 3090 XC3 Ultra, i9 computer | 250 to 350 W | +15.6 % | +16.7 % |
| The laptop | 95 W fixed to boost at 150 W | +28.6 % | +19.6 % |

On the two 3090 Tis the last 150 W buy 9 to 12 per cent more pictures for 16 to 23 per cent more energy each (the EVGA board's ladder ran through 331 pictures at 350 W and 347 at 400); on a 5080 the last 60 W buy almost nothing; on the grid, the 3080 Ti's last 50 W bought 1 to 3 per cent of time for 10 to 12 per cent of energy (5). A cap saves something only on a card that was using the watts.

The ZOTAC 3090 Ti's +23.5 per cent is the ratio of the unrounded joules (369.9 W × 601.91 s ÷ 341 pictures = 652.93 J against 268.2 × 601.423 ÷ 305 = 528.86 J, from the render bench's r4 files; 1.2346); from the rounded rows above a reader gets +23.4. (Added on the fold.)


### The predictions, registered before the first picture and scored after the last {#the-predictions}

| # | Registered before the run | Outcome |
|---|---|---|
| 1 | FLUX.2 [klein] 4B, 512×512 at 8 steps, on the 3090 Ti at 450 W: 1.45–1.90 s | Pending, with that card's grid pass |
| 2 | The same cell on the workstation card at 600 W: 0.40–0.70 s | **Holds:** 0.586 s |
| 3a | The ninety-second rule removes no cell on the workstation card | **Holds:** 18 of 18; costliest 26.2 s against ~38 predicted |
| 3b | It removes exactly FLUX.1 [dev] at 2048×1280 and 32 steps on the 3090 Ti | Pending |
| 4 | 300 W costs the 3090 Ti at most 12 per cent at 2048×1280 on FLUX.2 [klein] 4B | Pending |
| 5a | Per-step cost rises 2.5 to 4.5 times from 1024×1024 to 2048×1280, every model, on the workstation card | **Holds:** 3.01, 3.04 and 2.76 times |
| 5b | The same on the 3090 Ti | Pending |

Not registered, and true: the laptop and the 3080 Ti each lost exactly the cell 3b names, and the 5080's, the laptop's and the 3080 Ti's whole size pairs (2.83 to 3.14 times) sit inside 5's band.

**Registered for the 12 GB card on 2026-09-25, in words, before it ran** (no number was invented for them):

| # | Registered | Outcome |
|---|---|---|
| 12-1 | FLUX.2 [klein] 4B's transformer (7,392 MB) reads whole through sampling at every size | **Holds:** 6 of 6 cells, 18 of 18 timed pictures (edited on the fold) |
| 12-2 | Z-Image-Turbo's (11,738 MB) and FLUX.1 [dev]'s (11,350 MB) read paged at 2048×1280 and very likely at 1024×1024; at 512×512 either verdict is a real outcome | **Holds:** paged at every size, 6 of 6 and 5 of 5 cells, 18 and 15 timed pictures (edited on the fold) |
| 12-3 | The ninety-second rule applies unchanged; a paged cell may go over 90 s, and the costlier cells are then skipped | **Fired once:** FLUX.1 [dev] at 2048×1280 and 32 steps, 93.45 s; its 300 W twin skipped |
| 12-4 | A tiled decode at 2048×1280 is a recorded outcome, not a stop | **None:** no cell used one |
| 12-5 | With a second board in the air it breathes, the ten-minute run may stop at 83 °C; its temperatures are not directly comparable with a card measured alone | **Ran the full ten minutes,** peaking at 80 °C; the caveat stands on its row |


## The cold loads

**The cold loads, as a headline.** Recorded, but the page cache was not controlled: the bench re-hashes every model file before it runs, and what that leaves in memory differs by computer.

| Cold load, seconds | FLUX.2 [klein] 4B | Z-Image-Turbo | FLUX.1 [dev] |
|---|---:|---:|---:|
| Workstation card | 10.7 | 13.3 | 6.4 |
| 5080 | 6.8 | 9.8 | 5.6 |
| Laptop | 24.4 | 55.3 | 67.2 |
| 3080 Ti | 23.6 | 29.3 | 20.7 |


## The dated windows

**The dated windows (UTC).**

| Card | Grid, stock | Ten minutes, stock | 2048×1280 cells, 300 W | Ten minutes, 300 W |
|---|---|---|---|---|
| Workstation card, 2026-09-24 | 16:18:16–16:27:16Z | 16:27:33–16:28:27Z, stopped at 83 °C | 16:30:55–16:40:52Z | 16:41:44–16:52:10Z |
| 5080, render computer, 2026-09-24 | 17:47:44–18:08:42Z | 18:09:15–18:19:35Z | 18:21:12–18:36:35Z | 18:37:15–18:47:37Z |
| Laptop, 2026-09-24 | 19:20:34–19:49:47Z | 19:51:21–20:04:22Z | Not run | Not run |
| 3080 Ti, bench computer, 2026-09-25 | 13:31:45–13:59:16Z | 13:59:40–14:10:09Z | 14:12:37–14:29:28Z | Not run |

The three 300 W caps were set by a person and read back at 300.0 W in every sample; the 3080 Ti's stock limit read 350.0 W throughout; the laptop's enforced limit read 138.11 to 150.0 W across the cells and 150 W at the end of its ten minutes. Idle before each pass: 18.1 and 18.2 W on the workstation card (stock, then 300 W), 15.4 and 15.5 W on the 5080, 11.2 W on the laptop, 14.1 and 14.5 W on the 3080 Ti.


**The bench computer's render bench (the render-bench note).** The three cards ran the render bench's own `renderlib.py`; each card sat in the same x16 slot at PCIe generation 4, one at a time, its cap read back unchanged in every sample and the UPS watched as a stop. ECC was turned off on the ZOTAC 3090 Ti before either of its runs. The build was ComfyUI 0.34.0 (`3216c62e`), torch 2.13.0+cu130 and driver 595.84, the build and the driver read at 17:55Z; the 5080's files, written hours earlier (07:19 to 09:59Z, its 360 W rows first), record the checkout's torch but neither the commit nor the driver, and the card was swapped out between its rows and that reading. ECC read off on the EVGA board; the ZOTAC board arrived with it on. (Moved from the page.)

| Card and cap | Recipes | Ten minutes |
|---|---|---|
| EVGA 3090 Ti, 450 W | 22:36–22:40Z | Not run |
| EVGA 3090 Ti, 300 W | 21:15–21:19Z | 21:19–21:30Z |
| ZOTAC 3090 Ti, 450 W (stock) | 19:31–19:35Z | 19:35–19:46Z |
| ZOTAC 3090 Ti, 300 W | 17:55–17:59Z | 17:59–18:10Z |
| 5080, 300 W | 09:44–09:48Z | 09:48–09:59Z |
| 5080, 360 W (stock) | 07:19–07:23Z | 07:23–07:34Z |

Over the three ten-minute runs at 300 W the cores peaked at 68 °C on the 5080, 58 on the EVGA board and 65 on the ZOTAC, with fans at 44, 71 and 44 per cent at the median. **The older rows** ran in the i9 computer between 2026-09-17 01:55Z and 2026-09-18 01:09Z on the old build, and on the laptop on 2026-09-21, 19:20 to 19:34Z at 95 W and 21:34 to 21:50Z under boost.


## Notes the page points at

**The temperatures (finding 2's note).** At stock the cells' core peaks ran from 46 to 91 °C on the workstation card (up to 91 on Z-Image-Turbo, each model's instance starting on a card still warm), 55 to 73 on the 5080, 50 to 83 on the 3080 Ti with a second board in the air it breathes, and 47 to 72 on the laptop under boost; at 300 W, 56 to 70, 63 to 68 and 68 to 77 on the three desktop cards. The workstation card's clocks settled 0 to 11 per cent lower in the 32-step renders than the 8-step ones (under 1 on the 5080, 0 to 2 on the 3080 Ti) and no thermal slowdown was raised on it; on the 3080 Ti the driver's software thermal-slowdown flag was set on 2.4 to 5 per cent of the samples of four timed renders in three stock cells, at 80 to 81 °C. Finding 5's cells: the workstation card's stock 2048×1280 cells peaked at 70 to 91 °C and its 300 W cells at 56 to 70; the 3080 Ti's at 79 to 83 and 68 to 77. (Moved from the page.)

**The neighbours (How it was measured's note).** The workstation card had the workshop's language services stopped and read empty at every check; the EVGA GeForce RTX 3090 XC3 Ultra 24 GB beside it kept 18,072 MiB of live language services in two processes and sat at 26.5 to 27.0 W at the mean of the 2 Hz trace over each of the two grid passes and the stock ten-minute run, peaking at 39 °C; during the 300 W ten-minute run it answered one 17 s request (16:43:35 to 16:43:52Z, peaking at 131.1 W), and the eight pictures that overlapped it ran at a median of 2.298 s against the run's 2.295, no measurable effect; the 2 Hz trace follows with the raw files. The i9 computer's own services were paused for the pass. In the bench computer a second board is allowed only when named, held idle and watched: after each model's first picture the measured card's memory must have grown and the idle board's must not. The EVGA GeForce RTX 3080 Ti XC3 Ultra 12 GB below the 3080 Ti held at 1 MiB through all 7 loads, with no process, at 27.4 W at the median over the stock pass and 27.2 over the 300 W pass and at 31 to 33 °C, in the air the Founders Edition cooler draws; over the ten-minute run it read 27.3 W, 1 MiB and 32 °C at most. (Moved from the page; the burst's clock times, peak and medians are from the run's trace, as the v4 fold read them.)

**The UPS logs and the fans (What this page cannot say's note).** The three desktop UPSes were a safety stop only, none a wall meter: the workstation and bench computers' read on mains throughout their passes; the i9 computer's log read a frozen 9 per cent through the 5080's 300 W pass (830 of 886 samples, while the card's per-cell mean draw was 272 to 297 W) and will ship in the kit marked as such. The laptop's driver cannot report its fan, so it was set to maximum by hand; three USB fans on the bench computer's open frame (air across the cards, one exhaust to the room) are turned up by hand before every run, and the run records that they were. No room temperature was read. (Moved from the page.)