What Is Clash Meta and the Mihomo Rename?

Clash Meta is an enhanced fork of the Clash core maintained by the MetaCubeX community. After upstream Clash stopped receiving public maintenance, Clash Meta became the de facto choice for users who wanted modern protocols, steady releases, and an active ecosystem. In 2024 the project renamed its main repository to Mihomo. The change is branding and positioning: your existing config.yaml structure, proxy groups, rules, and DNS blocks remain valid, so day-to-day migration friction stays low.

The Mihomo name reflects a broader goal than “Clash-compatible only.” The core now targets first-class support for QUIC-style transports, Reality-style TLS camouflage, and large rule sets without blowing up memory. Rule matching, DNS routing, and connection lifecycle handling were reworked so that upgrades feel faster and more stable on laptops, desktops, and phones alike.

If you still run an old Clash build or an early Clash Meta bundle inside a legacy GUI, moving to a current Mihomo-based client is the cleanest way to unlock Hysteria2, TUIC v5, and VLESS+Reality without maintaining parallel tools. The sections below follow the same structure as our Chinese edition: preparation, per-platform upgrades, protocol examples, DNS tuning, FAQs, and a short note on why curated builds matter.

Before You Upgrade

A few minutes of preparation prevents half an hour of guesswork. Treat this as a short checklist you can reuse whenever a new Mihomo stable lands.

1. Back up your configuration

Copy config.yaml and any imported rule files, providers, or snippets to a safe folder (cloud drive or version control). If you maintain multiple profiles, name them with dates so rollback is obvious. For more on options and safe defaults, see our documentation hub.

2. Confirm your GUI matches the kernel

Not every third-party UI tracks Mihomo at the same pace. Before you upgrade, open your client’s About or Kernel page and note the embedded Mihomo version. If the UI is several releases behind, update the app bundle first—mixing a brand-new kernel with an obsolete front-end often triggers parser errors or missing toggles. Our download page ships tested Windows, macOS, Android, and other builds so the GUI and kernel stay in sync.

3. Validate subscription compatibility

Most provider subscriptions parse cleanly on Mihomo. Edge cases appear when a feed relies on deprecated VMess fields or very old Shadowsocks dialects. If nodes fail to import after upgrade, skip ahead to the FAQ; usually trimming stale nodes or asking the provider for an updated URI fixes it.

Compatibility note: Mihomo keeps standard Clash configuration keys backward compatible. In the typical case you do not need to rewrite proxies, groups, or rules—only add new blocks when you adopt fresh protocols.

Platform-by-Platform Upgrade Steps

We recommend installing an integrated client from this site so the kernel, permissions, and updater match. Advanced users can still compile or replace binaries manually; that path is slower and easier to misconfigure.

Windows

  1. Open your client, go to About or Kernel, and write down the current Mihomo version.
  2. Visit the Windows download section, grab the newest installer, and close any running Clash tray app before setup.
  3. Run the installer and follow the wizard; it replaces kernel files for you—no manual rename dance inside resources folders.
  4. Launch the app, confirm the version bump on the About screen, then run a latency test on a few groups.
  5. If something fails to start, restore the backed-up YAML and compare diffs; remove GUI-only extensions (see FAQ) before retrying.

macOS

  1. For ClashX Pro, Mihomo Party, or similar GUIs, download the latest .dmg from our macOS channel and drag the app into Applications to overwrite the old copy.
  2. If you manage Mihomo through Homebrew instead, stop the service, upgrade the formula, and start it again: 
    # Stop the existing service
brew services stop mihomo
# Update package to latest version
brew upgrade mihomo
# Restart the service
brew services start mihomo
  3. When macOS shows an unidentified developer warning, open System Settings → Privacy & Security and choose Open Anyway for the bundle you trust.
  4. Your prior config.yaml path usually survives in place; reselect the profile if the app asks.

Android

