Mihomo is a headless, rule-based proxy core that reads a YAML configuration and routes each connection through the proxy or direct path you specify, serving as the engine behind many Clash-style desktop and mobile clients.
Mihomo is the networking engine that most modern Clash-style clients ship inside them: a headless proxy core that takes a YAML configuration and decides, connection by connection, what travels through a proxy and what goes straight out. There is no window to click, because Mihomo is built to be embedded—inside a desktop client, a phone app, a router, or a system service. You point it at a configuration folder, it loads the file, opens its listeners, and streams logs to the terminal. The configuration itself is where the value sits: proxy nodes, groups that pick between them, and an ordered rule list that maps domains, addresses, processes, and ports onto a policy.
Compared with a standalone VPN app, Mihomo separates policy from presentation. The core understands protocol details, but it also understands context: a rule can send one domain through a specific node, keep local network ranges direct, route a named application differently from the rest, or fall back to a catch-all at the end of the list. Groups make that dynamic rather than static—latency testing can choose the fastest reachable node, fallback keeps a working path when a server dies, and a manual selector lets you override everything on demand. Anyone who wants a comparable tunnel without editing configuration files usually starts with Outline Manager instead.
The strongest reason to choose Mihomo is the granularity it puts behind a single configuration file. Instead of a blunt on/off tunnel, you get per-connection decisions: keep banking domains on a domestic path, push a work application through a specific server, bypass private address ranges entirely, and let everything else follow an ordered list that stops at a catch-all. That same file travels with you, so a phone, a laptop, and a home router can behave identically without three separate setups. Because Mihomo is headless, it also fits where a desktop application cannot go—behind a system service, inside a container, or embedded in a client someone else maintains. Communities build rule sets and proxy groups around it, so good configurations are shared rather than rebuilt, and updates to rules happen without rewriting the whole file.
Key capabilities and highlights.
Routing rules are evaluated from top to bottom and the first match wins, so a configuration can send specific domains through a chosen node, keep local address ranges direct, and hand everything remaining to a catch-all policy. Conditions can also be combined logically, which makes precise per-application behaviour possible.
Mihomo speaks the protocols that current proxy subscriptions actually use, including Shadowsocks, VMess, VLESS, Trojan, Hysteria2, TUIC, and WireGuard, along with transport and security options such as TLS, WebSocket, gRPC, and Reality. One core can therefore connect to a provider's entire node list.
Proxy groups sit between nodes and rules, deciding which connection is used at any moment. A manual selector lets you override everything by hand, latency testing picks the fastest reachable node, fallback switches when one fails, and load balancing spreads sessions across several servers.
Node lists and rule sets can live outside the main file as providers, referenced by name and refreshed on a schedule. That keeps large configurations readable and lets blocklists or service lists be updated automatically instead of copied by hand when a provider publishes new entries.
Name resolution is configurable rather than automatic. Fake-IP answers domain-based rules reliably even for applications that connect to bare addresses, while a split resolver can send different queries to different servers. Filters exclude local devices and services that need real addresses from the mapping.
TUN mode creates a virtual network interface so traffic is captured at the IP layer instead of relying on applications to respect a system proxy setting. This covers programs and games that ignore proxy configuration, with selectable stacks and explicit direct rules to keep local networks reachable.
An external controller exposes a RESTful interface, protected by a secret, that dashboard tools use to display live connections, per-connection routing decisions, traffic totals, and latency results. The same interface allows switching groups, testing nodes, or reloading configuration while the core keeps running.
Mihomo is a command-line program with no interface of its own, started against a configuration directory so it works the same on a desktop, a server, or in a container. That design is why graphical clients embed it, and why advanced users can script it as a background service.
Browse historical releases and previous builds.
Common questions about Mihomo.
Mihomo is a headless proxy core: a background program that reads a YAML configuration, connects to the proxy servers listed there, and forwards traffic according to the rules you define. It performs the networking itself but provides no window, buttons, or status screen of its own.
Yes, that is the intended standalone use. You start the core against a directory containing its configuration, and it runs as a foreground process or a background service. That suits servers, routers, and containers where no desktop session exists to host an application.
They are related but not identical. Mihomo started life as the community fork known as Clash.Meta and later took its current name, keeping the Clash configuration model while extending it. Older Clash configurations often still parse, but fields added since then will not work if you move back to the original core.
The protocols common in modern subscriptions are covered, including Shadowsocks, VMess, VLESS, Trojan, Hysteria2, TUIC, and WireGuard, together with transport options such as WebSocket, gRPC, and Reality. Availability can vary with the build you run, so a link appearing in a subscription is not by itself proof that it will connect.
Rules are checked in order from the top, and the first match decides the outcome, whether that is a proxy group, a direct connection, or a rejection. Because order matters, specific rules belong above broad ones and a catch-all entry should stay at the very end of the list.
Traffic is intercepted at the network layer through a virtual interface instead of depending on a proxy setting that applications may ignore. That captures more programs, including games, but it relies on system permissions and correct routing, so local and private address ranges usually need explicit direct rules.
Mihomo is a headless, rule-based proxy core that reads a YAML configuration and routes each connection through the proxy or direct path you specify, serving as the engine behind many Clash-style desktop and mobile clients.
v2rayN is a desktop GUI that drives Xray, sing-box, and other proxy cores, letting you import subscriptions, test server latency, choose routing rules, and enable system proxy or TUN mode from one window.
sing-box is a configurable proxy platform that runs as a single binary, accepting traffic through inbounds, matching it against routing rules, and forwarding it through outbounds that can speak dozens of protocols.
Clash Verge Rev is a desktop GUI for the Mihomo rule-based proxy core, letting you import subscription profiles, switch nodes, edit rules visually, and route traffic through system proxy or TUN mode.
Radmin VPN is a free tool that links computers into a virtual local network over the internet, so remote machines and friends behind firewalls can reach each other as though they shared a LAN cable.
Comments