How to Test Particle System Performance Online

A particle system is one of the most honest ways to push a GPU, because it scales smoothly from “trivial” to “impossible” just by adding more particles. That makes a particle system performance test easy to reason about: you raise the count, watch the frame rate respond, and find the point where your hardware can no longer keep up. This guide walks through what these systems are, how a browser test drives them, and — most importantly — how to read the numbers so you can tell a genuinely smooth result from one that only looks fine at a glance.

What a particle system actually is

A particle system draws a large number of small, independent sprites — points, quads, or tiny textured billboards — that together create effects like smoke, fire, sparks, rain, or magic. Each particle usually carries its own position, velocity, colour, size, and lifetime. Every frame, the system updates all of those values (moving each particle, fading it, recycling dead ones) and then draws every surviving particle to the screen.

The reason this is such a useful stress workload is that the cost grows almost linearly with count. Ten thousand particles is roughly ten times the work of one thousand. There is no clever shortcut the GPU can take, so the frame rate you measure reflects raw throughput rather than a scene’s specific quirks. That predictability is exactly what makes particles a clean benchmark.

What the browser test is doing under the hood

The particle system performance test uses WebGL to run the whole simulation on your GPU. When you increase the particle count, the tool submits more geometry and more per-pixel work each frame, then measures how long each frame actually takes to produce.

It is worth being precise about what the browser can and cannot see. The test can measure timing extremely well: how many frames render per second, how many milliseconds each frame takes, and how consistent those times are. What it cannot read is your GPU’s temperature, its utilisation percentage, how much video memory the scene is using, or how much power the card is drawing. Browsers simply have no API for those hardware sensors. So when a test reports a “workload” or “stress level,” that is the configured complexity it is asking the GPU to render — not a measured percentage of how hard the chip is working. Keeping that distinction in mind stops you from over-reading the results.

Running the test step by step

You don’t need to install anything. The whole thing runs in a browser tab.

1. Open the tool and let it initialise. Launch the particle system performance test and give it a second to create its WebGL context and warm up. The first frames after any change are always slower while shaders compile and buffers allocate, so ignore that initial spike.
2. Start at a modest particle count. Begin low enough that the frame rate is clearly smooth. This gives you a baseline where your hardware is not the bottleneck.
3. Increase the count in steps. Raise the particle count gradually and watch the frame rate at each level. You are looking for the point where FPS starts to fall and frame times start to climb.
4. Let each level settle before reading it. Wait a few seconds at each setting so the numbers stabilise. A reading taken in the first moment after a change is dominated by warm-up, not steady-state performance.
5. Note where it breaks down. The interesting result is the count at which the animation stops feeling smooth. That is your practical ceiling for this browser, on this device, right now.

Run the same sequence in the same browser each time if you want to compare before and after a driver update or a settings change. Comparisons are only meaningful when the conditions match.

Reading the metrics: FPS, frame time, and 1% lows

Three numbers tell you almost everything, and they are far more informative together than any one alone.

Frames per second (FPS) is the headline figure — how many frames finished in the last second. It is intuitive, but it hides variation. An average of 60 FPS can be perfectly smooth or visibly stuttery depending on how evenly those 60 frames were spaced.

Frame time is the same information turned inside out: how many milliseconds each individual frame took. This is the more useful lens, because smoothness is really about consistency between frames, not the average. A steady frame time feels smooth; a frame time that jumps around feels like stutter even at a high average FPS.

1% lows capture the worst frames — roughly the slowest 1% of frame times over the measurement window. This is where hitches, garbage-collection pauses, and momentary overload show up. Two devices can post the same average FPS, but the one with much weaker 1% lows will feel worse to use, because those occasional long frames are exactly what your eye notices as a jolt. When you judge a particle test, weight the 1% lows heavily.

A genuinely good result is a high average FPS with frame times that stay flat and 1% lows that sit close to the average. A poor result is a respectable-looking average FPS undermined by spiky frame times and 1% lows far below it.

What moves the numbers

