The same eighteen pictures, card by card

strata→signal is a small workshop that runs its own machines and writes up what it measures. This is its first page about pictures only, and the first where every grid card ran the identical Python stack: the same ComfyUI (the free program that runs image models on your own computer) and the same 103 packages installed fresh on each computer; the graphics driver differed by computer; the bench's own files record no operating system, and each computer's own release file, read after the runs on 2026-09-26 at 15:32Z, said Ubuntu 26.04 LTS on the workstation, i9 and bench computers and Ubuntu 26.04.1 LTS on the laptop. Two of the three models are Black Forest Labs'; a short history of that company is the companion to this page.

Five of the workshop's cards, photographed 2026-09-26, back to front: an EVGA GeForce RTX 3080 FTW3 Ultra 10 GB, which is not in the grid (its only rows are the kit's older render-bench rows, run as a pair beside a Gigabyte GeForce RTX 3080 10 GB); the NVIDIA GeForce RTX 3080 Ti Founders Edition 12 GB of the grid; the EVGA GeForce RTX 3090 XC3 Ultra 24 GB of the second dated section; the ZOTAC GeForce RTX 3090 Ti AMP Extreme Holo 24 GB of the render bench; and the ZOTAC GeForce RTX 5080 Solid CORE OC 16 GB of the grid. The EVGA 3090 Ti of the first dated section stayed in its computer, serving, and is not in the picture.

Who ran where

Four cards, four computers, one grid; on the second test, the render bench, three cards took turns in one of those computers (Three cards in one computer). A fifth card, the EVGA GeForce RTX 3090 Ti FTW3 Ultra 24 GB, ran the grid on 2026-09-26 at 350 W in the workstation computer, and a sixth, the EVGA GeForce RTX 3090 XC3 Ultra 24 GB, the same day at its stock 350 W in the bench computer; their columns are the two dated sections at the end of this page. Drivers: 595.84 in the workstation and bench computers, 595.71.05 in the i9 computer, 595.91.07 on the laptop.

Card	Computer and processor	System memory	Link under load	Settings run
NVIDIA RTX PRO 6000 Blackwell Workstation Edition 96 GB	Workstation computer: AMD EPYC 7532, 64 threads	126,353 MB	PCIe x16, generation 4	600 W (stock) and 300 W
ZOTAC GeForce RTX 5080 Solid CORE OC 16 GB	i9 computer: Intel Core i9-10850K, 20 threads	47,041 MB	PCIe x16, generation 3 (the processor's limit)	360 W (stock) and 300 W
NVIDIA GeForce RTX 5090 Laptop GPU 24 GB	Laptop: Intel Core Ultra 9 290HX Plus, 24 threads	62,699 MB	PCIe x8, generation 5	138 to 150 W, Dynamic Boost
NVIDIA GeForce RTX 3080 Ti Founders Edition 12 GB	Bench computer, 2026-09-25: AMD Ryzen 7 3700X, 16 threads	30,990 MB	PCIe x16, generation 4	350 W (stock) and 300 W

The workstation computer on its battery backup, photographed 2026-09-25 after the swap that put the EVGA GeForce RTX 3090 Ti FTW3 Ultra 24 GB of the first dated section beside the bracket of the RTX PRO 6000; on 2026-09-24, when the workstation card ran the grid, an EVGA 3090 XC3 Ultra sat beside it in a different x16 slot. 1, the processor's cooler; 2, the server board's memory; 3, the 3090 Ti; 4, the RTX PRO 6000's bracket; 5, the battery backup. The picture and its key are from One 3090 out, one 3090 Ti in.

Below they are the workstation card, the 5080, the laptop and the 3080 Ti; in the tables, RTX PRO 6000, RTX 5080, RTX 5090 Laptop and RTX 3080 Ti FE. System memory is what ComfyUI's startup line printed on each computer; its MB, like every MB the runtime prints, are MiB, and paged weights live there. The 5080 was in two computers on 2026-09-24 (the kit's Who ran where has the hours). The 3080 Ti ran on 2026-09-25 in the bench computer's x16 slot with an EVGA GeForce RTX 3080 Ti XC3 Ultra 12 GB held idle in the chipset x4 slot directly below it, seated there for a later test of the two 3080 Tis (finding 4); the 3090 XC3 Ultra took the same slot on 2026-09-26 with the same board idle below it (the second dated section).

The EVGA GeForce RTX 3090 Ti FTW3 Ultra 24 GB of the second test below has its column now, in the first dated section at the end of this page: its first grid pass was stopped early when, under the combined load, the battery backup of the computer it ran in reported a low runtime estimate and that computer's power safety released its other work, and the column was measured again on 2026-09-26 at 350 W, not at stock. The EVGA GeForce RTX 3090 XC3 Ultra 24 GB, the workstation card's neighbour on 2026-09-24 (The neighbours), has its column too, in the second dated section, at its stock 350 W. One more card is coming to the grid, under its own dated section when it lands (How to check our work): the ZOTAC GeForce RTX 3090 Ti AMP Extreme Holo 24 GB, also of the second test.

The EVGA GeForce RTX 3090 XC3 Ultra 24 GB, photographed 2026-09-25: the workstation card's neighbour on 2026-09-24 (The neighbours); its own column, measured on 2026-09-26 in the bench computer, is the second dated section at the end of this page.

Until then the grid's desktop cards with 24 GB are the two of the dated sections: the 3090 Ti at 350 W rather than its stock limit, and the 3090 XC3 Ultra at its stock 350 W.

Words this page leans on

• A sampling step. An image model draws by cleaning up noise a step at a time. The grid times 8 and 32 steps as two points on a line, not as quality settings; at another step count your seconds should lie near the line through them (two points were timed; each model's own workflow count is in How it was measured).
• Seconds per step, the headline. The 32-step time minus the 8-step time, over the 24 extra steps, on ComfyUI's own clock. Once-per-picture work (prompt, decode, save) cancels; work the computer does every step, the debug log included (What this page cannot say), does not.
• A cell. One model at one size and one step count, eighteen per card: the median of three timed pictures (their spread is in the kit's cell-tables note).
• The ninety-second rule. A picture past 90 s is stopped, its cell reads "over 90 s", and every costlier cell of that model on that card is skipped; ruled before the first picture to keep each pass short, and not a verdict on the picture. A first load's limit is 600 s.
• Board power, and joules per picture. What the card itself draws, read from its driver twice a second and summed over the picture's own run (3,600 J is a watt-hour); the processor, memory, fans, power-supply loss and, on the laptop, the processor's side of Dynamic Boost are outside it, and nothing is measured at the wall. A picture under about two seconds has too few readings and prints a dash.
• Stock, cap and posture. Stock is the limit a desktop card ships with (600, 450, 360 and 350 W here); a cap is a lower limit set on purpose and read back in every sample: 300 W on every desktop card here, and 350 W on the EVGA 3090 Ti, its everyday cap (the first dated section); a person typed the three caps of the first four cards, and the dated sections' window scripts set theirs (How it was measured). 300 W is the cap most of the workshop's cards run at day to day, most of a card's speed for less heat and power, on a card whose stock limit is near it (the 600 W card's step takes 1.69 to 1.73 times as long at 300 W, finding 2). The laptop's Dynamic Boost budget (default 95 W, up to the board's own 175 W maximum; 138 to 150 W here, set by the driver against the processor's draw) is a posture, not a cap.
• "Same software, different computer." The label on every grid figure that compares cards, but one pair: the first four grid cards each ran in their own computer, so a ratio between them includes the computer; the RTX PRO 6000 and the 3090 Ti of the first dated section shared the workstation computer, the second beside a serving card on its host, and keep the label; the 12 GB card and the 3090 XC3 Ultra, measured alike in the bench computer's one slot a day apart (the second dated section), are the one pair printed without it (What this page cannot say). Per-step figures are the fairest comparison, and no whole-picture second is set in a ratio across computers. A picture with no model in it took 0.025 s on the workstation computer and 0.007 s on the i9 computer (each computer's dry run just before its grid pass), so a fast card's smallest cells partly measure the computer.

The grid, and the one thing it holds fixed

