Guide · From setup to troubleshooting

V2Ray Guide

For your first connection, follow the steps in the Quick Start Guide. Return to this guide when you need to understand why settings work, adjust which traffic is handled, or troubleshoot an issue. If you're configuring a client for the first time, read the chapters in order; if you already have a working setup, jump to the section you need to check.

Core concepts: Apps, clients, and cores

Understand settings by tracing a request

Start by tracing the request path, then learn the interface options. An app generates a request and may connect directly or send it to a local proxy. On desktop, the core usually listens on a loopback address; on Android, the client can use the system VPN interface to capture traffic. Once a request reaches the core, routing rules select an outbound: the core may connect directly to the destination or first connect to the selected proxy server. The app sees only the final result, so a timeout alone can't tell you which step failed.

The GUI client manages nodes, subscriptions, and configuration, and starts or stops the core. The core handles listening, routing, and forwarding. A visible window or tray icon doesn't mean the core is running; selecting a node doesn't mean the browser is sending traffic to the core. Troubleshoot by checking three things separately: did the core start, is the app using the expected entry point, and did the request reach the expected outbound? Use evidence for each question instead of relying on a single connectivity indicator.

Separate protocol, transport, and security

The protocol in a node configuration defines how the client and server exchange proxy requests. Transport determines how that data is carried, while the security layer handles connection protection and authentication according to the settings at both ends. These are separate fields with different roles. For example, two VLESS entries can use different transport or security settings, so the protocol name alone doesn't tell you whether they are interchangeable. A node appearing in a different client also doesn't mean its core supports every parameter in that entry.

When comparing nodes, check the server address, port, and protocol first, then review the transport, security layer, and related fields. A connection that is established but fails during negotiation is a different problem from a hostname that hasn't resolved or a connection that hasn't been established. Don't disable security checks just to make an error disappear. If the server name, certificate, or device time doesn't match, correct the relevant setting. For unfamiliar fields, consult the Concepts at a Glance, then compare them with the configuration provided by your service. Don't combine parameters from different nodes.

Treat subscription updates and connections separately

A subscription retrieves node entries from a configuration source; it isn't a proxy protocol. A successful update means the client fetched and processed the content, not that every entry can connect. Conversely, existing nodes may still work while the subscription service is temporarily unavailable. They usually use different addresses, so identify whether the failure is an update request or an app's access request. Changing subscriptions won't fix every timeout.

DNS resolution can happen at more than one point. The client may need to resolve the proxy server's hostname before connecting, while the hostname of a site an app visits may be handled by the app, the operating system, or the core. Connecting by IP address doesn't prove that all hostnames resolve correctly; websites usually still need the correct hostname. When testing, specify which name failed: the subscription hostname, the proxy server's hostname, or the destination hostname. That tells you which part of the logs to check.

Client selection: OS, architecture, and core

Recommended desktop client: v2rayN

Check the operating system and processor architecture of the machine that will run the client, then choose a package from the client downloads page. If the client runs in a virtual machine, use the guest OS and architecture, not the host's specifications. On a work device, first confirm that you're allowed to install a client, change system proxy settings, or create a virtual network interface. Being able to download a file doesn't mean you have permission to install it or enable TUN later.

PlatformClientHow to choose
Windowsv2rayNCheck the download page for x64 and runtime requirements, then choose the desktop or WPF edition.
macOSv2rayNChoose the disk image for Apple Silicon or Intel.
AndroidRecommended: v2rayNG; alternative: v2flyNGChoose an app based on the required core, then select arm64 or a universal package supported by your device.
Linuxv2rayNCheck the distribution's package format and architecture, then choose deb or rpm.

The Windows desktop edition uses a cross-platform UI framework, while the WPF edition uses the traditional Windows UI framework. For a first installation, start with the desktop edition. If you're maintaining an existing WPF setup, consider your established workflow, configuration paths, and runtime requirements. These differences say nothing about connection speed. To compare them, use the same node, network, and request method, and make sure two instances aren't competing for the same local entry point. For differences in the interface, tray, and package names, see Choosing Between the Desktop and WPF Editions.

On macOS, check the chip or processor in the device information. Choose the native package for an Apple silicon Mac, or the x64 package for an Intel Mac. On Linux, check both the package system and hardware architecture. Debian- and Ubuntu-based distributions typically use deb packages, while Fedora-based distributions typically use rpm. The terminal values x86_64 and aarch64 correspond to x64 and arm64 on the download page. A matching package format doesn't guarantee that all dependencies are available, so check the supported distributions before installing.

