Gaming FPS & Frame Time Calculator
Convert FPS to frame time in ms (1000 / FPS) and back, get 1% and 0.1% lows from a pasted frame-time log, check a G-Sync/FreeSync VRR window and FPS cap, and compare CPU vs. GPU frame budgets.
Use the Gaming FPS & Frame Time Calculator
Bidirectional FPS & Frame Time Converter
Convert between frames per second (FPS) and milliseconds per frame (ms = 1000 / FPS).
Range: 1.0 to 1000.0 FPS
Range: 1.0 to 1000.0 ms
Must be less than or equal to Average FPS.
Common Cadence Targets
Conversion & Pacing Output
Average Frame Time
16.67 ms
1000 / FPS
Average Rate
60.0 FPS
1000 / ms
1% Low Frame Time
—
1000 / 1% Low FPS
Stutter Ratio (Low FT / Avg FT)
—
1.00x = equal reported rates
Display Refresh Interval & Alignment
Compare display scan-out intervals against application delivery rate.
Range: 24 to 500 Hz
Range: 1 to 1000 FPS
Standard Display Standards
Scan-Out & Pacing Diagnostics
Display Scan Interval
6.94 ms
1000 / Refresh Rate
Rendered Frame Time
8.33 ms
1000 / Observed FPS
VRR Window (G-Sync / FreeSync) & FPS Cap
VRR maximum (Hz)
= Display Refresh
The minimum is in the monitor spec or driver panel (often 48 Hz; 1 Hz for G-Sync module displays).
Average FPS, 1% Low & 0.1% Low from a Frame-Time Log
Paste the frame-time column (MsBetweenPresents in PresentMon / CapFrameX, frametime in MangoHud, or an OCAT/RTSS export). Numbers can be separated by new lines, commas, spaces or semicolons; header text is ignored.
Percentiles use the nearest-rank method on frame times. "Low average" is the mean of the slowest 1% (or 0.1%) of frames, at least one frame. Analysis runs in your browser; nothing is uploaded.
Log Summary
Average
—
FPS
1% Low
—
FPS (P99)
0.1% Low
—
FPS (P99.9)
Pipelined Frame Time Budget (CPU vs. GPU)
Inspect measured CPU and GPU execution times. Modern graphics run concurrently in pipelined stages: effective throughput is governed by max(CPU, GPU), not their sum.
Target budget: 1000 / Target FPS (e.g. 144 FPS = 6.94 ms)
Game logic, physics & draw submission
Geometry, shading, post-processing
Bottleneck model is simplified. Pipeline overlap allows concurrency across frames, but deep render queues introduce input latency when the CPU runs ahead of a GPU-bound stage.
Budget Analysis Results
Target Budget Limit
6.94 ms
at target rate
Pipelined Frame Time
7.80 ms
max(CPU, GPU)
FPS to ms Chart (Frame Time = 1000 / FPS)
| FPS / Hz | Frame time | Where you see it |
|---|---|---|
| 24 | 41.67 ms | Film cadence |
| 30 | 33.33 ms | Console performance floor, 30 FPS cap |
| 40 | 25.00 ms | 40 FPS mode on 120 Hz TVs (3 refreshes per frame) |
| 45 | 22.22 ms | Half of 90 Hz (VR reprojection) |
| 48 | 20.83 ms | Common FreeSync minimum |
| 50 | 20.00 ms | PAL video, 100 Hz half rate |
| 60 | 16.67 ms | 60 Hz monitors and TVs |
| 75 | 13.33 ms | Entry high-refresh monitors |
| 90 | 11.11 ms | VR headsets |
| 100 | 10.00 ms | 100 Hz ultrawides |
| 120 | 8.33 ms | 120 Hz TVs, consoles, laptops |
| 144 | 6.94 ms | Most common gaming monitor |
| 165 | 6.06 ms | 165 Hz monitors |
| 180 | 5.56 ms | 180 Hz monitors |
| 200 | 5.00 ms | 200 Hz ultrawides |
| 240 | 4.17 ms | Competitive esports monitors |
| 280 | 3.57 ms | 280 Hz overclocked panels |
| 360 | 2.78 ms | 360 Hz esports panels |
| 480 | 2.08 ms | 480 Hz OLED panels |
| 500 | 2.00 ms | 500 Hz panels |
| 1000 | 1.00 ms | 1 ms frame time |
Pipeline note: The refresh interval is only one part of input latency. A higher frame rate can still lower latency on a fixed-refresh display because each scan-out shows a newer frame, but without sync it tears.
How 1% Lows and VRR Limits Are Calculated
Average FPS = number of frames ÷ capture seconds = 1000 ÷ mean frame time. Worked example: 99 frames at 10 ms plus one 50 ms hitch take 1,040 ms, so the average is 100 ÷ 1.04 s = 96.15 FPS.
1% low (P99) sorts frame times and takes the one at rank ⌈0.99 × n⌉, then converts it to FPS. In the example that frame is 10 ms, so the P99 low is 100 FPS: one hitch in 100 frames is not enough to move a percentile. 1% low average averages the slowest 1% of frames instead (here the single 50 ms frame) and gives 20 FPS. Use captures of at least 1,000 frames (10,000 for 0.1% lows) and report the method.
VRR window: a 48–144 Hz FreeSync panel follows any frame time between 1000/144 = 6.94 ms and 1000/48 = 20.83 ms. Below 48 FPS, LFC shows each frame ⌈48 ÷ FPS⌉ times (40 FPS → 2× → 80 Hz). LFC needs max ≥ 2 × min. Above the maximum, the display falls back to V-Sync or tearing, which is why caps sit a few FPS below the refresh rate.
Summary
A deterministic frame timing utility for gaming and real-time graphics. Convert between frames per second (FPS) and milliseconds per frame, compute average FPS, 1% lows and 0.1% lows from a pasted PresentMon / CapFrameX / MangoHud frame-time log, check whether a frame rate sits inside a variable refresh rate (VRR) window with low framerate compensation (LFC), pick an FPS cap below the refresh rate, and analyze measured CPU and GPU times against a target frame budget.
How it works
- Frame time and FPS are reciprocals: frame time (ms) = 1000 / FPS, and FPS = 1000 / frame time (ms). 144 FPS = 6.94 ms; 16.67 ms = 60 FPS.
- Average FPS from a log is time-weighted: frames ÷ total seconds = 1000 ÷ mean frame time. Averaging the per-frame FPS values instead overstates it.
- 1% low is reported two ways: the 99th-percentile frame time converted to FPS, and the mean of the slowest 1% of frames converted to FPS. 0.1% low uses the 99.9th percentile.
- A VRR display (G-Sync, FreeSync, HDMI VRR) follows the frame rate between its minimum and maximum refresh. Below the minimum, LFC repeats each frame when max ≥ 2 × min.
- The frame-time budget tool compares measured CPU and GPU times with max(CPU, GPU), because the two stages run in parallel on different frames.
Use cases
- Convert benchmark frame rates (FPS) into exact frame durations (ms) for pacing and latency analysis.
- Paste a frame-time column from PresentMon, CapFrameX, MangoHud or OCAT to get average FPS, 1% low, 0.1% low and stutter counts.
- Check whether a game's frame rate stays inside a monitor's FreeSync / G-Sync range and whether LFC covers drops below it.
- Choose an FPS cap a few frames below the refresh rate so VRR stays engaged and V-Sync latency is avoided.
- Identify whether a rendering loop is CPU-bound or GPU-bound using measured execution times.