RTX 5080 Crushes 4090: 16% Faster RT [2026]

Picking between the RTX 5080 and a leftover RTX 4090 is not the simple generational upgrade it should be. NVIDIA’s Blackwell flagship trades raw silicon for efficiency and newer software tricks, while the older Ada Lovelace card still wins several ray tracing tests outright. Street prices for both cards have also swung hard through a memory shortage that has kept GDDR7 and GDDR6X supply tight into October 2026, so the “better” card on paper is not always the better buy at the price you can actually get today.

This tutorial skips the marketing slide and shows you how to build your own test rig to settle the RTX 5080 vs RTX 4090 question with numbers you captured yourself. You will set up matched benchmark software, log power draw and thermals, measure ray tracing and frame generation separately, and run a short Python script that turns raw capture files into a price per frame and FPS per watt report. By the end you will have a repeatable process you can rerun on any two GPUs, not just this pair.

Twelve steps cover the full process from pricing research to a finished comparison report, with troubleshooting and advanced tips folded in after the core workflow. Expect to spend roughly 90 minutes on the first pass, most of it spent waiting on benchmark runs rather than typing commands, and less time on every repeat run once your scripts and save file naming are in place.

Google · Preferred Sources

Don't miss new tech stories on Google

Add TrendinTech once in the Google app and our stories appear in your news suggestions.

Add Now

What You Need Before You Start

This project mixes hardware testing with a bit of scripting, so gather the following before you touch a single setting. None of it is exotic, and most of the software is free.

A PC running Windows 11 (24H2 or later) with a free NVMe or SATA slot so you can swap drives between test runs if you only own one GPU
An RTX 4090 and an RTX 5080, either in two separate machines with matched CPU and RAM, or one machine you can swap the card in and out of
A power supply rated for the card under test: NVIDIA lists 850W as the recommended minimum for the RTX 4090 and 850W for the RTX 5080
The latest NVIDIA Game Ready or Studio driver for your GPU, downloaded directly from nvidia.com rather than through a third party updater
Python 3.12 or newer, plus the packages pandas, nvidia-ml-py, and pynvml installed via pip
PresentMon (Intel’s open source frame time capture tool) for in-game FPS logging
3DMark, ideally the Professional edition, for repeatable synthetic Port Royal and Steel Nomad ray tracing runs
HWInfo64 as a cross check on temperatures and clocks if your power logging script reports anything that looks off
A kill-a-watt style wall power meter if you want whole-system draw rather than GPU-only readings
At least two current PC games that support ray tracing and DLSS or FSR frame generation, installed and patched on both test systems

Budget about 90 minutes for setup and a first pass of testing, and plan on repeating the capture steps at least three times per card if you want numbers you can trust.

Step 1: Define Your Use Case and Set a Budget Ceiling

Before you open a benchmark tool, write down what you actually do with the GPU. The RTX 5080 vs RTX 4090 decision changes depending on whether you game at 1440p or 4K, whether ray tracing is on in the titles you play, and whether you also render video or train small AI models on the side. A card that wins a synthetic test by 10 percent is irrelevant if your monitor caps out at 144Hz and both cards already clear that bar.

Set a hard budget ceiling now, in writing, before you start comparing prices. The RTX 5080 launched at a suggested price of $999, but tracked street pricing has moved well past that figure during 2026’s GPU memory shortage, and a used RTX 4090 is not automatically the cheap option anymore either. Decide what you are willing to spend before the benchmark numbers can talk you into stretching it.

If your main workload is 4K gaming with ray tracing maxed out, weight your testing toward Step 9 below. If you edit video or do light AI inference, weight it toward VRAM capacity and sustained clocks instead of peak FPS. Writing this down first keeps you from cherry picking whichever benchmark happens to favor the card you already wanted.

Step 2: Check Current Street Prices Before You Decide

Launch MSRP is close to useless for this comparison right now. Both cards are trading well outside their original price brackets because of the component shortage rippling through the GPU and memory markets this year, so the only numbers worth trusting are the ones tracked in real time.

New RTX 5080 Pricing

