DeviceBenchFree bottleneck calculator
Bottleneck calculator that shows what it compared
Pick a processor, a graphics card and the resolution you play at, and the page names which of the two runs out of headroom first and how much of the other one goes unused — as a band, not as a percentage to one decimal place. Both columns are relative index numbers rounded from published benchmark aggregates, anchored on a Ryzen 5 7600 beside an RTX 4070 at 2560 × 1440 as a matched pair, and the multiplication is printed underneath so you can disagree with it. No frame rate is predicted anywhere: a frame rate belongs to one game at one settings preset, while which part is the ceiling travels with you between them.
- 100% free
- No signup
- 40 CPUs, 42 GPUs
- Four resolutions
- Method printed
The percentage under each resolution is how much of its 2560 × 1440 frame rate a card holds on to there. It is not the pixel ratio: a 3840 × 2160 frame has 2.25 times the pixels of a 1440p one and costs roughly 60% more time, because geometry, draw calls and shadow maps are drawn once whatever the output size.
Processor-limited
Severe≈ 42% unused
Index 80, unchanged at every resolution
Index 100 x 1.39 for 1920 × 1080
80 vs 100 × 1.39 = 139.0 → (139.0 − 80.0) ÷ 139.0 = 42%
The processor runs out first at 1920 × 1080. The GeForce RTX 4070 could push about 74% more frames than the Ryzen 5 5600 can prepare for it, so roughly 42% of the card sits idle waiting for the next frame to be handed over. Raising the resolution or the settings moves work back onto the card and narrows this.
A faster processor, or faster memory on the one you have, is what moves this number. A bigger card would not.
Bands rather than a decimal, and no frame rate at all: the two columns hold 40 processors and 42 cards as whole index points rounded from published benchmark aggregates, so five points either way is inside the disagreement between the sources themselves. Four things this arithmetic genuinely does not know about are ray tracing, which moves load onto the card and reorders the graphics column; upscaling, which renders at a lower resolution than the one you picked and therefore quietly changes the multiplier; memory speed and timings, worth several index points on the processor side; and simulation engines that lean on one thread far harder than the average of the charts.
How to read a processor and card against each other
Three inputs, and the second one is the one people get wrong.
Choose the two parts by their exact model
The lists are grouped by generation, so a Ryzen 7 5800X3D sits with the rest of Ryzen 5000 and not next to the 7800X3D it is often confused with. Model suffixes matter more here than anywhere else in a build: an X3D part carries a stack of extra cache that is worth more in games than two extra cores, and an F on an Intel part changes nothing at all for this comparison because it only removes the integrated graphics.
Set the resolution you actually play at, not the one your desktop runs
This is the input people get wrong. A 3840 × 2160 desktop with games running at 2560 × 1440 behaves as 1440p for every purpose on this page, and picking the desktop figure will push the verdict a whole band toward the card. If you use an upscaler, choose the internal render resolution it is working at rather than the output size, because that is the resolution the card is genuinely drawing.
Read the band, then read the bar that is shorter
The shorter bar is the ceiling: it is the part that decides your frame rate, and the amber coloring marks it as the one holding the pair back. The percentage beside the band is how much of the longer bar goes unspent, and it is deliberately shown as an approximation — five index points either way is inside the disagreement between the benchmark sources the numbers came from.
Technical specifications
| Processors in the table | 40, covering Ryzen 9000, 7000 and 5000 alongside Core Ultra 200S and Intel's 14th, 13th and 12th generations |
|---|---|
| Graphics cards in the table | 42, covering GeForce RTX 50, 40 and 30, Radeon RX 9000, 7000 and 6000, and two Arc cards |
| Where the scores come from | Relative index numbers rounded to whole points from published benchmark aggregates — not measurements taken by this page, and ±5 points is inside the noise |
| Scale anchor | Ryzen 5 7600 = 100 and RTX 4070 = 100, pinned to each other as a matched pair at 2560 × 1440 |
| Resolution multipliers | The card's index is multiplied by 1.39 at 1920 × 1080, 1.00 at 2560 × 1440, 0.83 at 3440 × 1440 and 0.63 at 3840 × 2160 — frame-rate ratios, not pixel ratios |
| Bands | Balanced under 5%, Mild 5-15%, Clear 15-30%, Severe over 30% of the faster part left unused |
| What the output is | A side and a band. No frames per second, no score out of 100, no grade |
| Deliberately not modeled | Ray tracing, upscaling, memory speed and timings, per-engine threading behavior, and every laptop part |
Frequently asked questions
Is having a bottleneck actually a problem?
Every machine has one, always, and a graphics-limited machine is the healthy outcome. Two parts cannot be exactly equal, so one of them is always the ceiling; the question is only whether the gap is large enough to be worth money. A card at its limit while the processor coasts is what a gaming build is supposed to look like, because the card is the part you can push settings up and down against. The verdict worth acting on is the opposite one: a processor at its ceiling means you paid for graphics performance that is queueing behind frame preparation.
Why does the answer flip when I change resolution?
Because the work the processor does per frame is almost the same at every resolution, and the work the card does is not. Draw calls, physics, animation, AI and streaming decisions happen once per frame whether the output is two megapixels or eight, so the processor's ceiling is a flat line across the whole page. The card is billed per pixel on top of a fixed cost, so raising the resolution lowers its ceiling and moves the limit toward it. That is why the same pair can read as processor-limited at 1920 × 1080 and graphics-limited at 3840 × 2160 without a single part changing.
Why is there no frames-per-second prediction?
Because a frame rate belongs to a specific game at specific settings, and this page has neither. A pair that averages 140 frames in an esports title averages 55 in a heavy open-world one, so any single number printed here would be wrong for almost every reader. What does transfer across games is the ratio between the two parts and therefore which one you would replace, and that is the only thing this calculator claims to tell you.
Does DLSS, FSR or XeSS change the result?
Yes, and it moves it toward the processor every time. An upscaler renders the frame at a lower internal resolution and reconstructs it to the output size, so the card is doing 1280 × 720 or 1706 × 960 of work while the screen shows 4K. Frame preparation on the processor does not shrink to match, which is why turning on an aggressive quality preset can raise the frame rate far less than the pixel saving suggests. Set the resolution control on this page to the internal render size to see it.
My exact processor is not in the list — what should I pick?
Choose the nearest part from the same generation and family, and treat the answer as one band wider than it looks. A locked Intel part sits a little below the K version of the same tier, and a Ryzen non-X below its X sibling, so picking the neighbor above yours and reading the result generously is closer than picking a different generation with a similar number. Laptop parts are the exception and should not be substituted at all: the same model name runs at a fraction of the sustained power in a chassis, so a mobile 4070 behaves nothing like the desktop card of that name.
How much of a gap is worth spending money on?
Under 15 percent, almost never; over 30 percent, usually. A mild reading is smaller than the difference between two driver releases or between a game patched and unpatched, and no upgrade you can buy will make it visible. A severe reading means one part is delivering roughly two-thirds of what the other could use, which is where a replacement changes the frame rate rather than the spec sheet. Between the two, the cheaper fix is usually settings: raising resolution or detail spends the idle processor headroom you already own.
Does memory speed belong in this calculation?
It belongs on the processor side, and it is the single largest thing this page leaves out. Frame preparation stalls on memory far more than on arithmetic, which is exactly why cache-stacked parts sit so far above their core count in the table, and moving DDR5 from 4800 to 6000 with tight timings is worth several index points on a Ryzen 7000 or 9000 build. Mismatched or single-channel memory costs considerably more than that. If a real machine reads worse than this estimate, memory configuration is the first place to look.
About bottlenecks, and why most calculators will not show their arithmetic
A rendered frame is made twice. The processor prepares it — decides what exists, where it has moved, which objects are visible, which textures to stream and what to ask the driver for — and hands a list of work to the graphics card, which turns that list into pixels. The two run in parallel across a queue, so the frame rate settles at whichever of them finishes last, every frame, forever. That is the whole mechanism, and it has one consequence that decides everything else on this page: the preparation cost barely moves when the output resolution changes, because a draw call is a draw call at any size, while the drawing cost climbs with the pixel count. Raise the resolution and you shift the burden onto the card; lower it and you hand the burden back to the processor. Nothing about the hardware changed — only which half finished last.
The scaling is not proportional, and that is the second thing worth knowing before you trust anyone’s number. A 3840 × 2160 frame has four times the pixels of a 1920 × 1080 one, but it does not take four times as long: geometry is transformed once, shadow maps are generated at their own fixed resolutions, and the command stream is identical. Measured across ordinary raster titles the frame rate falls by roughly 28 percent going from 1080p to 1440p and by a little over half going from 1080p to 4K, which is where the multipliers on this page come from. They are applied to the card alone. If you want to see what those multipliers turn into on your own machine, the fps test counts the frames a browser can actually paint, and converting a frame rate into milliseconds makes the difference legible: 60 to 90 frames saves 5.6 ms per frame, while 144 to 165 saves 0.9 ms and is not a purchase.
What almost every calculator in this category gets wrong is not the arithmetic but the refusal to publish it. A page that returns “your system has a 17.4% bottleneck” from an unnamed formula over unnamed data has produced a number with no unit, no source and no way to be wrong, which is why two such sites will happily disagree by twenty points about the same pair. The honest version is smaller and duller: two rounded indices, one multiplier, one subtraction, all four printed. It also means stating what is missing — ray tracing reorders the graphics column, upscaling changes the resolution you should have entered, and memory configuration is worth several points on the processor side. Before you replace anything on the strength of an estimate, it is worth checking what is actually in the machine on the device info page, and if the plan is a larger card, working through the power supply sizing first, since the part that fixes a graphics ceiling is also the part that trips an undersized supply. When the hardware question is settled, the two settings that need carrying between games are mouse sensitivity and field of view, both of which change meaning between engines the way these indices change meaning between resolutions.
Where your part selection goes
Every number on this page is worked out by JavaScript running in the tab you are reading it in. Nothing you type, paste or open is uploaded, logged or kept, which is also why the tools carry on working after you disconnect from the network.
The two dropdowns and the resolution button are read straight into a multiplication and a subtraction in this tab. No build is submitted anywhere, nothing is remembered between visits, and the selection resets to a Ryzen 5 5600 with an RTX 4070 at 1920 × 1080 every time the page opens, because there is no store behind it to remember anything else.