You probably know that FPS numbers can vary wildly depending on the tool you use. Knowing how to measure fps in pc games lets you see the true performance of your hardware and tweak settings for smoother gameplay. This guide walks you through why the numbers differ, how to pick the right method, and the exact steps to get reliable readings.
Our research uses the latest drivers (2026) and common benchmarks to show that builtโin overlays, GPU utilities, and thirdโparty loggers each have a role. Youโll see concrete examples like a 1% low of 58โฏFPS versus an average of 120โฏFPS, and learn how to avoid common pitfalls. Pick the right path, and youโll trust every frame count you capture.
How to Measure Fps in Pc Games
Open the inโgame console and type stat fps for Unreal Engine. Launch Windows Game Bar (Ctrl+Win+G) for a realโtime overlay. Enable RTSS/Afterburner, start PresentMon, and record frame timestamps.
Capture at least 30โฏseconds of steady gameplay for reliable averages. Export CSV and compute 1% low, 0.1% low, and mean FPS.
Why FPS Numbers Differ Across Tools
The first thing to understand is that many factors can change the FPS you see. Each measurement method captures a slightly different moment in the rendering pipeline.
Rendered vs. displayed frames, Some tools report what the GPU produced, others show what the monitor actually refreshed.
VโSync and frame caps, Enabling these adds a wait for the refresh cycle, lowering raw FPS.
Overlay overhead, Overlays like GeForce Experience inject a small performance hit that can shave milliseconds.
Antiโcheat restrictions, Programs such as BattlEye may block certain logging tools, skewing results.
Variable refresh tech, GโSync, FreeSync, and VRR can make FPS fluctuate in ways static tools miss.
Our research notes that a game might report 120โฏFPS on a raw API read, yet a monitor using GโSync only displays 96โฏFPS because of variableโrefresh limits. For deeper insight into how refresh rate works, see the article on variable refresh rate basics. When comparing AMD and NVIDIA solutions, the discussion of GโSync vs.
FreeSync helps to explain these differences in practice.
Measuring FPS isnโt just about opening a counter; itโs about understanding what that number actually represents. By knowing the source of variation, you can choose the right tool and avoid misinterpreting performance.
Choose Your Path: Quick Check vs. Deep Benchmark
Youโll notice two main approaches when you start measuring FPS. A quick check gives you a fast snapshot, while a deep benchmark digs into frameโtime variance for fineโgrained analysis.
Quick Check
- Windows Game Bar, oneโclick overlay, good for onโtheโfly numbers.
- Inโgame counters, built into engines, shows rendered frames only.
- GPU vendor overlays, RTX HUD, Radeon Overlay, quick stats without extra software.
Deep Benchmark
- RTSS/Afterburner + PresentMon, records raw timestamps, captures 1% lows.
- OCAT / FrameTime Analyzer, creates visual graphs of frameโtime spikes.
- Manual CSV export, lets you compute custom percentiles with spreadsheet tools.
Use a quick check when you want to verify that a setting change raises FPS. Choose a deep benchmark when you need to compare hardware or prove that a frameโtime spike is gone. If you are picking a new monitor, the discussion of monitor resolution can show why deeper data matters for highโrefresh panels.
Below is a simple comparison table to guide your first choice.
| Feature | Quick Check Tools | Deep Benchmark Tools |
|---|---|---|
| Setup time | <โฏ2โฏminutes | 10โ15โฏminutes |
| Accuracy (1% low) | ยฑ5โฏ% | ยฑ1โฏ% |
| Realโtime overlay | Yes | No (postโrun) |
| CPU/GPU overhead | Minimal | Moderate |
| Ideal for | Onโtheโfly tweaks | Review, publishing, tuning |
Choosing the right tier saves time and ensures you get the data you need without unnecessary complexity.
Easy Tier: Windows Game Bar and GPU Vendor Overlays
If you want a fast, reliable FPS readout without extra software, Windows Game Bar and the builtโin GPU overlays are the way to go. They integrate directly with the OS and most modern GPUs.
Enable and configure Windows Game Bar
- Press Winโฏ+โฏG to launch the bar.
- Toggle โCaptureโ on if not already active.
- Open Settings โ General and turn on โRecord background gameplay clip.โ
- Use the overlay dragโhandle to position the FPS counter where you want it.
- Set a hotkey (default Winโฏ+โฏAltโฏ+โฏR) for instant toggling.
Use NVIDIA GeForce Experience overlay
- Open GeForce Experience, go to Settings โ Preferences โ InโGame Overlay.
- Enable โShow FPS Counterโ.
- Choose position (usually bottomโleft).
- Disable โDetect Game Modeโ if you need raw GPU frames.
Use AMD Radeon Software overlay
- Launch Radeon Software, navigate to Gaming โ Global Settings.
- Turn on โOverlayโ and select โFPS Displayโ.
- Adjust the overlay position to avoid HUD clash.
Tips for accurate readings
- Turn off VโSync before you start; otherwise youโll measure the display refresh, not the GPU output.
- Close background apps that consume CPU cycles; they can cause frameโtime spikes.
- Update drivers (2026 releases) to get the most stable overlay performance.
- Disable any competing overlays like Streamlabs; they can conflict with the swap chain.
These steps give you a clean, immediate FPS display thatโs perfect for daily play or quick validation of settings.

