RTX 5090 Beats 4090 for AI by 66% [2026]

Most RTX 5090 vs RTX 4090 coverage still measures the same thing: frame rates in the latest shooter, with DLSS toggled on and off. That tells you almost nothing if the card is going into a workstation that runs Stable Diffusion, a local Llama model, or Blender renders overnight. AI and content creation workloads stress a GPU differently than games do, and the gap between a 32GB card and a 24GB card shows up in ways that gaming benchmarks never surface.

This tutorial builds a repeatable benchmark rig for comparing the RTX 5090 vs RTX 4090 specifically on AI inference, image generation, and rendering workloads. You will install the right drivers, set up isolated Python environments, run Stable Diffusion and local LLM benchmarks, render a Blender test scene, log everything to a CSV file, and calculate a real cost per image and cost per token for each card. By the end you will have your own numbers, not just numbers borrowed from a review published months before your specific driver, PyTorch, and quantization setup shipped.

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

Why RTX 5090 vs RTX 4090 AI Benchmarks Differ From Gaming Benchmarks

Gaming benchmarks care about rasterization throughput, ray tracing cores, and upscaling tricks like DLSS frame generation. AI and content creation workloads care about three different things: raw VRAM capacity, memory bandwidth, and sustained compute under long, uninterrupted loads. A GPU that wins a gaming benchmark by 20 percent might win an LLM inference benchmark by 60 percent or more, because the workload is bandwidth bound rather than shader bound.

The RTX 5090 ships with 32GB of GDDR7 memory and 1,792 GB/s of memory bandwidth, according to NVIDIA’s own RTX 5090 product page. The RTX 4090 carries 24GB of GDDR6X and 1,008 GB/s of bandwidth, per the side by side specification breakdown published by PC Guide. That is roughly 78 percent more bandwidth on the RTX 5090, and bandwidth is exactly what large language model inference and high resolution diffusion models lean on hardest. Gaming benchmarks rarely expose that gap because a game’s render pipeline does not move anywhere near as much data through the memory bus every frame as a 70 billion parameter model does during a single forward pass.

VRAM capacity matters even more for AI workloads than it does for games. A game that runs out of VRAM usually just drops texture quality. A diffusion model or LLM that runs out of VRAM crashes outright with an out of memory error, or silently falls back to CPU offloading that tanks throughput by an order of magnitude. The extra 8GB on the RTX 5090 is the difference between running a 13 billion parameter model fully in VRAM at a comfortable batch size and having to quantize aggressively or split layers onto the CPU on the RTX 4090. That single fact reshapes almost every benchmark you will run And it is the main reason a pure frames per second comparison misses the real story for creators and developers.

There is also a practical availability angle worth setting expectations around before you start buying hardware for this test. The RTX 5090 has been reported as difficult to find at anywhere near its original price, with most remaining stock coming through third party resellers, according to PC Gamer. The same report notes unconfirmed industry chatter that NVIDIA may be redirecting GB202 silicon away from consumer RTX 5090 production toward data center and RTX Pro workstation cards, which would make the RTX 4090 a more realistic near-term purchase for a lot of buyers even though it is the older part.

Prerequisites: Hardware, Drivers, and Software Versions

Before you run a single benchmark, get the environment consistent. Mismatched driver, CUDA, or framework versions are the single biggest reason two people report wildly different RTX 5090 vs RTX 4090 numbers for the same workload.

An RTX 5090 (32GB GDDR7) or RTX 4090 (24GB GDDR6X) installed in a system with adequate case airflow and a power supply rated well above the card’s board power. NVIDIA lists RTX 4090 board power at 450W and RTX 5090 at 575W in official and third party spec comparisons, so budget your PSU headroom accordingly.
A CPU and motherboard that will not bottleneck PCIe bandwidth, ideally PCIe 4.0 x16 or better.
At least 64GB of system RAM if you plan to test CPU offloading scenarios for large local LLMs.
Windows 11 or a current Linux distribution (Ubuntu 24.04 LTS or newer is the most tested path for AI tooling).
The latest NVIDIA Game Ready or Studio Driver, installed directly from NVIDIA’s driver download page. Do not rely on a driver version number from an old article; NVIDIA ships multiple driver releases per year and whichever is current on your install date is the one to use.
Python 3.11 or 3.12, with venv or conda available for creating isolated environments.
Git, and roughly 60GB of free disk space for model weights and generated test images.
A kill a watt style power meter or a smart plug with power monitoring, for the power draw steps later in this tutorial.

