The Entropy Map: Which Browser Signals Give You Away

Which browser signals carry the most information, which studies proved it, and why 95% of fingerprints are unique

---

Skin ridges make every human singular. Browsers carry their own version of that mark, and they're far less coy about handing it over. You never held out your palm. Your browser did it for you, silently, on every HTTP request, to every site, without a whisper of consent.

One nagging question drives the whole fingerprinting trade: out of hundreds of harvestable signals, which ones actually split the herd? Which carry genuine identifying weight, and which just add dead air? Working that out took serious academic muscle. German longitudinal studies with real names attached. A colossal Google experiment spanning ten million Chrome clients. Years of painstaking peer review.

What follows is, at its marrow, a map. An entropy map of your signals. You'll see what gives you away, why the math holds, and which buried signals almost nobody writes about. If you figured turning off cookies handled it, have a seat.

In short: WebGL renderer carries 6.8 bits of entropy. 13 attributes yield 60% unique. 300+ signals push it to 95%. Your fingerprint is unique. You don't control any of it.

---

Anatomy of a Fingerprint: Body as Blueprint

Before we wade into numbers, let's lay down a frame. A browser's digital fingerprint behaves like a human body. Each signal group maps to a biometric trait. And like any body, identification doesn't hinge on a single tell; every organ, every scar, every quirk of gait adds up.

Canvas = face. When a browser draws a test scene on Canvas, results shift with the GPU, drivers, font rendering, subpixel smoothing. Everyone's got two eyes and a nose, sure, but the blend of fine detail stays one of a kind. A perceptual Canvas hash grabs the visual scaffolding, and comparing output from the main thread against a Web Worker catches anyone swapping the rendering mid-stream. Plastic surgery shows when you look from two angles.

Audio = voice. OfflineAudioContext runs a sound signal through the pipe, and the resulting hash leans on the device's audio stack. Between a MacBook Air on Safari and the same MacBook Air on Chrome, the raw gap sits at 0.0000023%. No ear alive catches that. An algorithm nails it at once. Everyone speaks the same tongue, yet timbre, overtones, and micro-pauses diverge. You can switch the words. You can't swap the vocal cords.

WebGL = hands. Vendor, renderer, extension set, test scene output. WebGL lays bare hardware with the bluntness of palm lines. Hashing the full combo plus flagging software renderers like SwiftShader and LLVMpipe outs virtual machines. A prosthetic works fine until someone pulls an X-ray.

Fonts = handwriting. Installed fonts form a set as idiosyncratic as penmanship. A stock Windows install ships one collection. macOS loaded up with Adobe Creative Cloud, a wholly different one. Linux with custom packages, a third. Over 200 fonts on a machine claiming to be vanilla Windows raises an immediate red flag. You can switch the pen. Slant and pressure stay.

Behavior = gait. How you steer the mouse, how you scroll, how fast you click. Your digital walk. Faking it means fighting neuromotor function: involuntary muscular micro-contractions that spring from biology, not choice. Try walking in a way that isn't yours. Sixty seconds in, habit wins.

Environment = DNA. Time zone, language, screen resolution, logical core count, memory size. None of these budge between sessions. Scaffolding on which everything else is built. Dye your hair all you want. Chromosomes don't take dye.

---

Three Studies That Reshaped Our Grasp of Entropy

Academic science usually creeps at glacial speed. When it comes to how easily you're tracked online, that glacier's picked up an unsettling pace.

Erlangen: Three Years, 1,304 Users, Ground Truth

Friedrich-Alexander University of Erlangen ran the world's first longitudinal study with genuine identity binding. Not anonymous hits on a website, à la Panopticlick. Real people with real accounts. Science that knew its subjects by name.

Gaston Pugliese's team recruited 1,304 participants who signed up by email and got personalized links each week for fingerprint readings. Each could use several browsers and devices. Over three years, from 2016 to 2019, they gathered 88,088 readings across 305 attributes. No synthetic crawler dataset. Three years of real lives logged with German fastidiousness.

A pivotal method they forged: attribute stemming. Strip out the mutable bits of signals. Version numbers from User Agent, for instance. Without stemming, a fingerprint drifts within days. With stemming, it holds for months. Limpid in hindsight, invisible in the moment. Nobody before them had done it end to end. Sometimes the best engineering calls are obvious only after someone else makes them first.