If you want to understand why the frame rate falls as you push the test — rather than just watching it happen — a few factors dominate.

• Particle count is the obvious one. More particles means more per-frame updates and more draws, and cost rises roughly in step with the count.
• Resolution matters just as much and is easy to forget. Particles are usually transparent and overlap heavily, so the GPU ends up shading the same pixels many times over (this is called overdraw). At a higher resolution — or on a high-DPI display running at native scale — every one of those overlapping fills costs more pixels. The same particle count can run smoothly in a small window and struggle full-screen.
• Blending and transparency add cost because translucent particles must be combined with whatever is already drawn behind them, and that read-modify-write per pixel is more expensive than opaque drawing.
• Particle size interacts with count: large soft particles cover more pixels each, so a few big ones can cost as much fill rate as many small ones.
• Thermal throttling explains a result that starts strong and then sags. Under sustained load a GPU heats up, and to stay within its limits it lowers its clock speeds, which drops FPS even though nothing in the test changed. You can’t see the temperature in the browser, but you can see its effect in a slowly declining frame rate.

The companion explainer on how particle effects affect GPU performance goes deeper into overdraw and fill rate if you want the full picture of where the cost comes from.

A note on running sustained load responsibly

A particle test at high counts applies a real, sustained load to your GPU — that is the whole point of it. Keep a general eye on the device while it runs. Laptops in particular will get warm, so run on AC power and set the machine on a hard, flat surface so its fans can actually pull air; a bed or couch blocks the vents. Phones and tablets have no fans and will throttle quickly, so treat their results as “how this device behaves when hot” rather than a peak figure. There is no danger in a normal test, but if the device gets uncomfortably hot, the fans scream indefinitely, or the screen starts glitching, just stop the test and let it cool. None of this requires opening hardware or changing any physical settings.

Where the particle test fits with other GPU tests

A particle test is strongest at measuring throughput and fill rate under a scalable, transparent-heavy load, but it is not the only tool worth running. For the broader context — what each in-browser GPU test measures and how to combine them — the overview on how to test GPU performance ties the family together. And because these tools ride on the same graphics API, the guide to the WebGL performance test explains the layer that actually drives your GPU from the browser.

Frequently asked questions

How many particles should my device handle?

There is no universal target, and any specific number would be misleading — it depends entirely on your GPU, your display resolution, your browser, and even your current thermal state. The useful approach is relative: find the count where your device stops rendering smoothly, then use that same count as a reference point when you re-test later or compare against another machine.

Why does my FPS drop the longer I run the test?

The most common cause is thermal throttling. Under sustained load the GPU warms up and reduces its clock speed to stay within safe limits, which lowers frame rate even though the workload is unchanged. The browser can’t display the temperature, but a frame rate that slowly declines while everything else stays constant is the classic signature of throttling.

Is a browser particle test as accurate as a native benchmark?

For timing — FPS, frame time, frame-to-frame consistency — a browser test is genuinely accurate, because it measures real rendered frames. Where it can’t compete with native tools is hardware telemetry: it cannot read GPU temperature, utilisation, VRAM, or power draw. So it’s an excellent measure of performance and smoothness and simply not a source of hardware sensor data.

Why is my full-screen result so much worse than in a small window?

Because particles are transparent and overlap, the GPU shades many overlapping pixels each frame. Full-screen (and high-DPI) rendering multiplies the number of pixels for every one of those overlapping fills, so fill-rate cost rises sharply. A high-resolution display can turn a comfortable particle count into a struggling one without changing the count at all.

Do 1% lows really matter if my average FPS is high?

Yes — arguably more than the average. Smoothness is about consistency, and 1% lows expose the worst frames where hitches live. Two systems with an identical average FPS can feel very different; the one with weaker 1% lows will show visible stutter during exactly those slow frames, which is what your eye picks up.

Once you understand the shape of the results, the test becomes a quick way to gauge your graphics throughput. Open the particle system performance test, push the count until it breaks, and read the frame time and 1% lows rather than the headline FPS — that’s where the truth about smoothness lives.