How an image can render brighter than your screen's white

superwhite.app · technical notes

You may have seen posts on LinkedIn or Instagram where the image seems to glow — visibly brighter than the white page around it. It looks like it breaks the rules of the screen. It doesn't. It exploits a real, documented gap between what "white" means in SDR and what modern displays can actually output.

SDR white is not your display's maximum

A normal image tops out at signal value 255 — "white." Your operating system maps that to a comfortable reference level, roughly 200 nits. But an HDR-capable panel (recent MacBook Pro, iPhone, Pixel, most OLED TVs) can physically output 1,000–1,600 nits. The gap between reference white and panel peak is headroom — Apple calls its implementation EDR. It's reserved for HDR content: video highlights, HDR photos. Regular UI never touches it.

The trick is convincing the renderer that your still image is HDR content.

The signal: a Rec.2100 PQ color profile

HDR video signals its brightness using the PQ (Perceptual Quantizer) transfer function, standardized in ITU-R BT.2100. Unlike sRGB's relative curve, PQ is absolute: each code value maps to a specific luminance, up to a theoretical 10,000 nits.

ICC color profiles can describe a PQ encoding. And it turns out that if you embed a Rec.2100 PQ profile into an ordinary 8-bit JPEG, color-managed renderers — Chrome, Safari, macOS, iOS — will honor it and render the image's bright values into the display's headroom. White in the image lands at 1,000+ nits while the page's white sits at ~200. The image out-glows the interface.

The pipeline

Naively tagging an sRGB image as PQ remaps everything — colors shift and the entire image blows out. Superwhite does it properly, per pixel:

• Decode sRGB to linear light
• Convert primaries from sRGB to Rec.2020 with a 3×3 matrix, so hues stay accurate under the new profile
• Mask: compute a "whiteness" mask (min channel above a threshold). Non-white content is pinned at 203 nits — SDR reference — so it looks completely normal
• Boost: masked (white) regions are scaled to the chosen peak, e.g. 1,000 nits
• Encode with the PQ curve, write an 8-bit JPEG, and splice in the Rec.2100 PQ ICC profile

The ICC embed itself is a small APP2 segment inserted after the JPEG's SOI marker:

FF E2 [len] "ICC_PROFILE\0" 01 01 [profile bytes]

That's it. No 10-bit encoding, no gain maps, no video container. An 8-bit JPEG is enough — which is also why simple, flat graphics work best: smooth gradients can band at 8 bits under the aggressive PQ curve, but logos and wordmarks are ideal.

Where it works — and dies

• Survives: LinkedIn feed posts, uploaded directly as JPEG. No cropping or editing in the composer — re-processing strips the profile.
• Dies: screenshots (they capture the tone-mapped SDR result), re-saving in most editors, messenger compression, copy-paste.
• Visible to: viewers on HDR displays in color-managed apps, with battery saver off. Everyone else sees a normal image with marginally dimmer whites.

The honest caveats

This is attention arbitrage, and it lives on borrowed time. Platforms clamped auto-HDR video brightness after the same trick flooded Reels and Shorts; still images will likely follow. Treat it as a novelty with a window, not infrastructure. And use taste — a subtle glow on a logo reads as craft; a 4,000-nit full-frame flashbang reads as a pop-up ad. The feed will tune out whatever gets abused.

Everything Superwhite does happens in your browser — canvas pixel math plus the byte splice above. Your image never touches a server.