Three takeaways that sting. First: older users are easier to track because their setups shift less often. Second: most defenses that participants trusted didn't actually block fingerprinting. Third: tuning attribute sets separately for mobile and desktop through greedy sequential search trounced a one-size-fits-all approach by a wide margin.

Upshot? Mobile and desktop fingerprints need different checks. Different planets entirely. Running one tool for both is like fixing a watch with a sledgehammer.

Google WWW'24: Ten Million Clients and a Myth Crumbling

March 2024 brought the largest fingerprinting study anyone's ever run. Ten million Chrome clients. Over a hundred thousand live sites. 5,383 surfaces from 161 Web APIs. Data from real browsing, not lab benches.

First bombshell: every prior entropy estimate had been inflated. Academic consensus had collectively overstated the threat. Cold comfort, that.

Why? Dead simple. Earlier studies stacked entropy from lone signals naively, as though the signals were statistically independent. System language and keyboard layout correlate tightly. A Russian layout strongly hints at a Russian interface language. Add their entropies and you've double-counted the same bit of information. Summing height and leg length as two freestanding measurements would be a howler. Earlier studies did exactly that.

Google used Chow-Liu decomposition to gauge joint entropy while accounting for cross-API correlations. Outcome: no client leaked more than 20 bits of device-specific information. Earlier guesses ran as high as 33 bits. A twofold gap.

Does that mean fingerprinting doesn't work? Hardly. 20 bits covers over a million combinations. For a typical site drawing tens of thousands of visitors, that's more than enough for tracking. Google simply said: we've been overshooting the risk, but the risk is still real. Diagnosis slightly less grim. Patient's still sick.

For any detection system, Google's findings clinched a correlation-first stance. Hundreds of signals don't mean hundreds of independent bits. A lattice of links forms where the worth of one signal hinges on the rest. Don't just hash everything blindly. Check whether the signals tell the same story. An interrogation with cross-checks: one suspect, but the accounts had better line up.

Google and MIT PoPETs'25: Demographics Tip the Scale

October 2024 saw Google Research and MIT release a study that for the first time tied browser fingerprints to demographic data. 12,461 participants recruited through Prolific. 8,400 of them shared browser data alongside age, gender, income, and race.

Result with 13 attributes: 60.2% of users are unique. Combined entropy: 12.1 bits. Lines up with the open-source FingerprintJS numbers, which advertise roughly 60% accuracy.

Yet the most jarring finding wasn't about uniqueness. Fairness. Or rather, its wholesale absence.

People with low income turned out to be more exposed to fingerprinting. Blunt reason: old, cheap hardware is less common, and rarity breeds distinctiveness. Every MacBook Pro M3 shares the same WebGL renderer. A 2018 Acer laptop with a budget Intel GPU wears its own peculiar print. Poverty literally makes you more visible in digital space. Digital inequality, it turns out, cuts in both directions.

Older participants both worried more about privacy and were more vulnerable at the same time. Erlangen had shown the exact same thing three years earlier. A cruel irony, ratified by two independent teams on two continents.

One more finding that makes you want to shut the laptop: from a browser fingerprint you can infer gender, age, income bracket, and race. Fingerprinting isn't just tracking. Profiling. Your browser spills more to strangers than you'd ever volunteer yourself.

Top signals by entropy from that study:

Signal	Entropy	% Unique
WebGL Unmasked Renderer	6.833 bits	3.2%
Screen Resolution	5.51 bits	4.5%
User Agent	4.613 bits	2.8%
WebGL Unmasked Vendor	3.313 bits	0.1%
Hardware Concurrency	2.34 bits	0.1%
Platform	2.114 bits	0%
Timezone	2.064 bits	0.2%
Languages	1.73 bits	2.4%
Device Memory	1.611 bits	0%
Touch Points	1.463 bits	0%
WebGL Renderer	0.782 bits	0.1%
Color Depth	0.616 bits	0%
WebGL Vendor	0.465 bits	0%
Total, 13 attributes	12.101 bits	60.2%

A single WebGL Unmasked Renderer carries close to 7 bits. One out of 114 distinguishable variants. Add screen resolution and you're already telling one person from several thousand. Toss in a few hundred more signals and the math turns merciless. Math has no sympathy.

Beyond the Crawl: An Invisible Half