Eighteen cells per card: three models at three sizes (512×512, 1024×1024, 2048×1280) and two step counts (8 and 32), batch 1. FLUX.2 [klein] 4B in bf16 runs from the workshop's everyday 8-step workflow (euler, Flux2Scheduler, cfg 1.0; the print lab, the workshop's picture service, draws with it) with only the size, the step count and the batch changed; Z-Image-Turbo in bf16 runs from its official ComfyUI template on the same text encoder; FLUX.1 [dev], one fp8 all-in-one checkpoint, runs from the official template at its default guidance of 3.5. All three are diffusion transformers, timed here and nothing more; a UNet model such as SDXL was not measured. The prompts are two real print-lab prompts with their style words removed, and the seeds follow a formula, so no two pictures in one run are the same request; the formula is the same on every card, so every card was sent the same requests in the same order.

The one thing held fixed is the ComfyUI stack: commit 3216c62e (v0.34.0) with the same 103 packages from one hashed lock on every card, without --fast, so FLUX.1 [dev]'s weights are stored in fp8 and its math is done in bf16 on every card. The stack in full, the five differences from a desktop ComfyUI and the run order are in How it was measured.

Seven things the grid found

Every figure here is from grid.json or sustained.json, one pair per card and setting, which follow in the kit (How to check our work); every figure is in its tables file now. Cross-card figures carry the label same software, different computer; the one pair printed without it is in the second dated section.

1 · Twelve gigabytes: which models fit whole

The NVIDIA GeForce RTX 3080 Ti Founders Edition 12 GB of the grid, its fan side, photographed 2026-09-25, the day it ran in the bench computer's x16 slot (Who ran where).

The runtime prints every model's resident megabytes after every node, and the harness reads those lines for the sampling model over the sampler's own span (re-read by residency.py v2, which follows with the raw files; the verdicts the files were first written with are kept beside it). Every instance loaded through ComfyUI's dynamic VRAM path (each log reads "DynamicVRAM support detected and enabled" and every model "prepared for dynamic VRAM loading"), which streams what does not fit from system memory each step; the 12 GB verdicts are this version's. A cell whose transformer sat whole on the card through that span is whole; one that did not is paged, its per-step figure has weight traffic inside it and carries the label, and a pair measured two ways gets no figure. On the three of the first four cards with 16 GB or more, every transformer read whole through every step of every cell: klein's 7,392 MB, Z-Image-Turbo's 11,744 of 11,738 staged, FLUX.1 [dev]'s 11,360 of 11,350 (the runtime rounds up); the two 24 GB cards of the dated sections read whole in every cell too (their sections). On the 12 GB card, at stock:

Model on the 3080 Ti	Transformer staged, MB	Resident inside the sampler's span, MB	Verdict
FLUX.2 [klein] 4B, bf16	7,392	7,392	Whole, 6 of 6 cells (18 timed pictures)
Z-Image-Turbo, bf16	11,738	8,064 to 11,104	Paged, 6 of 6 (18)
FLUX.1 [dev], fp8	11,350	8,640 to 11,008	Paged, 5 of 5 (15); the sixth cell ran over 90 s

Z-Image-Turbo, bf16 FLUX.1 [dev], fp8

The 12 GB card's grid.json at 350 W, per_step[].sampling_min_fraction for each model and size, and for FLUX.1 [dev] at 2048×1280 its 8-step cell's renders[].residency, as the table moved from finding 1 to the kit's tables file prints them; the megabytes behind each share are in the kit's residency note.

The bigger the picture, the more of the transformer the runtime evicts for the step's working memory; the rest of the graph left first (two of the three text encoders and all three decoders fell to nothing on the card during the steps; the megabytes, and the 300 W pass's, are in the kit's residency note), and at 300 W the same two models paged the same way. Paged weights cross the computer's link and memory every step (here PCIe x16 at generation 4, a Ryzen 7 3700X and 30,990 MB of system memory), so a paged figure is more the computer's than any other here, and this page sets none in a ratio with a whole one. No cell failed, ran out of memory or needed a tiled decode; the one cell the 12 GB card lost, it lost to the clock (finding 7), and that cell's 300 W twin to the rule.

