Documentation / Complete Guide

Complete Clash Guide

Configure your client from installation through traffic routing, following the path your traffic takes. For your first connection, start with the Getting Started tutorial. To understand settings, verify rules, or troubleshoot issues, use the relevant sections of this guide.

01 Core Concepts: Inbound Traffic, Policies, and Outbound Connections

Start by separating the UI from the core

Clash clients generally have two layers. The UI manages profiles, displays connections, and changes system settings. The core listens for local traffic, parses configuration, applies rules, and establishes connections according to the selected policy. mihomo is a common core in the Clash ecosystem, but a client's name, icon, or menu layout doesn't prove that a particular core feature is enabled. Whether a setting works depends on the core in use, the configuration format, and how the client exposes that setting. For example, a core may support a configuration field without offering a toggle for it. Conversely, a UI toggle may override a field with the same name when applying the configuration.

How a connection travels

Take a desktop browser as an example. First, the browser decides whether to use the system proxy. If it does, the request goes to a local port that the client is listening on. The core identifies the destination and, based on the current mode, checks the rules, uses the global group, or connects directly. A matched rule can select a built-in policy or a proxy group in the configuration. The group then picks the actual outbound connection. The destination, matched rule, policy group, and outbound connection shown in logs are separate fields. Troubleshoot along this chain: don't switch nodes as soon as a page fails to load, and don't assume every app uses the chain just because the client has an enabled toggle.

One distinction is easy to miss: an app that bypasses the client and connects directly to the network may end up using the same local network as an app routed through the client and assigned DIRECT. Only the latter is subject to Clash policy decisions and will usually appear in the connection log. Conversely, a connection listed there only means the core received it. Whether the page loads also depends on name resolution, the outbound connection, and the destination service's response. A log entry doesn't prove connectivity, and a page still loading after you exit the client doesn't, by itself, prove that it bypassed the proxy beforehand.

How profiles, subscriptions, and nodes fit together

A profile is a set of settings loaded together, commonly in YAML. A node describes the connection details for a proxy outbound; a proxy group decides how to choose among outbounds; and rules direct requests to the appropriate policy. A subscription may return a complete profile, a node list, or another format the client recognizes. Seeing nodes after import doesn't mean you also got rules, DNS settings, or custom proxy groups. Check which profile is selected, then confirm that the proxy groups and rules you expect appear in their respective tabs. After switching profiles, identical group names don't guarantee identical outbounds.

DNS resolves domain names to addresses. Successful resolution and a successful outbound connection are separate things. Depending on the traffic entry point and configuration, resolution may happen in the app, the local system, or the core. If a log shows only an IP address, there may not be enough information to match a domain rule. If the domain is visible and the correct rule matches, focus next on the proxy group and connection process. For your first setup, don't change DNS, rules, and the traffic entry point all at once. Get one connection working that you can test again, then build on it section by section. Keep a known-good starting point after each step so you can compare against it if a later change breaks something.

02 Choosing a Client: Platforms and Configuration Support

Narrow down your options by platform

For Windows, macOS, Android, and iOS, start by comparing Clash Plus. For Linux, look at Clash Verge Rev first, then compare it with FlClash. These recommendations are a starting point, not a ranking of speed or reliability. Network entry points, permission prompts, and background behavior differ across operating systems. Even when the same client is available on multiple platforms, check the profile import format, log location, and proxy modes on each one. Don't assume desktop menus map directly to their mobile counterparts. See the download page for installation links.

Platform options and pre-installation checks
PlatformClient optionsWhat to check
WindowsClash Plus, Clash Verge Rev, FlClash, Clash Nyanpasu, Clash for Windows (archived)System architecture, system proxy, service permissions
macOSClash Plus, Clash Verge Rev, FlClash, ClashX Meta (archived)Chip type, network extension permissions
AndroidClash Plus、Clash Meta for Android、FlClash、SurfboardPackage architecture, VPN permissions, background restrictions
iOSClash Plus(App Store)System compatibility requirements, VPN configuration permissions
LinuxClash Verge Rev、FlClashDistribution package format, architecture, desktop proxy support

