How We Test

ScreenTail is a set of browser tools for testing and using screens. This page documents how those tools were designed, what was measured while they were built, and how the work is checked before anything ships.

The measurements below were taken during development and written down at the time, which is why they carry odd numbers rather than round ones. Where something could not be measured, this page says so, and that section is the one to read first if you are deciding whether to trust the rest.

There is no account, no upload and no server doing any of the work. Every page is a static file, every tool is code running on your own machine, and nothing about your screen is sent anywhere. You do not have to take that on trust — open your browser's network panel and watch what a tool page requests.

The site sets no cookies and stores nothing on your device. Two analytics scripts load, both named on the privacy page, and neither writes to your machine. That page is the enforcement point rather than a description of one: a build check lists every external host in the built site and fails on any host the privacy page does not declare. Adding a third-party script means editing the policy in the same change, or nothing ships.

The dead pixel test cycles nine full-screen fields in a fixed order, and the order is an argument rather than a preference. Dell's pixel guidelines state that a dark pixel is visible on white or coloured backgrounds but not on black, and that a bright pixel is always visible and especially so on dark. White and black are therefore blind to each other's faults, which forces them into the first two positions. The primaries come next, because a speck that appears only on the red field is a dead red sub-pixel rather than a dead pixel — a different fault, and often a differently warrantable one. The secondaries cross-check those results in pairs, and mid grey closes on the one thing solid colours cannot show: backlight unevenness.

All nine hex values are written into the build checks as literals rather than read from the same table the tool reads, and that distinction is not pedantry. A check that computes its expected value with the function it is testing agrees with itself even when both are wrong — a defect that shipped here once, reported green, and was caught only when somebody deliberately broke the thing it was watching.

Auto-advance runs at one field every three seconds, and the interval restarts whenever you step manually, so a tap just before a scheduled tick cannot show two fields a tenth of a second apart. Holding a key is guarded separately: key repeat fires at roughly 30 a second, which would turn a deliberately slow diagnostic into full-screen flashing on the one diagnostics tool that ships no warning gate. Repeated key events are discarded rather than acted on.

The grey screen serves 25%, 50%, 75% and 100% as true sRGB percentages of white rounded to eight bits —#404040, #808080, #BFBFBF, #FFFFFF — and deliberately not gamma-corrected. The point of those fields is a known drive level sent to the panel, not a perceptually even ramp.

One more thing was measured rather than assumed: whether the controls render dark-on-light or light-on-dark as the surface colour changes under them. A single threshold flips that decision continuously when the surface sits near it — a signal oscillating by a twentieth either side of the boundary was measured flipping 254 times. There are now two thresholds with a dead zone between them, and a byte-for-byte comparison of every page before and after confirmed not one of them shipped a different value.

Every animated tool shares one loop, driven by real elapsed time rather than by a frame count, capped at 60 frames a second, pausing when the tab is hidden and never resuming on its own. That last property is a safety decision, because one of the tools using the loop flashes.

Frame counting is the failure this design exists to avoid, and it hides in small places. The matrix rain trail is a translucent wash whose opacity is derived from elapsed time, so the trail is the same length at 144 Hz, at 60 Hz and at 30 frames a second; the check that proves it composes two half-frames and compares them against one whole frame. The obvious alternative — repainting every visible glyph at a decreasing opacity — measured about 2,760 text draws per frame at 1080p, roughly 28 milliseconds, which is a long frame on every frame.

The bouncing logo changes colour when it hits a wall, and in a viewport barely wider than the sprite that is nearly every frame. A 400 millisecond floor caps it at 2.5 changes a second, against the accessibility guideline threshold of three, and it lives in the shared logic where a check can read it rather than in the animation code where it cannot.

Neither screensaver starts on its own; both render a static first frame and wait for a gesture. The flip clock is the deliberate exception, because a clock that does not advance is not a paused clock, it is a wrong one.

The three noise generators build a twelve-second buffer once, on the first press of Play, and loop it. Their spectra are measured by the build rather than asserted in a comment — a windowed transform over twelve blocks of 32,768 samples, fitted as a straight line in log-log:

• White noise measures −0.022 dB per octave from 100 Hz to 10 kHz, against a target of flat.
• Pink noise measures −3.009 dB per octave at 44.1 kHz and −3.023 at 48 kHz, against a target of −3.
• Brown noise measures −5.848 dB per octave from 500 Hz to 8 kHz, against a target of −6.

Both sample rates are measured because some browsers have historically locked audio to 44.1 kHz while the device itself runs at 48. The brown measurement starts at 500 Hz rather than 100 Hz for a reason worth stating: from 100 Hz it reads −5.5, because that band sits inside a corner where the filter flattens by design — close enough to the target to pass, on a filter that was wrong.

A twelve-second loop is only indistinguishable from twelve hours if the seam is inaudible, so the seam was measured too: as a multiple of the buffer's own average sample-to-sample step, across eight different seeds. Brown noise went from 5.2 times that step to 0.88, and pink from 1.6 to 1.06 — the join stopped being a jump and became an ordinary part of the signal. The crossfade is equal-power rather than linear, because summing two uncorrelated signals with linear weights dips about 3 dB in the middle; measured through the join, the level holds to within 0.05 dB.