The 16 GB card is not paged, and not free of moves (its text encoder and part of its transformer cross its generation-3 link around each encode and decode; the kit's residency note has the megabytes), which sits in its fixed cost and ten-minute count, not its per-step figure. Peak memory is a budget on three of the four cards, not a footprint: ComfyUI fills a card to what it has, so the 12 GB card peaked within 388 to 650 MiB of its 12,288 on every cell, the 16 GB card within 465 to 851 of its 16,303, and the laptop's 22,409 MiB on Z-Image-Turbo at 2048×1280 and 32 steps sits under the 96 GB card's 27,306 on the same cell (same software, different computer). The 96 GB card's row (the kit's peak-memory table) is what ComfyUI holds when nothing forces it out, not what a model needs: klein peaked at 22,978 MiB there and still sat whole on the 12 GB card, in another computer. Another Z-Image-Turbo does fit 12 GB: on the RTX 5080 vs RTX 3080 Ti page its INT8 build (6.2 GB, decimal), timed warm with the prompt's encoding cached, sat whole on this same Founders Edition; the grid ran the bf16 file with the encoder re-run for every picture.

2 · Seconds per sampling step, and what 300 W does to the gap

First the unit most people look at: the median seconds per picture at 1024×1024, each desktop card at its stock limit and the laptop under Dynamic Boost (lower is faster; the 3080 Ti's Z-Image-Turbo and FLUX.1 [dev] cells are paged, finding 1). 8 steps is Z-Image-Turbo's template count and klein's recipe count, so those rows are a default workflow's time; FLUX.1 [dev]'s template runs 20, between its two rows.

Card, setting and steps, 1024×1024	FLUX.2 [klein] 4B	Z-Image-Turbo	FLUX.1 [dev]
RTX PRO 6000, 600 W, 8 steps	1.506	1.993	2.758
RTX PRO 6000, 600 W, 32 steps	4.368	6.718	9.601
RTX 5080, 360 W, 8 steps	3.593	5.650	7.033
RTX 5080, 360 W, 32 steps	12.023	18.570	25.689
RTX 5090 Laptop, 138–150 W, 8 steps	4.501	6.436	9.777
RTX 5090 Laptop, 138–150 W, 32 steps	16.011	24.240	37.231
RTX 3080 Ti FE, 350 W, 8 steps	5.725	8.604, paged	10.857, paged
RTX 3080 Ti FE, 350 W, 32 steps	19.004	30.289, paged	39.809, paged

FLUX.2 [klein] 4B, bf16 Z-Image-Turbo, bf16

Each card's grid.json at its higher setting, the cells klein4b-1024x1024-8st and zimage_turbo-1024x1024-8st, row.exec_s, as the first table under finding 2 prints them; every size and every cell's joules are in the kit's cell tables.

Every size, and every cell's joules, are in the kit's tables. The page's own instrument is seconds per sampling step, here at 2048×1280, the one size every setting ran:

Card and setting, seconds per step at 2048×1280	FLUX.2 [klein] 4B	Z-Image-Turbo	FLUX.1 [dev]
RTX PRO 6000, 600 W	0.3589	0.5985	0.7875
RTX PRO 6000, 300 W	0.6215	1.0289	1.3312
RTX 5080, 360 W	0.9933	1.6354	2.2085
RTX 5080, 300 W	1.0090	1.6510	2.2965
RTX 5090 Laptop, 138–150 W	1.4091	2.3272	No figure
RTX 3080 Ti FE, 350 W	1.5812	2.6002, paged	No figure
RTX 3080 Ti FE, 300 W	1.6442	2.6899, paged	No figure

At the higher setting At 300 W

Each card's grid.json at each setting, per_step[].seconds_per_step for klein4b at 2048x1280, as the second table under finding 2 prints them; the per-step figures at every size are in the kit's tables.

it/s is one divided by the seconds (the 3080 Ti's klein column, for instance, reads 0.632 and 0.608 it/s). ComfyUI's console bar times only the sampler's last interval and differs from this figure by up to 7 per cent on 32-step renders and 32 on 8-step ones across these cells at both settings (6 and 29 at each card's higher setting alone), so compare your bar against a 32-step render. No figure: the laptop's and the 3080 Ti's 32-step FLUX.1 [dev] cells ran over 90 s, and the 3080 Ti's 300 W twin was skipped by the rule. Read, under the label, on the cells that are whole everywhere:

• At stock, the laptop under Dynamic Boost, the workstation card does a klein step in 0.36 of the 5080's time, a lead of 2.77 times; 2.73 on Z-Image-Turbo, 2.80 on FLUX.1 [dev]. The 3080 Ti takes 1.59 times as long per klein step as the 5080; the laptop takes 1.42 times as long as the 5080 on both models with a figure. The lead depends on size (2.57 times at 512×512, 2.94 at 1024×1024 on klein; the kit's per-step tables): the subtraction cancels once-per-picture work, not the computer's share of each step.
• With the desktop cards held to 300 W the workstation card's lead over the 5080 is 1.62 times (0.6215 against 1.0090); 1.60 on Z-Image-Turbo, 1.73 on FLUX.1 [dev]. The cap makes the workstation card's step 1.69 to 1.73 times as long; the 5080's 1.6 per cent longer on klein, 1.0 on Z-Image-Turbo and 4.0 on FLUX.1 [dev]; the 3080 Ti's 4.0 per cent longer on klein and 3.4 on its paged Z-Image-Turbo. 300 W is half the workstation card's stock limit, five-sixths of the 5080's and six-sevenths of the 3080 Ti's; that asymmetry is the finding.
• The figures at each card's higher setting are a hot card's. The cells' core peaks ran up to 91 °C on the workstation card (each model's instance starting on a card still warm), 73 on the 5080, 83 on the 3080 Ti with a second board in the air it breathes, and 72 on the laptop under boost; at 300 W the three desktop cards peaked at 70, 68 and 77. No thermal slowdown was raised on the workstation card; on the 3080 Ti the driver's thermal-slowdown flag was set on 2.4 to 5 per cent of the samples of four timed renders in three stock cells. The ranges by setting, and the clocks, are in the kit's temperatures note.

3 · Joules per picture, and per step

The ZOTAC GeForce RTX 5080 Solid CORE OC 16 GB, its fan side, photographed 2026-09-25; on 2026-09-24 it ran the grid in the i9 computer and the render bench in the bench computer.

Joules per picture is the trapezoid over the card's power readings inside the picture's own window; every cell's figure is in the kit's tables, and the mean draw of every 2048×1280 cell in its mean-draw table. The wall pays more, unmeasured. Across computers the fair figure is joules per step: the 32-step picture's joules minus the 8-step picture's, over 24. FLUX.2 [klein] 4B's is drawn below; all three models' figures, at both settings, are in the kit's tables (its joules-per-step table, moved from this page).

At the higher setting At 300 W

Each card's grid.json at each setting, row.joules_per_image of the klein4b 2048x1280 cells, the 32-step figure minus the 8-step figure over 24, as the kit's joules-per-step table, moved from finding 3, prints them; every cell's joules are in the kit's cell tables.

Read, under the label: the 5080 spends more energy per step than the workstation card and the laptop on every whole cell, 1.57 to 1.73 times the workstation card's with both at 300 W and 1.43 to 1.65 times at stock. The 3080 Ti spends the most: per klein step 1.77 times the 5080's at stock and 1.65 at 300 W, 2.62 and 2.58 times the workstation card's, 2.64 times the laptop's. The laptop spends 1.10 to 1.14 times the workstation card's at 300 W, 0.5 and 5.0 per cent below it with the workstation card at stock, and about two-thirds of the 5080's (0.67 against the 5080 at stock, 0.70 to 0.71 against it at 300 W).

4 · Ten minutes of drawing at 1024×1024

FLUX.2 [klein] 4B at 8 steps, back to back, one prompt always queued, on ComfyUI's own clock from the first counted picture's start to the last one's end; from each run's own file, the count, the median seconds, the mean draw, the joules and the peak temperature. The 3080 Ti's row is its stock run; it has no 300 W run on this cell. The last column, kilowatt-hours per thousand pictures, is the J per picture over 3,600 (3,600 J is a watt-hour).

Card and setting	Pictures	Seconds per picture, median	Mean board W	J per picture	kWh per thousand pictures
RTX PRO 6000, 300 W	252	2.295	279.1	666.7	0.185
RTX 5080, 360 W	164	3.608	270.1	991.6	0.275
RTX 5080, 300 W	164	3.611	265.8	977.6	0.272
RTX 5090 Laptop, boost, 150 W throughout	132	4.482	145.4	663.0	0.184
RTX 3080 Ti FE, 350 W	101	5.814	321.2	1,908.4	0.530

At the higher setting At 300 W

Each run's own sustained.json, images and joules_per_image, as the table under finding 4 prints them with the median seconds, the mean draw and the kilowatt-hours per thousand pictures.

Core peaks were 70, 67, 67, 71 and 80 °C, and the card was busy for 0.966 to 0.983 of each window. Read as counts, under the label. The laptop (limit 150 W, 145.4 W mean) and the workstation card (limit 300 W, 279.1 W mean) spent the same per picture, 663 against 667 J, within sensor noise; on the fairer figure across computers, joules per step at 2048×1280 (finding 3), the laptop spends 1.10 to 1.14 times the workstation card's. These counts carry more of the computer than the per-step figures do: once-per-picture work, some of it the computer's, is 0.55 s of the workstation card's 1.51 s picture at stock (its 300 W row has no grid cell at this size), 0.78 s of the 5080's 3.59 s, 0.66 s of the laptop's 4.50 s and 1.30 s of the 3080 Ti's 5.73 s.

Two conditions on the 3080 Ti's row. Its core sat at 79 to 80 °C for most of the window (68 °C at the open, 66 at its lowest, 80 °C peak, the 83 °C stop never met), the driver's power-cap flag was set in 98 per cent of the samples (mean draw 321.2 W) and its thermal-slowdown flag on 2.7 per cent of the window's 1,081 samples, so its count is a warm card's at its limit; and a second board sat idle in the air it breathes (27.3 W, 1 MiB, 32 °C at most over the run), a seating registered before the run as not directly comparable with a card measured alone. Its seconds, watts and memory are read by UUID and are its own.

Why there is no stock row for the workstation card. Its stock run started 22 seconds after the grid's last cell (which had peaked at 90 °C), opened at 76 °C and met the ten-minute run's 83 °C stop at 31.1 s, 20 pictures inside a 31.5 s counted window, so no figure is printed from it; the stop is the bench's rule, below the card's own slowdown point, the absence is the queue order's as much as the card's, and at 300 W the same card ran the full ten minutes and peaked at 70 °C.

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 the seconds and joules in each card's two result files; the cell-by-cell change table, the seconds, the joules and the mean draws are in the kit's tables.

Card	Stock limit	Time at 300 W	Board energy at 300 W
Workstation card	600 W	+54 to +68 %	−9 to −22 %
5080	360 W	−0.1 to +3.8 %	−3 to −11 %
3080 Ti	350 W	+1.3 to +3.3 %	−10 to −12 %

On the workstation card, 300 W is half its stock limit, and it shows. One caveat: these stock cells ran at 70 to 91 °C and the 300 W cells at 56 to 70 °C, so the saving is the cap and the cooler silicon together, and this grid cannot split them. A limit acts on an average: single readings reached 530 W on the workstation card under its 300 W cap and 186 W on the laptop under its 150 W boost limit, in their ten-minute runs. On the 5080, 300 W is 60 W under its 360 W stock limit, and at stock it drew 289 to 344 W at the mean on these cells, above 300 W on four of the six. On the 3080 Ti, 300 W is 50 W under its 350 W stock limit, and it was using the watts: 331 to 345 W at the mean on the five of these cells it finished at stock (its Z-Image-Turbo and FLUX.1 [dev] cells paged at both settings), with its stock cells at 79 to 83 °C and its 300 W cells at 68 to 77, the workstation card's caveat again. The render bench's own cap ladders on other cards, the two 3090 Tis' among them, are in the kit's tables (What 300 watts buys). A cap saves something only on a card that was using the watts.

6 · A 2048×1280 step costs about three 1024×1024 steps

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 at each card's higher setting (stock on the desktop cards, Dynamic Boost on the laptop, the 3090 Ti's 350 W cap), all thirteen whole pairs with a figure fall between 2.75 and 3.14 times: the first four cards' nine between 2.76 and 3.14, the 3090 XC3 Ultra's two at its stock limit at 2.81 and 2.86, and the 3090 Ti's two at 350 W at 2.75 and 2.95 (the kit's size table; the 3080 Ti's paged Z-Image-Turbo pair is printed there under its label and read against no band). That is near the linear end of the registered band: a 2048×1280 step costs about three 1024×1024 steps, not two and a half, on every whole pair with a figure.

