Troubleshooting · Browse by symptom
Clash Troubleshooting Guide
For your first install, import, and connection, start with the quick-start path in the Setup Guide. This handbook is for when something goes wrong: choose the closest symptom from the contents, run a comparison test, then revisit the relevant steps in the guide. Change one setting at a time, noting its original value, test time, and result. Revert any change that hasn’t been confirmed.
No internet: restore a direct connection, then check what’s being routed
Establish a baseline without the client
First determine whether the entire device is offline or just a particular site or app. Save your work, then turn off the system proxy and TUN in the client, and exit it normally. Don’t just close the window: many desktop clients keep running in the system tray, so a closed window doesn’t mean the listening port is off. After quitting, check the system network settings for any leftover proxy address pointing to this device. A proxy set by your organization isn’t leftover configuration; note its original settings and don’t remove it without authorization.
Reopen two unrelated sites that usually work, then compare with another device on the same network. If neither device can access them, check Wi-Fi authentication, the gateway, or the upstream network rather than reinstalling the client. Guest networks may require you to accept terms on a sign-in page; do that with traffic routing off, then test again. If only this device fails when connecting directly, check that it has a valid IP address and default gateway, and that no other VPN or network-filtering software is routing traffic. Don’t diagnose an outage based on a single failed ping; some servers don’t respond to ICMP.
Trace a request from the app to its outbound connection
Once direct access works again, restart the client and enable just one routing method. For a desktop browser, start with the system proxy and leave TUN off. If the issue only affects an app that requires TUN, keep the system proxy off and reproduce the problem with TUN alone. Send the same request to the same destination each time, then look for a matching entry in the connection list immediately. The list isn’t a history log, and short-lived requests may disappear quickly. Open the logs before reproducing the issue so that a missing entry isn’t mistaken for proof that the request never reached the core.
| What you see | What to check next |
|---|---|
| The app sends a request, but there’s no matching core log | Check whether the app uses the system proxy, bypasses the destination, and whether the local listener is running. |
Matches a rule and goes DIRECT | Test the same destination directly to confirm the rule is behaving as expected. |
Matches REJECT | Find the matching reject rule. Change the rule for that destination only if you’ve confirmed it’s a false positive. |
| Enters a proxy group, then reports a connection failure | Expand the policy chain and check the node actually selected, not just the group name. |
A client showing that a configuration was imported only confirms that the file is in the configuration list. Make sure it’s selected as the active configuration and that the core loaded it successfully. If you’ve changed an override script or merged configuration, the original subscription shown in the UI may not reflect what’s running. Check the active configuration and the rule matched by the connection. Rules are usually evaluated from top to bottom, so a broad rule near the top may capture the destination before the apparently correct rule below it ever runs.
Compare behavior by switching modes
If rule mode fails but a brief global-mode test using the same known-good node reaches the destination, go back to rule mode and check the matching rule. Global and rule modes may save separate policy-group selections. Confirm the actual node is the same before switching, or the result will depend on both the rules and the node. If both modes fail but disabling traffic routing restores access immediately, narrow the test to one destination and check the local listener and outbound connection separately. If only the browser fails while other apps work, check its own proxy settings and extensions before changing the client.
After making a fix, retry the original failing action rather than just checking whether the client icon changed color. Confirm that commonly used sites still work directly and that destinations requiring a proxy match the expected policy. If the problem only returns after a restart, note whether the client started at login, when the core became ready, and whether the system restored an old proxy setting first. The sequence can distinguish a startup timing issue from a persistent configuration error.
Proxy node timeouts: distinguish probe failures, handshake failures, and unreachable destinations
Reduce bulk latency tests to one comparable request
The milliseconds shown in a client usually come from a request to a test URL; they aren’t the network round-trip time between your device and the node. The test may include DNS resolution, connection setup, protocol negotiation, and the destination’s response; the exact timing depends on the core. A timeout only means the request didn’t finish within the time limit. If every node times out, first check that the client is online, the test URL works, and the configuration hasn’t just changed. If only a few nodes fail, keep the test URL and local network constant, then test one working node and one failing node.
Select one node manually in the policy interface, then visit a familiar destination that’s different from the latency-test URL. Check the connection details to confirm traffic actually used that node. Don’t troubleshoot manually while an automatic group is switching nodes: a page may make several requests, and logs from before and after a switch aren’t directly comparable. If the test URL fails but your real service works, retry with a small, predictable response URL recommended by your provider. If the real service also fails, save the first error and continue troubleshooting based on where it occurs.
Identify where the error occurs
A no such host error in the logs often points to a DNS failure, but check whether the unresolved name is the node’s server or the destination. If the node’s server can’t be resolved, the proxy server can’t be reached at all; changing browsers won’t help. For the destination, consider the protocol, routing policy, and where DNS resolution happens. connection refused means something actively rejected the connection. The destination port may not be listening, or an intermediary may have sent the rejection. A persistent connection timeout provides no such clear response; that message alone can’t tell you whether the service is down, packets are being dropped, or the connection is restricted.
If the logs report an expired certificate, a name mismatch, or an untrusted certificate, first sync the system date, time zone, and clock. Then check that the server address, server name, and transport settings in the node configuration match the provider’s original settings. The address field and the name used for certificate validation can differ; don’t change them just to make them match. Don’t hide certificate or handshake errors by turning off validation. For authentication failures, confirm that the updated configuration is active rather than an old saved copy. Get refreshed credentials from your provider when needed; don’t copy or share them from the logs.
Determine whether the issue is with one node, one network, or the probe settings
Test the same node on another available network, such as a phone hotspot you’re authorized to use after it fails on your usual network. If it fails on both networks while other nodes in the same group work, note the node label and error time and ask your provider to check its status. If it fails only on one network, repeat the test with the same device, node, and destination. A consistent result is a reason to investigate that network’s outbound path. Hotspot tests can also be affected by data limits, signal, or phone settings, so one success or failure is only a clue.
Automatic-group checks and subscription updates are separate mechanisms. url-test probes the group’s candidates and selects one according to its policy; a proxy provider’s health-check checks the provider’s nodes. If both are configured, first identify which one produced the result you’re looking at. Don’t fix timeouts by setting an extremely short interval: frequent probes can amplify temporary congestion and make logs harder to correlate. Get a single test working first, then enable periodic checks and see whether results stay consistent over several rounds.
If the connection drops only when a node switch is triggered, check new requests separately from connections that were already open. New requests may use the new node while long-lived connections remain active or need the app to reconnect. Close and reopen the test page, or end one test transfer and retry; there’s no need to clear every connection. For help interpreting results, see How Clash Node Latency Tests Work.
Subscription errors: distinguish downloading, parsing, and applying the configuration
First check whether the download succeeded
On the configuration management page, manually update the subscription and check the message, timestamp, and logs for that attempt. If the download fails, check whether the domain resolves, whether the connection times out, and whether there’s a certificate error. If you receive an HTTP response, check its status code. 401 usually indicates an authentication issue; 403 may mean insufficient permissions, an access policy, or a server-side restriction; 404 may mean an old link has expired or the resource isn’t publicly available. Use the status code to choose what to investigate next—it doesn’t prove that an account is unpaid or suspended.
Go to your provider’s own account page and confirm the subscription is still active. Copy the link marked for your current client or for Clash. Don’t try to reconstruct the path or query parameters from memory. Check for accidental spaces or line breaks, and make sure you didn’t copy a web sharing link instead. A newly issued link may replace the old one. Being able to open the account page in a browser doesn’t mean the client can download the subscription: they may use different proxies, send different request headers, and have separate login sessions. Don’t submit your subscription link to a public converter or online diagnostic tool.
If updates use the current proxy and all your current nodes are down, you may not be able to recover by updating through that same connection. Check whether the client lets you choose a download method. If you can reach the provider directly on your current network, change the method for the update only; otherwise, retry on another network you know can reach the provider. Restore the original setting when the update finishes. Don’t delete a working old configuration as your first step. Keep a copy you can roll back to so a failed update doesn’t cut off your current connection too.
The request succeeded, but the response isn’t a usable configuration
HTTP 200 only means the server returned some content successfully. It could be a login page, verification page, error message, or a list of share links intended for another client. A full configuration and the node list used by proxy-providers serve different purposes: the former can include policy groups and routing rules, while the latter is usually referenced by a main configuration. Importing a node list as a full configuration may appear to succeed but leave out the policies you expected. Check the link type first, then identify the step where the client reports an error.
If a YAML error includes a line number, inspect that line and the few lines above it offline. Common causes include incorrect indentation, tabs used for indentation, misaligned list items, or plain text containing a colon followed by a space that isn’t quoted as a string. The reported line may be where the parser finally failed, while the actual problem is earlier. If the error mentions an unsupported protocol, field, or group type, check which core you’re running rather than deleting unfamiliar lines. Removing fields at random may make the file load while breaking protocol settings, policy references, or rule behavior.
The update succeeded, but the old configuration or nodes are still in use
Check which entry is selected as the active configuration in the subscription list, then confirm the core reloaded it successfully. A successful download doesn’t mean the UI switched to that configuration. If a policy group can’t find an old node after an update, check whether the node was renamed or removed, then select a node that still exists. If you use local overrides, merges, or filters, test the new subscription as a separate configuration and restore local changes one layer at a time. Avoid making extensive manual edits directly to a remote configuration; the next download may overwrite them.
Sometimes the main configuration updates while nested proxy providers keep using an old cache. Check each provider’s own last-updated time, errors, and node count rather than relying only on the main configuration’s timestamp. For HTTP providers in proxy-providers, interval is measured in seconds. Use a manual update to verify a single fetch; change the periodic interval only after the fetch and load both succeed. For details on the fields, see A Section-by-Section Guide to Configuration Files. If you need a different client, choose Clash Plus or another recommended option for your device in the Download Center, and back up your local rules before migrating.
Slow speeds: use comparison tests to pinpoint the node, route, or local overhead
First identify what’s slow
A page that stays blank after you click may point to DNS, connection setup, or time to first byte. If a download starts quickly but soon slows down, check sustained throughput and short-term fluctuations. For choppy video calls, look at packet loss, jitter, and when the connection switches. These symptoms can overlap, but one latency ranking can’t explain them all. Choose a destination you can test repeatedly and are allowed to access. For large-file tests, use the same file or service, and limit data use to avoid repeated downloads on a metered connection.
Keep the test destination, device, and location the same. First test a direct connection with traffic routing off, then test a fixed node, and finally change only the node and test again. If the destination doesn’t allow direct access, use another reachable one to establish a local baseline, but don’t treat speeds from two different destinations as an exact comparison. Browser caching and connection reuse can make the second visit faster. Use a new session to test the first visit, and distinguish a cold start from repeat access. Check speed units too: bytes per second and bits per second differ by a factor of eight. Convert them to the same unit before comparing.
Narrow down the cause with phase-by-phase timings
The commands below are for a POSIX shell with curl installed. The first explicitly disables proxies; the second explicitly uses a local HTTP proxy. Replace 7890 with the client’s actual HTTP or mixed port. Turn off TUN before testing a direct connection, because disabling an app-level proxy doesn’t bypass system-level routing. These lightweight pages are for checking the handshake and time to first byte, not sustained bandwidth.
curl --noproxy '*' --max-time 20 -o /dev/null -sS \
-w 'dns=%{time_namelookup} connect=%{time_connect} tls=%{time_appconnect} first=%{time_starttransfer} total=%{time_total}\n' \
https://example.com/
curl --noproxy '' --proxy http://127.0.0.1:7890 --max-time 20 -o /dev/null -sS \
-w 'dns=%{time_namelookup} connect=%{time_connect} tls=%{time_appconnect} first=%{time_starttransfer} total=%{time_total}\n' \
https://example.com/
These cumulative times are in seconds; they aren’t five separate durations. With a local proxy, the connection time mainly measures establishing a connection to the local listener. The client’s DNS timing may not include resolution of the remote destination. So a very low connect value in a proxied request doesn’t prove the route is fast. Check whether the time to first byte and total time repeatedly increase, and use core logs to distinguish waiting before the request reaches the proxy from waiting after it goes outbound.
Focus on repeatable differences
If only one node stays slow on the same network, switch to another reliable node; don’t sacrifice sustained speed just to get the lowest latency. If several nodes slow down at predictable times, repeat the same test at different times and note whether shared-link congestion could be a factor. If both direct connections and all nodes are slow, pause cloud sync, system updates, and other high-bandwidth tasks. On home Wi-Fi, try a wired connection or move closer to the access point. A better result on another network doesn’t automatically mean the original network is throttled; channel interference and a saturated upload can look similar.
If direct connections and the system proxy work but TUN is slow, check whether TUN is routing extra apps or DNS requests for the same destination. Don’t start by changing the MTU at random. Only test it in small steps if you can consistently reproduce a pattern such as small requests succeeding while larger transfers stall, and save the original value. If only some page resources are slow, check whether the failure affects the main site or other domains hosting images and scripts, and which rules those connections match. It’s normal for a page and its static resources to use different routes. Whether to change anything depends on the failing requests, not on how complete the page looks.
For more examples, see A Layered Approach to Troubleshooting Slow Speeds. Finish by repeating the original action that stuttered: a sustained download, a page’s first load, or a call. A lower latency number only means that particular probe got faster.
DNS problems: find out what’s resolving, what’s being queried, and what response came back
First distinguish a DNS failure from a connection failure
Note the failing domain, not just the site name. A webpage may request resources from several domains, so the browser may still show a title or cached content when some resources fail to resolve. Run the query below to inspect the system’s default resolution path, then compare it with the affected app’s behavior at the time of failure. A successful query only means that this command got a result; it doesn’t prove the browser, TUN, or proxy egress used the same resolver.
nslookup -type=A example.com
nslookup -type=AAAA example.com
Replace the example with the domain that’s failing. No AAAA record doesn’t mean the domain doesn’t exist. If an address is returned but the connection still fails, investigate the outbound route, port, or IPv6 connectivity. Don’t enter the resolved IP directly in the address bar as a substitute for testing an HTTPS domain: the domain affects certificate validation and virtual host selection, so a failed request to the IP doesn’t necessarily mean the address is unreachable. Different networks may return different addresses for a public site as part of normal distributed routing.
Check the relevant mihomo DNS settings
In the active configuration, check dns.enable first, then confirm whether DNS requests are actually reaching the core. Enabling core DNS doesn’t make every app query it: an app may use its own encrypted DNS, or the system may keep sending queries to the previous resolver. If only one browser is affected, note its secure DNS setting, briefly compare it with system DNS, then restore the original value. If the issue only occurs with TUN, check the client-generated DNS routing settings and core logs rather than drawing conclusions from the system DNS panel alone.
| Field | Purpose | What to check |
|---|---|---|
nameserver | Upstream used for resolving regular domain names. | Check whether the upstream is reachable on the current network; distinguish a timeout from a negative response returned by the upstream. |
nameserver-policy | Assigns a resolver to matching domains. | Check whether the problem domain is being sent to the wrong resolver scope. |
proxy-server-nameserver | Specifies the upstream resolver for proxy node domains. | Avoid relying on a node that must already be reachable to resolve its domain during startup. |
fake-ip-filter | Excludes matching domains from fake-IP allocation. | Add exceptions only for destinations with confirmed compatibility issues, then test the affected app. |
When using an encrypted DNS upstream specified by domain name, consider how that upstream is resolved initially. If a series of requests fails after startup but works once a connection is established, check for circular dependencies between resolving the upstream’s domain, resolving node domains, and routing DNS traffic. If internal domains need a resolver provided by your organization or local network, don’t replace everything with an external resolver. First assign a controlled set of domains and test it to avoid disrupting printers, file sharing, and internal services.
Understand how fake-IP and caching affect results
In fake-ip mode, the core can return a mapped address and restore the domain name when the connection reaches it. Seeing a mapped address doesn’t automatically mean DNS is broken. Investigate routing coverage or an exception for that domain only if the app receives a mapped address but its traffic isn’t handled by a route that can restore the domain. If the problem began after switching networks or DNS modes, the app may still have a cached response. Close and reopen the affected app first. If needed, clear the local DNS cache using your operating system’s procedure, then test again on the same network.
After changing settings, retest a public domain, a domain that previously failed, and any local network name you need for work. Check both resolution and connection setup for each. Fixing a public site while breaking internal names isn’t a complete fix. For differences in core fields and defaults, see How mihomo Differs from the Original Clash. Don’t paste an entire configuration made for a different client into your current setup.
System proxy not working: trace the settings through to app behavior
Check the local listener, then the system proxy setting
The system proxy tells apps that honor the setting where to send requests; it doesn’t provide the listener itself. First check that the core is running and that the mixed-port or HTTP listener port in the configuration matches the port set in the system settings. A desktop system proxy usually points to the device’s loopback address, such as 127.0.0.1. If reloading the client’s port fails but the system proxy setting succeeds, the browser may try to connect to a port where nothing is listening. Check the core startup logs for a bind error. If another process is using the port, identify it first, then choose a free port for the client and update the system setting to match.
Run the explicit proxy test below in a terminal with curl, using the actual HTTP or mixed port. In Windows PowerShell, use curl.exe as the command name. If the client only exposes a SOCKS listener, an HTTP command won’t test it; use the correct protocol or enable the matching listener for apps configured to use an HTTP proxy. After a successful request, check the connection details to confirm the expected policy was used. Receiving a status code only proves the request reached the HTTP response stage.
curl --noproxy "" --proxy http://127.0.0.1:7890 --max-time 15 -I https://example.com/
Find out which settings the app actually uses
| Platform | Where to find the setting | Behavior that’s easy to confuse |
|---|---|---|
| Windows | Settings → Network & Internet → Proxy | Desktop apps, WinHTTP programs, and services don’t necessarily share the same proxy settings. |
| macOS | System Settings → Network → Current network service → Details → Proxies | After switching network adapters, the new network service may have different proxy settings. |
| Linux | Network proxy settings in the desktop environment, or settings within the app | Command-line tools may only read environment variables or their own configuration files. |
If an explicit proxy test succeeds but an app launched normally fails, check whether it uses the system proxy, its own manual proxy, an automatic configuration script, or a direct connection. Check the bypass list too: bypassing local addresses is often expected, but an overly broad domain suffix may inadvertently exclude your destination. Terminal tools often use environment variables such as https_proxy and no_proxy; changing the desktop toggle won’t necessarily update the environment of an existing terminal process. Compare with a newly opened app window or fully restart the app to make sure it isn’t reusing an existing long-lived connection.
Browser extensions, network management software, and another client may also keep changing the system proxy. Check whether the system settings actually change when you turn the toggle on, then wait a moment and see whether they revert. If an organization policy restores the proxy, leave it in place and follow your administrator’s instructions rather than repeatedly forcing changes. If you use an automatic configuration script, test it separately from a manual proxy only in an environment where you know the original value and have permission to change it. Deleting an unfamiliar setting can break an existing network connection.
Decide whether TUN is needed, then check that settings revert on exit
Some apps don’t use the system proxy, or need to handle traffic that it can’t route. Consider TUN only then. For your first test, turn off other traffic-routing methods and confirm that the virtual adapter, routes, and DNS are set up as expected by the client. TUN requires additional permissions and affects routing, and enabling it may change local network access. If you only want to proxy a browser, fix how it interacts with the system proxy instead of switching the entire device to TUN for one app.
After making a change, check that the destination matches the expected rule in the connection logs. Then turn off the proxy and exit the client normally, confirming the system hasn’t kept a setting that points to a closed port. If the issue only happens after startup, check whether two clients launch automatically, whether the system restores a proxy address first, and whether the core is ready when the app starts. For a complete first-connection checklist, see First Connection After Importing a Subscription.
Client crashes: distinguish a closed UI, a stopped core, and a rejected configuration
Preserve the evidence and identify which component exited
Note whether the problem starts when opening the window, loading a configuration, enabling TUN, updating a subscription, or resuming from sleep. A missing taskbar icon doesn’t mean the core stopped, and an unresponsive window may only indicate a frozen UI. Check the system tray, process list, and existing startup logs first. If the UI disappears while the proxy still handles requests, investigate the UI process. If the UI remains but reports the core is offline, check why the core exited and whether the local listener is active. A validation message with a line number during import usually means the configuration was rejected, not that the whole client crashed.
Save a short section of the logs from before and after the exit, including the first error. Repeated restarts in the final lines are usually a consequence; an earlier bind failure, file read error, or permission denial is more useful for diagnosis. Share a redacted copy with maintainers. If the system still points to a listener that closed when the client exited, restore the network settings using the No internet section. Avoid repeatedly force-quitting the process, especially during a download or file write; exit normally where possible.
Isolate the configuration and runtime with minimal changes
If the issue started after an update or import, back up local configurations, rules, and overrides, then try switching to a configuration that worked before. If the UI opens, roll back through the UI first. If the client exits immediately on every startup, follow its documentation to locate the user data directory. Fully close related processes, rename the suspected damaged configuration or directory to keep it, then launch with default settings. Don’t clear all app data without knowing what it contains: the directory may hold subscriptions, logs, preferences, and provider caches. Deleting it would remove both the evidence and your rollback option.
If you use a standalone mihomo installation that you can run from the command line, its built-in test mode can validate a single configuration file. The command below assumes config.yaml is in the current directory. If the configuration references provider files, rule sets, or other dependencies, use the same data directory and core as the actual runtime. Passing a check with a different core doesn’t prove the desktop client will pass. A configuration test also doesn’t launch the client or guarantee that ports, system permissions, and traffic routing will work.
mihomo -t -f ./config.yaml
If the client starts with default settings, restore only the main configuration first, not overrides or old caches. Once it loads successfully, restore other items one at a time. If the client exits after restoring an item, keep the smallest reproducible configuration and confirm the issue again in the same environment. If it only exits when TUN is enabled, focus on service permissions and conflicts with the virtual adapter or another VPN. Don’t use administrator privileges as a blanket fix; doing so may hide problems with paths or service installation under normal permissions.
Check the installer and system environment
If the client keeps exiting even with default settings, check your operating system, processor architecture, and the client’s release notes. A core running successfully doesn’t mean the graphical interface will; the core doesn’t need the UI’s dependencies. Use the system’s application error logs to identify the failing module. If the system says a program file was quarantined or blocked by policy, don’t disable protection to launch it. Confirm the source and your organization’s requirements for installing apps on managed devices. When comparing versions, keep the configuration as similar as possible so a configuration incompatibility isn’t mistaken for an installer regression.
If you need another client, start with the Client Comparison, then use the Download Center to choose the right operating system and architecture. Clash Plus is a recommended option on supported platforms. After fixing the issue, exit normally and restart at least once. Test the default configuration, your original configuration, and the action that originally caused the crash. If it still happens, provide your OS and architecture, the steps that trigger it, whether the client runs with default settings, and the first error. There’s no need to submit your entire user data directory.
Mobile troubleshooting: VPN routing, background activity, and network switching
Check system permissions and identify what’s routing traffic
Mobile clients usually route traffic through the system VPN interface. The connection button in the client and the system’s VPN status are separate things. Grant system authorization the first time you connect. Then check the VPN name shown in system settings and test a fixed destination, confirming the client logs the connection. A VPN icon only indicates that a VPN feature is connected; it doesn’t prove the selected node works. If the device has another VPN, content filter, or organization-managed network profile, identify what’s actually routing traffic. Don’t remove profiles installed by your organization.
Android may also have an always-on VPN setting and an option to block traffic when the VPN is unavailable. If the entire device loses internet when you stop the client, check whether either option is enabled instead of just switching nodes. With work profiles or app exclusion lists, personal and work apps may also have different routing coverage. If only one app bypasses the proxy, check whether it’s on the allow or exclude list, then compare with another app using the same domain. Don’t use one public IP lookup to draw conclusions about routing across the whole device.
Separate lock-screen disconnects from network-switch disconnects
Split the variables into two tests. For the first, stay on the same Wi-Fi network and node, connect in the foreground, lock the screen, then unlock after a few minutes and note the VPN status and whether new requests work. For the second, keep the screen on, switch from Wi-Fi to mobile data, wait for the system to confirm the new network is available, then send a new request. A failure in the first test points more toward background restrictions; a failure in the second points more toward the new network’s reachability, tunnel re-establishment, or app long-lived connections. An old connection dropping doesn’t mean it failed to reconnect; send a new request to check.
Android power-saving and background-management settings vary by device. Check whether the system restricts the client’s background activity only if there’s evidence it stops when the screen locks. Note the original value, change one setting, then compare unlock behavior and standby battery use. Don’t apply Android background-keepalive steps to iOS. Instead, check the system VPN status, whether the client supports on-demand connections, and whether logs record a network change at the time of the issue. If you have to unlock and connect manually each time, check whether the on-demand rules cover the current network and whether a management policy restricts behavior.
If the connection works on Wi-Fi but not mobile data, turn off traffic routing and check that both the affected app and the client have permission to use mobile data, then enable routing and test again. If it only fails on one Wi-Fi network, complete its sign-in first and note whether the node address fails to resolve, the connection times out, or only certain destinations are assigned an unusable policy. Switching access points changes both routes and DNS results. Use the same node and destination for a meaningful comparison.
Check local network access, per-app routing, and recovery
Screen mirroring, printer discovery, and local file access rely on local network routes; some also need broadcast or multicast. Public internet access doesn’t prove local network services are working. First turn off the VPN and test the target device, making sure both devices are on a network that allows them to communicate. Guest Wi-Fi may isolate devices. If discovery only fails with the VPN on, check whether the client can bypass VPN routing for local traffic or configure routing per app, and confirm the system’s local network permissions. Don’t expose the client’s listener to the entire local network just to fix device discovery; they’re separate settings.
Verify recovery in order: first a new connection on Wi-Fi, then a new connection on mobile data, and only then the lock-screen and network-switch scenarios. If a setting change caused the issue, restore the old value and repeat the test under the same conditions to rule out a temporary signal fluctuation. Before reinstalling or switching clients, keep your subscription link and local configuration, then choose a compatible option from Android Downloads or iOS Downloads. Client setting names vary; use the system VPN status and actual connection logs to guide troubleshooting.