Skip to content
Back to search

fury-antidetect-browser

Free, open-source anti-detect browser. A Chromium 155 fork that spoofs the fingerprint in C++ rather than with injected JavaScript, with per-profile personas and proxies, a built-in MCP server for AI assistants, and a self-hostable team server with per-project access. No seats, no per-profile pricing, no telemetry.

Safety scan

A static text scan, not a guarantee. Select the badge to see what was scanned and every finding.

Checked today

Check it deeper on your machine

It has changed since its scan on 11 Nov 2026.

As a Claude Code plugin, install it and then ask Claude Code:

/plugin marketplace add keithmackay/mackayi/plugin install scanskillsafety@mackayiDo a deep scan of https://github.com/furyteamtop/fury-antidetect-browser with scanskillsafety

Or from a terminal, clone it and run it:

git clone https://github.com/keithmackay/scanskillsafety-skill ~/.claude/skills/scanskillsafetynode ~/.claude/skills/scanskillsafety/cli.cjs --deep 'https://github.com/furyteamtop/fury-antidetect-browser'

It checks the exact commit: every file, its packages against OSV (api.osv.dev), how it compares with this page's scan (findsafeskills.com receives the repository's address), and, if you agree, Claude reading every file with your own Claude subscription. It never runs the code.

Badge for your README
findsafeskills safety rating

Markdown

[![findsafeskills safety rating](/api/listings/furyteamtop--fury-antidetect-browser/badge.svg)](/listings/furyteamtop--fury-antidetect-browser)

HTML

<a href="/listings/furyteamtop--fury-antidetect-browser"><img src="/api/listings/furyteamtop--fury-antidetect-browser/badge.svg" alt="findsafeskills safety rating" /></a>

Install

i

What was scanned

The files the safety scan read, as written by the repository's author and shown as plain text. Lines with a finding are marked.

README.md · README · 410 lines

