How to Measure FPS in PC Games โ€“ Quick Guide

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

  1. Press Winโ€ฏ+โ€ฏG to launch the bar.
  2. Toggle โ€œCaptureโ€ on if not already active.
  3. Open Settings โ†’ General and turn on โ€œRecord background gameplay clip.โ€
  4. Use the overlay dragโ€‘handle to position the FPS counter where you want it.
  5. 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.

Xbox Game Bar

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.csv from 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.csv in 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 type stat fps.
  • For frameโ€‘time detail, use stat unit to see seconds per frame.
  • stat net can 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 1 combined with thirdโ€‘party loggers.

Unity

  • Press Ctrlโ€ฏ+โ€ฏAltโ€ฏ+ (default) to toggle the console.
  • Enter console.show to bring up the log, then type time.frameTime for perโ€‘frame data.

id Tech (Doom, Wolfenstein)

  • Use +cmd to open console, then type r_measurefps 1.
  • r_showfps 1 adds 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 0 to 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.

Frame 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.

how to measure fps in pc games

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.