7 · The ninety-second rule fired twice on the first four cards

The costliest cell of the grid is FLUX.1 [dev] at 2048×1280 and 32 steps. It finished on the workstation card (26.194 s at 600 W, 43.646 at 300 W) and on the 5080 (72.198 at 360 W, 74.933 at 300 W). The laptop's warm-up was stopped at 92.9 s at step 28 of 32, its progress bar reading 3.23 s a step, so the 32 steps finish in about 105 s (the 8-step median, 27.711 s, plus 24 × 3.23); the 3080 Ti's at 93.45 s at step 27 of 32, its bar at 3.31 s a step, about 108 s the same way (28.867 plus 24 × 3.31), and its 300 W twin was skipped by the rule. Since at 2048×1280 every warm-up on every card sat within 3 per cent of its cell's timed median, the timed renders would have run over too. Every cell that ran finished under the limit: 36 at stock and 12 at 300 W on the workstation card and the 5080, 17 of 18 on the laptop, 17 of 18 and 5 of 5 on the 3080 Ti. The two 24 GB cards of the dated sections lost the same cell, each with its 300 W twin left out by the rule: the 3090 Ti at 350 W at 92.9 s at step 31 of 32, the 3090 XC3 Ultra at stock at 93.8 s at step 28 of 32 (their sections).

Three cards in one computer, one checkout, one recipe

The ZOTAC GeForce RTX 3090 Ti AMP Extreme Holo 24 GB of this section, bought refurbished, photographed 2026-09-25 with its light bar on.