Android: choose the app for the core, then the package for your architecture

On Android, start with v2rayNG, which uses the Xray core by default. Consider v2flyNG when the configuration source specifically requires the V2Fly core. First confirm whether you've been given a standard node entry, subscription content, or a complete configuration intended for a particular core. Standard node entries are usually converted into core settings by the app, while a complete configuration may use core-specific fields. Similar names don't guarantee compatibility; don't assume custom parameters will transfer unchanged when switching clients.

The Android package architecture must match the app architectures supported by your system. Don't rely only on whether the processor specifications say 64-bit. If you confirm that your system supports arm64 apps, choose the corresponding package. If you're unsure, check your device documentation before considering the universal package. Universal packages also have system requirements and aren't compatible with every device. If Android reports that the app is incompatible, check the OS version and supported app architectures instead of repeatedly downloading the same file.

When moving to a new device, note the core, subscription groups, and custom routing rules, then back up the configuration using the app's supported export method. On the new device, restore one group first and verify an individual node before restoring other settings. Local ports, startup paths, and system proxy state are specific to the old environment and shouldn't all be copied over. If you're replacing a build on the same device, exit the old instance, keep a recoverable copy of your settings, and verify that the new build starts on its own.

Installation and first launch: verify that the core is running

Install on desktop

Follow the download card and system prompts to install the client; don't import your entire configuration yet. On Windows, run the installer if you downloaded one. If you downloaded an archive, extract it fully before launching the app; don't run it from the archive preview. Check the selected build's requirements and the actual error to determine which runtime is needed. If you're told a desktop runtime is missing, distinguish it from a regular runtime and check that the architecture matches. Repeatedly launching the app won't install missing dependencies.

Use a standard user account for the first launch. For a portable build, choose a directory you can manage and that isn't repeatedly modified by a sync service. If the app opens but can't save settings, check write permissions on its configuration directory rather than running the entire client as an administrator indefinitely. If it crashes on startup after an upgrade, keep the error details and old configuration, then follow Troubleshooting Startup Crashes to distinguish runtime, directory permission, and configuration parsing issues.

On macOS, open the appropriate disk image and place the app as instructed. Launch it from its installed location rather than using the mounted image as a permanent run directory. If macOS reports an architecture mismatch, a damaged app, or a device policy restriction, note the full message and address the specific cause. Follow the approval process on work devices; don't disable system-wide protections just to launch one app. If proxy issues persist after quitting the app, check the system network settings instead of repeatedly copying the app.

On Linux, install the matching package with your distribution's package manager so it can report dependency issues and conflicts. After installation, launch the app from the desktop menu, or diagnose startup issues within the current desktop session. A command-line program working doesn't guarantee that its GUI or tray will display correctly. Likewise, a missing tray icon doesn't prove the process isn't running. If the app launches without a window, check the process, app logs, and desktop session before trying again and potentially starting multiple instances.

Handle Android installation and network permissions separately

Download the appropriate Android package and open it with the system installer. If the source requires installation permission, grant it only for the source you're actually using, following your device's rules. If an update fails, read the system message first: an unsupported architecture or OS version is different from an existing app that can't be replaced. If you need to uninstall the old app, back up any subscriptions and settings you need to restore; uninstalling usually deletes the app's saved data.

After installation, confirm that the client opens correctly and saves settings. If a system VPN permission dialog appears on first connection, the client is asking the system to route the relevant traffic through it. This doesn't mean the subscription has been updated or the remote server is reachable. If the device already has an active VPN, check whether switching could affect a work connection. Don't disable a connection managed by your organization. Once connected, test with a real app, then confirm you can disconnect normally.

Define first-launch checks

First verify that the interface works, settings can be saved, and the process exits normally. On desktop, import one supported configuration, then verify that the core starts and listens on the expected address and port. If you only see that a port is open, use process information to confirm which program owns it. On Android, confirm that the system permission and connection status match the app configuration. Until these checks pass, don't import multiple groups, enable startup on boot, or change several network settings at once; that can turn a simple installation issue into a hard-to-reproduce startup-order problem.

Import subscriptions: groups, updates, and verification

Identify the type of configuration you have

A subscription URL retrieves a group of nodes; a share link describes a single node; a complete configuration file may include inbound and outbound settings, DNS, and routing. All three may be provided as text, but they don't belong in the same input field. Check the configuration source's format and supported-core requirements, then choose subscription management, clipboard import for a node, or the app's configuration import feature. A URL opening in your browser doesn't mean it's a subscription; it may simply be an account page.

