RTX 3090 vs RTX 3090 Ti

The two cards, named once

The two boards are an EVGA GeForce RTX 3090 XC3 Ultra Gaming 24 GB and an EVGA GeForce RTX 3090 Ti FTW3 Ultra Gaming 24 GB — the same maker, the same 24 GB, the same x16 slot of the same desktop on two nights — so a 3090 and a 3090 Ti everywhere below are those two boards and no others. Both are stock: factory thermal pads, factory cooler, factory BIOS, nothing re-padded, re-shrouded or flashed. That is deliberate, and deliberately unlike the pair of 3080s this workshop priced, where one of the two cards had been re-padded by hand. The only difference between these two units is age and use.

This Ti was new. Ordered 15 September 2026, unboxed on the 17th, first powered on for this bench — and given no burn-in: the first hours of load in its life are the four cap blocks on this page, its language arms 19:07 to 23:46 UTC and its renders 19:41 to 00:01. Every Ti figure here is a new unit's first day, with whatever a reader takes that to mean.

This 3090 is a used board bought in 2021, on its third life, and it still carries its original thermal pads: it mined Ethereum, it flew Flight Simulator, and now it serves language models, draws pictures and trains. Ethereum stopped paying for that kind of mining in September 2022, so the first of the three is over and dated. The ten-minute temperature rows further down are therefore a 2021 board on factory pads against a board that was days old.

And the Ti is out of production. The GeForce RTX 3090 Ti went on sale on 29 March 2022 at $1,999 — NVIDIA's own announcement that day calls it “24GB of the fastest 21Gbps GDDR6X memory” — the last and fastest of the GeForce RTX 30 line. On 16 September 2022, less than six months later, EVGA told two interviewers it was ending its partnership with NVIDIA and would build no further graphics cards, selling through the RTX 30 stock it had. It published no last-built date, so how long this board kept being made is not on the record and this page does not say; what is on the record is that nobody has built one since. The unit measured here is new, boxed stock of a 2022 card, bought for $2,119.99 on 15 September 2026 — $120.99 above its own launch price, four and a half years later.

Both limits are read off the card in every result file, never from a specification.

At a glance

Both cards, one slot, two nights. The run-as-it-comes rows are for a reader who runs a card the way it ships — 350 W against 450 W; the rows that say “both at 300 W” are the controlled comparison, and the asymmetry inside that cap is the page: 300 W is 86 per cent of a 3090's own 350 W limit and 67 per cent of a Ti's 450 W. Rows marked ↓ are won by the smaller number; every figure repeats below with its cap and its receipt file.

The question

Two cards a generation apart in name and eighteen months apart in age, both holding 24 GB, both in the same slot within a day and a half. A 3090 Ti's argument over a 3090 is memory bandwidth: 21 Gbps per pin against 19.5, over the same 384-bit bus — 1,008 GB/s against 936 on paper. Both boards held their memory one bin under their own reported maximum throughout: 9,501 MHz against a 9,751 MHz reading, 10,251 against a reported 10,501. So every ceiling below (912.1 and 984.1 GB/s) is a ceiling at the clock these two units actually held, about 2.5 per cent under those paper figures. Writing a token on a quantised model waits on how fast a card streams its own weights, so if that argument is real it has to appear here and nowhere else.

A dense model uses all of itself for every word and a mixture wakes only a few billion, which at 300 W is why the mixture writes 2.8 times a 3090's dense rate and 3.4 times this Ti's. The cap-active flag below is the driver's report of whether the cap held the clock down; mean draw ÷ cap, beside it, says how hard the card actually pushed. Answer quality is not measured here at all.

The instrument, and the control