Price tracking site Basketprice recorded the cheapest available new RTX 5080 at $1,848.43 as of October 18, 2026, roughly 85 percent above its original $999 launch price. That is a steep premium for a card NVIDIA still lists as a current product on its official RTX 5080 product page, and it reflects how tight GDDR7 supply has become rather than anything NVIDIA changed about the card itself.

Used RTX 4090 Market

The RTX 4090 is no longer a current NVIDIA product in regular retail channels, and most remaining new-in-box units are commanding resale prices in the $2,200 to $2,700 range on secondary marketplaces, well above its original launch price. Used cards in good condition are trading closer to $1,460 to $1,500 on average, according to a market comparison published by iTechGuides. That puts a used RTX 4090 roughly $350 to $400 below the cheapest tracked new RTX 5080 as of mid October 2026, a gap that is large enough to change the decision for a lot of buyers.

Screenshot or save whatever price you find at the moment you check, since both markets move week to week. Do not reuse a price you saw a month ago when you run the price per frame math in Step 11.

Step 3: Line Up the Spec Sheets Side by Side

With pricing noted, pull the official spec sheets for both cards, cross-checked against a specs database like GPUs.net, so you know what the silicon is actually capable of before you run a single benchmark. The RTX 4090 is built on NVIDIA’s Ada Lovelace architecture and the RTX 5080 on the newer Blackwell architecture, and the two take very different approaches to hitting their performance targets.

Spec	RTX 4090	RTX 5080
Architecture	Ada Lovelace	Blackwell
CUDA cores	16,384	10,752
VRAM	24GB GDDR6X	16GB GDDR7
Memory bus	384-bit	256-bit
Boost clock	Approx. 2.52 GHz	Approx. 2.62 GHz
Total graphics power	450W	360W
Recommended PSU	850W	850W
Launch price	$1,599	$999
DLSS generation	DLSS 3 (single frame generation)	DLSS 4 (multi frame generation)

Notice the trade immediately: the RTX 4090 has 52 percent more CUDA cores and 50 percent more VRAM on a wider memory bus, while the RTX 5080 clocks slightly higher and draws 90 fewer watts to do it. On paper, raw shader throughput should favor the older card and efficiency should favor the newer one. The benchmark steps below check whether that holds up once ray tracing and frame generation enter the picture.

The memory bus difference is worth sitting with for a moment, since it explains a lot of what you will see later in this comparison. A 384-bit bus on GDDR6X gives the RTX 4090 more raw memory bandwidth to feed its larger core count, while the RTX 5080 leans on the faster per-pin speed of GDDR7 to make up ground on a narrower 256-bit bus. That combination is efficient, but it also means the RTX 5080 has less bandwidth in absolute terms, which can matter in memory-bound scenes even when its core clock is ahead.

Step 4: Prep Identical Test Systems or a Single Swap Rig

If you have access to two machines, make sure everything except the GPU matches: same CPU, same RAM speed and capacity, same storage drive holding the same game installs, same Windows build, and the same background services running. A faster CPU on one side will bottleneck your 1440p numbers and make the comparison meaningless before you even open a benchmark.

If you only have one machine, swap a single GPU in and out between passes instead. Uninstall the previous driver completely with Display Driver Uninstaller in Safe Mode before installing the new card’s driver. Mixed driver remnants are one of the most common causes of benchmark numbers that do not line up with anything published elsewhere, and they rarely throw an obvious error, they just quietly shave a few percent off your scores.

Close Discord, GeForce Experience or NVIDIA app overlays, RGB control software, and any background update checkers before every capture. These add CPU overhead and, in some cases, hook directly into the game’s render pipeline in ways that skew frame time logging.

Step 5: Install Matched Drivers and Benchmark Tools

Install the current driver for whichever card is in the machine, then confirm the system actually sees it correctly before moving on. Open a terminal and run:

nvidia-smi --query-gpu=name,driver_version,memory.total,power.limit --format=csv

This should print the exact GPU model, driver version, total VRAM, and the power limit the card is currently allowed to pull. If the power limit looks capped well below the card’s rated TGP, check your Windows power plan and any vendor overclocking utility running in the background before you log a single frame.

Install PresentMon, 3DMark, and HWInfo64 on both systems, and install the Python packages you will need for the logging script in the next step:

pip install pandas nvidia-ml-py pynvml

