Clash, mihomo & GUI Clients: A Guide to the Open-Source Ecosystem

Start by separating the core, GUI, and subscription

Before comparing software names, break a proxy client into layers. The core reads the configuration, resolves domain names, matches rules, and forwards connections. The GUI (graphical user interface) displays controls, manages subscriptions, selects proxy groups, and saves settings. These are often bundled in one installer, but they are separate projects.

Think of the subscription as a third layer. It provides configuration or proxy node details; it is neither the core nor the client. Installing Clash Verge Rev does not automatically give you working nodes, and having a subscription does not mean every app labeled “Clash” can read it directly.

Follow the traffic path: “app → local proxy endpoint → core → rule-selected outbound.” For example, if the client sets the mixed port to 7890, the browser sends a proxy request to 127.0.0.1:7890. The core then decides whether to connect directly or use a node. This port is an example, not a default shared by every client.

How Clash, Clash Premium, and mihomo fit together

The original Clash: where rule-based proxy cores began

First, identify the original project. The original Clash usually refers to the Go-based proxy core started by Dreamacro. It established configuration structures familiar to many users, such as proxies, proxy-groups, and rules. Desktop apps with Clash in their names, such as Clash for Windows and ClashX, are clients that provide an interface for working with a core.

Keep the original open-source core separate from Clash Premium. Premium was a separately released, closed-source core branch with a different feature set. When older guides say “requires Premium,” they describe the core requirements at the time; that does not tell you whether today’s mihomo supports the same field. In November 2023, major changes affected public maintenance of the original Clash project and several related clients. For current choices, check each project's own repository instead of treating them as a single release.

Clash Meta: extending the Clash codebase

Next, consider Clash Meta. Developed from Clash's codebase, it added support for more protocols, DNS features, rules, and TUN. TUN is a virtual network interface that lets the core receive traffic through system routing; it is different from the system proxy used by browsers.

Understand the name change. Clash Meta was later renamed mihomo, and the current project is under the MetaCubeX organization. Older configuration guides, process names, and client interfaces may still say Meta. So “Meta core” does not necessarily mean a completely different project. Check the actual core version and where it was released.

Similar names don't imply a shared official connection

Check each project's maintainers and repository. Clash Verge Rev, Clash Nyanpasu, and ClashX Meta have their own development and release schedules. Using the same type of core does not mean they are released by the same team, or that one project's release notes apply to another.

Compare GUI clients and their cores by platform

Start with the comparison table below, then verify the specific version you plan to install. It shows the core commonly used by each project, but historical versions, third-party repackaging, and forks may differ. Feature availability ultimately depends on the core actually running on your device and how the GUI integrates with it.

Pay attention to suffixes. FlClash and FlClashs should not be assumed to come from the same publisher just because their names look alike. Clients with Meta, Rev, or other suffixes also need to be checked separately against their project pages, release history, and core documentation. The platforms covered by this site do not necessarily match the upstream project's full platform support list.

Evaluate iOS clients separately. Network traffic handling on iOS relies on system-provided network extensions. An app may import Clash-format configurations without using mihomo directly. For specific products such as Clash Plus, consult the technical documentation for the release on your platform. Support for a subscription format alone does not prove that the app uses the same core.

Check whether a Clash subscription works with mihomo

Inspect the subscription before importing it. A subscription URL may return a complete YAML configuration, a list of proxy nodes, or a format intended for another app. A “parse failed” message does not necessarily mean the nodes are down; the parser may simply have received the wrong type of content.

Check compatibility in four steps

1. Check the top-level structure. A complete Clash-style configuration usually includes fields for proxy nodes, proxy groups, and rules. A file containing only a list of nodes often needs the GUI's subscription manager or configuration merge feature.
2. Check protocols and fields. Older cores may not recognize node types, transport options, or DNS fields supported by newer ones. If you see an error such as unsupported proxy type, check the core version and its documentation first.
3. Check external resources. proxy-providers are external proxy providers, and rule-providers are external rule providers. Being able to download the main configuration does not mean those external URLs are accessible too.
4. Check local overrides. A GUI may override ports, DNS, the controller interface, and TUN settings. Values in the subscription file may not match the final configuration passed to the core.

Think of compatibility as directional. mihomo can usually handle many Clash-style configurations, but configurations using mihomo-specific fields are not guaranteed to work with older Clash versions. Even two clients using mihomo may behave differently if they bundle different versions.