Android users should fetch the current APK from the same download page. Installing over an existing Meta-based client typically preserves subscriptions and local configs. After install, open About and verify the Mihomo revision. If your vendor ships a separate “Meta” fork, prefer the build that tracks upstream Mihomo release notes.

Android 14+: Before sideloading, enable installation from your browser or file manager under Apps → Special access → Install unknown apps. Without that toggle, the package installer will stop mid-way.

Hysteria2: High Throughput on Lossy Links

Hysteria2 builds on QUIC and Brutal-style congestion ideas so bulk transfers stay usable when latency spikes or UDP loss is high. Mihomo ships native hysteria2 proxies—no extra sidecar binaries.

Why people adopt it

  • Resilience: QUIC’s loss recovery keeps video calls and large downloads steadier than classic TCP tunnels on poor routes.
  • Fast handshakes: 0-RTT resumption means tabs feel snappier when you reopen a browser session.
  • Operational simplicity: Declare the node in YAML; the client negotiates ALPN and TLS like any other modern proxy type.
  • Tunable bandwidth hints: Honest up/down hints help the server avoid overfilling your last mile.

Sample proxy block

Add this under proxies: and reference the name inside your proxy groups:

proxies:
  - name: "HY2-Example"
    type: hysteria2
    server: your-server.example.com
    port: 443
    password: "your-password"
    sni: your-server.example.com
    skip-cert-verify: false
    up: "100 Mbps"
    down: "200 Mbps"

If your ISP aggressively polices UDP, cap up/down or ask your provider for a TCP fallback profile. Hysteria2 shines on UDP-friendly networks.

TUIC v5: Low-Latency QUIC Sessions

TUIC (Transparent UDP in QUIC) targets minimal handshake overhead and efficient stream multiplexing. Compared with Hysteria2, many users pick TUIC when they open hundreds of short-lived connections—think news sites with aggressive prefetching or chat apps with constant small packets.

Mihomo reads TUIC nodes without plugins. A typical v5 stanza looks like this:

proxies:
  - name: "TUIC-Example"
    type: tuic
    server: your-server.example.com
    port: 443
    uuid: "your-uuid-here"
    password: "your-password"
    version: 5
    alpn:
      - h3
    congestion-controller: bbr
    udp-relay-mode: native

congestion-controller: bbr is a solid default on most residential links; switch to cubic if you notice oscillation on a saturated uplink. udp-relay-mode: native keeps real-time UDP games and VoIP paths closer to wire speed.

VLESS + REALITY: TLS Camouflage Done Right

VLESS with REALITY borrows the TLS fingerprint of a real public site so censors see ordinary HTTPS chatter. Mihomo implements the client side, including reality-opts and XTLS Vision flows where your server supports them.

Unlike classic domain-fronting tricks, REALITY does not require you to own the front domain; you only mimic its certificate chain behavior. Pair that with disciplined servername choices—popular CDNs or software vendors—and passive inspection becomes far noisier.

Sample REALITY node

proxies:
  - name: "VLESS-Reality"
    type: vless
    server: your-server.example.com
    port: 443
    uuid: "your-uuid-here"
    network: tcp
    tls: true
    udp: true
    flow: xtls-rprx-vision
    servername: www.microsoft.com
    reality-opts:
      public-key: "your-public-key"
      short-id: "your-short-id"

Swap servername, public-key, and short-id for the values your operator publishes. Keep flow aligned with what the upstream actually enables; mismatched Vision flags are a frequent copy-paste mistake.

Pick the right tool: Hysteria2 favors harsh links, TUIC v5 favors chatty sessions, and VLESS+REALITY favors strict censorship environments. You can mix them in one profile and let proxy groups decide per rule.

Rule Engine and DNS Improvements

Beyond raw protocols, Mihomo tightens how rules and DNS interact. Large community rule sets (for example Loyalsoldier-style bundles) match faster thanks to improved indexing, which keeps CPU and RAM lower on laptops running 50k+ lines.