Run the nvidia-smi command again after installing everything to make sure nothing you just installed grabbed exclusive access to the GPU sensors and locked other tools out.

Step 6: Script Your Power and Thermal Logging

Power draw is where the RTX 5080 vs RTX 4090 story gets interesting, since the 90W gap in rated TGP should show up directly in your utility bill and your case temperatures over a long session. Rather than eyeballing a monitoring overlay, log it to a file so you can compare runs later.

import pynvml
import csv
import time

pynvml.nvmlInit()
handle = pynvml.nvmlDeviceGetHandleByIndex(0)

OUTPUT_FILE = "gpu_power_log.csv"
DURATION_SECONDS = 600  # 10 minute capture window

with open(OUTPUT_FILE, "w", newline="") as f:
    writer = csv.writer(f)
    writer.writerow(["timestamp", "power_w", "temp_c", "clock_mhz", "util_pct"])
    start = time.time()
    while time.time() - start < DURATION_SECONDS:
        power = pynvml.nvmlDeviceGetPowerUsage(handle) / 1000
        temp = pynvml.nvmlDeviceGetTemperature(handle, pynvml.NVML_TEMPERATURE_GPU)
        clock = pynvml.nvmlDeviceGetClockInfo(handle, pynvml.NVML_CLOCK_GRAPHICS)
        util = pynvml.nvmlDeviceGetUtilizationRates(handle).gpu
        writer.writerow([time.time(), power, temp, clock, util])
        time.sleep(1)

pynvml.nvmlShutdown()
print(f"Logged {DURATION_SECONDS} seconds to {OUTPUT_FILE}")

Start this script at the same moment you launch your benchmark run, let it log for the full session, and rename the output file to include the card name before you test the other GPU, for example gpu_power_log_4090.csv and gpu_power_log_5080.csv. You will feed both files into the comparison report in the final project section.

Step 7: Run Synthetic Baselines First

Before touching real games, run a synthetic pass so you have a controlled, repeatable number that is not affected by game patches, save files, or AI-controlled NPCs doing something different between runs. 3DMark's Steel Nomad tests raster performance without ray tracing, and Port Royal isolates ray tracing specifically, which makes the pair useful for separating the two variables.

If you own 3DMark Professional, automate the runs from the command line so both cards get exactly the same test parameters:

3DMarkCmd.exe --definition="Port Royal" --export=portroyal_result.xml
3DMarkCmd.exe --definition="Steel Nomad" --export=steelnomad_result.xml

Run each test three times per card and take the median score, not the average, since a single thermal throttle event or background Windows update check can drag one run down without affecting the others. Independent testing has shown this kind of spread matters: one pass recorded the RTX 4090 at 25,132 points against 22,113 for the RTX 5080 in a ray tracing focused test, roughly a 12 percent lead for the older card, while a more demanding pass widened that to 18,940 versus 16,069, close to a 16 percent gap. A single run would have missed how much that margin can move.

Step 8: Benchmark Real Game FPS at 1440p and 4K

Synthetic scores tell you about the silicon, but real games tell you about your actual experience. Use PresentMon to capture frame times directly rather than relying on an in-game FPS counter, since PresentMon logs every frame's timing and lets you calculate 1 percent low performance later, which an on-screen counter cannot do.

PresentMon.exe --process_name "game.exe" --output_file capture_4090_4k.csv --timed 120

Run this for 120 seconds in an identical section of each game, ideally a scripted benchmark sequence or a fixed replay rather than open world exploration, since your own movement choices introduce variance you cannot control for. Repeat at both 1440p and 4K, and repeat with ray tracing off before you turn it on in Step 9.

A sample line from the raw PresentMon output looks like this once you open the CSV:

Application,ProcessID,SwapChainAddress,PresentMode,MsBetweenPresents,MsInPresentAPI
game.exe,14820,0x0000023F,Hardware Composed: Independent Flip,15.42,0.11

Each row is one rendered frame. You will convert the MsBetweenPresents column into frames per second in the final project script rather than trying to do that math by hand across thousands of rows.

Step 9: Isolate Ray Tracing Performance

