How BlazeBench works

Measures: how much number-crunching your processor can keep up using every thread at once.

How: one background worker per logical core runs the same loop of math nonstop (multiplication, square roots, sine and cosine).

Threads − / +

How many workers run, from 1 up to the logical cores your browser reports (some browsers cap this for privacy). The default is all of them. With 1 thread you see single-core speed; with all, the full multi-core power.

Per thread

The score divided by the threads used, shown in the results. Compare it between 1 thread and all threads to see how well your CPU scales.

CPU pressure Chrome & Edge

A live badge from your browser: Nominal (relaxed), Fair (busy), Serious (working near its limit) or Critical (overloaded). It reflects how hard the CPU is pushed and, on some systems, heat and throttling too. During a full CPU test, Serious or Critical is normal: it means the test is doing its job. Lower levels at full load can mean a powerful CPU, while reaching Critical with fewer threads hints at heat or power limits. The results show the highest level reached. Readings only arrive while the tab is focused. It is not a temperature: browsers don't let websites read temperature sensors, for privacy. Firefox and Safari don't support it, so the badge is hidden there.

Ops/s

Loop rounds completed per second by all workers combined. M = million, G = billion.

Live score ops/s ÷ 100,000

Your CPU speed right now. The dial fills toward its right-hand number, which grows if your score goes past it.

Thread activity

One bar per worker, compared with the fastest one. Uneven bars are normal: many chips mix fast and power-saving cores, and the operating system moves work around.

Measures: how many particles your graphics chip can draw per second when fully loaded.

How: renders a particle galaxy at a fixed 1280 × 720, so window size doesn't affect the score. It starts at 100,000 particles and adds 60% more every 1.5 s until the frame rate drops clearly below your screen's refresh rate, then holds that load. If the load turns out too light, it ramps up again.

GPU name and API

Reported by the browser. Some browsers hide or simplify the name. WebGL2 is the default. WebGPU is an option where supported, but scores differ between the two, so compare runs with the same API.

FPS

Frames per second that the GPU actually finished, not just queued.

Frame time ms

Average time between finished frames. Lower is better: 60 FPS ≈ 16.7 ms, 30 FPS ≈ 33 ms.

Particles

The current load. It climbs while the test searches for your GPU's limit.

Score particles × FPS ÷ 20,000

Particles drawn per second. Moments when the browser stalls frames (for example, when the window is covered) are not scored.

No thread setting

The GPU isn't driven by CPU threads. It works through one graphics context, and the test finds its limit automatically by raising the particle count.

Measures: how fast data moves between your processor and RAM (memory bandwidth).

How: a few workers (by default half your threads, at most 8) copy large buffers back and forth. The buffers total 256 MB, bigger than any CPU cache, so the test measures RAM, not cache. If memory is short, the buffers shrink automatically.

Bandwidth GB/s

Gigabytes read plus written per second. Each copy counts its read and its write.

Live score GB/s × 100

Your memory speed right now. The amber bar fills toward a scale that grows if needed.

Buffers

Total memory the test is using. Below 256 MB means the browser couldn't allocate the full amount.

Threads − / +

How many workers copy memory, from 1 to 16. One thread shows how fast a single core can move data. Bandwidth usually stops rising after a few threads, once RAM is the limit.

Thread activity

One bar per memory worker, compared with the fastest one.

Measures: whether your whole computer stays stable and keeps its speed when CPU, GPU and memory are all at full load for a long time.

How: runs all three tests at once for 15, 30 or 60 minutes with their default settings. The parts compete for power, cooling and memory, so each runs slower than on its own page. That's expected, and it's why this test gives a verdict instead of a score.

GPU scene: instead of particles, the Extreme test ray-traces a morphing 3D fractal (a Mandelbulb) with soft shadows, which is much heavier per pixel. It keeps adding full-screen passes, blended for a smoother image, until the frame rate drops, so even fast graphics cards run flat out. Passes in the overlay shows how many it draws per frame.

Verdict

Stable: every part stayed within 10% of its best. Throttling: at least one part ended more than 10% below its best, usually from heat; the result says which part and when. Unstable: the graphics driver reset, or the scene kept stalling.

% of peak

Each bar and line compares a part's current 5-second average with its best one after the warm-up. 100% means it's running as fast as it did at its best.

Performance vs. peak chart

One line per part over the whole test. The dashed line marks a 10% drop, where throttling starts, and dots mark when each part first crossed it.

Not in Overall

Because the parts slow each other down, these numbers aren't comparable with the single tests and don't count toward the overall score.

Measures: how fast your internet connection is: download, upload, ping and jitter.

How: connects to a fast test server near you from a worldwide network. It measures ping first, then download, then upload. Each direction starts with small transfers and moves to bigger ones until a transfer takes about a second, so slow connections use little data and fast ones are still measured properly. It takes about 20–40 seconds and doesn't load your CPU or GPU, so there's no warm-up and no duration to choose.

Download / Upload Mbps

Megabits per second (divide by 8 for megabytes). The result is a high but typical speed across all transfers (the 90th percentile). The dial shows each transfer as it finishes.

Ping ms

Round-trip time to the server while the connection is idle (the median). Lower is better; under 20 ms is excellent, over 100 ms feels laggy in games and calls.

Jitter ms

How much ping varies from one measurement to the next. Low jitter means a steady connection, important for calls and gaming.

Ping while busy

Ping measured during the download and upload. A big rise means your router or line gets congested under load ("bufferbloat"), which causes lag when someone else in the house is streaming or uploading.

Data used

Total test data moved. Usually tens of megabytes, up to several hundred on very fast connections, so be careful on a limited mobile plan.

Why results differ from other tests

Every speed test measures to its own server. Results also depend on Wi-Fi signal, other devices using the connection and the time of day. For the most accurate result, use a cable and pause downloads and streaming.

Measures: a quick, repeatable score for your processor or graphics chip, ranked in a list of everyone's results. Use the CPU / GPU switch at the top to choose.

CPU benchmark: about 30 seconds. First one worker runs alone for 12 s (single-thread, important for everyday speed and many games), then all threads run together for 15 s (multi-thread, important for video editing, rendering and heavy multitasking). The first 3 s of each part are skipped and the middle value (median) of the rest is the score, so short hiccups don't count.

GPU benchmark: renders Blaze Core, a 3D knot of glowing plasma, at a fixed 1280 × 720 with WebGL2, so every device is measured the same way. It starts at 200,000 particles and adds 50% at a time until the particles drawn per second stop rising, then measures for 10 s at the best load.

Single-thread / Multi-thread ops/s ÷ 100,000

Same units as the CPU test. Multi-thread divided by single-thread shows roughly how many cores' worth of speed your CPU delivers.

GPU score particles × FPS ÷ 20,000

Same formula as the GPU test, but a different scene, so the two scores aren't interchangeable.

Results list

Every finished benchmark run is saved anonymously and ranked in a public list, so you can see where your PC stands. Your run is highlighted with You. Browsers don't reveal the processor model, so systems are named by their graphics chip (on Apple Silicon Macs, the chip itself), thread count and OS. Runs that look unreliable aren't saved. Sort the CPU list by multi- or single-thread score.

Unreliable result

Keep the window in front. If it's hidden or the scene stalls, the run stops or is marked as unreliable, and you're asked to run it again.