Output is hard-capped at −6 dBFS, and nothing ships as an audio file — all of it is generated. The chime on the Pomodoro timer is where that ceiling nearly failed quietly: the first draft used two tones at 0.2 peak each with a 40 millisecond overlap, summing to 0.4 at the output against a 0.25 ceiling. Checking each tone's individual peak would have reported 0.2 and passed. The check sums where the tones sum, and they are now 0.12 each.

The timers store a deadline rather than counting down. Nothing decrements, because a hidden tab is throttled to roughly one tick a second, so a decrementing timer runs slow in exactly the situation where nobody is watching it. If the deadline passed while the tab was hidden, the timer finishes once and reports how long ago.

Every change runs four gates before it ships: the type checker, a suite over the pure logic and the tool manifest, a full build, and a suite that reads the built HTML, CSS and JavaScript. Together they are 1045 automated checks across 83 pages.

The count is not the interesting part. The rule behind it is: a check is not trusted until somebody has proved it can fail. When a check is written, the thing it watches is deliberately broken, the gate is run, the failure is confirmed to name that check, and only then is the break undone. A suite that always prints PASS is worth nothing, and trying it is the only way to know which kind you have.

That discipline has caught three things review did not. A check that computed its expectation from the code it was testing, and so agreed with itself while the wrong value shipped. Two breakages that produced byte-identical output, because the build strips unused code — the mutation had removed nothing and there was nothing to catch, which reads exactly like a check that missed. And a test fixture whose published and updated dates were the same day, which meant a page could have bound one to the other and no check could have seen it; the dates are now a day apart, with a note saying why.

A separate audit asked a narrower question of every check that searches text: would it still notice if it found nothing to search? A check that scans zero pages for a forbidden pattern reports success, truthfully and uselessly. Every such check now states, as a number, the minimum it expects to find. Nine of the converted checks were then sampled three ways each: they failed when the subject was broken, failed when the corpus was emptied, and — in their old form, against that same emptied corpus — passed.

A web page cannot measure a screen. It can put a known signal on one and let you look at it, and everything below follows.

The brightness test does not change your backlight and cannot. It draws a black veil over a white field and varies the veil's opacity, which dims the image while the panel goes on emitting exactly what it did before. That is useful for comparing two areas of one screen. It is not a brightness measurement, and it will not tell two monitors apart.

Nothing here can read ambient light, panel calibration, colour accuracy, gamma, contrast ratio, or the luminance a display is actually emitting. Any of that needs a colorimeter. The backlight bleed and uniformity tools show you a field and leave the judgement to your eye, so the result depends on your room lighting and your viewing angle as much as on the panel.

The stuck pixel tool — which flashes rapidly, and which the next section is about — is an attempt, not a procedure with a known success rate. No such measurement exists here, so none is published. Dell's own guidance is to avoid do-it-yourself fixes and to pursue a replacement display, and that is stated on the page beside the tool rather than buried here.

The audio tools make no claim about hearing and will not. A browser cannot know the sound pressure level reaching your ear — that depends on your system volume, your headphones and your ears — and the international safe-listening standard warns against signalling "safe" from an estimate. After an hour of playback the panel states the elapsed time and nothing else. It does not stop, and it does not reassure.

And nothing on this site is a warranty determination. Whether a fault you find here is covered is a question for your manufacturer, and their thresholds differ from one another.

The stuck pixel fixer flashes colours rapidly, which is a risk for anyone with photosensitive epilepsy. It sits behind a warning that has to be dismissed deliberately, every time, and the construction of that gate is the part worth explaining.

The warning is rendered into the page's HTML on the server, and the animation can only start from the code path that runs when you accept it. If the page's JavaScript never runs — blocked, failed, switched off — you see the warning and nothing flashes. An overlay injected by JavaScript would fail the other way, which is the wrong direction for a seizure risk. Escape declines rather than dismisses, so it cannot become a shortcut past the warning, and consent is never remembered: one saved click is not worth somebody on a shared machine landing in a flashing animation they never agreed to.

The flashing area is bounded and has no fullscreen mode. It defaults to a 240-pixel square, cannot exceed 400, and is clamped inside the tool's own stage — a clamp verified by driving it with the keyboard and by dragging it to coordinates far outside the screen, where it stops at the four walls every time. There is a ten-minute hard stop, it stops when the tab is hidden, it never restarts on its own, and while it is running Escape stops it ahead of every other use of that key. A visible Stop control exists as well, because a safety stop must never depend only on a keystroke.

None of this amounts to a claim that the tool is safe for anyone. A browser cannot know that, and the page does not say it. The OLED burn-in test ships no gate at all: it changes field once every four seconds, two orders of magnitude below the range that matters, and the build fails if anyone lowers that interval past a floor the check names.

That is easier to show than to assert. The first published guide had five claims cut from it during verification, each for the same reason: no primary source could be read. A recommended brightness setting went because neither manufacturer page consulted mentions brightness at all. A pixel-fault standard went because the standards body's own site returned an error to the request. A per-brand dead-pixel threshold, a typical retailer return window and a stuck-pixel recovery rate all went for want of a figure anyone could point at — and the guide says out loud that it has no source for the first, rather than hedging.

Two things are banned outright in the tool copy and enforced by the build rather than by anyone's memory: health and medical claims of any kind, and any wording that would make a simulated screen look like a real support page — no phone number, no link inside a simulated surface, and no word from a list of scam-shaped phrases.

ScreenTail is built and written by one person, named, with a background and a contact address on the author page. If something here is wrong, or a tool behaves oddly on hardware nobody here owns, that is the address to use — those reports are the only way some of it ever gets found.