One harness produced every language figure: a frozen 2,101-byte prompt checked by sha256, 256 tokens out, temperature and seed at zero, one discarded warm-up then three scored runs, the median reported, with card board power read from the driver at 2 Hz and never the wall. The models are gemma4:26b (26 billion parameters, ~4 billion active per token) and mistral-small3.2:24b (24 billion dense), the same blobs by digest on both benches, Q4_K_M, on ollama 0.32.13 with an 8-bit cache; the pictures came from ComfyUI 0.21.1 on three certified graphs identical by hash on both sides (79df5a8b…, 7dd85f01…, 94bfd633…). The control is the slot — one card out, the other in, one box, one case. An image service sat on the card throughout, unavailable to every arm: 262 MiB of the Ti and 256 MiB of the older board when the render bench read it, 304 and 298 MiB when the language bench did.

What a power cap takes, and what each card does at its own limit

The two caps both cards were measured at, then each card at its own limit. The 300 W columns and all three of the Ti's higher columns ran 2026-09-17 (14:54 to 23:46 UTC); a 3090's own 350 W column ran 2026-09-18, 00:22 to 00:54 UTC, after the card went back in the slot. Receipts: 3090-m5-one-300w.json, 3090-m4-one-300w.json, 3090-m5-one-350w-auto-ladder.json, 3090-m4-one-350w-auto-ladder.json, and 3090ti-m5-one-<cap>w-auto-ladder.json / 3090ti-m4-one-<cap>w-auto-ladder.json at 300, 350 and 450 W.

Read the 350 W columns first: that is a 3090 at the limit it ships with. There the Ti wins both models, by 13.8 per cent on the dense one and 8.2 on the mixture; at each card's own limit, by 22.4 and 8.0. Only at 300 W, below both limits, does the dense row turn over — and the two energy rows do not agree with each other. On the dense model a 3090 spends less per thousand tokens at both shared caps — 12.2 per cent less at 300 W and 7.9 at 350, where it is also the slower board. On the mixture the answer changes with the cap: at the shared 350 W a 3090 spends 7.9 per cent less, and at the shared 300 W the Ti spends 6.9 per cent less. Cheaper to run is a property of the pairing, not of the board. "Cap active" is not "pinned at the limit": the driver called it active for 100 per cent of a 3090's 350 W dense arm while the card drew 78.1 per cent of what it was allowed, which is why every table prints the flag and the draw together.