If you only have access to one of the two cards, you can still follow every step and compare your results against the figures in the tables later As long as you note that cross-machine comparisons are always less precise than testing both cards in the same system.

Step 1: Verify Your GPU, VRAM, and Driver Version

Start every benchmark session by confirming exactly what hardware and driver combination you are testing. This sounds obvious, but it is the step most people skip, and it is the first thing to check when your numbers do not match anyone else’s.

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

On a correctly configured RTX 5090 system, this should report roughly 32607 MiB of total memory. On an RTX 4090 system, expect roughly 24576 MiB. If the reported VRAM is noticeably lower than that, you likely have a driver issue or the card is running in a reduced power or compatibility mode, and you should resolve that before benchmarking anything. Write down the exact driver version string from this output; you will want it later when comparing results across multiple test sessions or sharing your numbers with anyone else.

Step 2: Install the NVIDIA Driver and CUDA Toolkit

Install the current NVIDIA driver from the official download page for your card, then install a CUDA toolkit version that matches what your AI frameworks expect. PyTorch and the diffusers library generally track the two or three most recent CUDA major versions, so check the install matrix for whichever PyTorch release you plan to use before downloading CUDA, rather than guessing.

# Linux example: confirm CUDA toolkit version after install
nvcc --version

# Confirm PyTorch sees the GPU and reports the correct CUDA build
python3 -c "import torch; print(torch.__version__); print(torch.cuda.is_available()); print(torch.cuda.get_device_name(0))"

If torch.cuda.is_available() returns False, stop here and fix it before moving on. Every benchmark Depends on PyTorch correctly detecting the GPU. The most common causes are installing a CPU-only PyTorch wheel by mistake, a driver and CUDA toolkit version mismatch, or a secure boot setting blocking the NVIDIA kernel module on Linux.

Step 3: Set Up an Isolated Python Benchmark Environment

Keep your benchmark environment separate from any other Python project on the machine. Library version drift between test runs is a quiet killer of reproducible GPU comparisons.

python3 -m venv gpu-bench-env
source gpu-bench-env/bin/activate

pip install --upgrade pip
pip install torch torchvision --index-url https://download.pytorch.org/whl/cu124
pip install diffusers transformers accelerate safetensors xformers
pip install pandas matplotlib psutil

Pin your package versions once everything works by running pip freeze > requirements.txt, and keep that file next to your results. If you benchmark again in three months after a driver or library update, you will be able to tell whether a performance change came from the hardware, the software stack, or both.

Step 4: Benchmark Stable Diffusion Image Generation

Image generation is one of the clearest places the RTX 5090 vs RTX 4090 gap shows up, because higher resolution diffusion runs lean on both VRAM capacity and memory bandwidth. Tom’s Hardware’s own Stable Diffusion benchmark methodology, which tests 1024×1024 SD 1.5 generation, reported roughly 13.4 images per minute on an RTX 4090 in its published results, according to Tom’s Hardware’s RTX 5090 review. Use that figure as a sanity check for your own RTX 4090 run rather than an exact target, since sampler choice, step count, and whether xformers memory-efficient attention is enabled all shift the number.

import time
import torch
from diffusers import StableDiffusionPipeline

pipe = StableDiffusionPipeline.from_pretrained(
    "runwayml/stable-diffusion-v1-5",
    torch_dtype=torch.float16
).to("cuda")
pipe.enable_xformers_memory_efficient_attention()

prompt = "a detailed photograph of a mountain lake at sunrise"
warmup = pipe(prompt, num_inference_steps=20)

start = time.time()
runs = 10
for _ in range(runs):
    image = pipe(prompt, num_inference_steps=20).images[0]
elapsed = time.time() - start

images_per_minute = (runs / elapsed) * 60
print(f"Images per minute: {images_per_minute:.2f}")

Run this script three times per card and discard the first run entirely, since model loading and CUDA kernel compilation inflate the first iteration’s timing. Average the remaining runs. Then repeat the same test at SDXL resolution (1024×1024 with the SDXL base model) to see how the gap changes as VRAM pressure increases. Expect the RTX 5090’s advantage to widen on SDXL and Flux-class models compared to the older SD 1.5 baseline, since those larger models benefit more from the RTX 5090’s extra memory bandwidth and capacity.

