Clash Kernel Differences: Original Clash vs Clash Meta vs mihomo Comparison Guide

Kernel Timeline: Original Clash → Clash Meta → mihomo

The Clash kernel is the core process that loads configs, matches rules, and forwards traffic—GUI clients like Clash Verge and ClashX are essentially interfaces wrapped around that kernel. Interfaces come and go, but there are really only two kernel lines: the discontinued original Clash, and the community-maintained Clash Meta (now called mihomo). Telling these two apart is the first step before picking a client, reading a tutorial, or troubleshooting a problem.

• Original Clash: written in Go by Dreamacro, licensed under GPL-3.0. The author deleted the repository in November 2023, ending the project; the closed-source Clash Premium build (with TUN and script-based rules) was discontinued at the same time.
• Clash Meta: developed by the MetaCubeX team on top of the public original codebase, adding new protocols, open-source TUN, domain sniffing, and more—commonly known in the community as the Meta kernel.
• mihomo: Clash Meta was renamed mihomo in late 2023, with version numbers continuing from v1.18 onward. It's the only actively maintained mainline kernel today, and virtually every modern client bundles it.

Original Clash: The Feature Baseline at End of Life

Original Clash was frozen in November 2023, so its feature set serves as the common baseline shared by every Clash-family kernel:

• Proxy protocols: HTTP, SOCKS5, Shadowsocks, ShadowsocksR, VMess, Trojan, and Snell, with full inbound and outbound support.
• Rule-based routing: rule types including DOMAIN, DOMAIN-SUFFIX, DOMAIN-KEYWORD, GEOSITE, IP-CIDR, GEOIP, SRC-IP-CIDR, DST-PORT, and MATCH; five proxy-group types—select, url-test, fallback, load-balance, and relay.
• DNS module: nameserver, fallback, and enhanced-mode (fake-ip / redir-host), with support for routing resolution through specific channels by domain.
• Closed-source Premium extras: full TUN takeover, rule-providers rule sets (RULE-SET), PROCESS-NAME process matching, and SCRIPT-based rules—none of this code was ever open-sourced.

The impact of the shutdown goes beyond "no new features." Protocols that gained traction after 2023—Hysteria2, TUIC, Reality—simply aren't supported. The Go runtime and crypto components are frozen on old versions, so security issues will never be patched, and nobody is tracking compatibility with newer OS releases. The only thing the original kernel is still good for today is running old configs that haven't been touched in years.

Clash Meta and mihomo: What the Community Mainline Added

mihomo builds on the original baseline with systematic expansions across four main areas.

Protocols

Adds VLESS (with XTLS Vision flow control and Reality), Hysteria, Hysteria2, TUIC v5, WireGuard, and SSH outbounds, with newer releases adding protocols like AnyTLS. Legacy protocols—Shadowsocks, VMess, Trojan—are fully preserved, so existing nodes keep working.

TUN

Rebuilds the closed-source Premium TUN as an open-source implementation, with a choice of system, gvisor, or mixed stacks, plus auto-route for automatic route takeover, auto-detect-interface for automatic outbound NIC selection, and dns-hijack for intercepting system DNS queries. Full system-wide takeover no longer depends on closed-source components.

Sniffing and Rules

The sniffer feature recovers real domain names from the SNI in a TLS handshake or the Host header in an HTTP request, fixing rule mismatches that occur with IP-based rules under fake-ip. On the rules side, it adds AND, OR, and NOT logical combinators plus SUB-RULES, rule-providers gains inline behavior and the mrs binary format, and PROCESS-NAME process matching is now open-source and cross-platform.

DNS and Scheduling

DNS gains respect-rules (routing resolution based on your existing rules), proxy-server-nameserver (resolving node domains through a proxy), and direct-nameserver (a dedicated channel for direct resolution). On the scheduling side, it offers tuning options like unified-delay for consistent latency stats, tcp-concurrent for concurrent dialing, find-process-mode for process lookup, and global-client-fingerprint for TLS fingerprinting. The external control API stays compatible with the original, so existing dashboards work without changes.

Feature Comparison: Original Clash vs mihomo

The takeaway is straightforward: mihomo is a strict superset of original Clash, with backward-compatible config syntax. Anything that runs on the original kernel runs on mihomo too—but not the other way around. Any config using VLESS, Hysteria2, or the open-source TUN stack will error out or be silently ignored if you drop it back into the original kernel.

Config Differences: Fields You Must Change When Migrating

Migrating from the original kernel to mihomo, most fields work as-is, but there are four spots where people commonly get tripped up:

• external-controller syntax stays the same: dashboard address and secret auth format are identical, so after migrating, confirm your dashboard can connect to the kernel before troubleshooting anything else.
• TUN config structure is different: field names and nesting differ between original Premium's TUN and mihomo's open-source TUN, so rewrite the old tun section according to mihomo's docs. Enabling auto-route and auto-detect-interface eliminates most manual routing work.
• rule-providers format is extended: original Premium only recognizes yaml/text rule sets, while mihomo also supports inline and mrs. When referencing third-party rule sets, double-check that the behavior and format fields actually match.
• fake-ip and sniffing interact differently: mihomo's default behavior leans toward "sniff first, then match." If an old config relies on specific fake-ip behavior, check how sniffer and fake-ip-filter interact to make sure domain rules aren't being bypassed.

Which Kernel to Pick, by Scenario

New users

Just pick a client that bundles mihomo—skip the original entirely. New protocols, OS support, and rule sets only ever land on the mihomo line, so choosing the original means giving up on updates from day one.

Sticking with an old config

If your subscription only has legacy protocols like SS, VMess, or Trojan, and the config hasn't been touched in years, you can stay on the original kernel for now—but plan to migrate to mihomo soon. The migration cost is mostly limited to the TUN and rule-set sections, and it pays off once you've done it.

Need full system-wide takeover (TUN)

For game boosters, UWP apps, or programs that ignore the system proxy, use mihomo's open-source TUN with the mixed stack for the best balance of compatibility and performance. Don't rely on the closed-source Premium TUN anymore—no one is fixing it.

Subscription includes new protocols

If your node list has VLESS Reality, Hysteria2, or TUIC, mihomo is your only option—the original kernel simply can't parse them. This is also the fastest way to check whether a client's kernel is up to date: import a subscription and see if the new-protocol nodes show up at all.

Running multiple clients side by side

If you have several clients installed on the same machine, check each one's kernel version. Otherwise, one client might change the system proxy or routing while another one, running an outdated kernel, tries to take over with old logic—leading to rules stepping on each other.

Spotting Your Kernel in Three Seconds

1. Open the "About" or "Kernel Info" page in your client and check the kernel name and version. If it shows Clash with a version frozen in 2023, that's the original; if it shows mihomo or Clash Meta with a version of v1.18 or later, that's the community mainline.
2. Check the protocol list: if Hysteria2, VLESS, or TUIC show up as options, it's mihomo; if you only see SS/SSR/VMess/Trojan, it's the original.
3. Check the TUN settings: fields like stack, auto-route, and dns-hijack mean it's mihomo's open-source TUN; a single TUN toggle with no sub-options usually points to the closed-source Premium implementation.

A mismatched kernel shows up in predictable ways: large numbers of nodes missing after importing a subscription, TUN not taking effect even when enabled, or rule matching results that don't line up with a tutorial. If you see any of these three symptoms, check the kernel line first, then dig into the config.