Every study above feeds on data from crawlers or willing participants. In April 2025, a team from UCL, UC Riverside, and Google Zurich presented a paper at ACM Web Conference called Beyond the Crawl, questioning the very way we measure fingerprinting prevalence.

Automated crawlers were set against real browser sessions from 30 users across 3,000 sites. Finding: crawlers miss nearly half the sites that fingerprint. Three reasons. Pages behind login walls that bots can't reach: sign into a marketplace, and behind that login sit fingerprinting scripts no crawler will ever see. Scripts that fire only after interaction: a click, a scroll, a keystroke trips code the bot never touches. Bot-detection systems that simply withhold fingerprinting code from automated visitors, because why fingerprint a bot.

Every figure on fingerprinting prevalence in academic literature is understated by roughly half. When studies say a third of top sites fingerprint, the true number sits closer to two thirds. An industry hiding its tools from the people who count them. From everyday users, it hides nothing. An observer warping the experiment's outcome. Quantum mechanics of web tracking.

---

Hidden Signals: What Popular Blogs Skip

Everyone knows about Canvas and WebGL. Everyone's heard of fonts and User Agent. A body has less obvious biometric markers too: moles in tucked-away spots, the microbiome in your gut, vascular filigree on the retina. Browsers carry quiet signals that almost nobody writes about, yet they still hold serious entropy.

Error Stack Signature: You Can't Hide the Engine

When JavaScript throws an error, the stack trace format depends on the engine. V8 in Chrome gives you Error.captureStackTrace() and stores .stack through a getter-setter pair. SpiderMonkey in Firefox keeps .stack as a data property in a different format. JavaScriptCore in Safari yields a third.

Not a bug. A baked-in trait that doesn't shift in incognito, doesn't hinge on privacy settings, and isn't masked by most antidetect browsers. If an antidetect claims a Firefox User Agent but the stack trace follows V8 rules, the clash is instantaneous. Like someone claiming to be German but sneezing in Japanese.

CreepJS uses that signal for verification. Property enumeration order on objects also differs between engines. A small detail. Fakes shatter on exactly these slivers. Flawless documents, but the staple's from the wrong year.

Speech Voices Hash: Your Computer Can Talk, and That's a Leak

speechSynthesis.getVoices() returns the list of installed speech synthesis voices. macOS may hand back 55+. Windows gives a different set depending on installed language packs. Linux, a third, depending on synthesis packages.

Blending voice names, languages, and localService flags creates a fingerprint you never thought to hide. Who thinks of speech synthesis as a leak vector? Brave fights back: in standard mode it shoves a fake voice into the list; in aggressive mode it returns an empty array. Firefox with privacy.resistFingerprinting also returns nothing. Safari does zilch.

Here's the rub: an empty voice list is itself a signal. Flags enabled protection, which shrinks the candidate pool. Hiding also means standing out. A person wearing a mask in a room where nobody else wears one is anonymous right up until someone asks: why the mask?

Math Fingerprint: Arithmetic Under Duress

Math.atan2(-0.49999999999999994, 0.8660254037844387) returns different trailing digits in Safari and Firefox. Root cause: browsers lean on different math libraries. Firefox from version 118 onward, September 2023, switched to fdlibm for trig functions to plug that leak. Chrome and Safari still use platform-native libm, and the output shifts with the OS and CPU architecture.

A difference in the 15th decimal place. No human catches that. An algorithm catches it immediately. Hashing results of a set of math calls serves as a fulcrum for engine identification. Claimed browser says Firefox but the math returns platform libm results? Picture doesn't gel. Fifteenth decimal place. Truth hides where nobody expects.

Storage Quota: Disk Size as a Fingerprint

navigator.storage.estimate() returns the available storage quota. Chrome's formula: usage and min(10 GiB, ceil(disk_space)), rounded to 1 GB. Sounds generic. In practice, someone with a 256 GB SSD and someone with a 2 TB SSD get different values. Your hard drive talks behind your back.

In incognito mode Chrome's quota drops to roughly 5% of disk space, versus 60% in normal mode. Not just a disk size signal. An incognito detector. Back in Chrome 74 through 84, incognito hard-capped the quota at 120 MB. A trivial test: quota at or below 120 MB, user's in incognito. Google patched the hole, but a gap persists. Thinner now. Like a patch on jeans: hole's gone, but you can tell where it was.

---

Entropy Breakdown: Which Signals Weigh Most