Ray tracing is the part of this comparison where the RTX 4090's larger core count still shows up, and it is the step most reviewers run but few buyers replicate for themselves. Turn ray tracing on with everything else held constant from your Step 8 capture, and run the same 120 second PresentMon window again.

Test	RTX 4090	RTX 5080	Gap
Black Myth: Wukong, 4K, ray tracing on	65 FPS	59 FPS	4090 leads by 6 FPS
Dying Light 2, 4K, ray tracing and upscaling on	Higher	Trails by over 10 FPS	4090 leads
Ray tracing synthetic pass (lighter load)	25,132 pts	22,113 pts	4090 leads by ~12%
Ray tracing synthetic pass (heavier load)	18,940 pts	16,069 pts	4090 leads by ~16%

These figures come from independent testing reported by GamersNexus and compiled in iTechGuides' RTX 5080 vs RTX 4090 comparison, and the pattern holds across both the game captures and the synthetic passes: the RTX 4090's extra CUDA cores give it a real, repeatable edge in path traced and heavily ray traced scenes, with the gap widening as the ray tracing workload gets heavier. That is the opposite of what the generational naming would suggest, and it is exactly why running your own capture instead of trusting the model number matters.

Step 10: Test DLSS 4 Multi Frame Generation Against Native Rendering

Raw rendering is only half the picture now that both cards lean on AI upscaling and frame generation to hit high refresh targets. Run this step separately from Steps 8 and 9, and never mix frame-generated numbers into the same average as native frames, since doing so quietly inflates whichever card has the newer feature.

DLSS 4 Multi Frame Generation on the RTX 5080

DLSS 4's multi frame generation mode, which can insert multiple AI-generated frames between each rendered frame, is a Blackwell-generation feature and runs on the RTX 5080 but not on the RTX 4090's Ada Lovelace hardware. The RTX 4090 still supports DLSS 3 with single frame generation, so it is not locked out of upscaling entirely, it simply cannot match the newer card's multiplier in supported titles.

FSR and Cross-Vendor Upscaling

If you also want to test AMD's FSR frame generation on both cards for comparison in games that support it, log those runs in a separate CSV file labeled clearly, for example capture_4090_fsr4.csv. Keep every upscaling and frame generation combination in its own file so your final report in Step 11 and the project script do not accidentally average native, DLSS, and FSR numbers into one misleading figure.

Step 11: Calculate Price per Frame and FPS per Watt

Raw FPS numbers do not tell you whether a card is a good deal. Price per frame and FPS per watt put both the cost and the power draw gap from Step 2 and Step 6 into one comparable figure. Use the street prices you recorded, not launch MSRP.

def price_per_frame(card_price, avg_fps):
    return round(card_price / avg_fps, 2)

def fps_per_watt(avg_fps, tgp_watts):
    return round(avg_fps / tgp_watts, 3)

cards = {
    "RTX 4090 (used, ~$1,490)": {"price": 1490, "fps_4k_rt": 65, "tgp": 450},
    "RTX 5080 (new, ~$1,848)": {"price": 1848, "fps_4k_rt": 59, "tgp": 360},
}

for name, data in cards.items():
    ppf = price_per_frame(data["price"], data["fps_4k_rt"])
    fpw = fps_per_watt(data["fps_4k_rt"], data["tgp"])
    print(f"{name}: ${ppf} per frame, {fpw} FPS per watt")

Using the October 2026 pricing and the Black Myth: Wukong 4K ray tracing figures from Step 9, that script prints output close to this:

RTX 4090 (used, ~$1,490): $22.92 per frame, 0.144 FPS per watt
RTX 5080 (new, ~$1,848): $31.32 per frame, 0.164 FPS per watt

Read that both ways. The used RTX 4090 costs less per frame in this specific ray tracing test at current prices, because it is both faster here and cheaper on the used market right now. The RTX 5080 still wins on FPS per watt, meaning it is doing more with less power, which matters if your electricity costs or case cooling are the bottleneck rather than your budget. Swap in your own captured FPS numbers and the price you actually found before trusting either conclusion.

Step 12: Make the Call With a Decision Matrix

With pricing, specs, ray tracing results, frame generation notes, and your price per frame numbers all captured, lay them out in one table and match them against the use case you wrote down in Step 1.

