FPS Test
Runs for 10 seconds and animates continuously.
A game or a scrolling page can feel smooth on paper and still stutter in your hands — average FPS hides exactly the kind of dropped frame that makes something feel janky. This free tool runs a 10-second frame-time measurement right in your browser and reports the numbers that actually explain how something feels: average FPS, the 1% low, frame-time percentiles, a jank count, and your display's inferred refresh rate.
How it works
- Close Anything Else Demanding. Pause downloads, close other demanding tabs and apps, and give this tab focus — background load competes for the same frames this test is measuring.
- Click Start and Let It Warm Up. The first handful of frames are discarded automatically; they're not representative of a freshly-drawn animation settling in.
- Watch the Bar and the Frame-Time Strip. The sweeping bar and the strip beneath it are the exact thing being timed — a visible jump or spike is a real dropped frame, not a display glitch.
- Wait for the 10-Second Measurement. The test runs for a fixed 10 seconds so the 1% low and the percentiles are based on enough frames to be a stable statistic, not one lucky or unlucky moment.
- Read Your Average, 1% Low, and Jank Count. The average is the headline number; the 1% low and jank count are usually the more honest description of how it actually felt.
- Compare Against the Inferred Refresh Rate. Your result is graded relative to your display's inferred cap — 58fps is excellent on a 60Hz screen and mediocre on a 144Hz one.
How This Test Measures Your Frame Rate
Every frame your browser draws goes through requestAnimationFrame, a browser API that calls your code right before the next repaint and hands it a precise timestamp. This test times the gap between consecutive timestamps — that gap is the actual, physical time one frame took to reach your screen, which is a far more honest number than counting how many frames occurred in a second and calling it a day.
- The first several frames are discarded — a freshly-mounted animation, texture upload, and layout settling all make early frames unrepresentative.
- The bar sweeping across the canvas and the frame-time strip below it are drawn from inside the exact same timed loop — what you see IS what's being measured, not a separate animation running alongside it.
- A run lasts a fixed 10 seconds, long enough that a rare stutter shows up as a real statistic rather than getting lost in noise, or dominating a too-short sample.
Average FPS vs. 1% Low vs. Frame Time: What Each Number Means
A single average hides more than it reveals. A run that's silky smooth for nine seconds and freezes for one still averages out to a respectable number — which is exactly why this test reports four different numbers instead of one.
- Average FPS: total frames divided by total time. Easy to read, easy to game with a smooth majority masking a rough minority.
- 1% low: the average frame rate of just the slowest 1% of frames. This is much closer to what you actually feel as "stutter" than the average is.
- Frame time percentiles (p50/p95/p99): how long the typical frame took, versus the frame times only the worst 5% or 1% of frames reached — the spread between them is a direct measure of consistency.
- Jank count: how many frames took meaningfully longer than your display's frame budget — the frames a human eye can actually register as a skip.
What Causes Stutter That Average FPS Hides
A low 1% low or a high jank count with a perfectly fine average almost always points to something intermittent, not a hardware ceiling.
- Background tabs and apps competing for the CPU/GPU, especially anything doing its own rendering or video decoding.
- Browser hardware acceleration turned off, which pushes compositing work onto the CPU alone.
- Outdated or mismatched GPU drivers, particularly after a Windows update.
- Thermal throttling on a laptop — a stutter that gets worse the longer the test or the game runs, then recovers after a break, is a strong thermal signal.
- Power-saving mode capping CPU/GPU clocks, common on laptops running on battery.
- Browser extensions injecting scripts into every page, adding a small but real per-frame cost.
Why the Browser Can't Read Your Refresh Rate (and What "Inferred" Means)
No web API exposes your display's refresh rate directly — there's no navigator.refreshRate to call. What this tool does instead is infer it from the paint cadence itself: when frames arrive smoothly, most of them cluster tightly around one interval, and that interval is almost certainly your display's real frame budget.
- High confidence: the vast majority of frames land within a tight band of one clear interval that matches a common refresh rate (60/75/90/100/120/144/165/240Hz).
- Medium or low confidence: frames are more scattered, either because something was interfering with the test or because your display doesn't hold one steady rate to begin with.
- A result of "couldn't be determined" is itself informative — it usually means either the test was interrupted or your panel uses adaptive sync (see below).
Adaptive Sync: G-Sync, FreeSync, and VRR
Variable refresh rate (VRR) — sold as NVIDIA G-Sync, AMD FreeSync, or just "adaptive sync" — deliberately varies your display's refresh interval to match whatever your GPU is producing, instead of holding one fixed rate. That's a genuine feature, not a fault: it's specifically designed to make an inconsistent frame rate feel smoother by removing the mismatch between the GPU's output and the display's fixed schedule.
On a VRR panel, this test's refresh-rate inference will often, correctly, come back low-confidence — there's no single interval to lock onto, because your display isn't holding one. That's the test working as intended, not a bug. The frame-time statistics above it (average, 1% low, jank) are unaffected and stay meaningful regardless.
Common Fixes: Hardware Acceleration, Cables, and Refresh-Rate Settings
- Windows: Settings → System → Display → Advanced display, and confirm the refresh rate is actually set to your panel's maximum — a fresh driver install or a new cable sometimes silently resets it to 60Hz.
- macOS with ProMotion (120Hz): check System Settings → Displays → Refresh Rate is set to the dynamic/high-refresh option, not a fixed 60Hz.
- External monitor at less than its rated refresh rate: the cable and port matter — a high refresh rate at high resolution needs DisplayPort or a sufficiently new HDMI version, not whatever cable happened to be in the box.
- In-browser: confirm hardware acceleration is enabled in your browser's settings, and try disabling extensions one at a time if jank persists.
- On a laptop: plug in and set the power plan to "best performance" before testing, since battery-saving modes are a common, invisible cap.
What This Test Is Not
This is a frame-time diagnostic, not a GPU benchmark and not a dedicated refresh-rate meter. It deliberately doesn't render a heavy 3D scene to stress your graphics card for a comparable score, and it doesn't claim to read your panel's exact rate the way a dedicated hardware tool can — it infers it from paint cadence, honestly labelled as an inference throughout.
Frequently asked questions
Why does my FPS number change every time I run the test?
Some run-to-run variance is normal — background processes, thermal state, and what else is open all shift slightly between runs. Large swings usually point to something intermittent competing for resources; try closing other tabs and apps and testing again.
What counts as a good FPS?
It depends on your display, not an absolute number — 58fps is excellent on a 60Hz screen but mediocre on a 144Hz one, which is why this tool grades your result relative to your inferred refresh rate rather than a single fixed threshold.
Why does the test show 58 FPS on my 60Hz screen instead of exactly 60?
A couple of frames below the theoretical maximum is completely normal — nothing paints at a mathematically perfect, unwavering interval. It's the 1% low and jank count, not tiny variance around the average, that indicate a real problem.
What is "1% low" and why does it matter more than average FPS?
It's the average frame rate of just the slowest 1% of frames in the run. A high average with a low 1% low means most of the run was smooth but a real, noticeable stutter happened — exactly the kind of thing a single average number hides.
Can this test measure my GPU's real performance?
Not directly — it measures how consistently your browser paints a lightweight canvas animation, which mostly reflects your display pipeline and any competing load, not your graphics card's ceiling under heavy 3D rendering. A dedicated GPU benchmark is a different, heavier tool.
Why can't the browser tell me my monitor's exact refresh rate?
No web API exposes it. This tool infers it from how frames actually arrive, which is why the result is always labelled as an inference with a confidence level, not a direct hardware reading.
Why does my FPS drop when I switch tabs or minimize the window?
Browsers throttle background tabs to save power and CPU, which is exactly why this test aborts and asks you to try again if the tab goes into the background mid-run — a result from a backgrounded tab would be meaningless.
Does this test affect my battery or overheat my device?
No more than any other 10-second animation. It draws a simple 2D canvas, not a heavy 3D scene, and stops automatically once the measurement window ends.
Why do Chrome, Firefox, and Safari show different results on the same computer?
Each browser has its own compositor and scheduling behavior, and extensions, hardware-acceleration defaults, and update cadence all differ between them — some spread is expected, not a sign one browser is broken.
What is jank, exactly?
A frame that took meaningfully longer than your display's frame budget to arrive — long enough that a human eye can register it as a skip or a stutter rather than smooth motion.
This test runs entirely on your device — it draws a canvas animation and times your own browser's frames. No frame data, timing, or result is ever uploaded, transmitted, or stored anywhere.