Compare clients against your everyday needs

When setting up a client for the first time, it's more important to be able to check its status easily than to have lots of options. Make sure you can find four things: the active profile, each group's current selection, connections for a specific test destination, and a way to restore the system's original settings when you exit. If you mainly need to import subscriptions and switch outbounds, these are enough for an initial comparison. If you also need local rule overrides, check whether the client supports separate override profiles or merging, and confirm when overrides take effect after a remote update. If the feature isn't available, experiment with a local copy first rather than treating the subscription source as your only working file.

For multiple devices, choose one machine to maintain the rules, then import the same base profile on the others. Desktop systems often let you test one app at a time, while mobile devices usually route traffic through the system VPN interface. Check the status bar icon alongside the in-app logs. If a device already has a work VPN, find out whether both can run under the system's restrictions. If there's no supported way to use both, don't remove a network configuration required by your organization just for a temporary test. Consider how you'll roll back, too: keep the old client's local files if needed, but don't let two clients modify the same system proxy settings at once.

When migrating, compare formats before features

To migrate from discontinued clients such as Clash for Windows or ClashX Meta, first export a working profile and note the selections for important proxy groups. Import a copy into the new client, verify that the core loads it, then compare group names, node types, and rule matches. Startup behavior, ports, system proxy settings, and service modes in the old UI are usually client-specific settings; don't expect them to move with the YAML file. If the same profile works in the old client but fails in the new one, check the first incompatible field and determine whether the cause is a core difference, a client override, or a subscription format difference. Compare feature locations with the client selection guide. Once you have a working baseline, decide whether to migrate the remaining settings.

If you don't have a subscription yet, use the local example in Chapter 6 to check the configuration, rules, and logs. There's no need to buy a service or send everyday traffic through an unknown outbound first. The example is only for comparing direct and rejected connections; it doesn't test support for proxy protocols. Once you have a subscription from a trusted source, test the protocols, proxy groups, and rules you actually need using a copy. Simply confirming that the import succeeded isn't enough to choose a client.

03 Installation: Choose a Package and Establish a Clean Starting Point

Check your device architecture and system

Before downloading, check your own system rather than guessing based on another device's installer. On Windows, check System type under About in Settings. On macOS, use About This Mac to identify an Apple chip or Intel processor. On Linux, run uname -m in a terminal to see the machine architecture reported by your environment. Common results include x86_64 and aarch64. Choose a package format for your distribution as well. Architecture and package format are separate requirements: a matching CPU doesn't mean a package for one distribution will work on another. If no build is available for your platform, try another client for the same platform rather than installing a similarly named file.

If Android offers multiple options, check which app architectures your device supports and choose the matching package; not every client provides a universal package. On iOS, use the App Store link on the download page. Check the store listing for the required system version. Android may ask you to allow app installs from the current source; that's separate from granting VPN permission later. If a desktop system shows a security warning, check the file's source and the relevant release notes first. If your organization restricts installations, use an approved method rather than disabling system or organizational protections.

On first launch, leave the network entry point unchanged

After launching, make sure the profile, proxy groups, connections, and logs pages all open. On desktop, leave the system proxy and TUN off until the client has loaded a profile, so it doesn't change network behavior across the whole device prematurely. Note the system's existing proxy or VPN state, especially the auto-configuration URL on a work device. If other proxy clients have been installed, check whether any are still running in the system tray, menu bar, or background. Closing a window isn't the same as exiting a process. If two processes compete for a port or keep rewriting the system proxy settings, connectivity may come and go.