Priority	Better choice	Why
Lowest cost per frame in ray traced 4K today	Used RTX 4090	More CUDA cores and currently cheaper on the used market
Lower power bill and quieter cooling	RTX 5080	360W TGP versus 450W, a 90W gap per card
Newest frame generation features	RTX 5080	DLSS 4 multi frame generation is Blackwell-exclusive
Warranty and new-card support	RTX 5080	Sold as a current product with full manufacturer warranty
Maximum VRAM for creator or local AI work	RTX 4090	24GB GDDR6X versus 16GB GDDR7
Smallest, most efficient small form factor build	RTX 5080	Lower TGP eases PSU and airflow requirements

If two or more rows point the same direction for your actual use case, that is your answer. If they split evenly, default to whichever card is cheaper per frame in the specific workload you tested in Step 9, since that is the number least affected by marketing and most affected by what you will actually experience.

As a worked example: a buyer who games at 4K with ray tracing on and found a used RTX 4090 for $1,490 against a $1,848 new RTX 5080 would see three rows favor the RTX 4090 (price per frame, ray tracing FPS, VRAM headroom) against two favoring the RTX 5080 (power draw, warranty). That buyer should walk away with the RTX 4090 unless the lack of a manufacturer warranty on a used card is a dealbreaker on its own, in which case the extra few hundred dollars for the RTX 5080 is effectively buying peace of mind rather than more performance.

Beyond Gaming: Content Creation and Local AI Workloads

Gaming FPS is not the only reason people are weighing the RTX 5080 vs RTX 4090 decision in late 2026. Video editors, 3D artists, and anyone running local AI models on their own hardware care about a different set of numbers, and the spec sheet gap from Step 3 matters more here than it does in most games.

The RTX 4090's 24GB of GDDR6X on a 384-bit bus gives it real headroom for tasks that are VRAM-bound rather than compute-bound. Loading a large Stable Diffusion checkpoint, running a 13B or larger local language model, or working with 8K video timelines in DaVinci Resolve can hit the RTX 5080's 16GB ceiling and force it to offload to system RAM, which tanks performance in a way that a gaming benchmark never shows. If your workload regularly fills more than 12 to 14GB of VRAM, the RTX 4090's extra headroom is worth more than its ray tracing deficit in Step 9.

To check your own VRAM ceiling before you decide, run your usual creative or AI workload while watching the memory.used field from the same nvidia-smi query you used in Step 5:

nvidia-smi --query-gpu=memory.used,memory.total --format=csv --loop=2

Let that run in a second terminal window while you work normally for ten or fifteen minutes. If the used figure regularly climbs past 14GB, budget for the RTX 4090's VRAM headroom even if its ray tracing numbers trail in the games you tested. If it stays well under that mark, the RTX 5080's lower power draw and newer encoder improvements for video export are the more useful numbers to weigh instead.

5 Common Pitfalls When Comparing RTX 4090 and RTX 5080

Comparing launch MSRP instead of current street price. Both cards have moved far enough from their original prices that MSRP comparisons are meaningless in late 2026.
Testing on mismatched systems. A faster CPU, faster RAM, or a different storage drive on one test bench will bottleneck results and make the GPU look worse than it is.
Leaving overlay software running during capture. Discord, the NVIDIA app overlay, and RGB utilities add overhead that skews frame time logging in small but real ways.
Averaging native and frame-generated FPS together. Mixing DLSS 4 multi frame generation numbers into the same average as native rendering inflates the card that supports the newer feature.
Running only one pass per test. Synthetic scores alone swung by as much as 16 percent between a lighter and heavier ray tracing pass in independent testing, so a single run can mislead you badly.
Ignoring driver remnants from a previous GPU. Swapping cards without a clean Display Driver Uninstaller pass in Safe Mode is a frequent, hard-to-spot source of underperforming benchmark runs.
Forgetting ambient temperature and case airflow differences. A card tested in a stuffy case will throttle sooner and post lower numbers than the same card in a well-ventilated one, independent of which GPU it is.

Troubleshooting Your Benchmark Run

Even a carefully planned test session runs into snags. Here are the issues most likely to show up while you work through the steps above.