Check the core and configuration running on your device

Record the GUI version and core version separately. They may be updated independently. For example, the interface may be up to date while a failed core download leaves an older core in use. Conversely, replacing the core does not automatically change the GUI's available settings.

Cross-check the interface and startup logs

• Open the client's About or version information section and note the app name and full version number. Menu names vary between clients, so don't follow menu instructions written for a different app.
• Check the core management section for the selected core and its version. If you can switch between multiple cores, confirm which one is currently enabled.
• Restart the core and check the startup logs for its version, configuration errors, and listening ports. Don't rely only on whether the window opens.
• When asking the community for help, include your OS version, processor architecture, GUI version, and core version. Also say whether the system proxy or TUN is enabled.

If you run mihomo directly, run the command below from the directory containing the program. This example assumes you already have your own config.yaml in the current directory. Use PowerShell on Windows and a terminal on macOS or Linux. A successful configuration test only means it passed the relevant checks; it does not guarantee that every node can connect.

# Windows PowerShell
.\mihomo.exe -v
.\mihomo.exe -t -f .\config.yaml

# macOS / Linux
./mihomo -v
./mihomo -t -f ./config.yaml

Whenever possible, use the GUI's configuration checker to test the final runtime configuration. Some clients merge subscriptions, overrides, and script results, so testing the original subscription file may miss problems introduced during merging. Don't launch a second instance listening on the same port while the GUI is already running the core.

Tell proxy ports apart from the controller interface

Check what each port is for. For example, mixed-port: 7890 is a combined HTTP and SOCKS proxy endpoint, while external-controller: 127.0.0.1:9090 is an interface for a GUI or dashboard to control the core. These are example values. Pointing your browser at the controller interface will not forward web requests.

Choose a client based on your device and maintenance needs

Start with a client that supports your operating system, then choose an interface that suits you. Don't stick with an old release that's no longer compatible with your current system just because the name is familiar. Open source and free are project attributes; still check recent releases, issue reports, and where the installer comes from.

1. Check your OS and architecture. On Windows, distinguish x64 from ARM64; on macOS, check whether you have Apple silicon or an Intel Mac. On Linux, also confirm the package format, such as DEB or RPM.
2. Check the features your configuration needs. Look up the protocols, rule providers, and DNS settings used by your subscription in the core documentation. Don't judge support from interface screenshots alone.
3. Check how traffic is handled. For typical browser use, start with the system proxy. If you need to cover apps that ignore it, consider TUN and whether the client provides reliable permission handling and service management.
4. Make sure you can back up your configuration. Save your subscription URL, override rules, and any essential local settings. Record the core version before upgrading so you have a clear way to roll back if something goes wrong.

When migrating, quit the old client first, then import the subscription and enable features one at a time. If two clients both change the system proxy, DNS, or routes, it becomes much harder to find the cause of a problem. Validate in this order: configuration passes checks → system proxy works → rule-based routing works → enable TUN if needed.

If the same subscription works in an old app but not a new one, compare the actual runtime configurations and logs first. Don't immediately copy the old client's entire data directory; cache formats, service settings, and file paths may differ. For basic instructions, see the user guide. To troubleshoot by symptom, visit Troubleshooting.

FAQ: How to tell similarly named projects apart

Is mihomo the new official Clash client?

It's more accurate to think of mihomo as a separately maintained core project. It continues the Clash Meta development line; it isn't a single official client with a complete desktop interface. After choosing a GUI, check which core it bundles or launches.

Will clients using the same core always behave the same way?

Compare the configuration and system environment first. DNS, routing rules, node selection, TUN routes, and the local firewall can all affect the outcome. Using the same core version removes just one variable; it doesn't eliminate these differences. Client names alone don't tell you how fast a connection will be.

Can I replace any client's core with mihomo?

First check whether the client explicitly supports custom cores. A GUI may depend on a specific controller interface, launch arguments, or file layout; mobile apps also involve core integration and app signing. If support isn't documented, don't try to replace the core just by renaming a file. Choose a maintained client that already supports mihomo.

Do beginners need to install multiple clients?

Start with one client and use it to import your subscription, select a proxy group, and test connectivity. Recording four details—GUI, core, subscription, and traffic handling mode—is enough to describe most basic setups. Install a second client only if you need to compare them, and make sure only one client manages the system proxy or TUN at a time.