If the logs report a port conflict, check which port is named. The mixed port accepts requests; the controller interface is used by the UI or control programs. They aren't interchangeable. If an old client is using the port, exit its process and restart the current core. If both clients must run, change the active listening setting and update any apps that use that port. Changing only the browser address without changing the core's listener—or editing the profile while the UI still overrides it—can leave you with refused connections. Don't enable LAN access just to connect a local app; loopback is enough for initial testing.

Separate installation issues from connection issues

If the app won't open at all, note the system error and check the architecture, system requirements, and package type. If the app opens but the core won't start, check the core startup logs, configuration parsing, and port binding. Debug subscriptions and connections only after the core is listening on the expected address. On mobile, no traffic appearing in the Connections page before VPN permission is granted is normal. Import the profile first and grant permission when you're ready to test a request. If you enabled startup on boot, restart once after testing to confirm the actual client and entry-point states match what you expect.

A successful first installation isn't measured by benchmark results. At this stage, it's enough for the app to start reliably, for you to find the profile and log screens, and for you to know whether it has changed any system settings. If you tried the system proxy, turn it off and confirm that the OS proxy settings have actually been restored. If the internet still doesn't work after exiting, first check whether the system points to a local port that is no longer listening. Work or campus networks may require a proxy; restore the settings you noted earlier rather than turning everything off. Confirming that connectivity returns to its pre-installation state gives you a safe basis for testing rules.

04 Subscriptions and Profiles: Import, Activate, and Back Up

Know what you're importing and where to draw the trust boundary

Clients usually support importing remote URLs and local files. Remote URLs are useful for keeping up with provider updates; local files are better for fixed content or test copies. A complete profile may set proxy groups, rules, and DNS, so a profile from an unknown source is more than just a node list. Before importing, make sure the URL comes from the provider you expect. Subscription URLs may contain account details or access credentials. Don't paste them into public conversion sites, screenshots, or support tickets. If you need help identifying the format, share only a snippet with credentials, server addresses, and private domains removed. Keep the field names, indentation, and exact location of the error intact.

Add the remote profile on the Profiles page, enter the subscription URL, and save. Once downloaded, check the provider name and profile type, select the profile, and check the core's load result. Import success, selection in the list, and successful core loading are three distinct stages; some clients require an additional apply or reload step between the latter two. Don't rely on a success notification alone to confirm that the profile is active. Check that the expected proxy groups appear and find a recognizable rule, then verify with a new connection. If the previous profile's groups still appear after you select the new one, check the logs for a load failure and whether the client reverted to the earlier state.

Troubleshoot downloads, parsing, and loading separately

If the download fails, first check that the current network can reach the subscription service. Then check whether the URL has expired, requires authentication, or is affected by an incorrect system clock. Some services return a login or error page instead of a profile. The request may appear to complete at the network level, but the response body isn't valid configuration and will usually trigger a parsing error next. A URL that requires a proxy to update may also fail if the client has just been installed or its profile is broken. Restore connectivity with a previously working local copy, then update. Don't keep trying subscription URLs from unknown sources. For more cases, see the subscription import troubleshooting checklist.

For a parsing error, check the first error and the lines around it. YAML indentation should use spaces and remain consistent at each level. Keep the list marker on every item in a rule list. A misspelled field, a reference to a nonexistent policy group, and a document that can't be parsed at all are different kinds of errors. If parsing succeeds but loading fails, check whether the core supports the fields, protocols, and external rule resources used. If the log says a proxy group has no available members, confirm that it references a name or provider that actually exists in the profile rather than deleting the group immediately. Removing a group referenced elsewhere may only move the error to the next point.

Keep the remote original, local overrides, and backups separate

Don't use remote content as a long-term manual editing workspace. A subscription update may replace the whole file, removing custom rules and comments. If the client supports separate overrides, put local changes there and check whether they're inserted before the original rules, appended at the end, or used to replace a whole field. If overrides aren't supported, keep a separate local working copy and manually merge the changes you need after each update. Backups should clearly distinguish the last known-good original, local overrides, and untested experiments. Store originals containing credentials in a controlled location. For ways to manage multiple profiles, see Profile and Multi-Profile Management.