Step 5: Benchmark Local LLM Inference With llama.cpp and Ollama

Local LLM inference is where the memory bandwidth gap between these two cards matters most, because token generation is largely bandwidth bound rather than compute bound. GPU benchmark aggregator ComputingForGeeks reported Llama 3.1 8B generation throughput of roughly 250 tokens per second on an RTX 5090 versus roughly 148 tokens per second on an RTX 4090 in its tested picks. A separate benchmark writeup from Compute Market reported a more conservative gap for the same model class, putting RTX 5090 generation throughput at roughly 213 tokens per second against roughly 128 tokens per second for the RTX 4090, with prompt processing throughput of roughly 7,198 tokens per second versus roughly 4,300 tokens per second. The spread between those two outside results, even on the same model, is exactly why you are building your own benchmark rather than quoting someone else’s number.

Both figures point the same direction: somewhere between a 66 percent and 70 percent generation throughput advantage for the RTX 5090 on an 8 billion parameter model, depending on quantization, context length, and backend. That range itself is the headline. A single point estimate from one reviewer’s machine is not a reliable number to plan a purchase around; a range from multiple independent sources is.

# Build llama.cpp with CUDA support
git clone https://github.com/ggml-org/llama.cpp
cd llama.cpp
cmake -B build -DGGML_CUDA=ON
cmake --build build --config Release -j

# Run the built-in benchmark against a downloaded GGUF model
./build/bin/llama-bench -m ./models/llama-3.1-8b-instruct.Q4_K_M.gguf -ngl 999 -p 512 -n 256

Measuring Tokens Per Second Correctly

The -ngl 999 flag offloads every model layer onto the GPU; if your model is too large for the card’s VRAM, llama.cpp will silently reduce how many layers it offloads and the rest will run on CPU, which produces a result that looks like a GPU benchmark but is actually a mixed CPU and GPU result. Always check the console output for the actual number of layers offloaded before trusting a tokens per second figure. The llama-bench tool reports separate prompt processing (pp) and text generation (tg) throughput; record both, since they stress the GPU differently and a card that wins one does not always win the other by the same margin.

If you prefer a friendlier interface, Ollama wraps llama.cpp with simpler commands and exposes similar timing data through its API logs, which makes it a reasonable alternative for this step if you are less comfortable building from source.

Step 6: Benchmark Blender Cycles and OptiX Rendering

Blender rendering is a useful third data point because it stresses ray tracing cores and compute throughput rather than memory bandwidth the way LLM inference does, giving you a more rounded picture of where each card’s advantage actually comes from. Tom’s Hardware’s RTX 5090 review used Blender Benchmark version 4.3.0 for its test suite, so use the same version for comparability with published reviews.

# Download the official Blender Benchmark CLI package for your OS from
# opendata.blender.org, then run it against the standard scene set

./benchmark-launcher-cli benchmark -d monster,junkshop,classroom --device OPTIX

Run each scene at least twice per card and record the samples per minute figure the tool reports for each. There is no independently verifiable, review-confirmed RTX 5090 vs RTX 4090 OptiX score publicly available at the time of writing, which is exactly why this step matters: run it yourself, log the result in the spreadsheet from Step 9, and you have a number you can actually trust and reproduce. If you want public context for how your numbers compare to a broad field of other GPUs, the Blender Open Data benchmark database lets you filter by device once your own run has been uploaded or once you search its public results for the two cards.

Step 7: Benchmark Video Export and NVENC Encoding

Video editors care about export time more than almost any other metric, and NVENC hardware encoding performance does not always scale with raw CUDA core count the way rendering does. Use a consistent timeline in your editor of choice, export the same project at the same codec and bitrate settings on both cards, and time the export with a stopwatch or your editor’s built in render log.

# Command line alternative using ffmpeg with NVENC, for a controlled
# apples to apples export benchmark outside of a full NLE
ffmpeg -i source_4k_footage.mp4 -c:v hevc_nvenc -preset p5 -b:v 40M -c:a copy output_test.mp4