nvidia-smi returns no GPU or the wrong GPU. Check Device Manager for a stuck driver from a previous card, and confirm you are not accidentally querying an integrated GPU on a laptop or motherboard with onboard graphics.
PresentMon exits immediately with a permissions error. Run your terminal as Administrator; PresentMon needs elevated access to hook into the game process's present calls.
3DMarkCmd.exe is missing or refuses to run. The command line automation tool ships only with 3DMark Professional. The free edition requires running tests through the GUI instead.
Power readings in your CSV log show flat, capped numbers. Check whether a vendor overclocking utility has applied a custom power limit override, and reset it to the card's default TGP before testing.
Your CSV parser throws a column name error. Different PresentMon versions have used slightly different capitalization for columns like MsBetweenPresents. Print the header row first and adjust your script's column names to match exactly.
Results vary wildly between back-to-back runs on the same card. This usually points to thermal throttling. Let the card idle and cool for five minutes between passes, and check your max temperature column from Step 6.
Antivirus software flags or deletes DDU or your benchmark executable. Add a temporary exclusion for the specific folder you downloaded the tool into, then remove the exclusion once testing is done.
pip install fails on the nvidia-ml-py package. Make sure you are not also running the deprecated standalone pynvml package from PyPI alongside it, since the two can conflict. Uninstall both and reinstall only nvidia-ml-py.
HWInfo64 and your Python script report different temperatures. Only one process can often poll certain sensors exclusively on some driver versions. Close HWInfo64 while your logging script runs, then reopen it afterward to spot check.
Frame generation produces visibly duplicated or warped frames in your capture. This is a rendering artifact, not a capture bug. Note it in your results rather than discarding the run, since it is relevant to the real-world experience of that mode.

Advanced Tips for a More Accurate Comparison

Once the basic workflow above is running cleanly, a few refinements will tighten up your numbers further. Measure whole-system power at the wall with a kill-a-watt style meter alongside your GPU-only pynvml log, since CPU power draw can shift between the two test rigs even when the GPU numbers look identical, and that difference matters if your real concern is the electricity bill or a tight PSU budget.

Discard the first run of every session as a warm-up pass. Shader caches, Windows background indexing, and GPU boost clocks all need a minute or two to settle, and that first run is consistently the noisiest one in any test suite.

Test at a lower resolution first to confirm you are GPU-bound rather than CPU-bound before trusting your 4K numbers. If 1080p and 1440p results are nearly identical on both cards, your CPU is the bottleneck in that title and your 4K comparison is the only one worth reporting.

Finally, track used and new pricing for both cards over two to three weeks rather than a single snapshot before you buy. The secondary GPU market has been unusually volatile through 2026's memory shortage, and the price gap that makes the RTX 4090 the obvious buy one week can close or reverse within days.

Match your test resolution and refresh rate to the monitor you actually own rather than chasing the highest number a card can produce. A 4K/120Hz panel caps the real-world benefit of any FPS figure above 120, so if both cards clear that bar comfortably in your games, the ray tracing and price per frame numbers from Steps 9 and 11 should carry more weight in your final decision than the raw average FPS column.

Complete Working Project: A GPU Comparison Report Script

Pull everything from Steps 6 through 11 into one script that reads your power log and PresentMon capture for each card and prints a single side by side report. Save your files using the naming pattern below, then run this script once both cards have been through the full test sequence.

import pandas as pd

def load_power_log(path):
    df = pd.read_csv(path)
    return df["power_w"].mean(), df["temp_c"].max()

def load_frame_times(path):
    df = pd.read_csv(path)
    frame_times_ms = df["MsBetweenPresents"]
    fps = 1000 / frame_times_ms
    avg_fps = fps.mean()
    low_1pct = fps.quantile(0.01)
    return avg_fps, low_1pct

def build_report(name, power_log, frame_log, price, tgp):
    avg_power, max_temp = load_power_log(power_log)
    avg_fps, low_1pct = load_frame_times(frame_log)
    price_per_frame = price / avg_fps
    fps_per_watt = avg_fps / tgp
    return {
        "card": name,
        "avg_fps": round(avg_fps, 1),
        "1pct_low_fps": round(low_1pct, 1),
        "avg_power_w": round(avg_power, 1),
        "max_temp_c": max_temp,
        "price_per_frame": round(price_per_frame, 2),
        "fps_per_watt": round(fps_per_watt, 3),
    }