Subscription URLs often contain access credentials, so treat them like account details. Don't post the actual URL in public forums, online conversion tools, or shared screenshots. Before copying it, check for extra spaces, line breaks, or explanatory text, and don't edit query parameters without a good reason. When reporting an issue, record the error type and time; use an example like https://example.com/sub?token=xxxx to show the URL structure, not as a working subscription.

Update one group manually first

In v2rayN, open the subscription group settings, add a group, and give it a descriptive alias. Paste the full subscription URL into the address field, save it, then manually update the group. The alias is only for identifying the group in the interface; it doesn't determine which server you connect to. After the update, switch to that group, check that the imported entries look right, and test one supported node. Add a second source as a separate group to avoid accidentally replacing a known-good URL.

In v2rayNG or v2flyNG, open subscription group management, add a name and URL, save, then return to the list and update the group. Menu labels can vary between builds; the essential steps are to save the source, fetch its content, and select an entry to use. Subscription management and starting a connection are separate actions: seeing nodes in the list doesn't mean the system VPN is running, and an active VPN doesn't mean the update changed your current selection.

Set up automatic updates only after the first manual update succeeds. Choose an interval based on the source's refresh guidance and how you use the device; more frequent isn't always better. While troubleshooting, turn off automatic updates for that group or avoid its update window so entries aren't replaced midway through a test. Some clients rebuild groups from the latest subscription content, overwriting manual changes. Keep test entries that must persist in a separate manual group, and distinguish them from subscription entries.

Choose the fix based on where the update failed

If the logs show a name resolution or connection error, first check whether your current network can reach the subscription endpoint and whether the app lets you choose the route used for update requests. Don't force updates through an unverified outbound; if a node fails, the update request may fail too. If the server requires authentication or denies access, check whether the URL has expired and whether the account still has permission. Repeated retries won't fix that. If the server responds but the client imports no entries, check the response format, protocol support in the client, and whether the response is actually a login page.

After importing, test a known-accessible destination without changing other variables. A node test only verifies the parts covered by that test; it doesn't replace testing the actual app request. If one entry fails, compare it with other entries in the same group. If the entire group fails, check whether the core started, whether the local entry point is correct, and whether the network changed. For a step-by-step walkthrough, return to Import a Subscription in the Quick Start Guide. If connections still fail across groups, continue with Connection Troubleshooting.

Proxy modes: local ports and system proxy

Test the local entry point with the fewest moving parts

For an initial desktop test, configure a single app to connect explicitly to the local proxy. Open the settings and check the actual listening address, port, and type. The HTTP and SOCKS ports may be separate, or a mixed listener may handle both; you can't infer the type from the port number alone. If the proxy is for local use only, keep it bound to a loopback address. Don't enable LAN access to fix a local configuration issue. Traffic to a loopback address doesn't automatically come in from another device just because a remote node is selected.

The example below works with curl builds that support these options. First confirm that v2rayN's local HTTP or mixed listener uses the example port; otherwise, replace it with the port shown in the settings. In Windows PowerShell, call curl.exe explicitly. The example sends one request to a public example domain and doesn't make persistent system changes. If that domain isn't available on your network, use a test destination you know is accessible.

curl --noproxy "" --proxy http://127.0.0.1:10809 --max-time 15 -I https://example.com/

The explicit proxy options apply only to this command. An empty exclusion list prevents existing proxy exclusions from sending the destination directly. If the local connection is refused, check that a listener exists and that the address family matches—for example, the listener may be bound only to the IPv4 loopback address while the client connects to a different address. If the local proxy returns an error, check the destination or remote logs. A response from the destination confirms that this request passed through the configured local entry point; check the routing result separately to see whether the core used a direct or proxy outbound.

Understand what the system proxy actually covers

Setting a system proxy tells apps that follow system settings to use a specified proxy entry point; it doesn't route every packet on the operating system's behalf. Browsers often read the system configuration, but a profile, browser extension, or device policy can change how they behave. Whether terminal programs use system settings or environment variables depends on their implementation. Even if two commands can reach the same site, don't assume they use the same proxy. If browser and command-line results differ, check each one's effective configuration.