The dense model's whole ladder on both cards, from each card's m4-one-<cap>w-auto-ladder.json files and 3090-m4-one-300w.json. The ceiling is derived from the memory clock observed at that rung and the bus width — a ceiling at an observed clock, never an achieved rate; the streamed figure is what the decode really pulled. Both are dense-only, because a mixture reads a subset of its weights per token and neither bench has a receipt for which. A 3090's two bandwidth columns are not written by that bench's own per-arm harness, which predates the instrument — they are computed from what its files do carry (the median decode, a memory clock whose floor and max are both 9,501 MHz, the model's 15,177,384,862-byte store, and a 384-bit bus read live from NVML, receipted in 3090-measured-constants-350w.json) by the formula that file records, and the same six cells appear in that bench's own 350 W addendum. The Ti's 384 bits is declared rather than probed. The arm shape column is load-bearing: a step into or out of a single-window repeat is not a cap effect alone. A 3090's 250 W arms predate the cap-in-the-name convention and are the un-suffixed files — 3090-m4-one-auto-ladder.json here, r4.json in the ten-minute table and 3090-concurrency-one.json in the concurrency one.

Within a card the ceiling column is one number, repeated — neither memory clock moved, on any arm. What moved was the reach: a Ti goes from 66.3 per cent of its ceiling at 300 W to 88.5 at 450, under core clocks of 960 and 1,965 MHz. A power cap does not slow the memory down; it slows the core down, and a core with no power cannot drain a fast bus. A 3090's own last rung buys nothing, and the step that looks like a loss is not a cap effect. Its dense rung at 350 W reads 2.0 per cent slower than at 300 W on spreads that do not overlap (46.783 to 47.105 against 47.835 to 47.898) — a separated regression, not noise — but the two rows are not the same arm: a single-window repeat on a cold card against a ladder rung on a card eight degrees warmer, drawing 16.5 W less at 78.1 per cent of its cap. Its mixture gains 0.35 per cent. A 3090 has no reason to sit below its 350 W default and nothing to gain from it either.

And the same fifty watts are a starvation to one workload and an irrelevance to another, on one card. At 350 W a 3090's dense model drew 273.35 W — 78.1 per cent of its cap — and gained nothing over 300. At that identical 350 W, ten minutes of continuous drawing drew a median of 325.8 W with the cap flag active in 100 per cent of 1,153 samples (r4-350w.json, one picture at a time), and on the render ladder the pictures got faster at every step up to it: 1.683 → 1.560 → 1.509 seconds at batch three (r1-250w.json, r1-300w.json, r1-350w.json). Same board, same setting, two jobs — one wants every watt, the other has stopped asking. A cap is not a property of a wattage. It is a property of a card at a workload — those two files, 3090-m4-one-350w-auto-ladder.json and r4-350w.json, are the whole of that claim.

How a cap is set

Every cap on this page was set with the driver's own tool, one card at a time, and read back in the same call that set it:

nvidia-smi --query-gpu=power.default_limit,power.max_limit --format=csv   # what this board allows
nvidia-smi -pm 1                                                          # persistence mode
nvidia-smi -i <index> -pl <watts>                                         # the cap

Persistence mode matters: without it the limit goes back to the card's default at the next reboot, so the durable form is a boot-time unit that sets it again. A value below the board's own minimum is refused rather than clamped, and the two ends of the allowed range are what the first command prints — 350 W and 366 W for one of these boards, 450 W and 480 W for the other. This is a power limit, not an undervolt: it caps what the card may draw and lets the driver find the clock, and nothing on this page touched a voltage curve.

The two models want different caps

A 3090 Ti, both models at their headline windows, all four caps. The step is against the rung below it in watts. Receipts: 3090ti-m5-one-<cap>w-auto-ladder.json and 3090ti-m4-one-<cap>w-auto-ladder.json, four caps each.

The mixture is finished at 350 W; the dense model is not — everything above 350 W on the mixture sits inside the bench's own run-to-run spread, while the dense model is still buying 6.71 per cent at 400, and each model's cheapest rung sits one below its fastest. A rule written before the data — the lowest rung within 1.0 per cent of every higher one, refused outright if the within-rung spread is wider than that — names 350 W as the mixture's knee and names no knee at all for the dense model, whose 300 W spread is 1.925 per cent.

⚑ Two watt figures above may not be read as cap effects. Between 350 and 400 W the mixture drew 28.4 W less at identical core clocks and identical decode, because the fan read 49 per cent at one rung and 0 at the other, and board power contains the fans. The bench flags the step and corrects nothing.

Renders

Three certified graphs at batch 3, seconds per finished image, median of two timed submits. Two pairs of columns are like for like — 300 W against 300 W and 350 against 350; the rest are each card at its own settings, labelled so. Receipts: r1-<cap>w.json on each card's own render bench.

The Ti takes every graph at both shared caps, and by more at the higher one — 0.933×, 0.909× and 0.915× of the seconds at 300 W, 0.926×, 0.902× and 0.905× at 350, and 0.907×, 0.884× and 0.884× run as they come: 9 to 12 per cent off every picture. The core clocks differ too — 2,048 against 1,875 MHz median on the 8-step graph run as they come, 1,920 against 1,785 at the shared 300 W — so this is not single-variable.

The Ti's ladder saturates at 400 W: its cap flag over the ten-minute arm (r4-<cap>w.json) collapses from 92.9 per cent of samples at 300 W and 87.9 at 350 to 16.0 at 400 and 14.5 at 450 — and the render ladder agrees, 0.94 of samples at 300 and 350 W against 0.00 to 0.06 at 400 and 450 — and the last 50 W bought 0.006 s slower on the 8-step graph and one more image in ten minutes. A 3090, by contrast, is still power-limited at its own limit — cap flag 100 per cent on all three graphs at 350 W, drawing 336 to 338 W of the 350 allowed.

Ten minutes of continuous drawing, one card and one cap a row. Not a cooler comparison — the rows did different amounts of work at different caps, and the image counts are printed so a reader can see that. Receipts: r4-<cap>w.json.

The hottest this Ti ran was 62 °C, its board power holding a median of 357 W. A 3090 at its own limit ran twelve degrees hotter — 74 °C against 62 — while drawing 31 W less and making 37 fewer pictures: the one pairing here where each board sits at the setting it ships with, and still not equal work at the settings they ship with. The 83 °C stop armed at every rung and fired at none.

What fits, and what the cache costs

Largest window each card holds on itself, and what the cache settings cost at the full mixture window. Every cache row is at 350 W on both cards; the window rows do not move with a cap at all. Receipts: each card's m5-one-350w-auto-ladder, m4-one-350w-auto-ladder, m4-one-350w-forced-at98304, m4-one-350w-forced-at131072, m5-one-350w-kvf16-at131072 and m5-one-350w-kvq4_0-at131072 files.

Two cards, one answer: 24 GB is 24 GB — every window identical, every allocation within thirteen mebibytes of its twin, and on both the planner leaves a third of the dense model's window unclaimed until the layer count is named. The live suggestion is the cache: at the same 350 W the unquantised setting is fastest on both boards and fits the full window on both, +7.8 per cent on the Ti and +7.1 on a 3090, while four bits buys nothing.

Three more arms

Several people asking at once — the mixture at a 4,096-token window, tokens a second summed across simultaneous conversations (concurrency-one-<cap>w.json on both benches).

The Ti leads by 8.2, 8.6 and 13.4 per cent at the shared 300 W and by 8.1, 8.0 and 14.6 run as they come — four conversations at once being its widest margin here. A short gate-shaped call is the one arm where the boards are indistinguishable: 594.3 ms at the median against 591.7 (3090-g2-doorman-350w.json, 3090ti-g2-doorman-350w.json). A long document read cold — 98,000 tokens in a 131,072-token window, both cards at the shared 350 W — is taken in at 2,549.966 tokens a second by the Ti against 2,270.547 by a 3090, and written through at 80.056 against 73.327 (3090ti-m5-one-350w-filled.json, 3090-m5-one-350w-filled.json). Run as they come, the Ti's 450 W file reads 2,628.756 and 79.740.

What each costs to leave switched on, and why the figure has two answers. From 3090ti-idle-gemma4-300w.json and 3090-idle-gemma4-300w.json, 57 samples over thirty seconds each. With the mixture resident and nothing generating, a Ti reads a median of 18.74 W and a mean of 43.04; a 3090, 22.26 and 52.76. The gap is a load spike inside the window — a 3090's own 350 W file proves it, its empty and loaded windows sharing the identical 22.39 W median while their means differ by 26 W. Left on continuously the medians come to about $30 a year against $36, the means to $69 against $85, at 18.34 cents a kilowatt-hour (the United States residential average for June 2026, as the Energy Information Administration publishes it). The median is the idle figure and the mean an upper bound containing a load, so the faster card is the cheaper one to leave on, by $6 a year on the medians and $16 on the means — board power, so a wall meter would read more for both.

The card itself, as an object

All 24 GB is on the front. A 3090 Ti carries twelve 2 GB memory chips, every one face-up beside the processor; a 3090 carries twenty-four 1 GB chips, twelve on the front and twelve on the back — which is the heat a person feels through a 3090's backplate, and the reason that backplate is a cooling part. On this Ti the backplate is much thicker, and the memory it would have had to cool is not behind it.

It is a 450 W cooler, and it is the larger board by a measured margin — this version of it, at least; other 3090 Ti boards are built differently and none was handled here. Measured on 17 September 2026 by an operator with a kitchen scale and a tape measure, not a caliper or a bench balance: the XC3 Ultra 1,203 g and about 2 inches thick, the FTW3 Ultra Ti 2,157 g and about 2.75 inches — 954 g heavier, 1.79 times the weight, and about three quarters of an inch thicker. The weights are scale readings; both thicknesses are tape readings and carry their “about”. On the consumer board in this machine it covers both PCIe slots, so two of these did not go unmeasured: it is not possible, and the render bench deleted its two-card arms rather than leave them looking unrun. Where this workshop's other pages say "the pair", they mean two 10 GB cards, never two of these. Nothing else about either board was put on an instrument — no dimension beyond that one thickness, and no backplate measurement — and it ran cool to the touch at every cap, said here as the ten-minute plateaus above and not as a feeling.

A short history

The GeForce RTX 3090 Ti went on sale on 29 March 2022 at $1,999, in NVIDIA's own words with "24GB of the fastest 21Gbps GDDR6X memory" — the last and fastest of the GeForce RTX 30 line's flagships, six months before the generation above it replaced it, and its 2 GB chips are what let the whole 24 GB sit on one face of the board. Then its maker left. On 16 September 2022, less than six months after this card shipped, EVGA told Gamers Nexus and JayzTwoCents in closed-door interviews that it was ending its partnership with NVIDIA and leaving the graphics-card business altogether, and would sell through the RTX 30 stock it had; the reporting of those interviews put GPU sales at close to 80 per cent of its gross revenue, which is the interviewers' figure and not a number EVGA published. No last-built date was ever given, so this page does not claim one: what the record carries is that EVGA has not built a graphics card since, and that stock of a 2022 card was still boxed and unsold in 2026 — a finite pile, and nobody making another.

What it cost

This Ti has a price on record: bought new for $2,119.99, ordered 15 September 2026, listed as "EVGA GeForce RTX 3090 Ti FTW3 Ultra Gaming, 24G-P5-4985-KR, 24GB GDDR6X, iCX3, ARGB LED, Backplate, Free eLeash" — $120.99 above its own March 2022 launch price, four and a half years later. This 3090 has no price on record; it was already in the workshop, and the nearest dated figure is a listing of the exact board, "EVGA 24G-P5-3975-KR GeForce RTX 3090 XC3 Ultra Gaming, 24GB GDDR6X, iCX3 Cooling, ARGB LED, Metal Backplate (Renewed)", at $1,879.99, read by hand at the store page on 17 September 2026.

The two prices above, re-read. On 18 September 2026 between 00:25 and 00:35 UTC both retailers served no price to this workshop's fetcher, which is why the 17 September reading was taken by hand. One purchase and one dated hand reading, then — neither a claim about what either card costs today, both checkable the same way: open the retailer, search the listing title exactly as printed, read what it says on the day you do.

What the $240 buys, on those two readings

Not a recommendation — the arithmetic, and the reader's call, on the two prices printed above and nothing else: $1,879.99 and $2,119.99, a difference of $240.00, 12.8 per cent. Each row names its cap; the picture rate is the 8-step graph at batch 3 turned into images a minute.

Per dollar the cheaper card wins every row but one, losing the one that matters most to a dense-model buyer: 2.71 tokens a second per $100 against 2.49. What the $240 buys that per-dollar arithmetic cannot show is the road above 350 W: a Ti goes from 42.969 tokens a second on the dense model to 53.354 and then 57.396, 22.4 per cent past anything a 3090 reaches at its own limit; four conversations open a 14.6 per cent gap; every picture comes 9 to 12 per cent sooner; ten minutes of drawing runs twelve degrees cooler while making 37 more images. Against that it draws 17.7 per cent more board power on the mixture model and 53.2 more on the dense one, it is dearer to run per thousand tokens at every pairing here, and it covers both PCIe slots.

The setting this page would choose, and the dissent

A rule written before any of this ran asked for the lower of 350 and 400 W unless the higher wins at least 10 per cent on the 32-step graph and plateaus under 70 °C. Its first condition fails: 400 W wins 2.24 per cent there (5.1296 → 5.0150 s per image), so the second never decides anything. The setting is 350 W, and three lines land on it — that rule, the mixture's knee, and the cap flag going inactive at the same rung. The dissent: the dense model is not done at 350 W, gaining 6.71 per cent at 400, so a reader whose machine mostly runs one should read 400 W as their ceiling. 450 W is a measurement here, not a recommendation. What this workshop then did with its own two boards, stated as what was done and not as advice: the Ti went into the render box at 350 W, by the rule printed above, and a 3090 went back to language work at 300 W.

What this page does not measure

• Answer quality. Not once. Every figure here is speed, capacity, power, heat or price.
• No memory-die temperature, on either card at any cap: the driver answers [N/A], asked three ways, on every arm, so every temperature here is a core temperature. And no wall power, none estimated — every watt is card board power, a lower bound on what a room pays, and the only whole-box instrument in the room refused every request at every rung and is recorded as unreadable, which is not the same as quiet.
• A 3090 Ti at 250 W was not run, on an operator's ruling made before the bench started: "so far below the default max, it will likely limit the clock speeds too much." None is interpolated from the rungs around it, nor is 480 W, its max_limit rather than its shipped default. And no 400 or 450 W rung for a 3090 — above its own limit.
• Loudness. Fan speed is printed on almost every table and no sound was metered: a fan percentage is not a noise figure. Weight and one thickness ARE measured — by a kitchen scale and a tape measure on 17 September 2026, printed above with the instrument named — and nothing else about either board's dimensions is: no width, no length, no backplate thickness, and the remaining size sentences are an operator's plain description.
• No cross-box row, nothing about two of these cards (impossible on this board, not merely un-run), and no streamed-bandwidth figure for the mixture model on either card, which is a printed refusal rather than an invented number.

How to check our work

Four benches stand behind this page, with their pre-registrations, dated amendments, result files and verdicts in this workshop's repository. All of it ran between 17 September 2026 03:15 UTC and 18 September 01:09 UTC: a 3090's 250 and 300 W language arms 03:15 to 15:04 and its renders 17:09 to 17:35; a 3090 Ti's language arms 19:07 to 23:46 and its renders 19:41 to 00:01; then a 3090 back in the slot for its own 350 W default, language 00:22 to 00:54 and renders 00:56 to 01:09 on the 18th. The Ti's bank is 48 result files over 228 scored runs, zero arms refused. If a figure here does not reproduce, say so at the contact desk. This page keeps its receipts the way every page here does.

Who ran this, and thanks

The cards are an EVGA GeForce RTX 3090 XC3 Ultra 24 GB and an EVGA GeForce RTX 3090 Ti FTW3 Ultra 24 GB, and EVGA gets the credit twice: for boards still doing serious work four and five years after they were sold for games, and for publishing the figures this page checked itself against. NVIDIA published the launch specifications quoted in the history, and its driver is the instrument every reading came out of.

The language work stands on ollama and, beneath it, llama.cpp and NVIDIA's CUDA; the pictures on ComfyUI. The models are Google's Gemma 4, Mistral Small 3.2 from Mistral AI, Black Forest Labs' FLUX.2 Klein 4B and its decoder, which drew every picture timed here, and Qwen from Alibaba Cloud as the text encoder in those graphs. None of them owed us anything, and several ask for no credit, which is exactly why it is given.

A small human team owns the cards, moved one out of the slot and the other in, set the rules and the refusals before the runs and signed the numbers; a fleet of AI agents ran the harness and did the arithmetic under that team's rulings. Thanks to the readers of the page before this one, who asked the question this one answers: what happens if you put the faster card in the same slot?