05 Proxy Modes: Rule, Global, and Direct

Modes change outbound selection, not the traffic entry point

Rule mode checks rules in configuration order and is suited to routing everyday traffic to different outbounds by destination. Global mode sends connections that reach the core to the selected global policy, making it useful for briefly checking whether rules cause a difference. Direct mode connects to destinations directly from the core, which is useful for comparing against a proxy path. Switching modes doesn't automatically enable the system proxy or send apps that don't use it into the core. Global mode doesn't mean the whole device is taken over, and Direct mode doesn't mean the client has exited. If an app behaves the same in all three modes, first check whether its connection appears in the client instead of cycling through modes again.

How connections reaching the core select an outbound
ModeHow it worksWhat to check
RuleUses the policy from the first matching ruleMatched rule, policy group, group member
GlobalUses the global group's current selectionWhether the global group selects a node, subgroup, or direct connection
DirectThe core connects directly to the destinationName resolution and reachability on the direct path

Compare modes using the same destination

On desktop, start with a browser that follows the system proxy, or configure a test tool to use the local proxy explicitly. Choose a destination you can access and that behaves consistently. Open the Connections page and note the destination, time, proxy mode, matched policy, and actual outbound. If you're testing in Rule mode, check whether the destination matched a specific rule or the final fallback. Without changing the entry point or profile, switch to Global mode, check which outbound the global group actually selects, and send a new request. Existing long-lived browser connections, cached results, and background retries can skew the comparison. If needed, close the relevant page or app and try again; there's no need to clear the system's network settings.

If a site works in Global mode but not Rule mode, that doesn't necessarily mean the rule syntax is wrong. The rule may match correctly but send traffic to a different group, or the group may have selected an unavailable outbound. Compare the final outbounds for both requests before deciding whether to investigate rule selection or the outbound itself. If both modes selected the same node but results still differ, check whether the requests involved different destinations or reused old connections. A webpage may request resources from its main domain and several subdomains; loading the main page doesn't mean its APIs, images, and login resources all used the same rule. Check the specific failed connection.

What node tests tell you—and what they don't

A client's latency test usually targets a specific test address; it doesn't prove that every site and protocol will work. A node that responds quickly to the test address may perform differently for uploads, long-lived connections, or a particular destination. A failed test may mean the test address is unreachable, not that the node fails for every destination. Before changing a group selection, record results for the same test address and then check the actual destination you care about. For automatic selection groups, check the test address, interval, and current selection. The group may have changed outbounds between manual checks, so its name alone doesn't prove the route stayed the same.

For a first-connection walkthrough, see Choosing a Node, Testing Latency, and Verifying It Works. After comparing modes, restore your everyday mode and check the global group selection you changed during the test. If you use an external IP-checking service to identify the outbound, remember it only sees that one request, not all traffic from the device. It's more useful to pair the outbound observation with the corresponding connection log entry. Once you can reliably explain that entry, start writing your own rules.

06 Rule-Based Routing: Syntax, Order, and Local Testing

Put specific conditions first and the fallback last

Most rules use commas to separate the type, match value, and target policy. For example, DOMAIN,example.org,DIRECT matches the exact domain, while DOMAIN-SUFFIX,example.org,DIRECT also covers its subdomains. Keyword matches are broader and may catch other domains containing the same text, so define the intended match set before using one. Policies can be DIRECT, REJECT, or a proxy group that actually exists in the profile. Proxy in an online example is often just a group name; don't assume every subscription has one. Match group names exactly, including capitalization and spaces, and check their references.

