How I estimate FPS from Steam system requirements (and where it goes wrong)

Patrick — Mon, 02 Nov 2026 01:22:21 +0000

Steam's system requirements answer one question: will the game start. They don't tell you if you'll get 30 FPS or 120. I wanted a number, for every game in my library, without running a benchmark tool. So I built a model that turns the requirements into an FPS estimate. This post is about how that model works, and mostly about the places where it was wrong (I know Steam is working on an integrated feature like that).

The basic idea: requirements as anchors

Every game page on Steam lists a minimum and usually a recommended graphics card. I treat those as two measuring points:

Recommended spec ≈ 45 FPS at 1080p High
Minimum spec ≈ 40 FPS at 1080p Low

Every graphics card gets a performance score on a PassMark-like scale (G3D). Then the FPS for your card is the anchor FPS times the ratio between your card and the required one:

js
const GPU_EXP = 1.5;
const REC_FPS = 45, MIN_FPS = 40;
const PRESET_FROM_HIGH = { low: 1.8, medium: 1.35, high: 1.0, ultra: 0.78 };

const fromRec = REC_FPS * Math.pow(myGpu / recGpu, GPU_EXP);
const fromMin = (MIN_FPS / PRESET_FROM_HIGH.low) * Math.pow(myGpu / minGpu, GPU_EXP);
const high1080 = (fromRec + fromMin) / 2;

Why the exponent 1.5 and not 1? Because a linear ratio underestimated fast cards badly. A card with twice the score of the recommended one doesn't get 90 FPS, it usually gets more, since the game is designed around the recommended card and anything above it has headroom. With 1.5, twice the score gives about 127 FPS at High, which matched benchmarks much better.

From there it's multiplication: presets (Low ×1.8 up to Ultra ×0.78 relative to High), resolution, upscaling.

The CPU is a separate ceiling

The processor doesn't scale FPS the same way. A faster CPU doesn't double your frame rate, it raises the ceiling. So the CPU gets its own estimate with a much flatter curve:

js
const cpuFps = 110 * Math.pow(myCpu / recCpu, 0.5);
const fps = Math.min(gpuFps, cpuFps, gameFrameCap);
const bottleneck = cpuFps < gpuFps ? 'CPU' : 'GPU';

Whichever is lower wins, and that's also how the site tells you what's holding you back. If the game has its own frame cap (Elden Ring locks to 60), that's the third limit.

Some games just don't start

Before any of the math, there are hard checks that return 0 FPS:

the game requires ray tracing hardware and your card has none
the game needs Vulkan or DirectX 12 and your card doesn't support it
the game needs AVX or AVX2 and your CPU lacks it

These were the cases where users were most annoyed. "Runs at 45 FPS" for a game that crashes on launch is worse than no number at all.

Parsing requirement strings is half the work

Requirements look like this in the wild:

NVIDIA GeForce GTX 1060 6GB / AMD Radeon RX 580 8GB or better
DirectX 11 compatible card with 2 GB VRAM
Intel HD 4000 (performance mode) / GTX 960
GT 1060 (that card doesn't exist, it's a GTX 1060)

So there's a normalizer that maps hundreds of spellings to a known card, picks the stronger card when two are listed, and marks a requirement as "inferred" when it only names VRAM or a DirectX version. Laptop chips get their own handling too, because a "GTX 1060" and a "GTX 1060 Mobile" are not the same card. When people type a GPU the site doesn't know, it gets logged, and I add it from PassMark data. That list is still growing every week.

Where the model was wrong: publisher specs

The biggest error source isn't the math. It's the requirements themselves. Publishers write them at launch, sometimes way too high, sometimes way too low.

Kingdom Come: Deliverance II was my worst case. The site showed around 46 FPS for an RTX 4080 at 1440p Ultra. Notebookcheck measured 105.5. The game simply runs much better than its specs suggest.

The fix is a per-game correction factor, fitted against published benchmarks (TechSpot, Notebookcheck, ComputerBase, PCGH and others). For each benchmark result I compute the model's estimate for the same card, resolution and preset, and the correction is the geometric mean of the ratio. I only accept a new factor when:

at least two sources agree (spread no bigger than 1.8×), or
one source has 20+ data points and the change is above 10%

That rule threw out a lot of tempting single-source corrections. For KCD II the typical error went from 124% to 15%. Right now the model is checked against a bit over 4,000 published benchmark results.

Where the model was wrong: weak integrated graphics

Someone on Reddit with an old laptop (i3-6006U, Intel HD 520) told me some games "will definitely work but run awfully". He was right. Dota 2 showed 70 FPS at 1080p Medium. Notebookcheck measures around 26 FPS on that chip at 1080p High.

I pulled about 2,300 usable Notebookcheck results for weak integrated GPUs (HD 520/620, UHD 620/630, Iris Xe, Vega 8/11) and compared them to the model. With the 1.5 exponent it was off by a typical factor of 1.81. Old games came out 2 to 3 times too high, games with modern minimum specs 1.5 to 2 times too low.

The curve on weak iGPUs is simply flatter. So weak integrated graphics now use an exponent of 1.0, blending back to 1.5 for stronger chips like the Steam Deck or the 780M, so there's no jump at the edge:

js
const gExp = !gpu.igpu ? 1.5
: 1.0 + 0.5 * clamp(Math.log(gpu.score / 3000) / Math.log(1.5), 0, 1);

That brought the typical error down to 1.16 after per-game factors. Dota 2 on the HD 520 now shows 29 FPS at High instead of 52.

Player reports, but carefully

Players can submit the FPS they actually get. That sounds like the best data source, but it has traps. A lot of people run V-Sync or a 60 FPS cap, so "60" often means "at least 60". Those reports are marked as capped and can only raise an estimate, never lower it. Single reports for big 3D games are not trusted on their own, I check those against benchmarks first.

Stack

The estimation runs in the browser, so checking a whole Steam library doesn't need a server round trip per game. The backend is a Cloudflare Worker with a D1 database that fetches and caches requirements from Steam's store API.

What's still open
Source engine games (Left 4 Dead 2, Garry's Mod) are probably still too high on weak integrated graphics, but I have no measurements to correct them with.
Within one game, different GPU families still scatter. A per-GPU-family factor would be the next step.
Publisher specs for brand new games are the least reliable part, and there are no benchmarks yet when people care most.

If you want to try it: doesitrun.com. If a game is way off for your hardware, I'd honestly like to know, that's how most of the fixes above started.

DEV Community: Patrick

How I estimate FPS from Steam system requirements (and where it goes wrong)