Some systems and clients support an auto-configuration script that decides, when the app supports it, whether a request goes to the local proxy or connects directly. This is a separate decision from core routing: if the app never sends the request to the core, the core's routing rules can't match it. First test the local entry point with the explicit proxy method above, then restore the intended system proxy setup. If the explicit entry point works but the system proxy doesn't, investigate the system or app before changing nodes.

Verify proxy reset and app exit separately

When testing is done, use the client to clear or restore the system proxy, then exit if needed. If a work proxy was already configured, restore its original address, port, and auto-configuration settings rather than disabling all proxies as a universal fix. On managed devices, only system policy may allow these values to be changed. Re-test in an app that previously relied on the system proxy. If necessary, restart the app so it doesn't reuse an existing request session.

Android usually routes traffic through the system VPN and app-scope settings; don't apply desktop system proxy steps to it. When testing an Android app, first check whether it falls within the client’s capture scope, then confirm that the client has system authorization. For desktop issues limited to terminal commands, see How to Troubleshoot Browser and Terminal Proxy Issues Separately. If the core reports that a listening port is already in use, find the conflicting process instead of changing proxy protocols in other apps to hide a startup failure.

Routing: match conditions, order, and fallback

Define three expected outcomes first

Routing only applies to requests that have entered the core. Before making changes, write down three expected outcomes: which destinations should connect directly, which should use the selected proxy, and which should be blocked by a rule. Then define a default outbound for requests that don't match an explicit rule. The default is part of the configuration, not something to guess. If the interface has no separate fallback option, check the generated config's outbound order and rule targets against the core's behavior.

Preset routing modes are a useful starting point, but their names don't reveal what they actually match. After enabling a preset, review the rule list to see whether it uses domains, destination addresses, or category data, and note how unmatched requests are handled. Region or site-category datasets can change, and results may vary with DNS resolution. Keep a working baseline before adding custom rules. Don't change category data, DNS strategy, and the default outbound all at once, or you won't know which change made a difference.

Domain and IP rules have different limits

Domain conditions are suited to named destinations; IP range conditions are suited to specific network ranges. Whether a domain rule matches depends on whether the core has the destination name when it evaluates the request. If an app resolves the name itself and passes only an IP address, the domain may no longer be available. If a rule requires an IP address but the core only has a domain name, the result depends on the routing DNS strategy. Don't treat both cases as a failed category database.

For example, Xray checks field rules in order, and the first match determines the outbound. Put specific exceptions before broad rules. If a field rule has both domain and IP conditions, check how that core defines their combined behavior. To express “connect directly if either the domain or IP matches,” use two rules that target the same outbound. The example below is a routing object for an Xray configuration, not a complete config or client subscription. Before using it, confirm that direct is the tag of a defined direct outbound.

{
  "domainStrategy": "AsIs",
  "rules": [
    {
      "type": "field",
      "domain": ["full:example.com"],
      "outboundTag": "direct"
    },
    {
      "type": "field",
      "ip": ["192.168.50.0/24"],
      "outboundTag": "direct"
    }
  ]
}

The first rule matches only the exact hostname example.com, not its subdomains. The second matches the example IP range and doesn't replace checking your actual LAN ranges. AsIs doesn't resolve a domain to an IP for this stage of routing, so a request passed in as a domain won't match the second rule just because it ultimately resolves to an IP in that range. Unmatched requests follow other rules or the core's default outbound. Prefer entering equivalent conditions in the client's rule editor to avoid manually changing a file that the interface will regenerate.

Test both matches and non-matches

For every new rule, test at least two kinds of destinations: a positive case that should match and a similar negative case that should fall through to later rules. For an exact-domain exception, test the hostname and one of its subdomains. For an IP range, test an address inside it and one in a neighboring range. A successful command only proves the destination is reachable, not that it used the expected outbound. Check the core's routing or outbound logs too. If detailed logs aren't available, enable diagnostic logging briefly and restore the previous level after testing.

Web pages often request resources from multiple domains, as well as login services and APIs. If the main page loads but some content fails, identify the destination of the failed request before adding a rule; don't switch all outbounds to hide the difference. If a new rule affects LAN resources, shared services, or device management pages, restore the previous rules first. Then check whether the condition is too broad or is overridden by an earlier rule. Record each rule's purpose and how to verify it so you know what can be removed later.

TUN mode: traffic scope, permissions, and DNS

Enable it only when you need it