The core checks rules in order and uses the first match; it doesn't continue looking for a more specific condition. Put exact-domain exceptions first, then broader conditions such as suffix or geographic categories, and finish with a MATCH fallback. If an exception comes after a suffix rule for the same domain, it may be configured but will never be reached. When troubleshooting, don't just search the file for the destination domain. Check earlier rules too, in case a broader match has already caught the request. If the client only appends overrides to the end, confirm they can still appear before an existing MATCH rule.

Verify rule priority with a separate profile

The minimal example below is for mihomo-compatible clients and listens only on the local machine. It needs no subscription or proxy nodes. Save your current profile first, then save the example as a local YAML file. After loading it, confirm that the mode is Rule and the port is 7890. If the port is in use, choose a free one and update it in both commands below. If the client overrides the port or mode, use the actual values shown in the UI and startup logs. You don't need to enable the system proxy or TUN during testing. The commands use curl with HTTP proxy support. In PowerShell, where curl may be an alias, use curl.exe instead.

mixed-port: 7890
allow-lan: false
mode: rule
log-level: info
rules:
  - DOMAIN,example.org,REJECT
  - DOMAIN-SUFFIX,example.org,DIRECT
  - MATCH,DIRECT
curl -I --max-time 10 --proxy http://127.0.0.1:7890 https://example.org/
curl -I --max-time 10 --proxy http://127.0.0.1:7890 https://example.com/

The first command should match the exact-domain reject rule and may report that the proxy tunnel couldn't be established. The second uses the final fallback; whether it gets a response depends on whether your network can reach the destination. Swap the first two rules, reload, and run the first command again. This time, the log should show the suffix rule routing directly instead of rejecting the request. Judge the result by the difference in policy shown in the two logs, not by a specific response code. If neither command can connect to the local port, revisit the installation chapter and check the listener. If the port is reachable but the policy doesn't change, check the active profile, mode, and whether the client saved an override.

Tell domain rules, IP rules, and external data apart

Domain rules rely on the core having the domain name; IP rules match the destination address. If a connection exposes only an address, even a precise domain suffix rule may not help. Conversely, when a domain request reaches the core, some IP rules may trigger an additional lookup. For rule types that support no-resolve, the option prevents a lookup solely for that rule match; it doesn't disable DNS. GeoSite and GeoIP rely on domain-category and IP-address data respectively. Available categories and their contents depend on the data actually loaded. If a database update causes unexpected routing, check the matched rule and data source rather than masking the discrepancy with a broader rule. See Updating GeoIP and GeoSite Data.

07 TUN: Traffic Scope, Permissions, and Rollback

When to change the traffic entry point

The desktop system proxy is mainly for apps that follow the system's proxy settings. Some programs use their own network stack or proxy settings, or handle traffic that can't pass through a standard HTTP proxy. In these cases, TUN can receive more traffic through a virtual network interface and routes, then hand it to the core for processing. The actual scope depends on local routes, exclusions, system restrictions, and other virtual network interfaces. The toggle alone doesn't prove that every connection on the device is captured. Mobile devices often route traffic through the system VPN interface. The system icon indicates that the interface is up; it doesn't prove that every connection passes through a proxy node.

If you only need a proxy for one browser and the system proxy already works, keep the simpler entry point. Switch to TUN only when you know an app isn't reaching the core or need to test a specific traffic type. Before you begin, note the original system proxy state, active profile, and a destination you can reproduce reliably. Make sure no important transfer is in progress. If your organization has a work VPN, find out how it can coexist or use a test environment. When two virtual interfaces compete for routes, repeatedly toggling them can make test results impossible to compare.

Enable settings one at a time and check routing

Desktop clients may require additional permissions, helper services, or system network approval. Follow the client's prompts and your OS requirements. First turn off the system proxy you're using for comparison and keep the profile you've already verified. Enable TUN, then check the core logs to confirm that the interface was created and routes were configured. Some clients offer automatic routing and network interface detection. The former directs traffic to the virtual interface; the latter identifies the actual outbound interface. With multiple network adapters, hotspot switching, or another VPN in use, automatic selection may not match your expectations. Check the selected interface and actual connectivity first; don't also change the network stack and DNS policy in the same troubleshooting session.