Not all 300+ signals pull equal weight. A body has vital organs and it has the appendix. Fingerprint signals follow the same pecking order. Heavyweights carrying several bits each. Featherweight signals that alone do nothing, yet in chorus add the clinching bit.

Category 1: Heavy Artillery, 5+ Bits

WebGL Unmasked Renderer: 6.833 bits. Outright entropy champion among standalone signals per PoPETs'25. Points to the exact GPU model down to the revision. Angle, Nvidia GeForce RTX 4090, OpenGL 4.5 and Angle, Intel UHD Graphics 630, OpenGL 4.5 are two different people with odds above 99%. Your graphics card is your face. And it wears no mask.

Screen Resolution: 5.51 bits. 572 unique values in the Google+MIT sample. You'd reckon everyone sits on 1920×1080. DPR, available height, and oddball monitors spawn a long tail of rare combos. Your ultrawide at 3440×1440 with DPR 1.25 gives you away cold. Luxury carries a price, and not only a financial one.

Canvas Hash. Hard bit counts for standalone Canvas don't exist in public research, but FingerprintJS and AmIUnique rank it among the most telling. Depends on GPU, drivers, subpixel rendering, antialiasing, rasterization order. Two people with the same hardware but different driver versions can yield different hashes. A face that shifts with every driver update. Never enough to become unrecognizable.

Category 2: Mid-Caliber, 2 to 5 Bits

User Agent: 4.613 bits after UA reduction. Once carried up to 10 bits per Eckersley 2010. Google's freezing User Agent through Client Hints, but killing the information outright hasn't worked. No matter how you trim a passport, the number still shows.

WebGL Unmasked Vendor: 3.313 bits. Apple, Nvidia, AMD, Intel, Qualcomm cover the main slots. Once you count masking through Angle and version splits, variants climb to 36.

Hardware Concurrency: 2.34 bits. Logical CPU core count. 4, 8, 12, 16, 24, 32, and oddities like 6 and 10.

Platform: 2.114 bits. Win32, MacIntel, Linux x86_64, Linux armv7l, and mobile flavors.

Timezone: 2.064 bits. 49 unique values in the American PoPETs'25 sample. Globally, far more.

Category 3: Light Infantry, Under 2 Bits

Languages: 1.73 bits. Device Memory: 1.611 bits. Touch Points: 1.463 bits. Color Depth: 0.616 bits. WebGL Vendor: 0.465 bits.

Each one alone is nearly worthless. Color Depth tells apart exactly three variants: 24, 30, and 32 bits. Stack 50 such signals at half a bit each and you net another 25 bits. And 25 bits is 33 million combinations. Light infantry wins by headcount. Ask Napoleon.

Category 4: Hidden Heavyweights

Fonts Hash. Eckersley's early work yielded 13.9 bits in 2010. Browsers have since walled off font list access, but CSS-based detection through text metrics still works. Handwriting changed. Graphologist hasn't quit.

Audio Fingerprint. Rock-steady, free from cookies and incognito. FingerprintJS showed that even Safari 17's noise injection gets bypassed in 7.5 ms by averaging 262,144 noised copies. Trivial cost on an M1 MacBook. You can drown a voice in noise. 262,144 recordings strip it right back off.

GPU Timing and WASM Timing. Execution times for GPU ops and WebAssembly workloads create deep hardware signals tied to the specific CPU and GPU model. Faking them means emulating the exact timing profile of someone else's silicon. In practice, impossible. You can draw a cardiogram, but a living heart beats differently.

---

Three Axes of Trust: How Multi-Dimensional Verification Works

Modern anti-fraud systems, WHOX among them, organize checks along three axes. Each answers its own question. Three doctors, three specialties, one patient.

Uniqueness: How Far Does a Fingerprint Stand from the Rest?

Heavyweights live here. Canvas, WebGL, WebGPU, audio, fonts, screen parameters. Alongside them sit timing signals: GPU operation time, WebAssembly execution time, garbage collection patterns, paint timing entropy. Deep hardware signals. Can't be swapped through JavaScript injection or masked by antidetect extensions. Faking garbage collection timing would mean faking the physics of how a processor works. Good luck with that.

Consistency: Do All Signals Tell One Story?

Here's where antidetect browsers get caught. You can spoof the User Agent to Safari. If the WebGL renderer returns Angle with DirectX11, if error stack traces follow V8 formatting, if CSS properties start with webkit- instead of Safari-native prefixes, the mismatch gets flagged.