if __name__ == "__main__":
    cards = [
        build_report("RTX 4090", "gpu_power_log_4090.csv", "capture_4090_4k.csv", 1490, 450),
        build_report("RTX 5080", "gpu_power_log_5080.csv", "capture_5080_4k.csv", 1848, 360),
    ]

    header = f"{'Card':<10}{'Avg FPS':>10}{'1% Low':>10}{'Avg W':>8}{'Max C':>8}{'$/Frame':>10}{'FPS/W':>8}"
    print(header)
    for c in cards:
        row = (
            f"{c['card']:<10}{c['avg_fps']:>10}{c['1pct_low_fps']:>10}"
            f"{c['avg_power_w']:>8}{c['max_temp_c']:>8}"
            f"{c['price_per_frame']:>10}{c['fps_per_watt']:>8}"
        )
        print(row)

Running this against a real set of capture files produces output in this shape:

Card         Avg FPS    1% Low   Avg W   Max C   $/Frame   FPS/W
RTX 4090         65.1      54.6     441      78     22.89   0.145
RTX 5080         59.3      51.0     351      71     31.17   0.165

That single table is your entire RTX 5080 vs RTX 4090 comparison reduced to the numbers that matter for your specific games, your specific prices, and your specific power situation. Rerun it after every price check, since the price_per_frame column is the one most likely to flip as the market moves.

You now have a reusable benchmarking project. Swap the file names and TGP values in the cards list and the same script works for comparing any two GPUs you can get your hands on, not just this pair.

Frequently Asked Questions

Is the RTX 4090 officially discontinued?
NVIDIA has not published a formal discontinuation notice, but the card has been replaced in NVIDIA's current lineup and new stock is scarce, with most available units coming from resale and remaining retailer inventory rather than fresh production.

Is the RTX 5080 actually faster than the RTX 4090?
It depends on the workload. The RTX 5080 wins on efficiency and newer frame generation features, but independent ray tracing tests, including Black Myth: Wukong at 4K and multiple synthetic passes, have shown the RTX 4090 ahead by 6 to 16 percent in several heavily ray traced scenarios.

Which GPU is better for ray tracing specifically?
Based on current benchmark data, the RTX 4090's larger CUDA core count gives it a repeatable edge in path traced and ray tracing heavy titles, with the gap widening as the workload gets more demanding.

How much power supply do I need for each card?
NVIDIA recommends an 850W power supply for the RTX 4090 and a 750W power supply for the RTX 5080, reflecting their 450W and 360W total graphics power ratings respectively.

Does the RTX 4090 support DLSS 4?
The RTX 4090 supports DLSS 3 with single frame generation, but DLSS 4's multi frame generation mode is built around the Blackwell architecture and runs only on RTX 50-series cards like the RTX 5080.

Is a used RTX 4090 a smart buy in late 2026?
At current tracked pricing, with used units averaging $1,460 to $1,500 against a cheapest tracked new RTX 5080 of $1,848.43, the used RTX 4090 can be the better price per frame option for ray tracing heavy 4K gaming, provided you buy from a seller offering some form of return protection and test the card immediately.

What is the real price gap between the two cards right now?
As of mid October 2026, a used RTX 4090 at roughly $1,460 to $1,500 sits several hundred dollars below the cheapest tracked new RTX 5080 price of $1,848.43, though both figures move frequently given current supply constraints.

Can I run this benchmark project without 3DMark Professional?
Yes. Skip the command line automation in Step 7 and run Steel Nomad and Port Royal through the free 3DMark GUI instead, then manually record the scores. Every other step above, including the power logging and the PresentMon capture, works the same either way.

Which card makes more sense for video editing or local AI work?
The RTX 4090's 24GB of VRAM gives it an edge for workloads that fill more than 12 to 14GB, such as large local language models, big Stable Diffusion checkpoints, or 8K video timelines, since the RTX 5080's 16GB can force an offload to system memory that tanks performance in ways a gaming benchmark never reveals.

RTX 5080 vs RTX 4090: 16% RT Gap in 12 Steps [2026]