This section needs no label, with the 5080's caveat below. On 2026-09-24, between 07:19Z and 22:40Z, a ZOTAC GeForce RTX 5080 Solid CORE OC 16 GB, an EVGA GeForce RTX 3090 Ti FTW3 Ultra 24 GB and a ZOTAC GeForce RTX 3090 Ti AMP Extreme Holo 24 GB (bought refurbished) took turns in the same x16 slot of the bench computer, at PCIe generation 4, on the same ComfyUI checkout: the print lab's three saved ComfyUI workflows (its recipes) in batches of three, then its everyday 8-step recipe (graph 79df5a8b, 512×512 pictures with klein 4B) one picture at a time for ten minutes, a new prompt each picture, at 300 W and at stock. From the render bench's own files, the count and the board energy per picture (joules as mean draw × window ÷ pictures) are drawn below; the median seconds and the mean draw stand beside them in the kit's tables (Ten minutes on the 8-step recipe, the bench computer's block):

At stock At 300 W

The render bench's own r4 files for the three cards in the bench computer, cards[0].images and the mean board draw over the window, as the kit's ten-minute table for the bench computer, moved from Three cards in one computer, prints them; every ten-minute row this site has measured is in the kit's tables.

The conditions (caps read back, ECC, cores, fans) are in the kit's render-bench note; the one that needs saying here: the build and the driver (595.84) were read at 17:55Z, and the 5080's files, written hours earlier (07:19 to 09:59Z, its 360 W rows first), record the torch but neither the commit nor the driver, with the card swapped out in between. Only these rows may be set in a ratio with each other; the older render-bench rows, on other builds in other computers, are in the kit's tables and never share a column with the grid's joules.

Per picture, at 300 W: the 5080 did the work in 0.69 of the EVGA board's time for 0.64 of its energy; against the ZOTAC board, 0.65 and 0.64. At stock (the 5080 at 360 W, the ZOTAC board at 450 W; the EVGA board has no stock ten-minute run in this computer), 0.74 of the time for 0.53 of the energy. Per sampling step, at 300 W, 512×512, one picture's share of a batch of three (32-step recipe median minus 8-step median, over 24, from the kit's recipes table): 0.1050 s on the 5080, 0.1540 on the EVGA 3090 Ti, 0.1606 on the ZOTAC; the two 3090 Tis take 1.47 and 1.53 times as long, and the per-batch column, where the text encoder ran fresh on every card, gives 1.47 and 1.52. The two 3090 Tis have their own page, next on this site; the EVGA board's grid column is the first dated section at the end of this page, at 350 W. What the computer and the build moved on one of them, the EVGA 3090 Ti a week earlier in the i9 computer on the old build, is measured beside the old rows in the kit's tables.

fp8, briefly: on the RTX 5080 vs RTX 3080 Ti page an fp8 build of klein 4B (its text encoder in fp4), warm with the prompt's encoding cached, drew 1.64 to 1.79 times as fast as the bf16 file on the 5080 and 1.05 to 1.06 times on the 3080 Ti Founders Edition, which has no fp8 math; the workstation card and the laptop are Blackwell too, with the same generation of fp8-capable tensor cores, and neither ran that file. The full story is the fp8 door on that page.

The full tables

Every table this page does not print is in the data kit, the tables file published beside this page in its data/ folder, 31 tables with their headings and conditions: every cell's seconds and joules at every size at each card's higher setting and at 2048×1280 at 300 W, the mean draw of every 2048×1280 cell, the per-step figures at every size, peak memory, the recipes, every ten-minute row this site has measured, what 300 watts buys on the render bench, the change and size tables of findings 5 and 6, the two tables that moved here when this page drew them as charts on 2026-09-26 (finding 1's share of the transformer by size and finding 3's joules per step; Three cards in one computer's ten-minute rows, drawn as a chart the same day, were already here), the cold loads, the predictions, the dated windows, and the notes this page points at (the cells' spread, residency, temperatures, the neighbours, the UPS logs and the render bench's conditions). Licence: CC BY 4.0, the whole page and its data kit — name the source and link to it.

What this page cannot say

• A ratio between two grid cards as anything but "same software, different computer", but for one pair. No card has run the grid in two computers. Two computers have each hosted two grid cards (the dated sections). The bench computer's pair, the 12 GB card and the 3090 XC3 Ultra, ran a day apart (2026-09-25 and 2026-09-26) in the same slot beside the same idle board; a ratio inside it carries no computer term, and this page prints it without the label. The workstation computer's pair, the RTX PRO 6000 and the 3090 Ti, ran two days apart (2026-09-24 and 2026-09-26) beside different neighbours, the second beside a serving card that shared its host, and keeps the label. The nearest measurement of the computer's share is the 5080 in two computers the same day: 1.237 s on the grid's klein 512×512 8-step cell in the i9 computer, 1.212 s a picture on the same recipe at the same 360 W over ten minutes in the bench computer; two per cent, one reading on one cell from two instruments and two Python installs, not a bound and not a correction.
• What a 12 GB card does with the encoder kept off the card, a smaller encoder or a quantised transformer, or what paging costs. Not measured here; the INT8 build is in finding 1, and no model ran both whole and paged on one card.
• Batches above one, torch.compile, Sage attention, --fast and fp8 math, other samplers, clock locks and undervolts. Held fixed or absent.
• The cost of the debug log. Every instance ran --verbose DEBUG so the runtime would print its residency, and it prints every sampling step, not once a picture (about 30 lines a step on FLUX.2 [klein] 4B and 60 on FLUX.1 [dev]), so its cost sits inside the per-step figure as well as the fixed cost, on the host, heaviest where a step is shortest (0.040 s, the workstation card's klein step at 512×512); it was not measured. ComfyUI took the same attention path on every card (every log reads "Using pytorch attention"); which PyTorch kernel that path picked on each chip was not recorded.
• Power at the wall socket. The three desktop UPSes were a safety stop only, none a wall meter: the workstation and bench computers' read on mains throughout; the i9 computer's log read a frozen 9 per cent through the 5080's 300 W pass while the card drew 272 to 297 W at the mean, and it will ship in the kit marked as such (the kit's UPS note has the sample counts).
• The room temperature, or the laptop's fan. No room temperature was read; the laptop's driver cannot report its fan, so it was set to maximum by hand; the bench computer's three USB fans are turned up by hand before every run, and the run records that they were.
• The cold loads, as a headline. Recorded, and in the kit's tables, 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.
• Any picture, judged. Every picture is kept with its sha256 and none is judged; no picture from any model is published.

How it was measured

The grid. One harness, built in its own folder on each computer, its model files linked read-only where their sha256 matched the pin, else downloaded and checked. Timing is ComfyUI's own execution_start to execution_success. Power, temperature, clocks, fan and the enforced limit were read twice a second on every card in the computer; the headline power is power.draw.instant.

The stack, in full. Every card ran ComfyUI at commit 3216c62e (v0.34.0), CPython 3.14.4 built by uv and torch 2.13.0+cu130, with the same 103 packages from one hashed lock. ComfyUI started with --verbose DEBUG --cache-classic --preview-method none, locked to its card by UUID, in its normal memory mode (no low-memory flag) and without --fast. That flag and the file, a plain fp8 cast with no scale keys, decide what the FLUX.1 [dev] cells measure: the weights are stored in fp8 and the math is done in bf16 on every card, so the fp8 hardware in the Blackwell cards was never used. Five differences from a desktop ComfyUI: every render re-ran its text encoder (the part that reads the prompt), as a new prompt does, which re-rolling seeds on one prompt skips (0.1 to 0.7 s a picture here, on the driver's websocket clock); previews were off; every model ran at cfg 1.0, one model call a step, where cfg above 1 makes two and roughly doubles the per-step cost; every instance ran the debug log, about 30 to 60 lines a step (What this page cannot say), so a normal ComfyUI should match or beat these per-step figures by an amount not measured; and the laptop ran with its fan at maximum and its usual processor services running, so on its own fan curve, or with a busier processor, it may get less; neither was measured.

What ran on each card, in order. Each model starts in a fresh ComfyUI, its first picture (load included) kept apart; then its six cells, small to large, each three timed pictures on prompts A, B, A after a warm-up on B, the text encoder run every time. A check after every picture stops the run if anything else used the card, the limit moved in any sample or the UPS left mains. The grid at each card's higher setting is followed by the ten-minute run (klein 4B, 1024×1024, 8 steps, stopping at 83 °C), then the desktop cards' 2048×1280 cells at 300 W; every cap change was typed by a person, except on the cards of the two dated sections below, whose window scripts set each cap from the card's registered settings and read it back in every sample. Not ranked here: which card is "better", any single picture, anything in money.

Model	Sampler	Scheduler	Guidance (cfg)	Steps in the workflow run
FLUX.2 [klein] 4B, bf16, Apache-2.0	euler	Flux2Scheduler	1.0	8
Z-Image-Turbo, bf16, Apache-2.0	res_multistep	simple, shift 3	1.0	8
FLUX.1 [dev], fp8 checkpoint (Comfy-Org's all-in-one file), FLUX.1 [dev] Non-Commercial License	euler	simple	1.0, guidance 3.5	20

klein's 8 is the workshop's recipe count; the other two are their official ComfyUI templates' counts.

The neighbours. The workstation card's neighbour, the EVGA GeForce RTX 3090 XC3 Ultra 24 GB, kept 18,072 MiB of live language services and idled at 26.5 to 27.0 W; its one 17 s request during the 300 W ten-minute run moved nothing measurable in that run's median. 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: the EVGA GeForce RTX 3080 Ti XC3 Ultra 12 GB below the 3080 Ti held at 1 MiB through all 7 loads, at 27.4 and 27.2 W at the median over the two passes, in the air the Founders Edition cooler draws (finding 4); below the 3090 XC3 Ultra on 2026-09-26 the same board held at 1 MiB through all 8 loads at 13.9 W at the median over the stock grid, its persistence mode off where it had been on the day before (the second dated section). The rule and every reading are in the kit's neighbours note; the 2 Hz trace follows with the raw files.

The dated windows (UTC). The workstation card, the 5080 and the laptop ran the grid on 2026-09-24 (16:18 to 16:52Z, 17:47 to 18:47Z and 19:20 to 20:04Z), the 3080 Ti on 2026-09-25 (13:31 to 14:29Z), and on 2026-09-26 the 3090 Ti FTW3 Ultra in the workstation computer (08:50 to 09:54Z) and the 3090 XC3 Ultra in the bench computer (14:20 to 15:27Z), the two dated sections; the bench computer's render bench ran on 2026-09-24 between 07:19 and 22:40Z; the older render-bench rows ran in the i9 computer between 2026-09-17 01:55Z and 2026-09-18 01:09Z and on the laptop on 2026-09-21. Every window to the second, every cap's read-back in every sample and the idle draws before each pass are in the kit's windows tables.

How to check our work

The pre-registration was frozen before the first picture, revised once before that freeze after two review panels, and amended before each later pass: in words for the 12 GB card, and with figures for the 3090 Ti's 350 W pass and for the EVGA GeForce RTX 3090 XC3 Ultra. Its predictions: the three this page can score held; for the 12 GB card, the two testable predictions registered in words before its pass held and the three rules registered with them were followed (the kit's predictions table); the four registered for the EVGA GeForce RTX 3090 Ti FTW3 Ultra's grid pass, and the five registered before its 350 W pass, are scored in its dated section at the end of this page, as registered where that pass allows and as unscored where it does not; the eight registered on 2026-09-26 for the EVGA GeForce RTX 3090 XC3 Ultra, before it was seated, are scored in the second dated section. The kit's first drop, published with this page, is the tables file alone. The raw files the tables come from (grid.json with the runtime's residency lines, sustained.json, the cell graphs, the 2 Hz traces, the UPS logs, the websocket events, ComfyUI's logs, the lock file) and reduce.py, which re-derives every table from the raw render records (ComfyUI's stamps, the 2 Hz power samples and the runtime's log lines) with a --check that refuses on a single moved digit, follow once cleared of the workshop's private paths and names, with a manifest of every file's size and sha256, and this section will say when; the render bench's and the older tests' files follow with them. That check passed on every result file in our own run, and you can repeat it when they ship; the tables file passed the harness's gate before this page was published. The pictures, the prompts' full text and the harness code are withheld, and named as withheld. Anything measured again or corrected later is added under its own dated section, and the byline says when.

More on this site

• A short history of Black Forest Labs — the makers of FLUX; the companion to this page.
• RTX 5080 vs RTX 3080 Ti — the fp8 door in full.
• A laptop, asked the desktop's questions — three postures.
• RTX 3090 vs RTX 3090 Ti — the i9 computer's rows.
• Two 3080s against one 3090, and the cap decides — the pair.
• What 150 watts buys — the workstation card's earlier cap ladder.
• How the print lab works — the recipe's home.
• The hardware roster — every published figure, card by card.

Who ran this, and thanks

The cards are named in full in Who ran where and Three cards in one computer; the laptop is an MSI Raider 16 Max HX. NVIDIA for the silicon, the driver every reading came from and the Founders Edition board; ZOTAC, EVGA and MSI for the boards, and Gigabyte for one in the kit's tables. The pictures stand on ComfyUI and the comfy-kitchen and comfy-aimdo libraries beneath it, on PyTorch and NVIDIA's CUDA, on Astral's uv and on Network UPS Tools. The models are Black Forest Labs' FLUX.2 [klein] 4B and FLUX.1 [dev], Alibaba's Tongyi Lab's Z-Image-Turbo, Alibaba Cloud's Qwen 3 4B, and Google's T5-XXL and OpenAI's CLIP ViT-L/14, the text encoders inside the FLUX.1 [dev] checkpoint; Hugging Face hosted every pinned file. None of them owed us anything.

A small human team owns the cards, ruled the grid and its refusals before a picture was drawn, pasted every cap on the first four cards and started the window scripts that set the dated sections' caps, and signed the numbers; a fleet of AI agents built the harness, ran it and did the arithmetic under that team's rulings. Thanks to the people who ask, on every forum this workshop reads, what a picture costs on the card they have.

Measured on 2026-09-24, 2026-09-25 and 2026-09-26 by one pinned stack on four computers and one instrument in the fourth, with the label on every cross-computer figure.

The EVGA 3090 Ti FTW3 Ultra's column, at 350 W and 300 W (added 2026-09-26)

What this section adds, for a reader who scrolled straight to it. A fifth card's column for the grid above: the EVGA GeForce RTX 3090 Ti FTW3 Ultra 24 GB, the EVGA 3090 Ti of Three cards in one computer, ran the same eighteen cells on the same pinned stack, with the same prompts and seeds, on 2026-09-26 (UTC) from 08:50:51 to 09:54:48Z, in the workstation computer: the RTX PRO 6000's computer, where this card has served since 2026-09-25 (One 3090 out, one 3090 Ti in), in an x16 slot at PCIe generation 4, not the one the EVGA 3090 XC3 Ultra stood in on 2026-09-24, with 126,352 MB of system memory on ComfyUI's startup line and driver 595.84. Its pass ran at 350 W, not at its 450 W stock limit, so it is the one desktop column of the grid not measured at the card's stock limit, and every figure below says so where it sits beside the others: the eighteen cells and the ten-minute run at 350 W (08:50 to 09:15Z and 09:15 to 09:26Z), then the 2048×1280 cells at 300 W (09:28 to 09:43Z) and a second ten-minute run at 300 W (09:44 to 09:54Z). Against the four cards of the version published earlier the same day, whose figures above are unchanged, under the label (same software, different computer): per FLUX.2 [klein] 4B step at 2048×1280 with both held to 300 W, this card takes 1.42 times the 5080's time and 2.31 times the workstation card's (that one in the same computer, two days earlier), and spends 1.45 times the 5080's energy per step.

Why 350 W. The first take of this column, at 450 W on 2026-09-25, was stopped after FLUX.2 [klein] 4B's six cells and Z-Image-Turbo's first two: with the workstation card serving beside it, the computer's battery backup reported a runtime estimate under its low mark at 57 per cent of its rated load, that computer's power safety released its other work, and the run broke on its own live-neighbour check (Who ran where). Those eight cells' renders are kept where they were written and nothing here reads them. 350 W is the cap this card serves at day to day, and at it the steady load sits under that line, though not by much: in the 350 W pass the backup's runtime estimate read 250 s, under its 300 s low mark, on 19 one-second samples in two stretches, six from 09:03:43Z at 50 to 52 per cent of rated load and thirteen from 09:08:38Z at 65 per cent, straight after fourteen at 300 s at 69 per cent, without the backup raising its low-battery flag (every sample of every run read on mains; prediction 350-5 below); before the first 350 W render the bench's rule was rewritten so that any battery-backup sample reading on battery, low battery or shutdown stops the bench within that second (the kit's UPS note). Stock is withheld on this card in this computer, and the predictions registered for a stock pass are printed below as the rule says.

The workstation card was live the whole time. Every column above was measured beside a board that idled or sat empty (The neighbours); this one was measured beside a card that kept serving. The RTX PRO 6000 held the workshop's public language services through every pass, and the small language model that normally serves from this 3090 Ti was moved onto the workstation card for the window, so the card under test held nothing but the bench. The harness registered the workstation card as a named live neighbour before the first render: busy was its expected state and was never refused; its draw, temperature and memory were recorded across every run and beside every render (42.7 to 50.3 W at the mean over the four passes, 379.5 W at most, 48 °C at most, never under 85,900 MiB); what would have stopped the run was its live side breaking, and it did not. The caveat travels with every figure here: the render seconds are ComfyUI's clock on a host the neighbour shares, and this card's clocks follow its temperature, which the neighbour's heat can raise; no render was dropped, re-run or kept out of a median for the neighbour's load. This card's own seconds, watts and memory are read by UUID and are its own.

The cells at 350 W. Median seconds per picture at 1024×1024, the unit finding 2 opens with; every size, and every cell's joules, are in the kit's tables. On the 24 GB card every transformer read whole through every step of every cell (the runtime's own residency lines, finding 1); 17 of 18 cells finished under the ninety-second rule; the one that ran over was FLUX.1 [dev] at 2048×1280 and 32 steps, stopped at 92.9 s at step 31 of 32, and the rule left its twin out of the 300 W pass.

The 3090 Ti FTW3 Ultra at 350 W, 1024×1024	FLUX.2 [klein] 4B	Z-Image-Turbo	FLUX.1 [dev]
8 steps	5.021	6.987	9.202
32 steps	17.071	25.591	34.614

Per sampling step at 2048×1280, the page's own instrument (finding 2) and the fair energy figure across computers (finding 3), at 350 W and at 300 W, the same card, computer and prompts within a row:

At 2048×1280, per sampling step	FLUX.2 [klein] 4B	Z-Image-Turbo	FLUX.1 [dev]
Seconds, 350 W	1.3806	2.2852	No figure
Seconds, 300 W	1.4344	2.3715	No figure
Joules, 350 W	479.8	793.7	No figure
Joules, 300 W	433.5	708.5	No figure

Read, under the label: at 350 W against the 5080 at its stock limit, this card's klein step takes 1.39 times the 5080's, and the 12 GB card at its own 350 W takes 1.15 times as long as this card. Within the card, 300 W against 350 W on the same cells, no label: time per picture +3.3 to +3.8 per cent, board energy −10 to −12 per cent, on the cells that ran at both. The cells' core peaks were 67 °C at 350 W and 63 at 300 W; the ranges by setting, the clocks and the mean draws are in the kit's tables.

Ten minutes of drawing at 1024×1024, finding 4's instrument (FLUX.2 [klein] 4B at 8 steps, one prompt always queued, stopping at 83 °C), at both settings, the workstation card serving beside it through both:

Ten minutes at 1024×1024, 8 steps	Pictures	Seconds per picture, median	Mean board W	J per picture	kWh per thousand pictures
350 W	117	4.972	322.5	1,666.1	0.463
300 W	112	5.194	282.2	1,518.5	0.422

Core peaks were 66 and 62 °C, and the card was busy for 0.964 and 0.965 of the two windows. Read as counts, under the label, and with the neighbour's caveat above.

The predictions. Four were registered for this card before the grid's first picture, for a pass at its 450 W stock limit (How to check our work); five more were registered on 2026-09-25 and amended once on 2026-09-26, both before any render at 350 W, for the pass that ran (the kit's predictions table has both sets). Each is scored as registered where the 350 W pass allows it, and printed as unscored where it does not:

#	Registered before the run	Outcome
1	FLUX.2 [klein] 4B, 512×512 at 8 steps, on this card at 450 W: 1.45–1.90 s	Unscored: registered at 450 W; the pass ran at 350 W
3b	The ninety-second rule at stock removes exactly FLUX.1 [dev] at 2048×1280 and 32 steps	Unscored: registered at stock
4	300 W costs this card at most 12 per cent at 2048×1280 on FLUX.2 [klein] 4B, against stock	Unscored: registered against stock
5b	Per-step cost rises 2.5 to 4.5 times from 1024×1024 to 2048×1280, every model	Holds for the two it can score: 2.75 and 2.95 times at 350 W; FLUX.1 [dev] is unscored, its 32-step cell at 2048×1280 ran over
350-1	The same cell at 350 W: 1.50–1.95 s	Holds: 1.722 s
350-2	The rule at 350 W removes exactly FLUX.1 [dev] at 2048×1280 and 32 steps (about 140 s predicted); Z-Image-Turbo at 2048×1280 and 32 steps registered as borderline, about 85 s at 350 W and 91 s at 300 W	Holds: only FLUX.1 [dev] at 2048×1280 and 32 steps ran over; Z-Image-Turbo at 2048×1280 and 32 steps took 74.8 s at 350 W and 77.6 s at 300 W
350-3	300 W costs FLUX.2 [klein] 4B at most 10 per cent at 2048×1280, against 350 W	Holds: +3.8 per cent per picture on the 32-step cell, the larger of its two (+3.9 per step)
350-4	Per-step cost rises 2.5 to 4.5 times from 1024×1024 to 2048×1280 for every model that runs both	Holds for the two it can score: 2.75 and 2.95 times; FLUX.1 [dev] is unscored, its 32-step cell at 2048×1280 ran over
350-5	No battery-backup stop: every one-second sample reads on mains through every run, at risk from the neighbour's bursts	Holds: on mains in every sample

Where its rows sit. The charts above carry this card's rows, each labelled RTX 3090 Ti FTW3 with its 350 W said in the row's note: one picture at 1024×1024 and 8 steps (from the first table here), seconds and joules per step at 2048×1280 (the second) and the ten minutes at 1024×1024 (the third). Three cards in one computer is unchanged: its instrument is the render bench, not the grid. The kit's tables file carries this card's rows in every table the four cards have one in, and its raw files follow with the others (How to check our work).

The EVGA 3090 XC3 Ultra's column, at its stock 350 W and at 300 W (added 2026-09-26)

What this section adds, for a reader who scrolled straight to it. A sixth card's column for the grid above: the EVGA GeForce RTX 3090 XC3 Ultra 24 GB, the workstation card's neighbour on 2026-09-24 (The neighbours), ran the same eighteen cells on the same pinned stack, with the same prompts and seeds, on 2026-09-26 (UTC) from 14:20:06 to 15:27:27Z, in the bench computer: the 3080 Ti's computer (AMD Ryzen 7 3700X, 16 threads, 30,990 MB of system memory on ComfyUI's startup line, driver 595.84), in the same x16 slot at PCIe generation 4, with the same EVGA GeForce RTX 3080 Ti XC3 Ultra 12 GB held idle in the chipset x4 slot below it. Unlike the 3090 Ti of the first dated section, this card ran at its stock limit: 350 W is the limit the board ships with (its maximum is 366 W, and was never set), so its column stands beside the four cards above on their own footing, stock and 300 W: the eighteen cells and the ten-minute run at 350 W (14:20 to 14:46Z and 14:46 to 14:57Z), then the 2048×1280 cells at 300 W (14:59 to 15:15Z) and a second ten-minute run at 300 W (15:16 to 15:27Z). Against the page's other readings, all of them unchanged: per FLUX.2 [klein] 4B step at 2048×1280 with both held to 300 W, this card takes 1.60 times the 5080's time and 2.60 times the workstation card's, under the label (same software, different computer), and 0.98 of the 12 GB card's time in the same computer, same slot, a day apart (2026-09-25 and 2026-09-26), without it.

The grid's one pair measured alike. The 12 GB card ran here on 2026-09-25 and this card on 2026-09-26: the same processor, the same system memory to the byte on the startup line, the same driver, the same slot at the same link generation, the same board idle below, the bench computer's three fans turned up before each run, and the same harness in everything it measures (between the two days its code gained the at-once battery-backup stop, a mode for a live neighbour and this card's own settings; its timing, power-reading and residency code is unchanged, and each result file records every file's sha256). Two of the grid's cards have shared a computer before, the RTX PRO 6000 and the 3090 Ti of the first dated section, but beside different neighbours: on 2026-09-24 this card, holding live language services at an idle draw, and on 2026-09-26 the workstation card, serving; here the arrangement is the same to the board, and only the day and the idle board's own state differ (below). So a ratio between these two carries no computer term, and this page writes it without the label, on the one model that sat whole on both, FLUX.2 [klein] 4B: at 350 W, both cards' stock limit, this card's step at 2048×1280 takes 0.98 of the 12 GB card's time (1.5458 against 1.5812 s) for 0.97 of its energy (536.6 against 552.4 J); at 300 W, 0.98 of the time (1.6185 against 1.6442) for 0.99 of the energy (488.0 against 491.8). Z-Image-Turbo and FLUX.1 [dev] paged on the 12 GB card and sat whole on this one, and finding 1's rule sets no paged figure in a ratio with a whole one. Over ten minutes at 1024×1024 at stock, 111 pictures against the 12 GB card's 101, 1.10 times as many, at 1,795.8 J each against 1,908.4, 0.94 of the energy (finding 4's row was a warm card's at its limit; this card's core peaked at 77 °C with the same board idle below it).

What sat whole, and the board below. On the 24 GB card every transformer read whole through every step of every cell: 17 of 17 cells at 350 W and 5 of 5 at 300 W, all 66 timed pictures (the runtime's own residency lines, finding 1); the two models that paged on the 12 GB card in this slot the day before sat whole here, with 24,576 MiB on the board. The idle board is the bench computer's rule for a neighbour (How it was measured): named before the run, held idle and watched, it read 1 MiB with no process through all eight loads (8 of 8 residency-by-growth proofs: this card grew by gigabytes, the idle board by 0 MiB), drew 13.9 W at the median over the stock grid and 13.6 to 14.3 W over the four runs, and sat at 22 to 28 °C, in the air this card's open cooler draws from below it. The seating is the one registered for the 12 GB card, not directly comparable on temperature with a card measured alone; this card's own seconds, watts and memory are read by UUID and are its own. Two things about that board's own state read differently between the two days: the driver read its persistence mode as on at the 12 GB card's preflights and off at this card's, and its enforced limit as 300 W on 2026-09-25 and 350 W on 2026-09-26; and its idle draw read half, 27.4 W at the median beside the 12 GB card and 13.9 beside this one (prediction XC3-6 below).

The cells at 350 W. Median seconds per picture at 1024×1024, the unit finding 2 opens with; every size, and every cell's joules, are in the kit's tables. 17 of 18 cells finished under the ninety-second rule; the one that ran over was FLUX.1 [dev] at 2048×1280 and 32 steps, stopped at 93.8 s at step 28 of 32, the cell the 12 GB card lost in this slot the day before at 93.45 s and step 27 (finding 7; that finding's count is the four-card grid's), and the rule left its twin out of the 300 W pass.

The 3090 XC3 Ultra at its stock 350 W, 1024×1024	FLUX.2 [klein] 4B	Z-Image-Turbo	FLUX.1 [dev]
8 steps	5.180	7.716	10.015
32 steps	18.377	28.836	37.599

Per sampling step at 2048×1280, the page's own instrument (finding 2) and the fair energy figure across computers (finding 3), at 350 W and at 300 W, the same card, computer and prompts within a row:

At 2048×1280, per sampling step	FLUX.2 [klein] 4B	Z-Image-Turbo	FLUX.1 [dev]
Seconds, 350 W	1.5458	2.5133	No figure
Seconds, 300 W	1.6185	2.6326	No figure
Joules, 350 W	536.6	874.2	No figure
Joules, 300 W	488.0	788.8	No figure

Read, under the label, at stock against the other desktop cards at stock and the laptop under Dynamic Boost: this card's klein step takes 1.56 times the 5080's, 4.31 times the workstation card's and 1.10 times the laptop's; against the 3090 Ti of the first dated section, both at 350 W, that card's cap and this card's stock, in different computers, 1.12 times. Within the card, 300 W against 350 W on the same cells, no label: time per picture +3.4 to +4.6 per cent, board energy −10 to −13 per cent, on the 5 cells that ran at both. The cells' core peaks ran from 42 to 78 °C at 350 W and 70 to 73 at 300 W, with the idle board in the air the card breathes; the driver's thermal-slowdown flag was set on 1 of the 14 samples of one timed picture at 350 W (Z-Image-Turbo at 1024×1024 and 8 steps, 75 °C at its peak) and on none at 300 W; the clocks and the mean draws are in the kit's tables.

Ten minutes of drawing at 1024×1024, finding 4's instrument (FLUX.2 [klein] 4B at 8 steps, one prompt always queued, stopping at 83 °C), at both settings, the same board idle below it through both:

Ten minutes at 1024×1024, 8 steps	Pictures	Seconds per picture, median	Mean board W	J per picture	kWh per thousand pictures
350 W, stock	111	5.292	331.6	1,795.8	0.499
300 W	107	5.527	287.5	1,623.7	0.451

Core peaks were 77 and 72 °C, the card was busy for 0.977 and 0.978 of the two windows, and the driver's power-cap flag was set in 97 per cent of the samples of each; its thermal-slowdown flag on 2 of the stock window's 1,060 samples and on none at 300 W. Read as counts, under the label against the other computers' rows, and without it against the 12 GB card's row in finding 4, measured in this computer with this board below it.

The predictions. Eight were registered on 2026-09-26, before the board was seated in the bench computer and before any render of it, as an amendment to the bench's pre-registration (How to check our work). Their model was the grid's two-term fit, seconds per step and a fixed cost per picture, anchored on the 3090 Ti's FLUX.2 [klein] 4B cells at 1024×1024 at 350 W in the first dated section (0.5021 s a step, 1.0043 s fixed), with both terms times 1.08, a ratio taken from the two chips' published shader and memory-bandwidth counts (1.024 and 1.077, the larger rounded up), and carried to the other sizes and models by the harness's fixed size and model multipliers (and, at 300 W, a registered factor of 1.04); on the one term it names, seconds per klein step at 1024×1024, the model said 0.542 and the card read 0.5499. The 3090 Ti's own cells times 1.08, a cross-check registered beside the model, said 1.86 s for XC3-1's cell and about 80.8 s for XC3-2's borderline one. Each is scored from the files:

#	Registered before the run	Outcome
XC3-1	FLUX.2 [klein] 4B, 512×512 at 8 steps, at its stock 350 W: 1.55–2.20 s (1.77 s predicted)	Holds: 1.749 s
XC3-2	The ninety-second rule at stock removes exactly FLUX.1 [dev] at 2048×1280 and 32 steps (about 147 s predicted); Z-Image-Turbo at 2048×1280 and 32 steps registered as borderline, about 89.1 s at stock and 92.7 s at 300 W, either side a real outcome	Holds: only FLUX.1 [dev] at 2048×1280 and 32 steps ran over; Z-Image-Turbo at 2048×1280 and 32 steps took 82.1 s at 350 W and 85.8 s at 300 W
XC3-3	300 W costs FLUX.2 [klein] 4B at most 10 per cent at 2048×1280, against 350 W (about 4 predicted)	Holds: +4.3 per cent per picture on the 32-step cell, the larger of its two (+4.7 per step)
XC3-4	Per-step cost rises 2.5 to 4.5 times from 1024×1024 to 2048×1280 for every model that runs both sizes	Holds for the two it can score: 2.81 and 2.86 times; FLUX.1 [dev] is unscored, its 32-step cell at 2048×1280 ran over
XC3-5	Every transformer reads whole through sampling at every size on the 24 GB board	Holds: 17 of 17 cells at 350 W and 5 of 5 at 300 W, all 66 timed pictures
XC3-6	The idle board stays idle: every residency-by-growth proof passes (this card grows by gigabytes, the idle board by at most 64 MiB), and its draw over each run sits near the 27.4 W median it read beside the 12 GB card	Holds on the proofs, missed on the draw: 8 of 8 proofs passed and the board read 1 MiB in every sample; its median draw was 13.9 W over the stock grid and 13.6 to 14.3 W over the four runs, half the 27.4 W registered; the recorded differences in the board's own state are its persistence mode, on at the 12 GB card's preflights the day before and off at this card's, and its enforced limit, 300 W the day before and 350 W at this card's
XC3-7	No battery-backup stop: every one-second sample reads on mains through every run	Holds: on mains in every one of 3,659 samples, the load 9 to 46 per cent of rated
XC3-8	Both ten-minute runs finish without the 83 °C stop	Holds: peaks of 77 and 72 °C, both runs the full ten minutes

Where its rows sit. The charts above carry this card's rows, labelled RTX 3090 XC3, after the 3090 Ti's: one picture at 1024×1024 and 8 steps (from the first table here), seconds and joules per step at 2048×1280 (the second) and the ten minutes at 1024×1024 (the third). Three cards in one computer is unchanged: its instrument is the render bench, not the grid, and the render-bench rows this card has are the i9 computer's, on the old build (the kit's tables). The kit's tables file carries this card's rows in every table the other cards have one in, and its raw files follow with the others (How to check our work).

Corrections, 2026-09-26

What this section is, for a reader who scrolled straight to it. On 2026-09-26 (UTC), after the second dated section above went up, an audit of this page against its own result files found wording they do not support. Every line corrected here went up on 2026-09-26 (UTC), with this page's first publication or one of its two dated updates, and was fixed in place the same day (UTC), above and in the kit's tables file where it had a twin (its fourth-issue line says where); this is the receipt. No measurement changed: every figure in every table and chart is as it was, and no raw file was touched. Only words moved.

• "Two days apart" for the 12 GB card and the 3090 XC3 Ultra is now "a day apart": they ran on 2026-09-25 and 2026-09-26; the workstation computer's pair (2026-09-24 and 2026-09-26) is the one two days apart.
• The short version said four cards and the label on every cross-card figure, and four chart subtitles (one picture at 1024×1024 and 8 steps, seconds and joules per step at 2048×1280, ten minutes at 1024×1024) put every row in its own computer; six cards have run the grid, two computers have each hosted two, and the bench computer's pair is printed without the label (the Words bullet on the label, the four subtitles and the kit's label sentence over its cell tables and its joules-per-step table now say the same).
• "At stock" and "cap" said of the laptop are gone: its 95 W stock posture was never run, and Dynamic Boost is a posture, not a cap; it ran under it at 138 to 150 W (the short version, findings 2, 3, 5 and 6, The full tables, How it was measured, both dated sections, and the titles of the two per-step charts; in the kit, six headings and two table headers over its rows and the 3090 Ti's 350 W rows now name "each card's higher setting", and the change table's intro, the it/s note and the temperatures note say the same).
• The no-model picture took 0.025 s on the workstation computer, not 0.021: the dry run committed beside its grid reads 0.025; 0.021 was an earlier staged dry run whose file is not among the results.
• The 3090 Ti did not run in the slot the 3090 XC3 Ultra stood in on 2026-09-24: the two read different bus addresses under different root complexes, so different x16 slots (the first dated section, the workstation photo's caption).
• Two readings of the idle 12 GB board's own state changed between the days, not one: persistence mode, on then off, and the enforced limit, 300 W then 350 W (the second dated section, prediction XC3-6).
• The 3090 XC3 Ultra's predictions came from the grid's two-term fit anchored on the 3090 Ti's klein cells at 1024×1024 at 350 W, both terms times 1.08, not from "the 3090 Ti's column times 1.08", which was the cross-check registered beside it; every predicted number was right, the description was not.
• Three counts had stopped at four cards: finding 6's nine whole size pairs are thirteen (2.75 to 3.14), finding 1's three cards with 16 GB or more are five, and finding 7's "twice" is now the first four cards' count, the rule having fired once more in each dated section.
• The Words bullet on stock and caps said 300 W is the cap the workshop runs its cards at day to day, against the 3090 Ti's 350 W everyday cap on the same page, and listed no 450 W stock limit; both fixed.
• The closing line dated the measurements to 2026-09-24 and 2026-09-25, without the dated sections' 2026-09-26; the thanks said the team pasted every cap, where the dated sections' caps were set by window scripts the team started.
• In the kit, the dated windows table called the i9 computer "render computer" on the 5080's row.

Smaller wording fixes the same day, no fact behind them changed: labels added to finding 1's peak-memory comparison, the lineup caption's EVGA 3080 named in full, the dated windows extended to 2026-09-26, the amendments named for all three later cards, the harness's code changes between the two days named, the "+3.8" and "+4.3 per cent" outcomes given their basis, a licence line under The full tables, the two tables it names as moved to the kit when this page drew them as charts (the third chart's rows were already there), Who ran where's "that day" and "the next day" dated 2026-09-24 and 2026-09-25 (the kit's "that day" too), and the kit's opening line, which now reads "unless a heading or note says otherwise".