View this file on GitHub (read at the repository's current version: the scan did not record which commit it read)

This file has changed since it was scanned, so this is not exactly the text that was scanned, and no line is marked. The findings are listed with the safety scan above.

  1. <picture>
  2. <source media="(prefers-color-scheme: dark)" srcset="assets/logo-dark.png">
  3. <img src="assets/logo.png" alt="Fury" width="420">
  4. </picture>
  5. A free, open-source anti-detect browser with real team collaboration. Own
  6. Chromium fork, works standalone with no server, self-hostable when you need a
  7. team. No seats, no per-profile pricing, no telemetry.
  8. **[furybrowser.dev](https://furybrowser.dev)** · *[Русская версия](README.ru.md)*
  9. > **Status: in development, and now on both macOS and Windows.** The core builds
  10. > and spoofs; the agent launches profiles; the server and desktop shell work.
  11. > Builds are on the [Releases](https://github.com/furyteamtop/fury-antidetect-browser/releases)
  12. > page, marked pre-release. **macOS builds are signed and notarised since
  13. > 21.09.2026; Windows is not** — see below.
  14. >
  15. > **Windows works, as of 16.08.2026.** The Chromium core built (57 528 targets),
  16. > the agent runs on it, and `tools/verify-windows.ps1` passes 30 claims on a real
  17. > machine: the config reaches the browser as an inherited HANDLE, argv carries a
  18. > slot number and nothing else, no process in the tree has a persona string in
  19. > its command line, and the browser reports the persona's platform rather than
  20. > the host's. The desktop shell builds to an NSIS installer. This paragraph used
  21. > to say *not yet*, and it said so for as long as that was true.
  22. >
  23. > Getting there found eight defects that only running could find — a BSD `df`
  24. > flag, a bootstrap that returned success having done nothing, CRLF making
  25. > `git apply` claim a patch was stale, PowerShell reading UTF-8 as
  26. > Windows-1252, a persona leaking through `--user-data-dir` into every child
  27. > process, and a `beforeBuildCommand` that cmd.exe could not execute. They are in
  28. > the history, one commit each, with what they cost.
  29. >
  30. > **Team mode works end to end, as of 18.08.2026.** Invite, enrol on a second
  31. > machine, be let in with one button, send a profile to the server, open it
  32. > there. Every stage of that path had a defect and one of them — sending a
  33. > profile — had never worked at all: the fingerprint seed crossed as a number
  34. > where the server wants sixteen hex characters, so every upload since the
  35. > endpoint existed died in the request parser. They are in the history with what
  36. > each looked like from the operator's side.
  37. >
  38. > **macOS is signed and notarised, as of 21.09.2026.** The Apple Developer
  39. > enrolment paid for on 15.08.2026 came through that day, and the same evening
  40. > the 0.1.4 macOS files were rebuilt with the Developer ID and re-uploaded:
  41. > the application, the core and the disk image each carry a stapled ticket,
  42. > and Gatekeeper's verdict on a machine that has never seen them is
  43. > `accepted, source=Notarized Developer ID`. Open the DMG, drag, open — no
  44. > right-click, no `xattr`. The first real run of
  45. > [sign-core.sh](tools/release/sign-core.sh) and
  46. > [sign-shell.sh](tools/release/sign-shell.sh) found five defects in the
  47. > scripts themselves, which is in the history; [docs/17](docs/17-apple-signing.md)
  48. > is the paperwork.
  49. >
  50. > **Windows is not signed.** That is a separate certificate, not started, so
  51. > the installer shows SmartScreen: **More info → Run anyway**. A macOS download
  52. > of 0.1.3 or earlier is ad-hoc signed and needs `xattr -dr
  53. > com.apple.quarantine /Applications/Fury.app` once; [docs/15](docs/15-install.md)
  54. > walks through both.
  55. >
  56. > **Linux** is not a target. See the table at the bottom.
  57. >
  58. > Everything that is *not* done is listed at the bottom, honestly.
  59. ## Why another one
  60. Anti-detect browsers cost $30–150 a month per team and are closed source, so
  61. nobody can check what they actually spoof. We measured the popular ones: in one,
  62. the canvas readback was **byte-identical to a clean machine** — not spoofed at
  63. all, while the interface listed it as protected
  64. ([docs/08](docs/08-competitors.md)).
  65. This is the inverse. Every vector is documented against the Chromium file it
  66. lives in, the patches are in the repo, and you can measure it yourself with the
  67. bench that ships alongside.
  68. "Self-hosted" is a word others use now too — with a closed core behind a licence
  69. key and one token for the whole installation. Here three things come together,
  70. each of which exists somewhere on its own and nowhere together: **a core you can
  71. build and verify**, **a team** with roles, locks and an audit trail, and **a
  72. server you run yourself** that cannot read your bundles
  73. ([docs/08](docs/08-competitors.md)).
  74. ## Three ways to run it
  75. | | What you host | For |
  76. |---|---|---|
  77. | **Solo** | nothing | one person, own profiles |
  78. | **Team, self-hosted** | one binary + PostgreSQL | an agency or a team |
  79. | **Team, hosted for you** | nothing | people who do not want to run servers |
  80. **Solo is the default.** No account, no registration, no database. Profiles and
  81. proxies live on your machine. Everything that makes this an anti-detect browser
  82. works here in full — the team layer adds nothing to the fingerprint.
  83. **Self-hosted** is what you turn on when there is a team: projects, per-project
  84. access grants, a distributed lock. One binary and Postgres on any VPS —
  85. [docs/13](docs/13-self-hosting.md).
  86. **Hosted** exists, and it opened only once the condition it was gated behind
  87. was met: bundles are encrypted on the operator's machine, so the server holds
  88. data it cannot itself read. The address is prefilled on the sign-up screen
  89. (`srv.furybrowser.dev`, [desktop/src/defaults.ts](desktop/src/defaults.ts))
  90. and is editable — a team with its own server clears it and types theirs. It
  91. runs with open sign-up, every registration is its own organisation, and it is
  92. still somebody else's machine: [docs/13](docs/13-self-hosting.md) is one
  93. command if you would rather that not be true.
  94. ## What works today
  95. A profile using a Windows 11 / RTX 4060 persona, launched on an Apple Silicon
  96. MacBook, reports:
  97. ```
  98. navigator.platform Win32
  99. userAgent Windows NT 10.0; Win64; x64 … Chrome/157.0.0.0
  100. WebGL renderer ANGLE (NVIDIA, NVIDIA GeForce RTX 4060 (0x00002882) Direct3D11 …)
  101. screen 1920×1080, availHeight 1032 ← the taskbar
  102. Client Hints platform Windows brands: … Google Chrome/157
  103. timezone Europe/Berlin
  104. navigator.webdriver false
  105. ```
  106. Consistently — in the main frame, in a Worker, and in three kinds of iframe. A
  107. disagreement between execution contexts is three lines of JavaScript to find and
  108. gives away a spoof more reliably than not spoofing at all.
  109. One exception: speech synthesis voices. On a Mac this profile reports the macOS
  110. voices, because the system has no Windows voices and they cannot be invented.
  111. For real work, use a persona of the same OS as the computer; see "Open" below.
  112. The noise is deterministic: the same profile produces the **same** canvas hash
  113. on every read, forever. A fingerprint that changes between calls describes a
  114. machine whose hardware moves while you watch it, which is worse than an honest
  115. one.
  116. ## How it fits together
  117. ```
  118. desktop (Tauri) ──socket──▶ agent (Rust) ──spawn──▶ core (Chromium fork)
  119. │ │ through a relay
  120. └──HTTPS──▶ server (optional: teams)
  121. ```
  122. - **core** — Chromium 157 fork, [41 patches](core/patches/); spoofing is in C++,
  123. never injected JavaScript
  124. - **agent** — the only component holding decrypted secrets: proxy relays,
  125. launching, the local automation API
  126. - **server** — organizations, projects, permissions, locking. Deliberately dumb:
  127. it never generates a fingerprint and never decrypts a bundle
  128. - **desktop** — Tauri rather than Electron: a 12 MB download, not 120 MB
  129. Details in [docs/01](docs/01-architecture.md).
  130. ## Install
  131. If you only want to use it, you do not need any of what follows:
  132. [docs/15](docs/15-install.md) is two downloads and one command, and it is the
  133. page to send anybody who asks how to try this.
  134. How to use the application once it is installed (profiles, proxies, importing
  135. from other anti-detect browsers, a team, invitations and project access,
  136. updating): [docs/19](docs/19-guide.md).
  137. ## Build
  138. The core took **2 h 42 min** on an Apple M5 with 10 cores and 16 GB, in the
  139. `macos-arm64-lowmem` configuration — measured on 30.07.2026, not estimated. The
  140. checkout and one build directory come to ~39 GB, also measured; `fetch.sh` still
  141. demands 150 GB free and warns about ~100 GB, and that number is a cautious
  142. estimate rather than a measurement ([docs/03](docs/03-chromium-fork.md)).
  143. Everything else takes minutes. Incremental rebuilds after the first are 5-30
  144. minutes depending on what changed; `ccache` and `sccache` do not help, because
  145. the build uses `-fmodules` and they miss on everything.
  146. ```bash
  147. git clone https://github.com/furyteamtop/fury-antidetect-browser && cd fury-antidetect-browser
  148. cargo build --release
  149. ```
  150. ```bash
  151. cd desktop && npm install && npm run app:build
  152. ```
  153. Building the core: [docs/03](docs/03-chromium-fork.md).
  154. ## Run it
  155. Start the local daemon — this is the whole solo product:
  156. ```bash
  157. cargo run -p fury-agent -- serve
  158. ```
  159. Point it at a core binary if it is not beside the agent:
  160. ```bash
  161. FURY_CORE=/path/to/Chromium cargo run -p fury-agent -- serve
  162. ```
  163. Launch a persona directly, without any store, to see the spoofing work:
  164. ```bash
  165. cargo run -p fury-agent -- launch shared/personas/windows-11-rtx4060-1920x1080.json --proxy socks5://user:pass@exit.example:1080 --timezone Europe/Berlin
  166. ```
  167. ## Automation
  168. Six endpoints and one bearer token, off until `FURY_API_PORT` says otherwise.
  169. [examples/](examples/) has four working scripts — curl, Playwright, Puppeteer,
  170. and the one people actually want: run a job across every profile, one at a time,
  171. never leaving a browser open on a failure.
  172. **MCP server, built in.** Open **AI assistants** in the sidebar and press
  173. Connect: Claude Desktop, Cursor, Claude Code or any MCP client can then create
  174. profiles and proxies, open profiles, go to sites, read pages, click, type, take screenshots and
  175. warm profiles up, by asking in plain words: "open every profile tagged warm,
  176. check the inbox, close them". The server is `fury-agent mcp`, shipped in every
  177. install, and it carries its own skill, so the assistant knows how Fury works
  178. from the first message. Competitors sell this as an "AI agent", for credits, on
  179. their model, on their server, with access to your profiles. Here the assistant
  180. is yours, the key is yours, and proxy passwords never reach it.
  181. **Extensions** — a `.crx` is installed into a profile from the application; the
  182. extension's id survives cloning (the developer key is written into the
  183. manifest), so a wallet or an anti-captcha stays signed in inside the copy. Or
  184. pick one from the built-in catalogue, or by its Web Store id: the package is
  185. fetched through each profile's own proxy.
  186. **Warm-up and window sync** — warming visits ordinary sites in a profile, with
  187. human pauses and scrolling, so it carries everyday cookies before an account
  188. goes into it. Window sync repeats clicks and typing from one profile in several
  189. others.
  190. **Proxies** — paste a list in any common format; the exit is checked through
  191. the proxy itself (IP, country, timezone), a mobile proxy is rotated by its
  192. link, and profiles are created in bulk or from CSV.
  193. **Domain lists** — a per-profile blocklist enforced by the relay (DoH cannot
  194. route around it), or a whitelist: put `@allow-only` on the first line and the
  195. profile opens only the platforms named. For the team member who should be on
  196. one.
  197. **Fingerprint probe** — every profile's start page links to a full detect-suite
  198. run inside that profile: every vector, every execution context, in a secure
  199. context. The same probe the baselines are captured with, not a separate display.
  200. ## Check it yourself
  201. Do not take any of the above on trust — measure it:
  202. ```bash
  203. cd tools/detect-suite && python3 -m http.server 8791
  204. ```
  205. [`tools/detect-suite/status.html`](tools/detect-suite/status.html) is the last
  206. measurement rendered as a page — the gate's thirteen checks, the nine contexts,
  207. and Fury beside real Chrome on the same machine. It is generated from the
  208. captures in the repository, so it cannot say anything they do not.
  209. Open `http://127.0.0.1:8791/probe.html` in ordinary Chrome and in Fury, and
  210. compare the dumps. `fury-detect diff` shows what moved, `fury-detect gate` runs
  211. the release criteria and exits non-zero on failure, so it drops into CI
  212. ([tools/detect-suite](tools/detect-suite/README.md)).
  213. ## Documentation
  214. | Doc | Contents |
  215. |---|---|
  216. | [01 — Architecture](docs/01-architecture.md) | Components, processes, deployment tiers |
  217. | [02 — Fingerprint surface](docs/02-fingerprint-surface.md) | Every vector, where it lives, where to patch it |
  218. | [03 — Chromium fork](docs/03-chromium-fork.md) | Building, patch management, the rebase treadmill |
  219. | [04 — Data model & RBAC](docs/04-data-model-rbac.md) | Schema, roles, permission matrix |
  220. | [05 — Proxy & networking](docs/05-proxy-networking.md) | Relay design, DNS, WebRTC, leak prevention |
  221. | [06 — Profile sync](docs/06-profile-sync.md) | Bundle format, encryption, locking, conflicts |
  222. | [07 — Detection baseline](docs/07-detection-baseline.md) | Test harness and measurable pass criteria |
  223. | [08 — Competitors](docs/08-competitors.md) | What we measured in the commercial ones |
  224. | [09 — Roadmap](docs/09-roadmap.md) | Phases with exit criteria |
  225. | [16 — Parity and beyond](docs/16-parity-and-beyond.md) | What four competitors have that this does not, what none of them have, and the order to do it in |
  226. | [10 — Legal & licensing](docs/10-legal-licensing.md) | Chromium BSD, Widevine, branding, code signing |
  227. | [11 — Budget](docs/11-budget.md) | What costs money and what does not |
  228. | [12 — UX reference](docs/12-ui-reference.md) | What to copy from AdsPower, and where to beat it |
  229. | [13 — Self-hosting](docs/13-self-hosting.md) | Standing up a team server |
  230. | [14 — Team server](docs/14-team-server.md) | Accounts, enrolment, the RBAC model in practice |
  231. | [15 — Installing](docs/15-install.md) | For somebody with no toolchain ([ru](docs/15-install.ru.md)) |
  232. | [17 — Apple signing](docs/17-apple-signing.md) | Getting the Developer ID certificate that task 0.2 waits on, and what still has to be written once it exists |
  233. Documents are in Russian except 15, which is the one a downloader reads;
  234. translation of the rest is planned.
  235. ## Not done yet
  236. Three lists, kept apart on purpose: what is still open, what was decided
  237. against and why, and what has been closed. A closed item stays on the page
  238. with the measurement that closed it, because the next person to ask "does it
  239. handle X" deserves the answer and not the archaeology.
  240. ### Open
  241. | | |
  242. |---|---|
  243. | Code signing, Windows | not started. A separate certificate (EV or OV) and a separate process; until then the installer shows SmartScreen and the way through is **More info → Run anyway** |
  244. | Widevine on a machine with no Chrome | the agent stages the CDM out of the Chrome already installed on that machine, so nothing proprietary is redistributed and `com.widevine.alpha` is answered the way real Chrome answers it. A machine with no Chrome at all gets a working browser with no DRM, which is detectable |
  245. | Persona catalogue | 32 machines, two of them Android phones captured from real devices. More personas means better crowds to hide in, and it is the most useful thing an outside contributor can add — `fury-detect persona <capture.json>` turns a probe capture from your own computer into one |
  246. | Speech synthesis voices | a leak, found 24.09.2026. A persona of another OS reports the host's voices: a Windows persona on a Mac answers `speechSynthesis.getVoices()` with 180 macOS voices ("Milena", "Eddy (…)"), which no Windows machine has. The built-in personas carry `voices: []`, so the filter never engages; the contributed Windows 10 one lists only Google voices, which Fury does not have, and patch 0041 discards a filter that matches nothing, because an empty list gives the spoofing away even more surely. The patch can only narrow the list. A voice the system does not have cannot be added: `speak()` on it would fail in a way no real machine fails. So on a Mac a Windows persona cannot get Windows voices at all; until this changes, the rule is a persona of the host's OS. CreepJS and the Castle checks do not catch it, they only look for an empty list |
  247. ### Decided against, with the reason
  248. Each of these is a way to be caught or a way to be inconvenienced, and the
  249. row says why the alternative is worse.
  250. | | |
  251. |---|---|
  252. | Linux | not a target, and this is a decision rather than a gap. The Rust still compiles there so CI and contributors can run the suite; there is no Linux release, no Linux core config and no plan for one. Shipping a third platform nobody tests would be a claim, not a port |
  253. | WebRTC through the proxy | no. The relay is TCP; patch 0070 puts the browser in the state a real Chrome reaches under the enterprise `WebRTCIPHandlingPolicy` — no ICE candidates at all — rather than let a peer connection go around the proxy and hand the page the real address |
  254. | Hiding CDP from a timing check | no, and now known to be unclosable rather than merely undone. Split into its two parts ([cdp-timing.py](tools/detect-suite/cdp-timing.py)): attaching costs nothing, `Runtime.enable` costs a fixed 2.7x plus more as the logged object grows. A patch can remove the size half — preview generation — and not the fixed half, which is the message reaching the frontend at all. Real Chrome measures the same. The control that works is `cdp: false`, which is the default |
  255. | Updates | one button, never on its own. Since 0.2.18 the application asks GitHub for a new release at start and every six hours and shows a bar; Settings → About turns the check off. From 0.3.0 the bar's **Update** downloads the new version, checks its signature against the project's key, installs it and restarts; it refuses while profiles are open, and a file without that signature is never installed. The request goes from this machine's address, not a profile's proxy. How it is kept safe: [docs/15](docs/15-install.md) |
  256. | QUIC / HTTP-3 | no difference from Chrome, but it does show the proxy. Measured on three sites: real Chrome with no proxy uses h3; real Chrome behind a SOCKS5 proxy uses h2 and never h3. Chromium does not carry QUIC through a proxy, and a profile is always behind one, so Fury behaves exactly like Chrome behind the same proxy. That is not the same as looking like a home user: a site that offers h3 and sees a client stay on h2 visit after visit can conclude that UDP does not reach it, meaning the client is behind a proxy or on a network that blocks UDP. The signal is weak (h2 is also normal on office networks and on a first visit, before the browser learns about h3), but it exists and Fury does not hide it. Hiding it takes a proxy that forwards UDP, which Chromium cannot do through `--proxy-server`; turning that on would make Fury *differ* from Chrome behind a proxy |
  257. ### Closed
  258. | | |
  259. |---|---|
  260. | ~~Offline GeoIP~~ | done 09.10.2026 (0.2.23), contributed by @devrahmanbd: the checker field takes the path of a MaxMind `.mmdb` file. The exit address is still asked through the proxy, and country, city and timezone come from your file, so the only third party left is the one that reports the address. No database is bundled |
  261. | ~~Chromium 157~~ | done 05.11.2026 (0.5.0): both cores moved to 157.0.8103.39 |
  262. | ~~Chromium 155~~ | done: the Windows core moved from 153 to 155.0.8059.12 on 27.09.2026 (0.2.3), macOS on 30.09.2026 (0.2.10). A copy running an older build of the browser is told so and offered the new one (0.2.16). Both moved to the stable 155.0.8059.39, with its 247 security fixes, on 08.10.2026 (0.2.21) |
  263. | ~~pixelscan and iphey flagging profiles~~ | done 29.09.2026 (0.2.9), with edge noise that keeps the colour in 0.2.10: what they caught were the fonts a persona reported and the shape of the canvas and WebGL noise |
  264. | ~~MCP for AI assistants~~ | done 08.10.2026 (0.2.18): built into the application. It used to be a Python script that needed the HTTP API switched on by hand and was in no installer |
  265. | ~~Windows core build~~ | done 16.08.2026: the core builds on the build server, release `v0.1.2` ships `fury-core-0.1.2-windows-x64.tar.xz` on Chromium 153, `verify-windows.ps1` passes 30 claims, Widevine answers |
  266. | ~~Windows launcher~~ | done: agent and shell run, NSIS installer in the releases. The config reaches the browser as an inherited HANDLE and no persona value appears in any argv — checked on a live machine |
  267. | ~~Code signing and notarisation, macOS~~ | done 21.09.2026: Developer ID, notarised, stapled — application, core and disk image, [sign-core.sh](tools/release/sign-core.sh) and [sign-shell.sh](tools/release/sign-shell.sh). Verified on the files downloaded back from the release page with the quarantine flag set |
  268. | ~~Client-side bundle encryption~~ | done, and verified end to end against a running server: what it writes to disk holds neither the cookie, nor a tar header, nor a gzip header, and a foreign organisation key does not open it |
  269. | ~~Bundle sync with the server~~ | done. Packed and sealed on stop, fetched and unpacked on launch, versioned so a second uploader is refused rather than silently winning. Uploads stream to disk: they used to buffer, under axum's 2 MB default, which meant sync had never once worked for a real profile |
  270. | ~~Shared TOTP secrets~~ | done, both modes. A profile carries logins — username, password, two-factor seed — sealed with the machine key alone, or with a per-login data key wrapped under the organisation key when there is a server. The server holds a blob it cannot read; a foreign organisation asking for it gets 404 from the handler and zero rows from the database. All of RFC 6238's vectors pass, for SHA-1, SHA-256 and SHA-512, and the code is computed outside the webview in both modes |
  271. | ~~Per-organisation quotas~~ | done, and off unless set. `FURY_MAX_ORGS`, `FURY_MAX_PROFILES_PER_ORG`, `FURY_MAX_STORAGE_PER_ORG` — for a server that takes open sign-ups, where isolation between organisations is total and fairness is not |
  272. | ~~Row-level security on the server~~ | done. Migration 0006 adds FORCE (the app owns its tables, and an owner is exempt without it) and `auth::Db` binds the caller to the connection. Verified against a real PostgreSQL — remove either half and four tests fail |
  273. | ~~The "Google API keys are missing" bar~~ | done 22.09.2026, patch 0902, in the 0.1.6 core. Chromium showed it in the first window of every profile, in the UI language, saying "Chromium"; writing the check found it also left `innerHeight` 56 px larger than the viewport the page laid out in — a first-window mismatch real Chrome does not have. `core/verify/verify-0902.py` measures both |
  274. ## Contributing
  275. The most useful thing you can send is a persona from your own computer —
  276. `fury-detect persona` turns a probe capture into one, and the catalogue is 32
  277. machines, each of which is a crowd for somebody to hide in. The second most
  278. useful is a site that caught a profile. [CONTRIBUTING.md](CONTRIBUTING.md) has
  279. both, and the rule that governs everything else: measurements are welcome,
  280. claims are not.
  281. ## Licensing
  282. Three sets of terms, and they are not interchangeable.
  283. - `agent/`, `server/`, `desktop/`, `shared-rs/`, `tools/`, `core/build/`,
  284. `core/args/`, `core/verify/` — **AGPL-3.0-or-later** ([LICENSE](LICENSE))
  285. - `core/patches/` — derived from Chromium, **BSD-3-Clause**, upstream terms
  286. preserved, so a browser built from the series carries one set of terms and no
  287. copyleft reaches someone who only wants the browser
  288. - `shared/` schemas — **Apache-2.0**, so anyone can implement compatibility
  289. AGPL is deliberate: anyone running a service on this code has to publish their
  290. changes, which is what keeps "free" free. Reasoning in
  291. [docs/10](docs/10-legal-licensing.md).
  292. Chromium itself is not in this repository — `core/build/fetch.sh` downloads it
  293. from Google under its own licence.
  294. **Widevine is not distributed here and must not be.** The CDM is a proprietary
  295. binary. The low-memory GN args build with Widevine support and
  296. `core/build/link-widevine.sh` stages the blob out of the Chrome already
  297. installed on the build machine — which is fine because it is already there, and
  298. only because it never leaves. A bundle built that way contains a 20 MB
  299. unredistributable library inside
  300. `Chromium.app/Contents/Frameworks/…/Libraries/WidevineCdm/`. Do not ship it —
  301. `core/build/build.sh` says so when such a build finishes.
  302. ## Acceptable use
  303. Fury is a privacy and multi-account management tool, built for QA, ad
  304. verification, market research, scraping within terms, and running several
  305. legitimate business accounts. Using it for fraud, credential stuffing, phishing
  306. or evading law enforcement is not supported and not welcome in this issue
  307. tracker.
  308. Fury is an independent project, not affiliated with or endorsed by Google, and
  309. carries no Chrome or Google branding. Chromium is used under its own licence.
  310. The User-Agent declares Chrome because sites branch on it and a browser that says
  311. anything else is distinguishable in one line — which is the whole point of the
  312. exercise, and is what every Chromium fork does.
  313. ## Support
  314. Everything here is free, for everyone, and stays that way. No seats, no
  315. per-profile pricing, no paid tier held back, no telemetry. That is a decision
  316. rather than a stage: the licence is AGPL and every measurement is published
  317. precisely so nobody has to take anyone's word for what the browser does.
  318. There is no company behind this and nothing is sold. What it costs is ordinary
  319. and dull — a code-signing certificate so the download does not fight Gatekeeper,
  320. and a machine to rebuild the core against every Chromium release
  321. ([docs/11](docs/11-budget.md) itemises it). If the project is useful to you and
  322. you want to put something toward that:
  323. **USDT (TRC20)** — `TNvKC6tXKtsxA4tDrjU86zbmwMGuxfmatq`
  324. Nothing is gated behind it, now or later. And a persona measured on your own
  325. machine is still worth more than money — see [Contributing](#contributing).
  326. ## Author
  327. Bogdan Shapovalov — [@shapovalovbogdan](https://t.me/shapovalovbogdan) on Telegram.
  328. Questions about the measurements, a site that caught a profile, or a persona
  329. from your own machine are all welcome there or in the issue tracker.

Ratings and comments

Sign in to rate this skill.

Sign in

Free to use. If it’s helped, pass it on.