To test, make one connection that used to follow the system proxy, one that didn't, and one to a local resource that must remain accessible. Check the first two on the Connections page to see whether the changed entry point had the expected effect. Use the local resource to verify that any required direct connection or route exclusion still works. A rule targeting DIRECT means the core received the traffic and forwards it directly. A route exclusion may keep the traffic from reaching the core at all. These have different effects on logs, visible destinations, and troubleshooting. Don't exclude a broad range of addresses just to restore access to one local resource, and don't add local services that don't need to be captured to your test traffic.

Check DNS separately and test a clean exit

If only domain names fail after enabling TUN, first check resolution logs and routes, then review the client's DNS settings and the system's resolution path. Accessing the same service by IP isn't necessarily a valid comparison: HTTPS may need the correct domain for certificate validation and virtual host selection. Networks with local device names, internal DNS, or captive portals are especially worth testing both before and after enabling TUN. Before changing custom DNS forwarding or traffic interception, keep a working copy with the default settings. If you can reproduce the issue, restore the defaults and change only one setting at a time. For a detailed comparison, see TUN Mode vs. System Proxy.

To roll back, turn off TUN in the client and wait for the system routes to recover. Test a destination that should work directly, then restore the original system proxy if needed. If the client exited unexpectedly, check whether its virtual interface or network management service is still active and whether the system still points to a local proxy port whose listener has stopped. Don't clear route tables or delete another VPN's settings on a work network. Recording the difference between a normal exit and a crash can help identify whether the issue is in the core, service cleanup, or system network state.

08 Maintenance: Updates, Retesting, and Recovery

Treat updates as four separate sources of change

Client updates can change the UI and permission handling; core updates can affect parsing or feature behavior; subscription updates change nodes and rules; and rule database updates can change classification results. You don't need to update all of them at once. Unless compatibility requires simultaneous upgrades, record the working state, update one item, retest, then continue. If some sites stop working after an update, knowing whether the last change was a subscription or a geographic database is more useful than memorizing every setting name. If the UI supports automatic updates, find out what it updates and when it reloads the active profile.

Back up the active profile, local overrides, and easy-to-forget settings such as proxy group selections, the entry-point port, and automatic update behavior. Keep subscription credentials and recoverable node details in a controlled location; don't sync them in ordinary screenshots or share them publicly. Also keep a record of the system settings from before enabling the client, so you can restore them when you exit. A backup is only useful if you know how to load it. When it won't disrupt active connections, import a copy and confirm that the UI recognizes it and its referenced resources are still available, then switch back to the original profile. External rule resources can change; backing up the YAML doesn't back up all its dependencies.

Narrow the issue by its scope

If just one site fails, check connection records for that destination and any failed subresources, then confirm the policy and outbound. If just one app fails, check whether it follows the system proxy, has its own proxy setting, and created a new connection. If the whole device loses connectivity only when the client is enabled, check the system proxy port, TUN interface, and routes. If other devices on the same network also can't connect and aren't using the same profile, check the upstream network first. Don't change profiles, switch networks, enable TUN, and change DNS all at once. Even if connectivity returns, you won't know which change fixed it.

When recording a failure, note the time, active profile, entry point, mode, destination, matched policy, and final outbound. Send one easy-to-identify new request at a time so browser background connections don't drown it out. Temporarily increase the log level if the client supports it, then return to your normal level once you've found the issue. Don't publish logs containing domains, device details, internal addresses, or subscription identifiers. When sharing logs, retain the exact error type and necessary fields but remove values that could reveal your environment. One or two representative entries are clearer than pages of repeated errors.

Restore a working state before investigating