Consistency checks cross-reference User Agent against Client Hints, time zone against IP geolocation, platform against GPU. A separate class: impossible combinations. Android UA with an Apple GPU? Windows with a Metal renderer? A 64-bit OS with navigator.platform returning Win32? None of these combos exist in nature. Only tools with dropdown menus create them, where someone assembles a Frankenstein profile from clashing parts. A body sewn from stranger organs won't fool a surgeon.

Behavioral analysis falls here too. Linear mouse paths, missing micro-jitter, robotic click spacing: all automation flags. Prototype chain integrity, Proxy traps, rogue properties on the global window object round out the picture.

Masking: Is Someone Trying to Hide?

Tor exit nodes, VPN tunnels, datacenter IPs, open proxy ports. Client Hello's TLS fingerprint gets checked against the claimed browser: if the TLS print says Chrome while the User Agent says Firefox, someone's lying. WebRTC leaks, IPv6 leaks, QUIC exposure, DoH auto-translation, mDNS device name leaks. Headless-mode checks and automation markers. Every scrap adds up. An organism trying to conceal illness gives itself away by the very effort of concealing.

---

Why 95% of Fingerprints Are Unique

Back to the numbers and their lineage. Spoiler: bleak.

Peter Eckersley of the EFF laid the groundwork in 2010. Panopticlick gathered fingerprints from 470,161 browsers and set the baseline every later study builds on: 18.1 bits of entropy per average device. One in 286,777 variants. On a site with a hundred thousand visitors, 18.1 bits is enough to pin down nearly everyone. Of all collected prints, 83.6% were unique. Among browsers running Flash or Java, 94.2%. Eckersley formalized the principle confirmed ever since: each added bit doubles a fingerprint's telling power. Not a theoretical hunch. Information entropy math, tested on a half-million sample.

Six years on, Pierre Laperdrix and the Inria team launched AmIUnique and analyzed 118,934 fingerprints. Scale on par with Panopticlick, sharper methods. Result: 89.4% of desktop and 81% of mobile browsers are unique. Mobile devices are less varied in hardware: a narrower pool of chips and GPUs. Gap's shrinking as the ecosystem splinters. Laperdrix also confirmed what Eckersley suspected: hardware signals outlast cookie wipes, IP swaps, and browser updates. A fingerprint is steadier than any token a user can delete. You can reset a password. You can't reset a graphics card.

Pugliese's Erlangen team added a third dimension: verification over time. 1,304 real participants, 305 attributes, three years of watching. With tuned attribute sets and stemming, over 95% of devices stayed distinguishable months later. Not because each attribute is unique, but because combining 305 attributes opens a space where collisions are statistically impossible.

Google+MIT in 2025 got 60.2% unique with just 13 attributes and 12.1 bits.

Key phrase: with just 13 attributes. Modern systems gather hundreds. Each added bit of entropy doubles the telling power. If 13 attributes give 12 bits and 60% unique, then 300 attributes, even at a modest 0.1 bits per extra signal, push past 30 bits. Over a billion combinations.

In practice, correlations between signals eat away at entropy. Exactly what Google WWW'24 showed. Yet even after Chow-Liu correction, at 300+ signals the combined entropy stays high enough to pin down virtually any user in virtually any crowd.

Vastel and colleagues in 2018 showed that 50% of fingerprints shift within 5 days and 80% within 10. Sounds like that should help. FP-Stalker, however, tracks users through these shifts, linking old prints to new ones through a stable core. Andriamilanto and colleagues, on a sample of 4 million fingerprints from roughly 2 million unique visitors, confirmed: over 90% of attributes hold steady for 6 months. A fingerprint's core outlives most cookies.

Core stability from hardware signals like GPU timing and WASM timing makes month-long tracking feasible. Two-stage probabilistic matching links sessions through that stable core, where the network layer and deep hardware signals carry the main weight.

Enough signals push uniqueness toward 95%. Not because each signal is unique. Because a blend of 300 signals, each sorting groups of people, winnows the field to one.

Describing a person works the same way. Male isn't unique. Male, 182 cm tall, isn't either. Male, 182 cm, brown eyes, scar on the left arm, limping on the right leg, wearing a Casio watch and a North Face backpack. Very, very specific. Full circle.

---

Incognito Won't Help

