Mass-Production Proxy Client · Straight From the Open-Source Ecosystem
One blister pack, every part included: rule-based routing sorts traffic by domain and IP, the open-source mihomo core handles connection quality, and subscription management automates node import and updates. Ready to use out of the box, across Android phones and desktop platforms alike.
SPEC / KERNEL: mihomo · CONFIG: YAML
PROTO: Shadowsocks / VMess / Trojan / Hysteria2 / TUIC
Clash for Android Download
Cross-Platform Client · Rule-Routing GuideAccessory Shelf: Direct Links to All Five Platforms
download.html#windows … #linuxPick by Platform, One Slot Per System
Each slot maps to a platform shelf on the download page — click through and land right on it. Every slot gives just one line on scope; full client lists, system requirements, and install steps live on the download page.
Five Core Components, Spec by Spec
Slots on the left, manual on the right. Each component covers three things: what problem it solves, how to use it, and how it differs from the usual approach. By the end you'll know if this setup fits your needs.
Rule-Routing Engine
The problem it solves is specific: not wanting all traffic squeezed through the same channel. The rule engine matches each connection against conditions like domain keywords, domain suffixes, IP ranges, and process names, then sends it to one of three exits — Direct, Proxy, or Reject — the same three tags shown on the pack. Sites in mainland China go direct without detours, services outside China go through the proxy, and ad or tracking domains get rejected outright.
Usage is declarative: rules live in the YAML config, matched top to bottom, and stop at the first hit. The difference from an all-or-nothing "global proxy switch" is granularity — there's no need to flip back and forth between two network states; write the rules once, and every connection routes itself afterward. Paired with rule-set subscriptions, common rule sets can be referenced as a whole and updated on a schedule, instead of being typed out line by line.
Multi-Protocol Core
Connection quality is the core's job. Every client listed on this site is built on the open-source mihomo core (the continuation of Clash Meta), written in Go as a single cross-platform binary. Protocol coverage spans Shadowsocks, VMess, VLESS, Trojan, Hysteria2, TUIC, WireGuard, and other mainstream options, so a single config can mix nodes running different protocols without conflict.
In practical terms: switching providers or protocols doesn't mean switching software. If a subscription is Trojan today and adds Hysteria2 tomorrow, the client parses and runs it exactly the same way. Compared with single-protocol clients, having one core cover every protocol means config migration and multi-device sync all revolve around a single YAML file — learn it once, use it everywhere.
Subscription Manager
No copying node details by hand. Take a subscription URL from a provider, paste it into the client's config/subscription page, and node lists, groups, and rules all pull in at once; after that, the client refreshes on a set interval, so if the provider changes node addresses, the next update picks it up automatically without a manual re-import.
Multiple subscriptions can coexist too: each one is an independent config profile, switchable with a single click — handy for holding several services at once, or keeping work and personal use separate. Compared with older clients that require adding servers one by one, the subscription model shifts node maintenance to the server side — you only keep track of one URL. For the troubleshooting order when a subscription fails to pull, see the dedicated article in the blog section.
Proxy Group Switching
A proxy group is a storage bin for nodes. Group nodes by region or purpose, and rules point to the group instead of a specific node; how the group picks a node depends on its type: select for manual choice, url-test for automatically picking the lowest-latency node, fallback for stepping in order when the primary node fails, and load-balance for spreading connections across multiple nodes.
The benefit shows up the moment a node goes down: no need to edit rules, just swap a member in the group, or leave it to url-test to handle automatically. Video streaming can use a low-latency group, downloads a high-bandwidth group, work a fixed-IP group — each group doing its own job. Groups can be nested too; see the advanced config page for more.
TUN Global Takeover
Some programs ignore system proxy settings entirely — command-line tools, games, and some desktop apps bypass the HTTP proxy port outright. TUN mode creates a virtual network adapter in the system, intercepting all device traffic at the network layer and handing it to the core, so even uncooperative programs get covered by the rules. On Android, this is the VPN mode, and it turns on without root.
Paired with Fake-IP resolution, DNS queries first get a fake address from a reserved range, with real resolution deferred to the exit — this speeds up the first packet and avoids DNS results getting poisoned by the local network. Compared with setting a proxy for each program manually, TUN is a "turn on once, covers everything" solution, at the cost of a one-time system permission prompt; the step-by-step setup is on the Quick Start page.
Assembly Instructions: Three Steps to Wire Up
From installer to a webpage loading through the proxy, the standard flow is just three steps. This is the thumbnail version — the full guide has screenshot-level detail for every step.
Import the Subscription
After installing the client, paste the subscription URL from your provider into the config page to pull in nodes and rules. If the link format isn't recognized, first check whether it's a Clash-native link or a generic sharing format.
Pick a Mode, Choose a Node
Leave the mode on the default "Rule" setting; go to the proxy page and batch-test node latency, then pick one with a low number. The tutorial has a comparison table for when Global and Direct modes apply instead.
Connect and Verify
Flip the switch, then open an IP lookup page to confirm the exit address has changed — only a changed address counts as actually working; relying on the switch state alone can be fooled by leftover system proxy settings.
Proof of Origin: Fully Auditable Code
This isn't a black box. From the core to every GUI client, the source code lives in public repositories — inspect the build quality directly if you want.
Project History
Clash first appeared in 2018 as an open-source rule-based proxy core, quickly becoming the de facto standard in its category thanks to YAML config and flexible rule syntax. After the original repository was archived, the community carried development forward under the name Clash Meta, later renamed mihomo, which continues to iterate today — going further than the early versions in protocol support, rule types, and performance.
Open-Source Ecosystem
A ring of GUI clients has grown up around the core: Clash Plus and Clash Meta for Android on the Android side, and Clash Verge Rev, FlClash, Clash Nyanpasu, and others on desktop — each independently open-source and independently released, but all reading the same config format. This site gathers them onto one shelf by platform, saving the time of digging through repositories one by one.
How the Core and Clients Relate
GUI clients handle the interface, subscription management, and system integration, while connections and rule matching are all handled by the embedded mihomo core. That means rule behavior stays identical when switching between clients; server and router users can even skip the GUI entirely and deploy the core binary directly.
Update Mechanism
Version numbers and installer links on the download page are checked against upstream release records on a script-driven schedule, and swapped in as soon as new versions ship — the page always reflects the actual current downloadable version, not a manually maintained list that goes stale.
Unboxing Inspection
Clone the mihomo core repository locally with one command:
git clone https://github.com/MetaCubeX/mihomo.git
- LICENSEGPL-3.0 open-source license
- LANGGo · single-binary delivery
- PLATFORMWindows / macOS / Android / iOS / Linux
- CONFIGYAML, shared across clients