Built in the open.

The unglamorous groundwork that everything else depends on.

1. Project scope, principles, and architecture

2. De-Googled base via ungoogled-chromium, pinned to an exact upstream revision

3. Reproducible source-prep pipeline (fetch → prune → patch → verify)

4. Clean, automated build from source on a commodity machine

5. Published patch set

   every change human-readable and individually documented

The moment you can download something and check it yourself.

1. Windows x64 build as the first target

2. Checksummed release artifacts (SHA-256) on GitHub Releases

3. Reproducible build instructions a third party can follow to a matching binary

4. One-command source bootstrap for contributors

Engine-level control over the signals a browser exposes — designed to be consistent, not random.

1. Per-profile, deterministic identity seed (stable across sessions, or fresh on demand)

2. Engine controls for canvas, WebGL, audio, fonts, locale/timezone, navigator & hardware

3. Per-site coherence (farbling-style)

   same site sees a stable identity; different sites don't correlate

4. WebRTC

   reports your proxy's address coherently, rather than exposing the real one or disabling WebRTC outright

5. WebGPU adapter forced coherent with the WebGL persona GPU

6. Full screen-dimension, font-list, WebGL getParameter table & CSS @media spoofing; import a real machine's fingerprint via --fingerprint-profile

   pre.10

7. Cross-API coherence pass

   pre.10

   WebGPU↔WebGL GPU for seed-only personas, locale via --lang (Intl on main thread + workers), persona speech voices, UA-CH bitness/wow64, MediaCapabilities codec matrix & enumerateDevices media set

8. Real-GPU canvas bridge

   Canvas2D + measureText (pre.11) and WebGL op-forwarding for geometry, shaders, uniforms, draws, procedural textures, readPixels and toDataURL (pre.12); per-site bridging policy (pre.13)

9. Opt-in Widevine/EME so requestMediaKeySystemAccess('com.widevine.alpha') resolves and the DRM surface matches real Chrome

   pre.15

10. TLS ClientHello persona (--fingerprint-tls-profile)

    pre.18

    the network layer follows the claimed Chrome version instead of the build's native TLS

11. Best-effort Android mobile persona (--fingerprint-platform=android): touch, coarse pointer, mobile screen/DPR, Mali/Adreno WebGL, phone viewport

    pre.19

12. Network request-header hygiene

    pre.21

    under a persona the engine no longer emits redundant Cache-Control / Pragma request headers on navigations, matching a real Chrome cold navigation

13. Privacy-respecting defaults out of the box

    de-Googled base, WebRTC leak-proofing, Privacy Sandbox & intrusive APIs off, no telemetry or phone-home

Make it a true drop-in for the tools developers already use.

1. Python + Node + .NET SDKs (clearcote on PyPI + npm + NuGet), Playwright-first, with verified auto-download

2. launch() returns a standard Playwright object

   one-line migration

3. Auto-download + local cache of the verified binary

4. Saved profiles, persistent contexts, binary prefetch helpers, and opt-in auto-update with checksum/signature verification (SDK 0.9+)

5. geoip auto-match (timezone / language / geo / WebRTC-IP), plus a shared persona-seeded human-motion core driving cursor + input, bit-identical across the Python and Node SDKs

   pre.21

6. Optional in-browser AI agent

   pre.10

   drive a page autonomously via your own OpenAI-compatible / OpenRouter endpoint (bring your own key); off by default, real trusted input, password fields redacted

7. Raw serve() CDP endpoint

   drop-in for the whole ecosystem (Playwright connectOverCDP, Puppeteer, browser-use, Crawl4AI, Stagehand); render-backend coherence check; official Docker CDP-endpoint image

8. MCP server (clearcote-mcp)

   pre.20

   drive one shared stealth browser from Claude Desktop / Cursor / Cline with ~20 tools

9. Recipes & guides in the docs

   examples, deployment (Docker / CDP / frameworks), headless-on-servers and proxy configuration

Raise the bar on verifiability beyond "here’s a checksum."

1. Signed releases

   GPG detached signatures against a pinned key

2. SHA-256 checksums + a SHA256SUMS manifest for every release

3. Stealth-coherence regression gate + patch-integrity verifier run on every release — the shipped binary is launched and its invariants checked before it goes out

4. Build provenance / attestation (Sigstore-style) for every release

5. CI that builds, checksums, and publishes the browser in the open (SDK + Docker publish already run in CI)

Run it everywhere, and plug into the tools people already use.

1. Linux x64 build

   pre.17

   a native Linux persona (Mesa/OpenGL renderer, PulseAudio devices, Linux UA/UA-CH) with Widevine on Linux

2. Integrations with automation & agent frameworks

   the CDP endpoint + Docker image + MCP server cover Playwright, Puppeteer, browser-use, Crawl4AI, Stagehand, Claude and Cursor

3. macOS build

4. A self-hostable profile manager for organizing identities and proxies

5. Ongoing hardening informed by open fingerprinting research

Keep the free build alive by funding the work — openly, no dark patterns.

1. Clearcote Pro ($49/mo)

   pre.21

   a maintained, always-current build funds ongoing development

2. License-gated Pro binary + floating-concurrency SDK licensing (lease a slot per running instance, unlimited on Pro)

3. Direct email support from the maintainer

4. The free build stays 100% open and reproducible

   Pro is a maintained build + support, not a paywall on core features