DNS split and fallback

Newer builds expose richer fallback-filter controls and first-class DoH/DoT upstreams. The template below uses public resolvers suited to many regions; if you operate inside mainland China, replace nameserver entries with domestic DoH mirrors (for example AliDNS or DNSPod) while keeping international fallbacks for poisoned domains.

dns:
  enable: true
  ipv6: false
  enhanced-mode: fake-ip
  fake-ip-range: 198.18.0.1/16
  fake-ip-filter:
    - "*.lan"
    - "*.local"
  nameserver:
    - https://dns.google/dns-query
    - https://cloudflare-dns.com/dns-query
  fallback:
    - https://1.1.1.1/dns-query
    - https://8.8.8.8/dns-query
  fallback-filter:
    geoip: true
    geoip-code: CN
    geosite:
      - gfw

Here nameserver handles ordinary lookups, while fallback engages when GeoIP/GeoSite marks a domain as sensitive. Adjust geoip-code to match the country dataset you trust.

Refresh GeoIP and GeoSite data

Mihomo still relies on geoip.dat and geosite.dat for geography-aware rules. GUI clients usually bundle updater buttons; if you run headless, schedule a monthly refresh so streaming and CDN splits stay accurate.

Migration FAQ

These are the questions we see most often when people jump from legacy Clash or early Meta builds to current Mihomo.

Q: The client says “unknown config field” and exits

Strip vendor-specific blocks such as clash-for-windows or other GUI-only extensions. They are not part of the portable schema. After removal, reload the profile.

Q: Can I keep my existing subscription URL?

Yes, in the majority of cases. Stale node definitions may fail individually, but the rest of the list imports fine. Ask your provider for a refreshed subscription if more than a handful of entries break.

Q: How different is Mihomo YAML from original Clash?

Core sections—proxies, proxy-groups, rules, DNS, TUN—stay compatible. Mihomo adds types like hysteria2, tuic, and vless, plus knobs such as reality-opts or experimental ssh transports. Old files load untouched until you opt into new features.

Q: TUN mode broke after the upgrade

Elevate the process (Administrator on Windows, root where required on Linux desktop). Double-check the tun stanza:

tun:
  enable: true
  stack: system      # or "gvisor" as alternative
  auto-route: true
  auto-detect-interface: true
  dns-hijack:
    - "any:53"

If gvisor clashes with another VPN, try system or vice versa.

Q: How do I print the running Mihomo version?

Use the GUI About page or run mihomo -v / mihomo version from a terminal. Staying on the latest stable tag matters for security fixes and parser tweaks.

Why Use the Clients We Ship?

You can absolutely fetch upstream Mihomo from source repositories when you want full control—but that workflow means tracking release notes, reconciling GUI capabilities, and debugging YAML by hand whenever a provider ships a new transport. Many people underestimate how long that loop takes.

The builds we publish focus on repeatable installs: kernel and interface versions are regression-tested together, subscription import stays one click, and DNS leak–safe baselines are already wired. Compared with piecing together random releases, you spend less time troubleshooting and more time actually using the network path you paid for.

  • Matched versions: Every drop is checked so parsers, TUN helpers, and updater hooks agree.
  • Faster onboarding: Paste a subscription, hit update, and you are routing traffic without editing raw YAML first.
  • Modern protocols in one box: Hysteria2, TUIC v5, and VLESS+REALITY profiles parse as soon as your nodes expose them.
  • Sane DNS defaults: Reduce accidental plaintext queries to your ISP while keeping split-DNS behavior predictable.
  • Same workflow everywhere: Windows, macOS, Android, iOS-friendly companions, and Linux builds share the same mental model.

If your current install feels outdated or you keep hitting “protocol not supported,” skip the manual merge headache—grab a fresh client from our download page and import the profile you already backed up. When you want protocol theory without install steps, the docs section stays the quickest reference. → Download Clash for free and experience the difference.