Time this command with time ffmpeg ... on Linux or macOS, or wrap it in a PowerShell Measure-Command block on Windows. Run it three times per card and average the results, since disk read and write speed can introduce noise into export timing that has nothing to do with the GPU itself. If both cards finish within a few percent of each other on NVENC export specifically, that is a legitimate and expected result; NVENC encode blocks have not scaled generation over generation at the same rate as compute or memory bandwidth has.

Step 8: Monitor Power Draw, Thermals, and Clock Speeds During Tests

A benchmark number without power and thermal context is incomplete, especially when comparing a 450W card against a 575W card. Run a monitoring command in a second terminal while each benchmark executes, so you capture sustained behavior rather than a brief peak.

nvidia-smi dmon -s pucvmet -d 2

Watch for clock speed drops during long runs, which indicate thermal or power limit throttling rather than a genuine architectural limitation. If your RTX 5090 numbers look disappointing compared to published reviews, check this log first; a 575W card in a case with inadequate exhaust airflow will throttle well before a properly cooled RTX 4090 does, which can produce a misleadingly small gap between the two cards that has nothing to do with the silicon itself.

Step 9: Build a Repeatable Benchmark Logging Script

Now tie every test above into one script that logs results to a CSV file, so you can compare runs across cards, driver versions, and software updates without manually re-typing numbers into a spreadsheet. This is the complete working project for this tutorial: a single harness you can re-run any time you update a driver or want to re-check a number.

import csv
import time
import subprocess
from datetime import datetime

LOG_FILE = "gpu_benchmark_log.csv"

def get_gpu_info():
    output = subprocess.check_output(
        ["nvidia-smi", "--query-gpu=name,driver_version,memory.total",
         "--format=csv,noheader"]
    ).decode().strip()
    name, driver, vram = [x.strip() for x in output.split(",")]
    return name, driver, vram

def log_result(test_name, value, unit, notes=""):
    name, driver, vram = get_gpu_info()
    row = [
        datetime.now().isoformat(timespec="seconds"),
        name, driver, vram,
        test_name, round(value, 3), unit, notes
    ]
    file_exists = False
    try:
        with open(LOG_FILE, "r"):
            file_exists = True
    except FileNotFoundError:
        pass

    with open(LOG_FILE, "a", newline="") as f:
        writer = csv.writer(f)
        if not file_exists:
            writer.writerow([
                "timestamp", "gpu_name", "driver_version", "vram",
                "test_name", "value", "unit", "notes"
            ])
        writer.writerow(row)

    print(f"Logged: {test_name} = {value} {unit} on {name}")

# Example usage after running a Stable Diffusion timing block above:
# log_result("sd15_images_per_minute", images_per_minute, "img/min", "xformers enabled")

# Example usage after parsing llama-bench output for tg256:
# log_result("llama3_8b_tokens_per_sec", 213.4, "tok/s", "Q4_K_M quant")

Call log_result() at the end of each benchmark script from the earlier steps instead of just printing the number to the console. After a full pass through every test on both cards, you will have one CSV file containing the GPU name, driver version, VRAM, and every recorded metric with a timestamp. That file is your actual source of truth, not a number copied from an article, including this one.

Running the Full Suite End to End

Once each individual benchmark script calls log_result(), wrap them in a single shell script or Python orchestrator that runs Stable Diffusion, the llama.cpp bench, and the Blender CLI benchmark back to back, with a short cooldown pause between each test. A two to three minute pause between heavy tests lets GPU temperature return closer to idle, which keeps thermal throttling from one test from contaminating the results of the next one.

What the Output Should Look Like

Before you trust any of your own numbers, it helps to know roughly what a healthy, correctly configured run looks like at the console level. These are illustrative output shapes, not guaranteed values, since your exact figures will depend on your driver, model files, and settings.

A correct nvidia-smi query on an RTX 5090 system should look something like this:

name, memory.total [MiB], driver_version, power.max_limit [W]
NVIDIA GeForce RTX 5090, 32607 MiB, 580.xx.xx, 575.00 W

If that line instead reports only a few thousand MiB of memory, or a power limit far below 575W, stop and fix the driver install before running any benchmark; a correct reading on an RTX 4090 looks the same but with roughly 24576 MiB and a 450W limit.

A healthy llama-bench run against an 8 billion parameter GGUF model should produce a results table similar to this shape, with your own throughput numbers substituted in:

model                          size    params  backend  ngl  test      t/s
llama 3.1 8B Q4_K_M            4.58G   8.03B   CUDA     999  pp512     7021.4
llama 3.1 8B Q4_K_M            4.58G   8.03B   CUDA     999  tg256      208.7

The ngl 999 column confirming every layer offloaded is the detail to check first; if that number is lower than the model’s actual total layer count, part of the workload silently fell back to the CPU and the t/s figures are no longer a clean GPU comparison.

Finally, after a full pass through the logging script from Step 9, your gpu_benchmark_log.csv file should contain rows resembling this structure, one line per test per card:

timestamp,gpu_name,driver_version,vram,test_name,value,unit,notes
2026-10-15T09:14:02,NVIDIA GeForce RTX 5090,580.xx.xx,32607 MiB,sd15_images_per_minute,24.112,img/min,xformers enabled
2026-10-15T09:21:47,NVIDIA GeForce RTX 5090,580.xx.xx,32607 MiB,llama3_8b_tokens_per_sec,213.400,tok/s,Q4_K_M quant
2026-10-15T10:02:19,NVIDIA GeForce RTX 4090,580.xx.xx,24576 MiB,sd15_images_per_minute,13.400,img/min,xformers enabled
2026-10-15T10:09:33,NVIDIA GeForce RTX 4090,580.xx.xx,24576 MiB,llama3_8b_tokens_per_sec,128.000,tok/s,Q4_K_M quant

With that file in hand, loading it into a pandas DataFrame and grouping by gpu_name and test_name gives you a clean side by side table you can drop straight into a spreadsheet, without retyping a single number by hand.

Step 10: Normalize Results and Calculate Cost Per Image and Per Token

Raw throughput numbers do not tell you whether a card is worth the money. Normalizing for price and power turns your benchmark data into an actual purchase decision. Street pricing for both cards has moved well past MSRP given constrained supply; one GPU price tracking comparison from DropReference listed October 2026 European pricing around 5,687 euros for the RTX 5090 against roughly 3,990 euros for the RTX 4090, a gap of roughly 1,697 euros. Use your own local, current price rather than that figure directly, since GPU pricing moves quickly and varies heavily by region and retailer.

def cost_per_1000_images(images_per_minute, electricity_rate_per_kwh, watts):
    minutes_per_1000 = 1000 / images_per_minute
    kwh_used = (watts / 1000) * (minutes_per_1000 / 60)
    energy_cost = kwh_used * electricity_rate_per_kwh
    return energy_cost  # hardware cost amortizes separately; this isolates running cost

# Example: plug in your own logged images_per_minute and measured watts
rtx5090_cost = cost_per_1000_images(images_per_minute=24.0,
                                    electricity_rate_per_kwh=0.15, watts=520)
rtx4090_cost = cost_per_1000_images(images_per_minute=13.4,
                                    electricity_rate_per_kwh=0.15, watts=410)
print(f"RTX 5090 energy cost per 1000 images: ${rtx5090_cost:.2f}")
print(f"RTX 4090 energy cost per 1000 images: ${rtx4090_cost:.2f}")

Run the same formula structure for tokens per second instead of images per minute to get an electricity cost per million tokens generated. In almost every case, the faster card’s higher power draw is more than offset by finishing the job faster, so energy cost per unit of output tends to favor the RTX 5090 even though its wall-draw wattage is higher. The bigger factor in your total cost of ownership is almost always the purchase price gap, not the electricity bill, given current street pricing.

RTX 5090 vs RTX 4090 Specs and Benchmark Results at a Glance

The table below consolidates the officially sourced specifications and the benchmark data points referenced throughout this tutorial, so you have a single reference while running your own tests.

Specification	RTX 5090	RTX 4090
VRAM	32GB GDDR7	24GB GDDR6X
CUDA cores	21,760	16,384
Memory bandwidth	1,792 GB/s	1,008 GB/s
Tensor core generation	5th-gen, up to 3,352 AI TOPS	4th-gen, up to roughly 330 FP8 TFLOPS
Board power (TDP)	575W	450W
Launch MSRP	$1,999	$1,599

Workload	RTX 5090	RTX 4090	Source
Stable Diffusion 1.5, 1024×1024	Run your own test (Step 4)	About 13.4 images/minute	Tom’s Hardware
Llama 3.1 8B generation (tok/s)	About 213 to 250	About 128 to 148	Compute Market, ComputingForGeeks
Llama 3.1 8B prompt processing (tok/s)	About 7,198	About 4,300	Compute Market
Blender OptiX render	Run your own test (Step 6)	Run your own test (Step 6)	No verified public figure yet

