Clash Open-Source Ecosystem Explained: Original Core, mihomo, and GUI Clients

A-01Where It All Started: the Original Clash Core

To make sense of the many Clash-style clients on the market today, you need to trace things back to the origin. The original Clash was a rule-based proxy core written in Go, shipped only as a command-line program plus a YAML config file — it parsed subscriptions, matched routing rules, and managed proxy nodes, with no GUI of its own. That core set the baseline syntax the whole ecosystem still follows: proxies for node definitions, proxy-groups for policy groups, and rules for routing order. Nearly every fork and client since has kept this same config structure, which is why a subscription link from one source usually works across totally different clients.

Development on the original core stalled in mid-2023, with no new releases for a long stretch and no support added for newer protocol features or rule syntax. That doesn't mean the original core is "unusable" — plenty of older configs still run fine on it — but it's no longer the actively maintained mainline, so new features, protocol support, and security fixes won't land on this version.

A-02The Fork Timeline: How Clash Meta and mihomo Are Related

As maintenance of the original core slowed down, several community forks emerged, and the most influential by far was Clash Meta. Building on the original, it added a stable TUN mode implementation, more complete rule syntax (like RULE-SET and process-level rules), and support for newer proxy protocols such as Hysteria and TUIC. It quickly became the core that most GUI clients call under the hood.

Clash Meta was later officially renamed mihomo — this wasn't a rewrite or a fresh start, but the same development line continuing under a new name. Today, most mainstream GUI clients bundle the mihomo core rather than the original Clash core, which is why a client's settings page often shows a mihomo version number under "core version" instead of anything labeled "Clash." Once you understand this relationship, changelog entries like "upgraded core to mihomo x.x.x" make a lot more sense — they're referring to the underlying engine, not the client's own UI.

Put another way, mihomo is essentially the beating heart of the whole ecosystem right now, and each GUI client is the shell wrapped around it, turning the core's capabilities into something you can click through and inspect visually. Keep that in mind as you go through the client comparison below — it'll make things click faster.

A-03GUI Client Roundup: Different Interfaces, Same Core Underneath

GUI clients exist to solve one problem: editing raw config files is a hassle. They turn subscription imports, node switching, and rule inspection into point-and-click interfaces. Interface design, workflow, and extra features vary a lot between clients, but almost all of them call into mihomo or an earlier form of it under the hood. Here's how a few common client types stack up.

That last category deserves a specific warning. Clash for Windows was, for a long time, practically synonymous with the Windows platform, but the project has stopped receiving updates and no new commits are being merged — its core is stuck on an older version. Sticking with it won't break things overnight, but you'll gradually run into unrecognized newer protocol nodes and unsupported rule syntax, and the lack of security maintenance is a real long-term risk on its own. On Windows today, the actively maintained alternatives with real community traction are almost all built on the mihomo core.

Different Interfaces, Same Config Files — Here's Why

This comes straight from the inheritance chain covered above: most clients parse configs through the same mihomo core logic, following the same YAML syntax spec. So in theory, the same subscription link can be dropped into Clash Verge Rev, FlClash, or other clients without regenerating anything — you'll just see differences in UI layout and how many tunable parameters are exposed. That's also why picking a client is mostly about weighing interface style and platform fit, not worrying about whether your config will "actually work."

A-04Which One to Pick: By Platform and Use Case

Building on the timeline above, here are a few practical pointers for choosing a client:

1. On Windows and macOS desktop, lean toward actively updated clients built on the mihomo core — lighter-weight UIs with full config exposure suit users who want to tweak rules by hand.
2. On Android, pick a client that explicitly supports VpnService and is still under active maintenance, and after installing, check whether the system's battery-saving mode affects background connection stability.
3. On iOS, platform restrictions mean clients look and behave differently from desktop or Android — stick to versions distributed through official channels with a clear update history.
4. If your current client's docs still say it's "based on the original Clash core" and hasn't seen an update in ages, it's worth planning a move to a mihomo-based alternative — migration usually just means re-importing your existing subscription link.
5. Don't get hung up on "newer is always better." Stability, community feedback, and update frequency together are a more reliable signal than the version number alone.

What to Watch for When Migrating

Switching from one client to another is usually as simple as re-adding your subscription link — no need to rewrite rules by hand. But if your existing config includes custom policy groups, script-based rules, or unusual parameters, it's worth opening the new client's config viewer after migrating to confirm the rule count and policy group count match what you had before, so no rules get silently dropped due to parsing differences.

curl -x http://127.0.0.1:7890 https://www.gstatic.com/generate_204 -I

Once migration is done, you can use the command above to check whether the local proxy port is responding — a HTTP/1.1 204 No Content response confirms the new client's proxy service has taken over traffic correctly. From there, go through your policy group switching and rule matching to make sure everything behaves as expected.

A-05FAQ