You think you're ready to walk away from a piece of software because the backlog of remaining ideas is a long list. And something arrives from outside your own project and drags you back to the workbench anyway.
Brave shipped new WebGL and WebGPU fingerprinting protections recently. The browser now strips identifying GPU information and reshapes parts of the WebGL extension surface, so a website gets a blurrier picture of the hardware underneath.
That got my attention, because Traceveil had already been circling the same problem. But there's a difference worth sitting with. Brave can rewrite the terms at the source. They own the building. Traceveil is a tenant. It can rearrange the furniture in the room it's been let into, intercept what the page sees before the page sees it, stand in the doorway between the site and the browser and edit the view. It cannot touch the foundation.
That's a less comfortable place to work from. It's also the only place most people actually live. Brave asks people to switch browsers to get privacy. Chrome is the default for roughly two-thirds of the planet's browsing: pre-installed, synced, the water everyone's already swimming in. Brave treats the person in front of the screen as a client. The Chromium project, funded by the largest advertising company on Earth, treats the person as inventory. Both of those are just facts about who each product is built to serve. Somebody has to build for the people who are staying on Chrome anyway. Those users who are also, not incidentally, the product.
So the question worth asking wasn't "should I switch browsers."
It was: How much browser-native fingerprint protection can you smuggle into a browser that was never built to give you any?
The first idea was wrong, and the wrongness was interesting
My first instinct was to make the GPU look generic. Boring. Forgettable. That instinct was wrong, and it took a benchmark to prove it. Websites can interrogate your machine with more precision than most people would guess comfortable.
The graphics card is one of the more talkative witnesses. Unprotected, my laptop hands over something close to: NVIDIA GeForce RTX 5070 Laptop GPU. Useful if you're rendering a scene. Just as useful if someone's trying to pick you out of a crowd and unlike an IP address, nobody swaps their GPU before breakfast.
The first build of the fix hid the real card and reported WebKit / WebKit WebGL instead. No NVIDIA. No RTX. No driver fingerprint. A flat, anonymous-sounding value. Mission accomplished, I assumed.
Privacy engineering has a habit of punishing things that merely look private.
I ran it against EFF's Cover Your Tracks. That reassuring generic value showed up in roughly 1 in 4,956 browsers. I hadn't erased an identity. I'd swapped a rare GPU for an even rarer costume and the costume itself said something: this is a browser that deliberately rewrites its GPU identity. That's not camouflage. That's a new, more specific fingerprint, worn by fewer people than the one it replaced. Weird can be more common than fake-normal. Fake-normal can be the loneliest category on the internet.
With Traceveil 1.3.2 we had already tried something quieter. Instead of inventing a plausible lie, it made the identifying debug renderer simply unavailable. The result read as None. My gut said that looked suspicious. Nothing is stranger than something.
The measurements disagreed In the same EFF dataset, the suppressed result appeared in roughly 1 in 156 browsers. That put it in a crowd about 32 times larger than the carefully constructed generic value. Silence, it turns out, had much more company than the well-dressed lie.
That result rewired the design brief for 1.4:
Don't optimize for what looks normal. Optimize for what is actually common, and internally consistent with everything else the browser is saying.
Preserve capability. Remove identity.
Traceveil 1.4 suppresses the identifying WebGL debug interface instead of inventing a fictional GPU to hide behind. It does not solve privacy by breaking the browser. WebGL still works. WebGL 2 still works. Maps still renders. Web apps still get the GPU they asked for.
What changes is what they're told about it. Same system, same silicon: without Traceveil, NVIDIA GeForce RTX 5070 Laptop GPU. With Traceveil 1.4, Unmasked Vendor: undefined / Unmasked Renderer: undefined. The site still gets to use the graphics card sitting on my desk. It just doesn't get to know which one it is.
That's the whole design principle, distilled to five words: preserve capability, remove identity. Everything else in 1.4 is that principle being applied to increasingly stubborn surfaces.
Why not just randomize everything?
Because a graphics stack doesn't have one data point. It has a dozen. Texture limits, shader precision, framebuffer capabilities, supported extensions, actual rendered pixels, timing behavior. Hide the GPU's name and leave the rest of its fingerprints in plain sight, and you haven't hidden anything; you've just made the interrogation take one extra question.
The lazy fix is to randomize all of it. That's also the fix that gets you caught. If Traceveil claims one GPU while the rendering behavior matches a completely different one, a tracking script can ask both questions and compare the answers. A privacy tool that contradicts itself is not anonymous. It's a beacon with a disguise on.
So 1.4 is narrower and more disciplined than "make it noisy." WebGL's rendered output gets deterministic, first-party-scoped interference. The extension list gets a synthetic, site-scoped extension so a probing request finds a coherent object instead of a suspicious gap. WebGPU adapter identity fields get scrubbed wherever Chrome actually exposes them to something an extension can reach. The goal was never maximum entropy. It was correlation resistance without constructing a browser that couldn't survive contact with the real web.
Stability where it's expected. Separation where correlation is dangerous.
One rule from 1.3.2 survives untouched, because it's the load-bearing one: Traceveil does not hand a site a fresh random fingerprint on every reload. That sounds private right up until a site fingerprints you twice in one session and notices the numbers keep changing at which point the randomness itself becomes the identifier. A liar who changes their story every time you ask is easier to spot than one who's consistent.
Instead, the high-entropy surfaces, Canvas, WebGL, Audio are separated by first-party context. EFF now reports all three as: randomized by first party domain. A signature observed on one site shouldn't reappear as a reusable tracking key on some unrelated one. Stability where the web expects stability. Separation exactly where cross-site correlation turns dangerous. That's a harder problem than "add noise," and it's the one that actually matters.
The measurements got better. That doesn't mean the problem is solved.
he GPU result wasn't the only improvement. Across the broader fingerprint, some previously unusual values moved into substantially larger observed groups.
The HTTP Accept/language signal dropped from around 11.17 bits of identifying information to 1.52 bits in testing — roughly from 1 in 2,308 to 1 in 2.88 in the observed sample. Screen characteristics moved from around 11.80 bits to 2.85 bits. Timezone moved from around 6.23 bits to 3.18 bits.
Those numbers are useful. They are not a declaration of victory. Cover Your Tracks still reports the complete browser fingerprint as unique in its current sample. That isn't a contradiction.
A browser fingerprint isn't one value. It is a combination of many of them. Making individual signals less identifying does not automatically make the complete combination disappear into the crowd. Traceveil 1.4 reduces some sources of entropy and makes several high-entropy surfaces harder to reuse across unrelated sites.
It does not make you anonymous. This isn't solved. I'm not calling it solved.
Anyone who tells you browser fingerprinting is a finished problem is probably selling something.
The rest of the stack didn't go anywhere
1.4's headline is the GPU work, because it's where the lesson was sharpest. But it's an addition to 1.3.2's protection, not a replacement for it. Still in place are: protections around Canvas and OffscreenCanvas, WebGL rendering, Audio, CPU and memory reporting, screen geometry, timezone, language, Client Hints, font probing, battery information, WebRTC local-IP leakage, tracking-parameter stripping and known third-party tracker blocking.
Balanced and Strict modes remain. Per-site exclusions remain.
And the part that isn't a technical claim so much as a promise: everything runs locally. There's no Traceveil telemetry service. No account. No server anywhere collecting a log of what you did with your own browser. A privacy tool that phones home is a contradiction wearing a trench coat, and I'd rather ship less than ship that.
The interface got rebuilt around the same visual language running across the other Roamer projects, with separate views for protection, network controls, site exceptions, and diagnostics so it looks like it belongs to a family, because it does.
The bug that mattered more than it looked
Somewhere in testing, another contradiction turned up, and it's the kind that should worry anyone building this class of tool. Traceveil normalized the old navigator.platform to Win32. But Chrome's newer User-Agent Client Hints interface can still answer the same question through a side door: navigator.userAgentData.platform.
So a site could ask, "Are you Windows?" through one API and hear yes, then ask the identical question through a different API and hear something else entirely.
That isn't privacy protection. That's a tell. A privacy tool that disagrees with itself is doing the tracker's job for it, just more slowly.
Changing one field isn't enough. The browser has to tell a coherent story.
Platform and Client Hints consistency is therefore one of the areas I am continuing to test across Chrome versions rather than treating one successful interception path as proof that the entire surface is closed.
That's another lesson worth keeping:
A privacy feature isn't finished when one API gives the right answer. It's finished when asking the same question somewhere else doesn't expose the contradiction.
An extension operates at somebody else's pleasure
There's a boundary underneath all of this that I don't want to paper over. Traceveil lives inside Chrome, on Chrome's terms. It cannot rewrite TLS fingerprints. It cannot touch the HTTP/2 or QUIC implementation underneath it. It cannot fully govern every worker and renderer process the browser spins up. It gets the APIs Chrome is willing to expose to extensions, and nothing more and that grant is not a contract, it's a mood, one Google has already narrowed once for a different class of extension and could narrow again for this one.
That's not paranoia. It's just the weather an extension developer works in, on a browser owned by the company whose revenue depends on the opposite of what Traceveil is trying to do.
Brave doesn't have that problem, because Brave owns the engine. That's a real architectural advantage, and pretending otherwise would be its own kind of overclaim.
So Traceveil's question was never "how do we out-engineer Brave." It was narrower and, I think, more useful to more people: how much real privacy protection can you hand someone without asking them to abandon the browser they've already decided to use?
1.4 moves that answer forward a little. It also sharpens the case, eventually, for something that isn't an extension at all: some protections belong bolted onto the browser you have; others need you to own the engine outright. Finding exactly where that line sits is still part of the project, not a settled conclusion.
Ship it, then try to break it
Traceveil 1.4 is now the stable release line. It's open source, same as always.
I intend to leave 1.4 stable while the next round of research happens somewhere else, off to the side, where it can fail without taking a working release down with it. I'm especially curious about results from other GPUs, other operating systems, and the ordinary WebGL/WebGPU-using web that isn't a benchmark site: Maps, Figma, browser games, whatever you actually open forty times a day.
If you use it, try to break it. A privacy tool that wins a synthetic benchmark and quietly breaks the real web isn't a privacy tool, it's a demo. And one that hands you a reassuring, normal-looking fake value so you feel safer while standing out more isn't privacy either. It's theater with better lighting.
Open source is more useful when "trust me" can be replaced with "here is how to prove me wrong."
Sometimes looking normal is what gets you noticed. Sometimes saying nothing at all is the most ordinary thing a browser can do.