TUN is useful for apps that don't honor the system proxy. When a desktop client starts the relevant core feature, the system uses a virtual network interface and routing rules to send matching traffic through the processing path. Broader traffic capture doesn't mean every request uses the same proxy outbound, or that every interface and traffic type is covered. System routes and client settings determine what is captured; core routing determines how captured traffic is handled.

Before enabling TUN, verify that the regular local proxy and node work, and note the machine's existing system proxy, network interfaces, and frequently used LAN services. Identify which app needs to use TUN and prepare a test for that app alone. If you rely on a remote session or a managed VPN, don't change traffic capture without a way to restore it. Route changes can affect the connection keeping that session alive, even if the client interface shows no warning.

Enable TUN on desktop and check for conflicts

In v2rayN, find the Tun option or related settings. Confirm that your build and core meet the feature requirements, then grant the permissions requested by the operating system. Windows, macOS, and Linux use different permission and interface setup processes. If permission is denied, identify whether the failure involves a helper component, creating a virtual interface, or changing routes. Grant elevated access only when device policy allows it and the build actually requires it. Don't run every app with elevated privileges to work around a single interface permission issue.

For the first test, keep just one clear traffic-capture path. If a system proxy is already configured, record its original values and temporarily restore them before testing whether TUN captures traffic from the target app. Otherwise, the app may still connect directly to the local proxy, making it appear that TUN works when it doesn't. Check the virtual interface and client status, then test a regular hostname, the target app, and any local services that must remain accessible. Add one condition at a time—for example, configure LAN exceptions only after confirming the basic setup works.

If all connections suddenly time out after enabling TUN, turn it off first and check whether the baseline works again. The interface may not have come up correctly, system routes may not have been installed as expected, or the connection between the core and proxy server may be routed back through its own capture path. Check the failing step in the logs and whether the client offers automatic interface selection or an outbound exclusion suited to your network. Don't guess and manually delete system default routes. For more details, see v2rayN TUN Mode Setup.

Distinguish DNS issues from connection failures

If IP addresses are reachable but ordinary hostnames generally fail, investigate the DNS resolution path first. Use a destination that can be tested directly by IP for comparison. Replacing a website's hostname with an IP address is usually not a reliable test because certificates and site selection depend on the hostname. Check whether the core can resolve the proxy server's hostname, whether ordinary app queries follow the expected path, and whether the results suit both LAN and external destinations.

Some apps use encrypted DNS, so their results may differ from those returned by the operating system. Internal names on work networks may also need to use a designated resolver. Don't replace local, core, and app DNS settings all at once just because a hostname times out. First identify which kind of name is failing, then check whether the query gets a response, whether the returned address is in the expected range, and where the app connects next. Keep the original settings so you can restore them in reverse order if the change causes a regression.

Android VPN permission and the desktop TUN menu are different features. On Android, first check whether the VPN is active, then review app scope, always-on VPN settings, and conflicts with existing connections. After testing, use the client to stop traffic capture and confirm that the target app behaves as expected on the original network. If issues persist after turning it off, check the system network settings and client logs to confirm the actual state; don't keep toggling the switch and hoping for a fix.

Maintenance: updates, backups, and troubleshooting

Keep the three types of updates separate

Client updates can change the interface, configuration handling, or packaged files. Core updates can change protocol, DNS, and routing behavior. Subscription updates change node entries. Unless an installer updates both the client and core by design, avoid changing multiple layers in one troubleshooting session. Before updating, note the runtime environment, core, working entry point, and one test result. Re-test that baseline after the update before enabling anything else, so compatibility regressions are easier to spot.

Back up configurations you can re-import, routing rules, and essential usage notes rather than copying the entire runtime directory to a shared sync location. Backups may contain subscription credentials, server addresses, and complete connection parameters, so keep them in a controlled location. Record how to restore them and which clients they apply to. If you haven't tested a restore, at least confirm that the export is readable and complete, then test restoring one group without disrupting your regular connection.

When migrating between clients or platforms, separate reusable configuration from local machine state. Node groups and rule intent may be portable in a supported format; working directories, listening addresses, system proxy settings, and virtual interface selection need to be checked on the new device. After a failed upgrade, don't keep mixing old and new configuration in the same directory. Stop the process, keep a copy of the failed setup, and restore a known-good configuration in a separate writable location to compare the smallest differences.

Troubleshoot from the local machine outward

First establish the scope: all devices or one, all apps or one, all destinations or one type of hostname. Then check whether the client is running, whether the core is listening, and whether the app points to the same entry point. Once those are confirmed, check node parameters, DNS, and routing. If the issue started after switching networks, compare both networks with the same configuration. If it started after switching nodes, test the same destination with each node.