Everything above works the same in normal mode and incognito. Fingerprinting is stateless. Writes nothing to the device. Every signal, Canvas, WebGL, Audio, fonts, timings, math, voices, stays identical.

Incognito shields you from cookies and browsing history. Handy if you don't want the household seeing your searches. Against fingerprinting it's like slipping on sunglasses and believing no one will know you by your gait, voice, height, and the habit of tugging your right ear. Whole body in plain sight, eyes hidden. Bravo.

Google's own staff called incognito effectively a lie and a matter of professional ethics, as court filings from Brown v. Google LLC revealed. Settlement in 2024 cost Google a pledge to delete billions of records from 136+ million users. And to change the wording from browse privately to browse more privately. One word. A five-billion-dollar lawsuit ended in a non-monetary deal: Google said the plaintiffs got zero. Costliest adverb in legal history, and free for the defendant.

Safari from version 17 ships Advanced Fingerprinting Protection: noise in Canvas, WebGL, and Audio. Starting with iOS 26, that shield's on for all browsing by default. Best mass-market defense on offer. But FingerprintJS gets past the audio noise in 7.5 ms, and Canvas noise is caught statistically. Defense itself becomes a signal: user runs Safari 17+ with protection on. Candidate pool contracts. Paradox: the harder you guard yourself, the more you stand out in the crowd. A body in a spacesuit is safe from infection. Yet it's visible from orbit.

---

FAQ

What is entropy in the context of fingerprinting? Entropy measures the information a signal carries, counted in bits. One bit tells apart 2 variants, 10 bits tell apart 1,024, 20 bits tell apart over a million. WebGL Unmasked Renderer carries 6.833 bits, or 1 out of 114 variants. Combined entropy of 13 attributes is 12.1 bits per Google+MIT PoPETs'25. Each added bit doubles the telling power. With 300+ signals, uniqueness closes in on 95%.

Which signal carries the most entropy? WebGL Unmasked Renderer is the outright champion: 6.833 bits per PoPETs'25. Pins down the exact GPU model to the revision. Next: Screen Resolution at 5.51 bits with 572 unique values, User Agent at 4.613 bits, WebGL Unmasked Vendor at 3.313 bits. Hidden heavyweights: GPU Timing and WASM Timing are hardware-bound signals that can't be spoofed through JavaScript.

How many signals are needed for unique identification? Google+MIT showed 13 attributes yield 12.1 bits and 60.2% uniqueness. Erlangen study: 305 attributes kept 95%+ of devices distinguishable for months. Google WWW'24 on 10 million clients: no more than 20 bits of device-specific information after accounting for correlations through Chow-Liu. 20 bits equals a million combinations, enough for any site. Practical answer: 50 to 100 signals suffice to identify most users.

Can gender, age, and income be inferred from a browser fingerprint? Yes. Google+MIT PoPETs'25 study with 12,461 participants was the first to tie fingerprints to demographics. Gender, age, income level, and race can all be inferred. People with low income are more exposed: older hardware is rarer and more unique. Older users worry more about privacy yet are more vulnerable. Fingerprinting isn't just tracking. Profiling.

How does mobile fingerprinting differ from desktop? Mobile devices are less varied in hardware: a narrower pool of processors and GPUs. AmIUnique found 89.4% of desktop and 81% of mobile browsers are unique. Erlangen showed that tuning attribute sets separately for mobile and desktop yields far better results. Mobile fingerprints are shaped mainly by the device model itself, GPU and screen, while desktop prints lean on software setup and peripherals.

---

Read Next

• The Randomization Lie: Every Canvas Defense Has Been Beaten
• The Privacy Paradox: Protection Makes You Visible
• Full Audit: 8 Browsers × 157 Checks
• The Invisible Census: A Population Registry Built Without Consent

---

WHOX - We tell real signals from manufactured ones. Check your fingerprint at whox.com and find out what signals leak from your browser and how unique you are.

What All of It Means

Hundreds of signals. Not a marketing number but a distillation of academic research: from Erlangen's 305 attributes to Google's 5,383 surfaces, from PoPETs'25's 13 attributes to dozens of hidden signals like error stack signatures and speech voice hashes.

Each signal on its own may say nothing about who you are. Together they build a map where your dot glows brighter than you'd like. WHOX makes that map visible.

Your fingerprint is unique. Was unique yesterday. Will be unique tomorrow. Bodies don't lie. Only question is who's looking.