1 Why Gemma 4 pulls you into two overlapping graphs
Open-weights hype is easy to tweet; the underlying network graph is what actually decides whether your Friday-night fine-tuning run finishes. Gemma 4 arrives in a moment when Google still wants developers inside Google AI Studio for low-friction keys, prompt iteration, and hosted evaluation, while the broader ML community mirrors artifacts on Hugging Face for discoverability, community cards, and tooling that speaks the Hub API. Neither surface is “just one domain.” AI Studio inherits the same Google identity, static asset, and API mesh that any modern Google web product drags along. Hugging Face, meanwhile, splits traffic between the marketing shell, authenticated Hub JSON calls, Git operations, LFS storage domains, short links, Spaces runtimes, and whatever CDN front door happens to serve a particular region on a particular day.
Clash on the Mihomo core is a good fit because you are not optimizing for a single TCP session—you are encoding policy for a whole afternoon of mixed traffic. You want the browser tab that loads a Gemma card to share DNS and egress assumptions with the terminal window that runs huggingface-cli download, and you want both to stay coherent when the Hub redirects a large blob to a CDN hostname your subscription previously treated as generic “foreign media.” Split routing with explicit DOMAIN-SUFFIX anchors turns those surprises into predictable matches instead of silent stalls on DIRECT.
Nothing here is legal advice about regulated regions or employer acceptable-use policies. Treat the following sections as network-engineering patterns: capture evidence in logs, codify rules, version-control YAML, and iterate when vendors ship new subdomains.
2 Relationship to the Gemini 2.5 + AI Studio guide
If you already followed our Gemini 2.5 + Google AI Studio tutorial, you own a solid baseline for Google OAuth, Generative Language API fronts, and the wide *.googleapis.com family. Keep that module. This Gemma-focused article adds the missing half of the workflow: model download ergonomics on Hugging Face, LFS-aware host coverage, and the operational habit of refreshing rule providers when Hub engineers introduce new delivery domains. Duplicating the entire Gemini hostname essay here would help nobody; instead, think in layers—Google layer, Hub layer, CDN layer—and merge them in strict order inside rules:.
Readers who juggle Google notebooks as well should peek at NotebookLM + Clash for another angle on Google service bundles, then return here to ensure Hugging Face-specific suffixes are not still falling through to a domestic catch-all.
3 Hugging Face: what actually needs proxy coverage
The public catalog lives on huggingface.co, but downloads rarely stay on that origin for every byte. Large checkpoints flow through LFS infrastructure and signed URLs that may bounce you toward regional CDNs. Short links and alternate entry points use hf.co. Spaces and community demos may hit hf.space or additional hosts that change as the platform evolves. If your profile only lists huggingface.co, you will see the classic failure mode: the HTML renders, metadata calls succeed, then the multi-gigabyte object hangs because cdn-lfs.huggingface.co or another delivery hostname stayed on DIRECT while the shell used your proxy—same symptom class as half-routed streaming sites, except the timeout arrives twenty minutes into the transfer instead of twenty seconds into a chat stream.
Git clients deserve the same discipline as browsers. A git clone of a model repo may talk to huggingface.co for refs while LFS batch URLs point elsewhere. Tools such as the official CLI wrap redirects and resumable downloads, yet they still obey your OS routing table and environment proxy variables. When those variables disagree with what Mihomo enforces in TUN mode, you can waste hours blaming “bad Wi-Fi” instead of inconsistent policy.
Capture ground truth once per quarter: open Mihomo connection logs, start a small test artifact download, and note every SNI you see. Fold any recurring partner CDN into either your Hub proxy group or a narrowly scoped “HF CDN” group if you need different node characteristics for huge objects versus interactive browsing.
4 Google AI Studio for Gemma: minimum viable Google coverage
Hosted trials for Gemma still walk the Google identity and API garden. Expect overlap with accounts.google.com, oauth2.googleapis.com, ai.google.dev, assorted *.google.com shell hosts, and static delivery via *.gstatic.com. Generative endpoints may continue to use Generative Language API fronts depending on how Google wires the Studio UI during 2026 refreshes; SDK traffic may still touch generativelanguage.googleapis.com or regional Google API hosts. Rather than guessing from blog prose, diff your working YAML against the Gemini guide’s module whenever Google publishes infra notes for Gemma releases.
The product goal is simple: whichever tab or SDK session is “trying Gemma now” should not flap between countries mid-session. OAuth in particular hates it when HTML and token endpoints disagree about exit geography. Assign AI Studio to the same outbound group you trust for other Google research work, and avoid bouncing that group hourly unless you enjoy re-auth challenges.
5 Symptoms when Clash rules under-cover Gemma workflows
Misrouted ML traffic rarely prints a single obvious error string. You might authenticate, see the Hub file list, and watch LFS objects stall at zero percent because the signed URL domain never matched a proxy rule. Conversely, the CLI can report TLS handshake failures while the website still loads, which usually means one tool used Mihomo DNS with FakeIP while another asked the ISP resolver for the same name. Intermittent HTTP 403 responses on otherwise healthy keys often correlate with split-brain DNS rather than quota exhaustion—especially when corporate split tunnels send Google APIs domestic while Hugging Face stays global.
Another subtle pattern is partial success on open-weights mirrors: some shards download at line rate while others crawl, because each shard hit a different CDN POP matched by different rules. Uniform DOMAIN-SUFFIX coverage plus a stable outbound reduces that variance more than cranking concurrency blindly.
6 Recommended profile shape for “Studio + Hub” developers
Start from a sane baseline: mode: rule, clearly named proxy groups, and domestic finance or intranet destinations pinned to DIRECT. Add a dedicated group such as AI_DEV that points at nodes you trust for both Google research and Hugging Face downloads. If latency and congestion differ materially between “interactive Studio” and “10 GB weight pull,” you may split into AI_BROWSER and AI_BULK—just document the split so teammates do not fork contradictory YAML.
Order matters inside rules:. Place explicit DOMAIN and DOMAIN-SUFFIX rows for Hub and Google research hosts above broad GEOIP shortcuts or subscription catch-alls. After the AI module, fall back to your normal policy stack. Keep MATCH semantics predictable; a surprise default to DIRECT at the bottom silently defeats everything above it for forgotten suffixes.
7 Example DOMAIN-SUFFIX rules (illustrative, merge carefully)
The excerpt below is educational, not a frozen universal truth. Replace AI_DEV with your real group label, reconcile with your subscription’s naming, and extend suffixes after you inspect logs during a real Gemma 4 session. Keyword rules are intentionally omitted here because short tokens collide too easily with unrelated sites; prefer suffix precision once you know the hosts.
# Hugging Face stack (extend with log-driven DOMAIN rows)
- DOMAIN-SUFFIX,huggingface.co,AI_DEV
- DOMAIN-SUFFIX,hf.co,AI_DEV
- DOMAIN-SUFFIX,hf.space,AI_DEV
- DOMAIN-SUFFIX,cdn-lfs.huggingface.co,AI_DEV
# Google AI Studio + common shared Google dependencies (see Gemini guide for depth)
- DOMAIN-SUFFIX,google.com,AI_DEV
- DOMAIN-SUFFIX,google.dev,AI_DEV
- DOMAIN-SUFFIX,googleapis.com,AI_DEV
- DOMAIN-SUFFIX,gstatic.com,AI_DEV
- DOMAIN-SUFFIX,googleusercontent.com,AI_DEV
When Hub redirects to third-party CDNs, add those suffixes explicitly after you confirm them in DevTools or CLI verbose logs. Some transfers use well-known commercial CDNs; routing “all of CloudFront” through AI_DEV is usually too broad, but routing a specific bucket hostname you observe repeatedly is reasonable. Revisit after major Gemma revisions because delivery paths can shift.
DOMAIN-KEYWORD entries can steer unrelated traffic through research exits, which hurts latency and may violate policy. Prefer tight suffixes tied to evidence.
8 Rule providers: share lists, but own your overrides
Hand-maintained YAML scales to one disciplined engineer; it rarely scales to a whole lab unless you introduce automation. Community rule providers help teams import curated fragments that track churn in SaaS domains, ad lists, or regional splits. The failure mode is semantic mismatch: a provider built for “block trackers” might null-route telemetry domains that Hugging Face or Google Studio still expects during OAuth. Always read provider README assumptions before you merge them into a research profile.
A pragmatic workflow is to keep a tiny private provider—or plain include file—with the Gemma-related suffixes you personally validated, then layer a larger “global AI” provider beneath it. Set a realistic interval for provider refresh; daily pulls are not inherently better if they introduce unreviewed diffs during a deadline week. Pair refreshes with CI or at least a human diff notification so a surprise deletion of cdn-lfs.huggingface.co does not land at 2 a.m. without review.
If you have never wired providers before, our ACL4SSR rule provider walkthrough explains the mechanics—URLs, behavior: classical, and how merged rule order interacts with your base subscription.
9 CLI downloads, resumable transfers, and environment variables
Browser trials are only half the story. Most serious model download work flows through huggingface-cli, Python huggingface_hub, or raw Git LFS. Those tools honor HTTP_PROXY, HTTPS_PROXY, and ALL_PROXY when implemented correctly, yet many scientific stacks also spawn libraries that open sockets without consulting your shell exports. When you see “works in browser, fails in notebook,” suspect bypass before you blame Gemma weights corruption.
For quick experiments, exporting HTTPS_PROXY=http://127.0.0.1:7890 alongside HTTP_PROXY often aligns with Clash’s mixed port, but verify your local client’s actual listening ports. SOCKS-heavy environments sometimes read ALL_PROXY=socks5://127.0.0.1:7891 more consistently. Keep NO_PROXY tight so internal PyPI mirrors, corporate artifact registries, and Kubernetes API servers stay local. When in doubt, test with curl -v https://huggingface.co from the same shell that runs your downloader; if curl succeeds while Python fails, you are debugging library behavior, not node health.
Large transfers benefit from resumable clients and sane retry limits. Clash cannot magically fix a dead upstream, but consistent routing prevents the “resume restarted from a different POP and different TCP characteristics” whiplash that shows up as corrupted shards. Document the working combination of proxy env vars and Mihomo mode so OS upgrades do not send you back to first principles.
10 DNS, FakeIP, and why Gemma sessions feel “random” when resolvers disagree
Modern browsers aggressively parallelize DNS, DoH, and connection warming. Mihomo may map names to FakeIP while a stubborn OS stub resolver still answers differently for the same hostname. The mismatch surfaces as intermittent TLS warnings, partial page loads, or Hub downloads that start then freeze when the redirect hostname never entered Clash’s view of the world. Standardize on one resolver story per machine: either Mihomo owns DNS with explicit fallbacks you understand, or you align OS settings to defer cleanly to Mihomo without fighting it.
IPv6 is another silent leak class. If the OS prefers IPv6 first but your policy stack effectively assumes IPv4-only exits, some sessions will route outside Mihomo in ways that look like “Hugging Face is flaky today.” Either tunnel IPv6 deliberately or test with IPv6 temporarily disabled to isolate the issue, then document the long-term fix instead of toggling interfaces weekly.
For deeper patterns—DoH, DoT, FakeIP, and leak checks—reuse the guidance in our Meta core DNS leak prevention article whenever you touch enhanced-mode or add new upstreams while chasing Gemma connectivity.
11 When TUN beats per-app proxy exports for ML tooling
System proxy mode helps browsers and polite HTTP stacks, but scientific Python environments, containerized runners, and some Git helpers ignore env vars entirely. TUN pushes routing into the kernel so packets meet Mihomo before user-space libraries decide how to connect. For a workstation that mixes Google AI Studio tabs, local notebooks, and background Hugging Face pulls, TUN frequently reduces bespoke configuration. Our Clash Verge Rev TUN mode guide covers loop avoidance, verification, and the mental model for full-traffic capture—skills that transfer directly to Gemma-era workflows.
After enabling TUN, re-run a small Hub download with system proxy disabled to confirm the CLI still exits through Mihomo. Snapshot the YAML that worked; future you will thank present you when a kernel upgrade resets interface metrics.
12 FAQ
- Studio loads but model calls fail: Diff your Google module against the Gemini guide; confirm
googleapis.comand OAuth hosts share one stable group and DNS alignment. - Browser Hub works, CLI hangs: Compare proxy env vars versus TUN capture; many CLIs bypass system proxy unless forced.
- Downloads start fast then stall: Log the redirected CDN hostname and add a precise
DOMAIN-SUFFIXrow above catch-alls. - Do I need a separate VPN? Not if your Clash profile already encodes the hostname graph; VPNs without fine-grained rules often add jitter without fixing LFS redirects.
- Where should teammates get the client? Prefer the site download hub for installers; keep GitHub for source and issues, not as the default onboarding path.
13 Wrap-up
Gemma 4 is a useful forcing function for a broader lesson: open-weights workflows are multi-vendor graphs spanning Google AI Studio, shared Google infrastructure, and the Hugging Face delivery plane. Clash shines when you stop treating those graphs as implicit knowledge and instead encode them as ordered split routing policies—anchored with DOMAIN-SUFFIX lines you can defend with logs, augmented by disciplined rule providers, and supported by DNS and optional TUN choices that keep every layer honest about the same exit path.
Compared with all-or-nothing VPN clients, a Mihomo-powered profile preserves domestic latency for everyday sites while giving research traffic the stable handoff it needs for both quick Studio trials and long model download sessions. Invest once in evidence-based YAML, then spend your cognitive budget on evaluation metrics instead of staring at stalled progress bars.
When you are ready to standardize clients across a team, start from our download hub so installers stay reproducible; upstream repositories remain the right place for license text and collaboration, not the first hop for a tired teammate who only wants routing to behave before dinner.