Notice the ranges in the LLM row. Two independent outside benchmarks of the same model class produced different absolute numbers but agreed on the same general conclusion: the RTX 5090 generates tokens meaningfully faster, in the range of roughly 44 to 70 percent depending on backend and quantization. That consistency in direction, even with disagreement in magnitude, is more trustworthy than any single number taken in isolation.

5 Pitfalls That Wreck GPU Benchmark Comparisons

Comparing different quantization levels. An FP16 Stable Diffusion run on one card and an FP8 run on the other is not a GPU comparison, it is a quantization comparison wearing a GPU comparison’s clothes. Lock precision and quantization identically across both cards before you record a single number.
Ignoring VRAM headroom as a separate variable from speed. A model that fits comfortably in 32GB but has to be quantized harder to fit in 24GB is not purely a speed test anymore; you are also measuring a quality tradeoff. Report both the speed number and whether quantization settings had to change to fit the smaller card.
Measuring model load time instead of steady state throughput. The first inference or render after loading a model is always slower due to CUDA kernel compilation and disk read overhead. Always discard the first run and average at least three warmed up runs.
Letting background software compete for GPU resources. Browser hardware acceleration, Discord’s overlay, or a second monitor running a video all pull GPU cycles. Close everything non essential before benchmarking, and check nvidia-smi for other processes using the GPU before you start.
Skipping thermal and power logging. A 575W card throttling in a poorly ventilated case can post numbers barely ahead of a well cooled 450W card, and without the power and clock logs from Step 8 you would never know that the result reflects your case’s airflow rather than the silicon.

Why Your Numbers Won’t Match Reviewers’ Numbers

Even controlling for all five pitfalls above, expect your results to differ from any published review by a meaningful margin. Driver versions change monthly, PyTorch and CUDA minor versions change performance characteristics release to release, and reviewers rarely disclose every setting they used down to the sampler and step count. Treat published benchmarks, including the ones referenced As directional context for what order of magnitude to expect, not as a number your own rig should match exactly.

Troubleshooting Guide: 8 Common Benchmark Problems

CUDA out of memory error during Stable Diffusion or LLM loading. Lower the batch size, enable attention slicing or xformers, or quantize the model to a smaller format. On the RTX 4090 specifically, this is far more likely to occur on larger SDXL and Flux models than on the RTX 5090 simply due to the 8GB VRAM difference.
CUDA driver version is insufficient for CUDA runtime version. Your installed NVIDIA driver is older than what your CUDA toolkit or PyTorch build requires. Update the driver from NVIDIA’s download page rather than downgrading CUDA, since a newer driver is backward compatible with older CUDA runtimes in almost every case.
torch.cuda.is_available() returns False. You likely installed a CPU-only PyTorch wheel. Reinstall using the correct CUDA-enabled index URL for your CUDA version from PyTorch’s official install selector.
llama.cpp reports 0 layers offloaded to GPU. The binary was not built with GGML_CUDA=ON, or the CUDA toolkit was not found during the build. Rebuild from a clean directory and check the cmake configure output for CUDA detection messages.
Blender Benchmark CLI does not list an OptiX device. Your driver is likely out of date, or Blender’s device list needs a restart after a driver update. Relaunch the benchmark launcher after confirming nvidia-smi shows the card correctly.
Stable Diffusion runs are unexpectedly slow on both cards. Check that xformers or PyTorch’s native scaled dot product attention is actually enabled; without memory efficient attention, generation speed on both cards drops substantially and the comparison becomes meaningless.
System randomly shuts down or reboots under sustained GPU load. This is almost always a power supply issue, not a GPU defect, particularly on the RTX 5090’s 575W board power. Confirm your PSU has sufficient headroom and that all required PCIe power connectors are seated correctly.
Results vary by more than 10 percent between identical runs. This usually points to thermal throttling, a background process competing for GPU time, or power limit throttling. Re-check the monitoring log from Step 8 and add cooldown pauses between runs.

Advanced Tips for Getting More Out of Either Card

