Open source · Built with Tauri and the mihomo core
Connections are handled by the mihomo core, while subscription links make it easy to manage configurations and rule routing.
Clash Nyanpasu brings configuration management, proxy modes, and core status together in a graphical interface. To get started, make sure your configuration loads, check how traffic reaches the core, then see which policy each rule assigns to a connection. The windows below illustrate what each setting does; menu names and available options vary by client build.
Current mode
Illustrative window for explaining settings only.
Proxy mode determines how connections entering the core are routed. For everyday use, start with Rule mode to route traffic according to the domains, addresses, and rule sets in your configuration. Global mode sends connections through the global policy and can help you test an exit temporarily; Direct mode is useful for comparison. Switching modes won’t fix an expired subscription or change whether an app follows the system proxy. As with other graphical clients using mihomo, routing depends mainly on the core and configuration, not the interface labels. Change one setting at a time to make troubleshooting easier.
Import remote configuration
Subscription management turns a remote link into a local configuration the client can load. Before importing, make sure the link returns a Clash-compatible configuration—not a login page, error message, or format intended for another client. After import, select the configuration, check that its policy groups appear, then enable automatic updates if needed. Remote updates may overwrite direct edits, so use the client’s supported override or merge mechanism for changes you want to keep. Subscription menus and merge behavior vary across clients. When migrating, check the final loaded configuration rather than relying on matching subscription names.
Rule example · Proxy must be defined first
DOMAIN-SUFFIX,github.com,Proxy
GEOIP,CN,DIRECT
MATCH,ProxyRules identify connections; policy groups determine their exit. They must be linked using the correct names. In this example, a specified domain is sent to Proxy, traffic matching the mainland China address rule goes direct, and MATCH handles everything else. Proxy is the name of a policy group, not a built-in keyword. A more specific rule won’t necessarily take effect if a broader rule above it matches first. When moving a configuration between clients, check rule sets, databases, and core support as well. If traffic takes the wrong route, start by checking the rule shown in the connection log.
Available network stacks
System proxy uses the operating system’s proxy settings to route connections from apps that honor them, such as browsers. TUN uses a virtual network interface and routing to capture more traffic. It can help with apps that ignore the system proxy, but may require additional permissions and checks for conflicts with DNS or other virtual adapters. Choose a network stack based on OS and app compatibility, not on assumptions that one is always faster. Graphical clients differ in how they handle service installation and permissions. For a first setup, test system proxy first, then enable TUN separately to compare.
Options shown for illustration; actual support depends on the client build.
The client interface and proxy core do different jobs: the client manages configurations and controls, while the core parses rules, establishes connections, and handles protocols. For everyday use, prefer a stable mihomo build that works with your subscription. Alpha builds are for testing changes that are still being validated; read the release notes and keep your original configuration before switching. Other cores may not support the same fields, so don’t swap them based on similar names alone. Being able to switch cores can help diagnose compatibility issues, but it also introduces more combinations to consider. If a configuration fails to load, check the logs for unknown fields or unsupported protocols first.
The order of setup matters more than the number of switches. A successful subscription import only means the configuration was saved. A successfully started core means it could parse the configuration. Seeing an app’s connection in the log means its traffic reached the client. Finally, check that the matched rule and exit are what you expected. Checking each layer separately is usually more effective than changing proxy mode, DNS, and network stack all at once.
You can keep using an existing configuration, but back it up before migrating. If it uses remote rule sets, external files, or override scripts, check that the new client supports them. The final configuration may be affected by both interface settings and the subscription file; when they conflict, trust what actually loads. For more on concepts such as Fake-IP, policy groups, and rule providers, see the glossary.
Choose an operating system first, then check the processor architecture and installation method. Clash Nyanpasu is a desktop client; phones and tablets need a client built for their platform. A platform link in the download center provides options for that system—it doesn’t mean every desktop app has a mobile version with the same name. The download page lists available installers, system requirements, and maintenance status; check the page for current distribution details.
Compare desktop options such as Clash Nyanpasu, Clash Plus, and Clash Verge Rev. Check your system architecture before installing, then import a configuration and verify the system proxy on first launch. If you need to route more app traffic, check the service permissions and TUN settings. If another proxy app is running, avoid having both apps overwrite the same ports or system proxy settings.
Go to downloads →Choose the right installer for Apple Silicon or Intel, and check the operating system version required by the client. If it needs a network extension, background service, or routing permissions, read the details in the system prompt. Quit your current client before switching to avoid multiple apps repeatedly changing the same system proxy settings.
Go to downloads →Choose among options such as Clash Plus, Clash Meta for Android, FlClash, and Surfboard based on your subscription format and preferences. Your first connection will usually require approval for the system VPN permission. If the connection drops when the screen locks, check battery optimization and background activity restrictions. Before migrating a configuration, make sure the target client supports its subscription format.
Go to downloads →The download center links to Clash Plus on the App Store and provides information from the official site, clashplus.io. After installing, import a compatible configuration, allow the VPN configuration when prompted, and check your policy selection. Desktop file paths, scripts, and permission settings don’t transfer directly to a phone; check which features the mobile client actually supports.
Go to downloads →For desktop use, consider Clash Verge Rev or FlClash, and install the package that matches your distribution and dependencies. Server and router users can also look for mihomo core packages, but the core alone isn’t a complete graphical client. Desktop tray behavior, system proxy settings, and service management vary by distribution. If startup fails, check the logs first.
Go to downloads →Don’t choose a client based on its interface alone. A subscription may include protocols or fields supported only by certain cores, so a successful installation doesn’t guarantee configuration compatibility. Prefer maintained options with clear system requirements that work with your current configuration. Archived clients can help explain historical behavior, but check compatibility and maintenance status before relying on them long term. For a detailed comparison, see the client comparison.
For a first setup, follow this path: make sure the configuration works, get traffic into the client, then verify the exit. The client reads the configuration and creates the proxy connection; the subscription provider supplies the servers, credentials, and validity period. Installing the app doesn’t give you a working configuration—you’ll need one separately. If the link has expired, resolve the subscription issue instead of repeatedly reinstalling the client.
Open the configuration or subscription manager, paste the full link, and import it. Once the configuration appears in the list, set it as active and check that its policy groups have loaded. If parsing fails, check whether the link returns a configuration file or a web page, and whether its access credentials need updating. Subscription links often contain private access tokens, so don’t share the full URL in screenshots or public discussions.
After importing, keep the existing rules for now; avoid adding overrides before the connection is verified. If you have multiple configurations, give each a name that makes its purpose clear, and check that the active configuration changes when you switch. That way, you’ll know which rules you’re testing when you review the connection log.
Select Rule mode, then enable the system proxy if your apps need it. Open the main policy group and choose an available exit or a suitable automatic selection group. Start by testing in a browser. If an app doesn’t appear in the connection log, it may not follow the system proxy; check the TUN settings next. TUN changes which traffic is captured—it won’t automatically resolve every network issue.
When enabling TUN for the first time, watch for permission prompts and check the status of other VPN or virtual network adapter software. Change one setting at a time and keep a record of the setup that works. To restore the previous state, turn off the traffic routing mode you just enabled, then check that the system proxy and routes have been restored.
Visit the website or app you want to test, then check the requested domain, matched rule, and selected policy in the client’s connection log. A page loading is only the first check: make sure connections that should go direct aren’t routed through a proxy, and that traffic meant for a specific policy group matches the right rule. A latency test reflects only a specific test request; it can’t replace real-world testing with downloads, video, or work apps.
If something goes wrong, record the minimum details needed to reproduce it: the app, the steps, the configuration, and the specific error in the logs. Before sharing logs, remove subscription links, access credentials, and private addresses. This information is much more useful for identifying whether the problem is in DNS, rules, the exit, or permissions than simply saying “the internet doesn’t work.”
Understanding where the software comes from also means distinguishing the interface, core, and subscription. Clash Nyanpasu’s source code and development history are available in its public repository. In practice, the client build, core capabilities, and subscription content together determine what works. This page focuses on how features fit together, rather than using unverified download counts, ratings, or performance figures to recommend a client.
Clash Nyanpasu is part of the Clash graphical client ecosystem, with a desktop interface built using Tauri. The public repository contains source code, issue discussions, and release records—useful for checking whether a feature has been implemented or a behavior is changing. Follow the commit history and release notes to understand the project’s history; similar names alone don’t establish that it descends from another client.
For interface questions, search the repository discussions for the behavior or error you’re seeing. When reporting an issue, include your operating system, reproduction steps, and relevant logs—not your full private configuration. Open source makes the implementation available for review, but you should still test it in your own environment; one user’s results don’t necessarily apply to every device.
Graphical clients handle subscription management, settings, process control, and status displays. mihomo parses configurations, matches rules, and handles connections. The two layers have distinct roles: changing the interface doesn’t necessarily change routing for the same configuration, while changing the core may affect support for protocols, DNS, and rule fields. The relationship between Meta and mihomo makes more sense in the context of how the core has evolved.
If settings save but the core won’t start, check the configuration and runtime logs first. If the core is running but app connections don’t appear, check how traffic is being routed into it. Identifying the layer where the problem occurs helps you decide whether to change a client setting, review the subscription, or consult the core documentation—and avoid unnecessary reinstalls.
A subscription distributes configuration; it doesn’t mean the client includes a connection service. A link may return a full Clash configuration or just server details in another format. Even when a file parses, its protocols, rule sets, and overrides may depend on a particular core or client extension. When migrating, check the format first, then make sure any external resources referenced by the configuration are reachable.
If the same link behaves differently across clients, the cause may be the request method, configuration conversion, or feature support—not a randomly failing link. Keep a known-good configuration for comparison and note whether automatic updates are enabled. Before making lasting rule changes, learn how overrides work so a later subscription update doesn’t overwrite them.
Client, core, and subscription updates are separate. A client update may change the interface or permission handling; a core update may affect protocol or configuration behavior; a subscription update usually changes servers and routing rules. Read the relevant notes before updating, and back up overrides and important settings. If behavior changes, check each source separately to identify what caused it.
For a stable setup, prioritize compatibility; there’s no need to switch just because a test build is available. If you use an Alpha build to investigate an issue, keep a way to restore the previous installation and configuration, and record what changed. This page doesn’t list specific release numbers. Find installers and current distribution details in the download center rather than treating the homepage as a live release feed.
If Git is installed, copy the following command into a terminal. Cloning downloads the project source code. If you just want to install and use a client, go to the download center instead.
git clone https://github.com/libnyanpasu/clash-nyanpasu.gitOnce the basic connection works, choose an advanced guide based on what you’re troubleshooting: if routing isn’t what you expect, start with rule order; if speed-test numbers don’t match the experience, distinguish handshake latency from throughput; if address classification changes, check the database and rule sets. The articles below are sorted by publication date, newest first, and unpack concepts that are easy to conflate. Use them to investigate a specific issue.
Learn where GeoIP and GeoSite data files come from and how their formats differ. Covers mihomo’s geodata-mode, custom update URLs, automatic updates, and common signs that your data is out of date.
Read the database update guide →Find out what client latency tests measure, how the test URL and timeout affect results, and how handshake latency differs from bandwidth and network congestion—so you can interpret speed tests correctly.
Understand the limits of latency tests →Using common routing scenarios, this guide breaks down top-to-bottom rule matching, policy group references, and how to organize remote rule sets with rule-providers—so traffic doesn’t take the wrong route because of rules in the wrong order.
See how to organize rules →Not sure what kind of issue you’re dealing with? Compare what you’re seeing with the FAQ, then revisit the guide’s import, mode, and traffic routing steps. Technical references help compare protocols and core behavior; the glossary explains configuration terms at a glance. Keeping practical steps separate from background concepts makes it easier to troubleshoot methodically.