Image source: Wikimedia Commons / Vincent Diamante from Los Angeles, CA, USA (CC BYโSA)
Pro Tier: RTSS, MSI Afterburner, and Frame-Time Loggers
When you need precise, researchโgrade data, tools like MSI Afterburner with RivaTuner Statistics Server (RTSS) and frameโtime loggers such as PresentMon or OCAT are the standard. They let you capture raw timestamps, generate graphs, and export statistics for analysis.
Install and set up RTSS
- Download MSI Afterburner from the manufacturer site and install.
- During setup, check the box to install RivaTuner Statistics Server.
- Launch RTSS and go to Settings โ Monitoring.
- Enable โGPU core clockโ, โMemory clockโ, and โPower consumptionโ if you want hardware metrics alongside FPS.
- Add a custom hotkey (default Altโฏ+โฏShiftโฏ+โฏM) to toggle the onโscreen display.
Configure FPS and frameโtime display
- In RTSS Display tab, check FPS and Average FPS.
- Enable Overlay โ Show FPS in the corner of your screen.
- Add a second overlay for Frame Time (ms) to see individual spike values.
Use PresentMon for precise capture
- Download the latest PresentMon release from the Microsoft PresentMon tool.
- Run
PresentMon -capture -output measure.csvfrom a command prompt while the game runs. - PresentMon records timestamps from DXGI, D3D12, and Vulkan swap chains, giving you lowโlevel data.
Export and analyze
- Open
measure.csvin Excel or a tool like Python pandas. - Compute 1% low, 0.1% low, mean FPS, and standard deviation.
- Create a simple line chart of Frame Time (ms) to spot stutter events.
Common pitfalls to avoid
- Antiโcheat blocking, some games blacklist RTSS; test in a nonโcompetitive title first.
- Injection lag, ensure the injection method matches the gameโs graphics API (D3D11/12, Vulkan, OpenGL).
- Driver mismatch, keep your GPU driver up to date; older drivers can misreport clocks.
- System load, close background processes, especially Windows Update or background games.
By combining RTSSโs realโtime overlay with PresentMonโs raw capture, you get both instant feedback and deep data for every tuning session.
If you ever feel stuck configuring these tools, the article on assembly tips offers practical guidance that applies equally to software setup.
Game-Specific Counters and Engine Debug Commands
Each game engine exposes its own FPS measurement method, often hidden behind a console or debug menu. Knowing these commands lets you capture the exact metric the developers intended.
Unreal Engine
- Open the console (
~by default) and typestat fps. - For frameโtime detail, use
stat unitto see seconds per frame. stat netcan show serverโclient latency if you are testing online play.
Source Engine (e.g., CS:GO, TF2)
- Press ““
(backtick) and entercl_showfps 1` for a simple counter. - For frameโtime, use
cl_showpos 1combined with thirdโparty loggers.
Unity
- Press
Ctrlโฏ+โฏAltโฏ+(default) to toggle the console. - Enter
console.showto bring up the log, then typetime.frameTimefor perโframe data.
id Tech (Doom, Wolfenstein)
- Use
+cmdto open console, then typer_measurefps 1. r_showfps 1adds a onโscreen display with milliseconds.
Valveโs Action games (Steam)
- Enable the Developer Console in Settings โ InโGame โ Enable Developer Console.
- Use
fps_max 0to remove the cap before measurement.
Below is a quick reference table to keep handy when you switch games.
| Engine | Inโgame command | What it shows |
|---|---|---|
| Unreal | stat fps |
Average FPS |
| Unreal | stat unit |
Seconds per frame |
| Source | cl_showfps 1 |
FPS counter |
| Unity | console.show + time.frameTime |
Frameโtime in ms |
| id Tech | r_measurefps 1 |
FPS measurement |
| Valve (generic) | fps_max 0 + cl_showfps 1 |
Uncapped FPS counter |
When you need to tweak Windows settings that affect performance, the guide on Windows settings that affect gaming performance explains which options to adjust before you start logging.
Our research shows that using engineโspecific counters reduces the overhead introduced by thirdโparty tools, giving you the purest measurement possible.
For timestamp calibration and bestโpractice benchmarking, the NIST time and frequency division resources provide standards that align well with the frameโtime units youโll be recording.
Now you have a full toolkit: quick checks, deep benchmarks, engine commands, and the knowโhow to interpret the numbers. The next sections will walk you through avoiding mistakes and matching the right tool to your specific use case.
Run a Clean, Repeatable Benchmark
A reliable benchmark needs more than just a tool. You need a controlled environment, a fixed scene, and a repeatable process. Without these, your numbers will drift and become useless for comparison.
Start by closing every background app. Windows Update, cloud sync, and chat clients can steal CPU cycles. Open Task Manager and end anything that is not essential.
Next, disable power-saving modes. Set your GPU to maximum performance in the NVIDIA Control Panel or AMD Software. This prevents clock throttling during the run.
In the game, pick a scene that is representative but stable. A busy street with lots of traffic works well. Avoid scenes with heavy physics or particle effects.
Turn off motion blur and depth of field. These add variable load that makes frame times jump around.
Configure your capture tool for a fixed duration. In PresentMon, use the -timer flag to run for exactly 60 seconds. In RTSS, set the overlay to record to a CSV file.
Make sure the file path is on a fast drive, not a network share.
Run the benchmark twice. The first run warms up the CPU and GPU. The second run gives you clean data.
After the run, open the CSV in a spreadsheet. Calculate the average FPS, the 1% low, and the 0.1% low. Plot the frame times to spot spikes.
A good benchmark also notes the hardware state. Record the GPU clock, memory clock, and temperature. This helps you see if the numbers are stable or if the card is throttling.
For timestamp accuracy, align your capture tool with the NIST time and frequency division standards. This ensures your frame-time measurements are traceable and consistent across different systems.
| Parameter | Recommended Setting |
|---|---|
| Duration | 60โ120 seconds |
| Scene | Fixed, no camera movement |
| VโSync | Disabled |
| Frame cap | Removed |
| Background apps | Closed |
| GPU power mode | Maximum performance |
When you analyze the data, focus on the 1% low FPS. This number tells you about the worst frames, which cause stutter. A 1% low that is less than 60% of the average indicates a problem.
Compare your results with online databases to see if your hardware is performing as expected.
Document every run in a simple log. Note the game version, driver version, and any overclocks. This makes it easy to reproduce results or track changes over time.

Image source: Wikimedia Commons / RobinColclough (CC BY-SA)
Mistakes That Skew Your Results
Even with the right tools, simple errors can make your FPS numbers useless. Knowing these pitfalls helps you avoid them before you start capturing.
- Leaving VโSync on, VโSync caps the frame rate to the monitor refresh. You will measure the display limit, not the GPU output. Disable it in the game and driver settings.
- Using multiple overlays, Running GeForce Experience, Windows Game Bar, and RTSS at the same time causes injection conflicts. Choose one overlay per session.
- Ignoring background processes, Windows Update, antivirus scans, and cloud backup can spike CPU usage. Close them or schedule them for after your benchmark.
- Antiโcheat interference, Games with BattlEye or Easy AntiโCheat may block RTSS or PresentMon. Check the gameโs whitelist or use an inโgame counter instead.
- Incorrect injection method, D3D9 games need a different hook than D3D12 or Vulkan. Using the wrong method adds overhead and skews frame times.
- Not warming up the hardware, Cold GPUs run at lower clocks. Run the game for two minutes before you start recording to stabilize temperatures.
- Forgetting to disable frame caps, Many games have an internal FPS limiter. Set it to off or an extremely high value so it does not interfere.
- Using a slow storage drive, If your capture tool writes to a HDD, the I/O wait can add latency. Use an SSD or NVMe drive for log files.
- Clock drift, Your system clock may not be synchronized. Use an NTP service or the NIST time and frequency division reference to keep timestamps accurate.
- Wrong API selection, Some tools only support DirectX 11. If your game runs on Vulkan, use a compatible logger like OCAT or PresentMon.
Each of these mistakes can shave frames or add milliseconds. By eliminating them, you get a clean signal that reflects only the game and your hardware.
Decision Guide: Match Tool to Situation
Choosing the right FPS tool depends on your goal, your hardware, and the game you play. Answer these questions to find the best match.
What is your primary goal?
- If you want a quick sanity check while gaming, use Windows Game Bar or the GPU vendor overlay. They install in seconds and show a number on screen.
- If you need to compare hardware or publish results, use RTSS with PresentMon or OCAT. These tools export CSV files that you can analyze with spreadsheets.
How deep does the data need to be?
- For a simple average FPS, any overlay works.
- For frameโtime analysis, 1% lows, and spike detection, use a logger that records timestamps. PresentMon and OCAT both provide this.
Does the game have antiโcheat?
- If yes, check if the tool is whitelisted. BattlEye and Easy AntiโCheat often block injection tools. If blocked, use an inโgame counter or the engine console command.
What graphics API does the game use?
- DirectX 11/12, RTSS and PresentMon work well.
- Vulkan, use OCAT or the latest PresentMon build.
- OpenGL, FRAPS or Special K are reliable.
Are you using a laptop with Optimus?
- If yes, the iGPU may handle the overlay. Use a tool that can force the discrete GPU, or measure with an external capture card.
Do you need realโtime feedback?
- If yes, stick with an overlay.
- If no, postโrun analysis with CSV export gives you more flexibility.
Below is a quick reference table.
| Scenario | Recommended Tool |
|---|---|
| Quick check, no install | Windows Game Bar |
| NVIDIA GPU, realโtime stats | GeForce Experience overlay |
| AMD GPU, realโtime stats | Radeon Software overlay |
| Deep benchmark, frameโtime | RTSS + PresentMon |
| Antiโcheat game, no overlay | Inโgame console (stat fps) |
| Vulkan game, detailed log | OCAT |
| Laptop Optimus, accurate FPS | External capture card or mangohud on Linux |
If you are on Linux, tools like mangohud and goverlay provide similar functionality without the Windows overhead. For monitors above 240 Hz, use a tool that can capture at least 1000 frames per second to avoid missing spikes.

Image source: Wikimedia Commons / ๆๅฎขๆนพGeekerwan (CC BY)
Follow this guide and you will spend less time guessing and more time tuning.
Frequently Asked Questions
What is the difference between FPS and frame time?
FPS is the number of frames displayed each second. Frame time is the duration in milliseconds to render one frame. A high FPS with high frame time variance feels choppy, while a lower but steady FPS feels smooth.
How often should I measure FPS?
Measure after every major change. This includes driver updates, game patches, or graphics setting adjustments. For routine checks, once a month is enough to catch regressions.
Can the measurement tool itself lower my FPS?
Yes. Overlays inject code into the rendering pipeline. This adds a small overhead, usually 1-3 FPS.
For precise numbers, disable VโSync and use a lightweight tool like PresentMon.
What is a good 1% low FPS?
A good 1% low is at least 60% of the average FPS. If your average is 120 FPS, a 1% low above 72 FPS indicates consistent performance. Below that, you may experience stutter.
How do I measure FPS in a game that has no builtโin counter?
Use a thirdโparty overlay like RTSS or the Windows Game Bar. If the game uses antiโcheat that blocks overlays, run a benchmark tool such as PresentMon from outside the game directory.
What is the best way to compare FPS across different games?
Use the same capture tool and settings for every game. Record the average FPS, 1% low, and frameโtime standard deviation. Publish these numbers in a consistent format so readers can compare directly.
2 thoughts on “How to Measure FPS in PC Games โ Quick Guide”
Comments are closed.