Once your baseline benchmarks are logged, a few adjustments can meaningfully change the picture, especially if you are deciding whether the RTX 5090’s price premium is justified for your specific workload.

Power limit tuning. Using nvidia-smi -pl to cap the RTX 5090’s power limit below its 575W default can recover most of its performance advantage at a meaningfully lower power draw, since GPUs typically deliver diminishing returns at their highest power states. Test a few power limit steps and log the throughput versus watts tradeoff for your specific workload.
Batch size scaling for throughput-bound jobs. If you are generating large volumes of images rather than a single image interactively, increasing batch size on the RTX 5090’s extra VRAM headroom often improves total throughput more than any other single setting, since the GPU is doing more useful work per model load and per kernel launch.
Quantization format selection for local LLMs. GGUF Q4_K_M offers a reasonable speed and quality balance on either card, but if you have the VRAM headroom the RTX 5090 provides, testing Q6_K or Q8_0 quantization can meaningfully improve output quality for a smaller throughput cost than you might expect.
Live monitoring during long jobs. Keep nvidia-smi dmon running in a background terminal during any multi-hour render or fine-tuning job, not just during short benchmark runs, so you catch thermal throttling episodes that only appear after sustained heat buildup.
Understand bandwidth bound versus compute bound workloads. LLM token generation is primarily bandwidth bound, which is why the RTX 5090’s bandwidth advantage produces an outsized gap there. Rendering and most compute shader work is closer to compute bound, which is why the CUDA core count difference matters more in Blender than in llama.cpp.

Frequently Asked Questions

Is the RTX 5090 actually worth it over the RTX 4090 for AI work specifically?
For local LLM inference and large diffusion models, the extra VRAM and memory bandwidth produce a real, measurable advantage, generally in the 40 to 70 percent range on generation throughput depending on the model and quantization, based on the benchmark sources in this tutorial. For lighter workloads that already fit comfortably in 24GB, the gap narrows and the RTX 4090’s lower price and lower power draw become more attractive.

How much VRAM do I actually need for Stable Diffusion and local LLMs?
SD 1.5 and SDXL at standard resolutions run comfortably on 12 to 16GB. Flux-class models and larger batch sizes benefit from 24GB or more. For local LLMs, VRAM needs scale with parameter count and quantization: an 8 billion parameter model in Q4 quantization fits in well under 8GB, while a 70 billion parameter model in Q4 quantization needs roughly 40GB or more, which exceeds either single card and requires either heavier quantization or multi-GPU setups.

Does the RTX 5090 really draw that much more power?
Yes. Official and third party specification comparisons list the RTX 5090’s board power at 575W against the RTX 4090’s 450W, a 125W difference at full load. In practice, power limit tuning can close much of that gap while sacrificing only a small amount of performance, as covered in the advanced tips section above.

Can I run these benchmarks on Linux instead of Windows?
Yes, and for AI workloads specifically, Linux is generally the more tested and better documented path. Every script Works on Ubuntu 24.04 LTS or newer with the proprietary NVIDIA driver installed; only the PowerShell timing example in Step 7 is Windows specific, and it has a direct Linux equivalent using the time command.

Why do my results not match the numbers Or in other reviews?
Driver versions, CUDA versions, PyTorch versions, sampler settings, quantization format, ambient temperature, case airflow, and background processes all shift GPU benchmark results. Treat every published number, including the ones referenced here, as a directional estimate rather than a value your specific rig should reproduce exactly.

Is the RTX 4090 still a reasonable card to buy in 2026?
For many AI and content creation workloads that fit within 24GB of VRAM, yes. Given reports of constrained RTX 5090 availability and a substantial price gap between the two cards, the RTX 4090 remains a practical option for buyers who do not specifically need the larger VRAM pool for bigger models or batch sizes.

Should I wait for the next generation instead of buying either card now?
That depends entirely on how urgently you need the compute today. Benchmarking your actual workload using this tutorial, rather than relying on marketing specs alone, is the most reliable way to decide whether your current bottleneck is even GPU-bound in the first place before committing to any new hardware purchase.

What is the single most important setting to keep identical between the two cards?
Model precision and quantization format. Every other variable From driver version to power limit, matters less than ensuring both cards are running the exact same precision, the exact same quantized weights, and the exact same batch size before you record a comparison number.

RTX 5090 vs RTX 4090 for AI: 11 Steps, 66% Faster [2026]