Built in the open.

The unglamorous groundwork that everything else depends on.

• Project scope, principles, and architecture
• De-Googled base via ungoogled-chromium, pinned to an exact upstream revision
• Reproducible source-prep pipeline (fetch → prune → patch → verify)
• Clean, automated build from source on a commodity machine
• Published patch set — every change human-readable and individually documented

The moment you can download something and check it yourself.

• Windows x64 build as the first target
• Checksummed release artifacts (SHA-256) on GitHub Releases
• Reproducible build instructions a third party can follow to a matching binary
• One-command source bootstrap for contributors

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

• Per-profile, deterministic identity seed (stable across sessions, or fresh on demand)
• Engine controls for canvas, WebGL, audio, fonts, locale/timezone, navigator & hardware
• Per-site coherence (farbling-style): same site sees a stable identity; different sites don't correlate
• WebRTC: reports your proxy's address coherently, rather than exposing the real one or disabling WebRTC outright
• WebGPU adapter forced coherent with the WebGL persona GPU
• Full screen-dimension, font-list, WebGL getParameter table & CSS @media spoofing; import a real machine's fingerprint via --fingerprint-profile (pre.10)
• Cross-API coherence pass: 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 (pre.10)
• 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)
• Opt-in Widevine/EME so requestMediaKeySystemAccess('com.widevine.alpha') resolves and the DRM surface matches real Chrome (pre.15)
• TLS ClientHello persona (--fingerprint-tls-profile): the network layer follows the claimed Chrome version instead of the build's native TLS (pre.18)
• Best-effort Android mobile persona (--fingerprint-platform=android): touch, coarse pointer, mobile screen/DPR, Mali/Adreno WebGL, phone viewport (pre.19)
• Network request-header hygiene: under a persona the engine no longer emits redundant Cache-Control / Pragma request headers on navigations, matching a real Chrome cold navigation (pre.21)
• 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.

• Python + Node + .NET SDKs (clearcote on PyPI + npm + NuGet), Playwright-first, with verified auto-download
• launch() returns a standard Playwright object — one-line migration
• Auto-download + local cache of the verified binary
• Saved profiles, persistent contexts, binary prefetch helpers, and opt-in auto-update with checksum/signature verification (SDK 0.9+)
• 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)
• Optional in-browser AI agent — drive a page autonomously via your own OpenAI-compatible / OpenRouter endpoint (bring your own key); off by default, real trusted input, password fields redacted (pre.10)
• 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
• MCP server (clearcote-mcp): drive one shared stealth browser from Claude Desktop / Cursor / Cline with ~20 tools (pre.20)
• 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."

• Signed releases — GPG detached signatures against a pinned key
• SHA-256 checksums + a SHA256SUMS manifest for every release
• Stealth-coherence regression gate + patch-integrity verifier run on every release — the shipped binary is launched and its invariants checked before it goes out
• Build provenance / attestation (Sigstore-style) for every release
• 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.

• Linux x64 build — a native Linux persona (Mesa/OpenGL renderer, PulseAudio devices, Linux UA/UA-CH) with Widevine on Linux (pre.17)
• Integrations with automation & agent frameworks — the CDP endpoint + Docker image + MCP server cover Playwright, Puppeteer, browser-use, Crawl4AI, Stagehand, Claude and Cursor
• macOS build
• A self-hostable profile manager for organizing identities and proxies
• Ongoing hardening informed by open fingerprinting research

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

• Clearcote Pro ($49/mo): a maintained, always-current build funds ongoing development (pre.21)
• License-gated Pro binary + floating-concurrency SDK licensing (lease a slot per running instance, unlimited on Pro)
• Direct email support from the maintainer
• The free build stays 100% open and reproducible — Pro is a maintained build + support, not a paywall on core features