If an issue is disrupting your work, revert to the last verified profile, mode, and entry point. Don't keep experimenting in an unknown state. If the system proxy points to a port that is no longer listening, restore the original settings first. If TUN is the problem, follow the previous chapter's shutdown steps and confirm that ordinary connections work again. Retest the same destination, then make a copy of the profile for further investigation. Profiles using remote rule resources may need to download them at startup. Record a full restart test separately from an immediate profile switch; different results can point to caching, background services, or startup order.

For common questions, check the download page FAQ and the documentation for installation and first-connection steps. Routine maintenance doesn't require lots of speed tests. Keep three useful test cases: a connection that should go direct, one that should use a specific group, and a local resource that must remain available. After each update, test all three using new connections, note what changed, and then decide whether further adjustments are needed.

09 Advanced Topics: Rule Sets, DNS, and Controlled Deployment

Move from individual rules to maintainable rule sets

When individual rules meet your needs, focus first on getting the order and exceptions right. As the rule list grows, consider using mihomo-compatible rule providers to manage groups of domains or IP ranges separately. Before adding one, confirm its content type, resource format, and update schedule. The provider's declared behavior should match the actual list. Where you place an external rule set in the main list still determines its priority; a long remote list doesn't automatically override earlier matches. Keep a few explicit local exceptions before the rule sets, leave the default policy clear at the end, and document the source and purpose of each set.

The more remote dependencies you have, the more important it is to test cold-start behavior. A resource loading successfully from cache doesn't mean a new device can download it on first launch. Before deployment, test in an isolated profile or environment to check whether resources are reachable, how load failures appear in the logs, and whether you have a local profile that can restore basic connectivity. Don't delete all data from a client you rely on just to simulate a missing cache. A separate test environment avoids wiping subscriptions, group selections, or system recovery information. Also check how your client updates remote resources in practice; core support doesn't guarantee the UI provides the same persistence behavior.

Adjust DNS to solve a specific, reproducible problem

Start DNS changes with a reproducible issue, such as a private domain on your internal network resolving incorrectly or a destination using an unexpected resolution path. First note whether the app has its own encrypted DNS, which resolver the system uses, and whether the core handles the connection. Then decide which layer to change. Some clients let you specify a resolver for particular domains, which can work well for clearly separated internal and external networks. Check both rule order and bootstrap resolution. If a remote resolver needs a domain lookup to connect but no initial resolution path is available, all lookups may fail when the client starts.

A common advanced setting, Fake IP, returns synthetic addresses that the core uses to associate later connections with their original domains. These aren't the destination service's real addresses, so seeing them doesn't mean the resolver returned an incorrect result. If an app depends on real addresses or internal name resolution, test compatibility with specific domains and apps before changing filters. An external DNS test page only shows the lookup path for requests triggered by that page; it doesn't represent other apps or another traffic entry point. To determine whether Clash DNS is leaking, identify which resolver should handle the request, which one actually did, and whether you're comparing the same app and entry point.

When to move from a GUI client to the core

Consider running mihomo directly only if you need a fixed configuration on a Linux host or router you manage, access to service logs, or control over startup order. First validate the profile and rules using a loopback listener, and understand the purposes of the proxy listener and controller interface separately. Then decide whether either needs to be accessible over a trusted network. Keep listeners scoped as narrowly as possible; don't expose the controller interface or proxy port directly to the internet. Restrict read access to profiles containing subscription or node credentials. Before routing traffic from other devices, confirm that routes are restored after exit or restart and keep a way to manage the device directly. For personal desktop and mobile use, a GUI client can handle the main tasks in this guide.

Use a small regression checklist to decide whether an advanced setup is ready for everyday use: it recovers after a restart, expected direct and proxied destinations match their intended policies, subscription updates preserve local exceptions, and the system returns to its original state when the entry point is disabled. If you can't reproduce a result, revisit the relevant section and narrow the issue to one variable. Advanced configuration isn't about having a longer file; it's about understanding why traffic takes a particular path and knowing how to roll back safely when it doesn't behave as expected.