Qwave is a sovereign browser: its thesis is that you can know, and control, what it sends. This page is the honest answer. It is written for a person, not an auditor — though the code origins are cited so an auditor can check every claim.
There are three kinds of outbound connection, and the difference matters:
- A — Qwave's own. Code in this app decided to make the request. This is the category Qwave is fully responsible for, and the one this page holds itself to: every A connection must be justified and either user-controllable or documented here as not.
- B — WebKit fetching a page you asked for. You navigated somewhere; WebKit loads that page and its subresources. Not Qwave's decision, but Qwave's Shields and container isolation govern it.
- C — WebKit's own service traffic. Things the web engine may do on its own, independent of a specific navigation (fraud checks, prefetch, connectivity probes). Least visible, and the part a sovereignty claim most depends on — so it gets the most honest treatment below.
Status of this document: the Category A inventory is compiled by reading the network call sites in the codebase (origins cited). Category C is verified from WebKit's configuration in this app plus documented WebKit behaviour; full on-the-wire confirmation (mitmproxy against a local build) is a tracked follow-up, noted per row.
2026-08-15 correction. This block previously said the Category A inventory was "verified by reading every network call site". That was not true: the omnibox suggestion endpoint (
duckduckgo.com) was a Category A host absent from both this table and the allowlist (#78). It is listed below now, it is on the allowlist, and an assertion inEgressGuardTestsnow reads the host out of the request the provider actually builds. Nothing mechanically enumerates call sites, so treat this inventory as carefully maintained rather than machine-proven — see "What the allowlist is, honestly" below the Category A table.
BrowserCore/ReadingLanguageRequest.swift adds the selected Accept-Language
to ordinary main-frame GET navigations. The destination site sees that language
preference. This does not add another destination or replay form submissions.
BrowserCore/ReadingLanguageBar.swift passes bounded page text to Apple's
Translation framework on macOS 15+ / iOS 18+. Translation runs on-device; there
is no Qwave remote-translation endpoint or fallback. The OS may request language
model downloads. These framework-managed downloads are outside Qwave's own
request builder and its endpoint allowlist; they have not been packet-capture
verified. The Language menu controls automatic translation and exceptions.
See coverage and restoration behavior.
| Endpoint | Why | When | Can you turn it off? | Origin |
|---|---|---|---|---|
github.com/8b-is/qwave/releases/latest/download/appcast.xml |
Auto-update: check whether a newer signed release exists | "Check for Updates…" (you click it), and — only after you consent on first run — a periodic background check | Yes. Never runs before you consent; the automatic check is a setting you control. See Auto-updates. | Sparkle, SUFeedURL in project.yml |
api.mullvad.net |
VPN relay/account API | Removed with the VPN layer — a tunnel is a different layer, not the browser's requirement. | n/a — no such client exists | — |
raw.githubusercontent.com/.../easylist.txt |
Blocklist refresh | Removed. The blocklist now ships as a committed build-time snapshot; Qwave makes no request at launch. | n/a — no runtime egress | Regenerated by scripts/update-blocklist.sh |
api.x.ai/v1 (the default endpoint) |
Memory Wave: summarise / ask over your own captured pages | Only when you invoke Summarize/Ask and have turned on the OpenAI-compatible provider and entered a key | Yes — off by default (providerKind defaults to .onDevice; the remote provider requires explicit selection). Local inference does not send the prompt to this endpoint. When you do invoke it, the page text itself is what goes to the endpoint — see the note below the table. |
MemoryWave/MemoryProvider.swift; default in MemoryWavePreferences.swift:14,32-37 |
| Any HTTPS endpoint you type in (self-hosted Ollama / LM Studio / vLLM, a personal gateway, another vendor) | Same as above, but pointed wherever you choose | Same as above | Yes — you chose it. HTTPS is required (MemoryWavePolicy denies a non-HTTPS base URL). Settings states the egress at the moment of consent: "Pages you summarise or ask about with this provider are sent to this endpoint." A cross-host redirect is refused, so the page text cannot be replayed to a host you did not configure. The host you configure is also the only non-committed host EgressGuard will let Memory Wave's own provider request reach — exact match, resolved against the preference at the moment of the request, so changing or disabling the endpoint revokes the previous host on the spot. It is permitted for that request, not for the process: no other client in Qwave gains it. |
MemoryWavePane.swift:52 (consent copy); MemoryProvider.swift EndpointRedirectPolicy; MemoryWavePolicy.swift:83-85 (#88); mark at MemoryProvider.swift:108, check at EgressGuard.swift:236 |
duckduckgo.com/ac/ |
Omnibox autocomplete: suggestions for what you are typing | Only while you type in the omnibox, and only if you turned network suggestions on and DuckDuckGo is your chosen engine | Yes — off by default (networkSuggestionsEnabled defaults to false). Off means on-device suggestions only — history, bookmarks, open tabs, actions — and nothing leaves the Mac. When on, the transport is deliberately cookieless and ephemeral (no cookie storage, 3 s timeout), so the query carries no session identity. |
transport BrowserCore/SearchSuggestionProvider.swift (SuggestionTransport); call site BrowserWindowController.swift (engine-gated); engine mapping SearchSuggestionProviderFactory |
ac.ecosia.org/autocomplete |
Omnibox autocomplete: suggestions for what you are typing | Only while you type in the omnibox, and only if you turned network suggestions on and Ecosia is your chosen engine (it is the default) | Yes — off by default, same gate as the DuckDuckGo row: cookieless, ephemeral, 3 s timeout. Ecosia and DuckDuckGo are the only engines Qwave ships, for exactly this reason — both have a vetted keyless autocomplete endpoint. | transport BrowserCore/SearchSuggestionProvider.swift (EcosiaSuggestionProvider); allowlist QwaveSupport/EgressAllowlist.swift and core/src/egress.rs |
10.64.0.1, inside the VPN) |
Post-quantum key exchange for the VPN tunnel | Removed with the VPN layer | n/a — no such client exists | — |
| The favicon URL of a site you visit | Show the site's icon in the tab | When you load a page | Tied to browsing. Fetched with a cookie-free, storage-free session and cached per container, so a favicon fetch can never carry one container's identity into another. | Sources/QwaveApp/FaviconLoader.swift |
A .md/directory URL you navigate to |
Render remote markdown in the reader | When you navigate to a markdown document | Tied to that navigation — it fetches exactly the document you asked for, and only after WebKit has already fetched a response from that host. Exempt from the allowlist by an explicit EgressGuard.markPageDriven(_:) marker, not by accident. |
BrowserCore/NavigationCoordinator.swift |
Precisely, because this is the row people care most about:
- The page text goes. "Summarize Page" sends the extracted article body,
clamped to 12,000 characters, in the prompt
(
WaveDirector.swift:320-323→ArticleExtract.clamped()atMemoryRecord.swift:94,MemoryWaveConstants.maxPageCharacters). "Ask" appends the same clamped page text to your question (WaveDirector.swift:360-363). If you would not paste a page into that provider's web UI, do not Summarize it with that provider configured. - Stored memory bodies never go — by a declared-intent gate plus a
caller-side guard. Worth being precise about what each half does.
MemoryWavePolicy.decideis a pure function over a context the caller supplies: when that context says the provider is remote andincludeStoredMemoryis true, it returns.deny(.cognitiveEgress)and the request is refused before it is built (MemoryWavePolicy.swift:81-82). It therefore catches a caller that declares it is carrying stored memories; it never inspects the prompt, so it cannot see a caller that attaches them without declaring. What actually keeps recalled memories out of a remote prompt isWaveDirector's own guard — the recall block is composed into the prompt only whenprovider.kind == .onDevice(WaveDirector.swift:415-421). The context handed to the policy is built by the sameinfer(WaveDirector.swift:400-410);asksetsincludeStoredMemoryonly for the on-device provider (WaveDirector.swift:364), andsummarize(:326) andsummarizeTimeline(:210) never ask for it at all. Both halves hold with a remote provider configured and a key entered. Say plainly which half is load-bearing: the caller-side guard is. The policy is a tripwire behind it, dormant in normal operation precisely becauseasknever declares the dangerous pair — it is what fails if a future caller does.inferhands it the intent as declared, without pre-filtering, or it could not be tripped at all. - Recalled memories are split by provenance before they reach a prompt.
Rows a model wrote (
.summary) or an automatic page capture produced (.browse) are markedderivedat the write site and rendered under a separate "Untrusted recalled content" heading that tells the model to treat them as quoted data, rather than beside the pins you wrote yourself (WaveDirector.recalledMemoryBlock,WaveDirector.swift:49-70; column added atMemoryStore.swift:388). That is a prompt-position boundary, not an egress one — it applies to the on-device prompt, which is the only prompt recalled memories are composed into at all. - Timeline summaries are the titles-and-times case. Summarising your
timeline with a remote provider sends time, title, and host per entry and
omits every page snippet (
includeSnippets: !remote,WaveDirector.swift:199-200;MemoryTimeline.swift:63-80).
Reading this table: after the launch-fetch removal, every Category-A
connection is either off-by-default, VPN-gated, user-consented, or a direct
consequence of a page you asked for. The tested shields preparation path makes no request through
URLSession.shared. This is a scoped assertion, not a guarantee of no
network traffic during app startup: EgressGuardTests registers a
URLProtocol recorder (EgressGuardTests.swift:705-713), drives the shields
launch path, and asserts zero requests were observed
(testShieldsLaunchPathMakesNoNetworkRequest, EgressGuardTests.swift:716-738).
Its reach, stated exactly, because it is narrower than "no egress at launch".
The recorder is installed with URLProtocol.registerClass, which reaches
URLSession.shared and nothing else. A URLSession you construct never
consults it — not even one built from URLSessionConfiguration.default, which
earlier wording here implied was covered. That includes the ephemeral
DuckDuckGo suggestion session (SearchSuggestionProvider.swift:59-69), Memory
Wave's provider session (MemoryProvider.swift:49-55) and FaviconLoader's
(FaviconLoader.swift:20-24) — the first two reach the guard only because they
call EgressGuard.install(into:) themselves. WebKit's own network process is
out of reach for the same structural reason, which the test file already states
(EgressGuardTests.swift:58-66). And the test constructs its own
ShieldsDirector (:727-730) rather than running the app's launch sequence, so
it asserts over the shields preparation path specifically, not over everything
the app does at startup. It is no longer the only dynamic assertion in that
suite — the guard's block/allow behaviour (:204-244), the suggestion host read
out of a real request (:139-152), the page-driven markdown exemption
(:528-572, :577-600), the user-configured endpoint's reach and revocation
(:339-483) and registerClass's actual reach (:614-637) are all
exercised through real URLSession machinery — but it is still not a
process-wide egress monitor.
What the allowlist is, honestly. The committed
allowlist of permitted hosts
is now backed by a real runtime enforcement point,
EgressGuard: a
URLProtocol that consults EgressAllowlist.permits(host:) and fails any
request whose host is not listed, wired into every fixed-host Qwave client —
MullvadAPIClient (via URLSession.mullvadPinned()), the DuckDuckGo
suggestion provider, and, through a process-wide
URLProtocol.registerClass at launch, any client that uses
URLSession.shared. Memory Wave's remote provider joined that list only
now — see below for what its absence meant. duckduckgo.com is on the allowlist as of this
change (#78) precisely because
runtime enforcement would otherwise break the opt-in suggestion feature the
moment someone turned it on.
This closes the runtime half of #77,
but it is still not a mechanical guarantee over the whole codebase, and CI
still runs the same hand-written assertions pinning four known endpoint hosts
(MullvadAPIClient().baseURL, MemoryWavePreferences.defaultRemoteBaseURL,
the literal github.com at EgressGuardTests.swift:97-102, and a literal
duckduckgo.com/ac/ URL at
EgressGuardTests.swift:109-115) plus a rejection test for unknown hosts. One
assertion is not a restated literal:
testSuggestionEndpointHostIsAllowlisted reads the omnibox suggestion host out
of the request DuckDuckGoSuggestionProvider actually builds (a capturing
URLProtocol on an injected session), so it fails if that call site's URL
changes to a host nobody reviewed. It exists at all only because the test
target now depends on BrowserCore: it did not until
#78, so no assertion in this suite
could reach the provider even in principle, which is the sharper reason
duckduckgo.com went unseen for a whole release. Nothing
enumerates network call sites, so a new fixed-host URLSession client that
does not call EgressGuard.install(into:) is not caught — a reviewer still
has to notice it and wire it up, same as before. And by design EgressGuard
does not gate every Category-A client: FaviconLoader and the remote-markdown
fetch are page-driven rather than a fixed set of hosts. See EgressGuard's doc
comment for the full, per-client rationale.
Memory Wave's provider used to head that exclusion list, and that was the
gap, not a design. The stated reason — its base URL is user-configurable to
any HTTPS endpoint, so it cannot be pinned to a committed list — was true of
the committed list and true of nothing else. Its session is built from
URLSessionConfiguration.ephemeral and never called
EgressGuard.install(into:), so the guard had never blocked, permitted, or
observed a single provider request: api.x.ai was on the allowlist as a
comment. It is gated now. The user-configurable half is carried per
request: OpenAICompatibleProvider marks its own request with
EgressGuard.markUserConfiguredEndpoint(_:) — the same shape as the
page-driven marker below — and the guard permits it only if it is going to the
host you have configured right now, exact match (unlike the committed
list, which matches subdomains: typing example.com is not consent for
telemetry.example.com). So the guard permits the committed hosts, plus, on
Memory Wave's own request only, the one host you configured.
Two properties of that shape are worth being explicit about, because the first draft of this change kept the host in a process-wide slot and got both wrong.
Revocation is immediate. Settings writes providerKind / remoteBaseURL to
MemoryWavePreferences and calls nothing else — no provider is rebuilt, and if
you have just switched Memory Wave off there may be no next inference ever. A
permission published when a provider is built would therefore have left the
previous host permitted, potentially for the life of the process. The guard
instead reads MemoryWavePreferences.egressPermittedHost at check time
(through a closure installed once in BrowserEnvironment, so QwaveSupport
does not depend on MemoryWave). Nothing is cached, so nothing can go stale.
Uninstalled, that closure reports no host and a configured endpoint is refused:
the failure mode is closed.
It is not a process-wide permission. The endpoint you typed for Memory Wave
is not added to EgressAllowlist, which stays purely the committed list. Only
a marked request may reach it — not URLSession.mullvadPinned(), not the
DuckDuckGo suggestion session, not anything on URLSession.shared. Unlike
markPageDriven(_:), the mark grants nothing on its own: it cannot name a
host, so a caller cannot use it to reach anywhere except the endpoint you
configured.
EndpointRedirectPolicy and MemoryWavePolicy
(#88) still do what they always did —
refuse a redirect off the configured origin, and refuse a request that
declares it carries stored memories — neither of which was ever a host check.
Page-driven requests use explicit boundaries. FaviconLoader constructs
its own session and never installs the guard. Remote Markdown constructs a
fresh ephemeral session for each re-fetch and explicitly installs the guard.
EgressGuard.markPageDriven(_:) marks the navigated document request and each
HTTP(S) redirect, so it remains usable on hosts outside the fixed allowlist.
No host or entire session is exempted.
The request jar is seeded only from the initiating web view's cookie store. Foundation applies domain, path and Secure matching at each hop; response cookies stay in that disposable jar and are never copied back to WebKit. The original WebKit navigation owns browser cookie updates. This prevents a late/cancelled reader re-fetch from mutating browser cookies. There is no URLCache or URLCredentialStorage, even for ordinary tabs. Sessions are invalidated when finished or cancelled, with a 20-second idle timeout, 45-second resource timeout and 8 MiB response limit. HTTP-auth and client certificate credentials cannot be imported from WebKit; these challenges fail rather than using another context's stored credentials. TLS validation still uses the system default. Credential-bearing and non-HTTP(S) URLs are refused.
Being straight about the cost, since a page-driven exemption is a hole in the
guard by construction: any caller that applies the marker bypasses the
allowlist, and only review stops one from doing so. Two things bound it. It is
per request, not per host or per session — URLSession.shared stays gated
for everything else, and an unmarked request to the very same host is still
refused (both pinned by
testPageDrivenExemptionDoesNotExemptTheHostOrTheSession). The initiating
request is tied to browser navigation: the fetch runs from decidePolicyFor navigationResponse, i.e. after WebKit has already connected to that host and
received response headers, so the marked request re-fetches a document the
browser just retrieved because you asked it to.
When you navigate somewhere, WebKit fetches that page and whatever it embeds (images, scripts, fonts, XHR/fetch the page makes). Qwave does not add to or subtract from the set of things the page itself requests, except to block:
- Shields apply a ~59k-rule EasyList content blocker plus per-site JavaScript control, so many third-party trackers a page would otherwise load never connect at all.
- HTTPS-First rewrites
http://main-frame loads tohttps://. - Containers keep cookies/storage separate per container, and burner (ephemeral) tabs keep nothing.
This is the traffic you initiate by browsing. Qwave's job here is to shield it, not to add to it.
These are things the web engine can do on its own. Qwave configures WebKit, so what is on and off is Qwave's responsibility to disclose even though the requests originate inside WebKit.
| Behaviour | On? | What it means | Follow-up |
|---|---|---|---|
| Fraudulent-website warning (Safe Browsing) | On | WebKit checks sites you visit against a fraud/malware database. On Apple platforms this contacts Apple's Safe Browsing service (Apple proxies Google/Tencent Safe Browsing so the provider never sees your IP, but Apple's servers receive hashed URL prefixes for hosts you navigate to). It protects against phishing; it is also egress on navigation. | Whether to expose an off switch (WebKit's isFraudulentWebsiteWarningEnabled is a per-configuration flag Qwave already sets) is an open product decision. On-the-wire confirmation of exactly what is sent needs a mitmproxy sweep — tracked. |
| Known-hosts HTTPS upgrade | On | WebKit upgrades known HSTS hosts to HTTPS using a built-in list shipped with the engine. No network request — it is a local lookup. | None — local only. |
| DNS prefetch / speculative connections | Engine default | WebKit may resolve or preconnect to hosts a page hints at (rel=dns-prefetch/preconnect). Driven by page content, so effectively Category B, but initiated speculatively. |
Confirm scope empirically in the same mitmproxy sweep. |
The honest statement: the fraudulent-website warning is on, and it is the one piece of Qwave's network behaviour that talks to a third party (Apple) on navigation without an explicit per-visit choice. It is a real anti-phishing protection, not telemetry — but a sovereignty-first browser should let you decide. That decision, and the empirical confirmation of exactly what crosses the wire, is the next piece of work after this inventory.
Qwave uses Sparkle, and the consent chain is:
- Nothing checks before you say so.
SUEnableAutomaticChecksis deliberately not set, so Sparkle asks your permission (its standard prompt) before it ever checks automatically. No update request fires until you've answered. - You can change your mind, visibly. Settings → General → "Check for updates automatically" toggles it any time. Off means zero background update requests — the only way an update check happens is you choosing "Check for Updates…" from the menu.
- Only one host, and it's allowlisted. Update checks reach exactly
github.com(the signed appcast); that host is on the committed egress allowlist, andEgressGuardTests.testSparkleFeedHostIsAllowlistedasserts it stays there (note the scope described above — the assertion is over the host string, not over Sparkle's fetch). - Updates are EdDSA-signed — a compromised host cannot serve a forged update without the private key.
The ~59k-rule blocklist ships as a committed build-time snapshot,
regenerated by scripts/update-blocklist.sh and reviewed as a normal diff.
There is no launch-time fetch and no runtime blocklist egress. (An earlier
build fetched the upstream EasyList at every launch and discarded the
result — egress that bought the user nothing; that has been removed.) See
docs/BLOCKLIST.md.
If the honest answer to any row is "we send this and you cannot turn it off", this page says so. A disclosed limitation is worth more than an omitted one.
Published as part of the 8b.IS Documentation Hub and 8b-public-documents.