Same Mac, five browsers, five scores

A Mac Studio with an M4 Max scored 10,630 on our benchmark at an Apple Store. The MacBook Pro that tested it — an older M2 Max — had scored around 12,900 at home. The newer, bigger chip lost by 18%, and the obvious suspects (36 GB of RAM vs 96, an idle demo unit vs a working dev machine) explain none of it.

So we ran one machine — that same M2 Max, same display, same afternoon — through five browsers:

Same silicon, same screen, a factor of two between best and worst. The per-scene numbers are stranger than the totals. Our raymarching scene, Liquid Chrome, held 25,523 units in Safari and 5,622 in Firefox — on the same GPU. Canvas 2D circles: 64,476 in Opera, 9,960 in Firefox. Our CPU physics scene ran 29% faster in Safari than in any Chromium browser, because JavaScriptCore likes that code more than V8 does.

And the store result turned out to be the same story wearing a different hat. On Safari, an M2 Max held 25,523 units of the raymarcher — but the store’s M4 Max held 6,222, and an M5 Pro 2,628. Same browser, same scene, newer and faster GPUs doing four to ten times worse. The shader had a 180-iteration loop, and some combination of newer GPU generations and the Metal compiler choked on it while older ones didn’t. That scene wasn’t measuring fragment throughput anymore. It was measuring compiler luck.

What a browser benchmark honestly measures

The number this site produces is not a chip rating. It is a measurement of the whole stack you actually use: silicon, driver, shader compiler, JavaScript engine, canvas rasterizer, compositor. That is a feature — it’s the performance you get when you open a page — but it means two rules matter when you compare:

Compare within one browser. A score from Safari and a score from Chrome are measurements of two different stacks that happen to share a chip. Our top-scores board has named the browser on every row for a while; now the results sheet also shows the same hardware’s median per browser, once enough samples exist.

A benchmark should not amplify the stack’s quirks. The stack being part of the measurement is honest. One scene collapsing 10× because a compiler dislikes a loop shape is not — that’s the benchmark being fragile, and it’s ours to fix.

What changed in benchmark 2.3.0

The raymarcher now draws in small passes. Instead of one shader looping to 180 samples, Liquid Chrome accumulates repeated four-sample passes — the same sample positions, the same total work, arithmetic unchanged to the digit. A four-iteration loop is the kind of shader every engine compiles well; whether that brings the newest Apple GPUs back to the fragment-rate trend is what the next store visit will show. Firefox didn’t move — 5,622 on the new shader too — because its cost is in the work each sample does, not the loop around it, and fixing that would change the workload itself.

One sustained budget for every display. Real vsync timestamps turn out to be messier than the tidy model we shipped in 2.2.0, and machines on fixed-rate displays were quietly allowed a ~9% softer sustained frame budget than adaptive-sync laptops. Everyone now answers to the same 17.5 ms trimmed mean.

Cold starts stopped producing garbage. First runs in a fresh browser used to be brutal: a store demo Mac scored 77, then 8,553 minutes later; our own first Safari runs at home read 304 and 1,149 before an 11,443. Three fixes: the benchmark now checks whether your machine is busy before spending three minutes, waits out first-visit shader-compile jank per scene, and gives a scene that measured nothing one more attempt at the end of the run if the machine has gone quiet. Nothing is invented — a retry is just a second measurement.

Flags tell the truth now. A run whose every scene measured, but where one level couldn’t be confirmed three windows in a row, used to be floored off the board entirely. Our production data shows those levels sit about 13% below what steady devices measure — that’s struggling hardware being honest, not a number being gamed — so they now publish with a flag, and each scene badge says exactly which of three things happened.

And results travel. Copy link now packs the whole result — score, per-scene loads, frame times, flags — into the link itself. Nothing is uploaded; open it anywhere and it renders read-only. If you ever benchmark a computer you don’t own, you no longer need to photograph the screen. We know. We photographed a lot of screens.

Scores from 2.3.0 never mix with older versions, so the board starts fresh. If you want the long version of how measurement works — the frame-time windows, the load ladder, what can invalidate a run — the methodology page has all of it. Or just run the thing: it takes about three minutes, and now it tells you up front if your machine isn’t in the mood.