In Windows, use PowerShell to check whether the example local port is listening and identify the process ID that owns it. Replace the port number with the actual value in the settings. On other platforms, see Troubleshooting a Local Port Conflict for platform-specific commands. If nothing is listening, check the core startup logs. If a listener appears, confirm which process owns it; don't assume that a port number alone identifies v2rayN.

Get-NetTCPConnection -State Listen -LocalPort 10809 |
  Select-Object LocalAddress, LocalPort, OwningProcess

If an old client instance is using the port, exit it normally through the app. If another essential program owns the port, leave it running and choose an available port for the client. Then update every browser, terminal, or app setting that explicitly refers to the old port. Don't change the port only in the client. Afterward, check that the new port is listening and repeat the request that originally failed. For authentication or negotiation errors unrelated to the port, check the relevant protocol fields instead of focusing on the local port.

Keep diagnostic notes focused but useful

Record the platform, client name, core, test time and time zone, last change before the issue, stage where the error occurred, and the shortest steps that reproduce it. Before sharing logs, remove subscription URLs, authentication fields, account details, internal hostnames, and unnecessary full request paths; keep error categories and event order. Raise the log level briefly only to capture evidence from one reproduction, then restore the usual setting. If the issue can't be reproduced right away, observe the conditions instead of repeatedly reinstalling the client or resetting all system network settings.

Advanced: reproducible configurations and rollbacks

Build a small test matrix first

Expand the configuration only after the baseline is stable. List the entry point, destination, and expected result for common scenarios—for example, a browser using the system proxy, a specific terminal command using the local entry point, a LAN management page following its established route, and an app that ignores the system proxy being captured only when TUN is enabled. State the expected result for each test instead of just writing “works.” The same destination might load through different entry points while using different outbounds.

Split tests into basic checks and scenario checks. Basic checks verify that the core starts, the port listens, one destination is reachable, and the app exits normally. Scenario checks verify that subscriptions update, routing exceptions work, DNS is available on the target network, and traffic can be restored after changing capture modes. Use the same destinations before and after a change, and record network conditions. A sporadic timeout doesn't necessarily mean the configuration is broken, but repeat the test under similar conditions to distinguish a temporary issue from a reproducible one.

Switch cores only to meet a compatibility requirement

Choose a core based on configuration requirements, not its name or how its interface looks. The cores and settings available in desktop v2rayN depend on the build and node type. On Android, check the source's core requirements before choosing between v2rayNG and v2flyNG. Save the original configuration before switching and test a copy rather than changing your everyday group. After startup, check the logs to make sure fields weren't ignored or rejected, then test a specific destination.

A node share link being importable into multiple apps doesn't mean custom routing, DNS policies, or extra transport parameters work the same way in each. Before migrating rules, write down their intent—for example, “send work hostnames through the resolver specified by the system, and route other destinations according to the existing conditions”—then express it using features supported by the new core. Don't assume replacing an outbound tag preserves the same behavior. Check unmatched conditions, when DNS resolution occurs, and whether connection reuse affects the test.

Make rule order and recovery steps easy to review

A GUI client usually rebuilds generated configuration when it starts or saves settings. If you need a custom configuration, first confirm whether the current interface has a separate import option and how it combines with interface settings. Changes to a temporary generated file may disappear on the next launch. Choose a clear location for persistent settings, record which values are managed by the interface and which come from imported files, and keep credentials separate from configuration notes you can share.

For each change, record the reason, what you changed, the expected result, and how to undo it. For routing changes, add one exception at a time and test positive and negative cases. For DNS changes, compare one public hostname with one internal hostname that must remain available. For traffic capture changes, confirm that traffic returns to normal when capture is disabled. Keep two recovery options: revert only the latest change, or restore a known-good set of settings if the impact is unclear. Document whether either option requires restarting the process, clearing the system proxy, or restoring the previous app scope.

When an issue returns, use your latest change to find the right section: if the node list changes after a subscription update, check the source and group under Subscription Import; if only some destinations use the wrong outbound, review match conditions and rule order under Routing; if LAN access stops after enabling traffic capture, revisit interfaces, exceptions, and DNS under TUN. For a refresher, follow the minimum connection steps in the Quick Start Guide, then return to Advanced settings. A setup is ready for daily use when you can explain the route each request takes and restore a verified state when something goes wrong.