How does the DeadTier test work?

What happens in the minute after you press the button: the screen’s refresh rate, every processor core running the same maths loop, twenty thousand moving shapes timed frame by frame, and how those become one score and a tier.

DeadTier runs entirely in your browser. Nothing is installed, and nothing about the device is looked up: every number on the results screen comes from code that runs on the device while you watch. This page walks through what that code does, in the order it does it.

Before it starts: what are you testing?

The test asks whether the device is a phone, a tablet, a laptop or a desktop, and it will not start without an answer. The browser makes a guess first — from things like the screen size, whether there is a touchscreen and whether a battery is reported — and the button names that guess: “Test my phone”, “Test my laptop”. If it is wrong, you tap the right one. The answer matters because the tier at the end compares your device with others of the same type. A score that is excellent for a phone is ordinary for a desktop.

If the browser can tell that a charger is plugged in, a note says so before you start, because charging changes how fast a battery device is allowed to run. Some browsers cannot tell, and then the note is a general reminder instead.

Step one: the screen

For the first two and a half seconds, the test counts how often the browser gets to draw a new frame. A browser can only draw when the screen refreshes, so the time between frames gives the refresh rate. The test uses the median of those gaps rather than the average, so one slow frame cannot drag the answer down. A 60 Hz screen draws a new frame about every sixteen milliseconds; a 120 Hz screen, twice as often.

What this measures is the rate the screen is running at right now, which is not always the number on the box. Battery saver, a display setting or the browser itself can hold a faster screen at 60.

Step two: the processor

Next, the test starts one worker for every processor core the browser reports. A worker is a separate thread, so all the cores run at the same time. Each one works through the same loop of arithmetic — sines, square roots and remainders — and counts how many operations it completes. They run for three passes of five seconds with a short pause between them, and the score comes from the middle pass rather than the average, so a single pass disturbed by a notification or a background task does not decide the result.

The CPU score is a count of work done: bigger is more. It grows with both the speed of each core and the number of cores. Because every worker reports separately, the test also keeps the gap between the fastest and the slowest. Many phone chips mix fast and slow cores, and a wide gap is strong evidence of that. The browser does not choose which core a worker runs on, though, so it is evidence rather than a reading of each core.

While this runs, the test also watches whether the work slows down. Each worker reports how long each block of work took, and if blocks start taking more than a quarter longer than they did at the start, the screen flags the device as throttling. A chart shows how its speed held up through the run: a device that is only fast for the first few seconds looks very different there from one that holds its pace.

Step three: drawing

The last stage draws twenty thousand moving shapes on a canvas, over and over, again for three passes of five seconds, and times every single frame. That produces several numbers:

Average FPS — frames per second across all three passes.
1% low FPS — the frame rate of the slowest 1% of frames. This is the number that matches how smooth a device feels: an average can look healthy while the device stutters.
Frame consistency — the 1% low measured against the run’s own average.
Worst frame and hitches — the single longest frame, and how many frames took more than twice as long as a typical one.

The first frame of each pass is left out, because the browser is still preparing the code. This drawing test leans heavily on the processor rather than the graphics chip, which is why the results screen calls it a render test and not a graphics score.

From measurements to one score

The score out of 100 combines four of those measurements. Each is compared with what a strong current desktop reaches, capped at 100%, and then they are weighted: the processor counts for half of the score, the average frame rate for a quarter, and the 1% low and the screen’s refresh rate for an eighth each. The same yardstick is used for every type of device, so a phone and a laptop can be compared directly — and a phone is expected to sit below a desktop.

Frame consistency is shown but deliberately left out of the score. A device that is slow at everything delivers its frames very evenly, so scoring consistency would reward it for being uniformly slow.

From one score to a tier

The tier — Flagship, High-End, Mid-Range, Entry-Level, Budget or DEAD TIER — is the one judgement on the screen. Until 30 devices of the same type have been tested here, it compares your score with an estimate of what a strong current device of that type scores. After that, it comes from where your device actually falls among the ones tested here. The results screen says which of the two is in force, and the exact ranges are in what the score means.

What it sends, and what it cannot measure

When a run finishes, the measurements are added to the public scale, once per device. They carry no name, account, IP address or device ID, and opening the test with ?contribute=off withholds them entirely. Nothing in the test reads the device’s model or brand to decide its score.

Some things are not measured at all, because a browser cannot measure them honestly: processor temperature, battery drain over a test this short, and the speed of the graphics chip. Rather than estimate them, DeadTier leaves them off the screen. For more on that line, see browser benchmarks vs app benchmarks.

Measure the device you are holding

About a minute, nothing installed, and it works on a device you do not own.

Run the test