01 Fundamentals
Core Concepts: Apps, Entry Points, Core, and Outbound Connections
Trace the path of a request
A web request usually starts in a browser. On desktop, a browser configured to use the system proxy sends the request to the client's local listener; without that setting, it may connect directly to the destination. Once a request reaches the listener, the core can inspect the destination, match a routing rule, and select an outbound. With a proxy outbound, the core connects to the remote server and forwards the request using the configured protocol. With a direct outbound, it connects to the destination itself; with a block outbound, it stops the request on the local device. The local entry point used by the browser and the remote endpoint contacted by the core are different addresses and may use different protocols.
Troubleshoot by finding where this chain breaks. An open settings window shows that the GUI is running, not that the core has started. A listening local port does not prove that the remote handshake succeeded. And a successful connection reported by the core does not guarantee that the destination returned usable content. Conversely, a page loading does not prove that it went through the proxy: it may have connected directly or loaded from cache. During testing, log these stages separately: process started, request received, outbound selected, and destination responded. Then change settings related to the stage that failed.
The client manages settings; the core handles connections
Project V provides the ecosystem background for tools like these, while V2Fly and Xray are related core projects. In this guide, the client means the GUI: it stores nodes, manages subscriptions, generates the runtime configuration from your current selections, and starts or stops the core or connects it to the system network. The core handles listening, forwarding, protocol processing, and routing. Seeing a node in the GUI does not mean the active core supports that node's combination of protocol, transport, and security settings. If importing succeeds but startup fails, first check which core is running, then use the logs to determine whether a field is unsupported, a resource is missing, or the connection failed.
A node describes how to connect to a remote server. The protocol defines how the two ends interpret requests; the transport defines how data is carried; security settings cover requirements such as authentication and encryption. These layers are not interchangeable. The same server address can use different ports, transport paths, or service names. A protocol name in the node's label alone does not tell you its actual settings. Use nodes or subscriptions provided by the service operator. If authentication fails, do not disable certificate verification just to make the connection appear to work.
Subscriptions, routing, and DNS each do a different job
A subscription is a source of node data; updating it does not test every node or prove that the currently selected node still works. Routing uses conditions such as destination domains, destination addresses, and inbound tags to choose an outbound. DNS resolves names to addresses and can also affect whether a routing rule matches. An app may pass a domain name to the core, or resolve it first and pass only the address. In the latter case, the core may not see the original name. If the same site is routed differently in two apps, first check what each app is actually passing to the core.
First identify which layer changed. A changed subscription list does not mean the active node changed, and changing the active node does not mean an app is using the proxy.
Before testing, choose a page you are authorized to access and whose response is easy to recognize. Record the result on your current network, then use the same destination for comparisons; do not compare load times across different sites. In particular, latency is not a measure of the connection path: local port response time, node test duration, and full page load time measure different stages. Breaking a request into separate stages gives you a way to verify client choices, routing rules, and rollback steps later.
02 Choose
Choosing a Client: Platform, Architecture, and Core
Narrow down your options by operating system
For desktop, start with v2rayN. On Windows, you can choose between Desktop and the classic WPF version; these are GUI options, and the interface alone does not tell you which node protocols are supported. The v2rayN desktop version is also available for macOS and Linux; choose the build that matches your chip or distribution's package format. On Android, v2rayNG is the usual choice and uses the Xray core. Consider v2flyNG if you specifically need the V2Fly core. Do not run both Android clients at once to compare stability: each needs the system VPN interface. Stop one before starting the other.
| Platform | Client | Download options | What to check first |
|---|---|---|---|
| Windows | v2rayN | Desktop、WPF | Processor architecture and software requirements |
| macOS | v2rayN | Apple Silicon、Intel | Chip or processor shown in system information |
| Android | v2rayNG、v2flyNG | arm64, universal build | App architecture and the core required by your nodes |
| Linux | v2rayN | deb, rpm; available for x64 and arm64 | Distribution package format and processor architecture |
Open the client download page, select your platform, and compare the options with your system information. On Windows, check System type under About; do not assume that a 64-bit system means x64, since 64-bit devices can also use ARM. On macOS, check About This Mac to see whether it has an Apple chip or an Intel processor rather than guessing from its age. On Linux, use the command below to check the machine architecture, then choose a package format used by your distribution. Typically, x86_64 maps to x64 and aarch64 to arm64. If the user space differs from the hardware architecture, follow the target architecture recognized by the package manager.
uname -m
cat /etc/os-release
Then check whether your configuration will work as-is
Most newer Android devices use arm64, but a chip's capabilities and the app architectures supported by the OS are not always the same. If you are unsure, choose the universal build on the download page. “Universal” means the package includes native libraries for multiple architectures; it does not mean broader protocol support. If a newer version will not install over an existing app with the same name, check for an architecture mismatch, unmet system requirements, or a different app signature. Do not uninstall as a first step. Check whether your subscription, manually added nodes, and per-app routing list are backed up so you do not lose connection settings while troubleshooting installation.
Before choosing a client, write down a few requirements you can verify: the protocols and transports provided by the service, whether a specific core is required, whether you need to proxy only a browser or also apps that ignore the system proxy, and whether traffic must be routed by app. If the only difference is GUI preference, test both desktop versions with the same node. If the node documentation requires a specific core, do not switch to another based on a similar name. Even if importing produces no errors, test that the node starts and that the service you need is reachable.
When migrating, bring over only settings you can identify
Import subscription links and individual nodes using methods supported by the client. Check proxy ports, DNS settings, rule sets, and app lists separately. Desktop and mobile platforms use different system entry points, so copying an entire configuration directory across platforms is usually a bad fit. Even when both clients show the same node name, verify that the active node, transport options, and routing policy match. If the old client still works, finish a basic test in the new one before disabling the old configuration. Do not run both clients against the same local listening port for comparison.
You do not need to configure every feature at the outset. Start with a minimal setup you can restore: one client for the platform, one known-good node, and one test destination. If using multiple devices, check each system entry point and record the result with the same node. This helps separate device-specific issues from server problems. If one device fails, another device's active proxy or different app settings will not interfere with the diagnosis.
03 Install
Installation & First Launch: Verify the Local Listener First
Prepare the runtime environment for the package you downloaded
On Windows, choose the v2rayN version you need from the download page. Run the installer as directed. If you downloaded a portable archive, extract the entire package to a fixed directory you can write to before launching it; do not run the app from the archive preview. Do not copy only the main executable: the core, rule resources, and related files may need to stay in their original relative locations. If the app exits on startup, check system messages and application logs, then install any runtime components explicitly required by that package. If access to the directory is restricted, first try a location writable by a standard user. Running the whole app as administrator permanently is not the preferred way to troubleshoot directory permissions.
On macOS, mount the disk image for your chip, copy the app to Applications, and launch it. If macOS blocks it, check the source in line with your security policy; if you cannot verify it, stop the installation rather than weakening system protection globally. On Linux, install the matching package with your distribution's package manager so it can handle dependencies and track the installation. For missing dependencies, check the package names in the error rather than overwriting the installation with a package in another format. On Android, grant permission to install apps only to the source from which you actually open the package. Check that the main screen works on first launch; verify system network permission when you start a connection.
Confirm the port from what you observe, not a memorized default
On first launch, do not change the system proxy or enable TUN. In v2rayN's settings, find the local or mixed listening port, then compare it with the actual listening address in the logs. The two ports mentioned in common tutorials may come from different versions or listening modes; do not assume there is a separate HTTP listener in your current setup. For local apps only, keep the listener on a loopback address. Enabling LAN access changes who can connect; it is not necessary to fix a local connection failure. Even if the GUI shows a port value, confirm it took effect in the startup log or with a system query.
On Windows, use PowerShell to check listeners on loopback or wildcard addresses. The command below is read-only and does not change ports. Use the process ID in the results to check the owning process in Task Manager; a wildcard address may also occupy a port the client needs. If there is no output, first check whether the core is running, then inspect startup errors. Do not enter a remote node port as the local port. If another instance is using the same port, exit the duplicate client normally or assign one instance a different port, then update any apps that depend on it.
Get-NetTCPConnection -State Listen |
Where-Object { $_.LocalAddress -in '127.0.0.1','::1','0.0.0.0','::' } |
Select-Object LocalAddress,LocalPort,OwningProcess
Start and stop once to establish a clean baseline
Start and stop the app once, and check whether it remains in the system tray. Closing the main window may only hide the GUI while the core keeps listening. To free the port, use the client's stop or exit command, then check again. If another previously installed instance is using the entry point on first run, identify whether any task depends on it before stopping a process; do not terminate an unfamiliar process based only on its port number. For more detail, see how to troubleshoot local port conflicts. For a desktop walkthrough, see the v2rayN installation and setup guide.
Installing the app does not mean you should start it automatically with the system. First note how the client stores its data, which port it actually listens on, and how to stop it. After importing a node, connect and exit manually once. If the system may have an old proxy address configured, record its value before changing anything; do not assume a proxy managed by your organization is leftover client configuration. Configure startup only after confirming that the system network returns to its previous state when the client exits normally. On Android, note whether another app is using the system network entry point and stop any conflicting app before testing in the next section.
04 Configuration Sources
Subscriptions & Adding Nodes: Update First, Then Choose an Active Node
Know the difference between a subscription URL, a shared node link, and a runtime configuration
A subscription is a URL requested by the client, and the client determines which response formats it supports. A shared node link usually describes one connection. A full core configuration may also include separate inbounds, multiple outbounds, and routing rules; it cannot be submitted as an ordinary subscription URL. Before importing, read the provider's instructions. If they gave you an account webpage rather than a subscription URL, pasting it into the client may return a login page. A URL opening in your browser does not prove its contents are valid. Do not send it to an unknown online conversion tool to troubleshoot. Query parameters and paths may contain access credentials, so protect the URL like a password.
In v2rayN, open subscription group management, create a group, and enter a recognizable name and subscription URL. Save it, select the group, and update the current subscription. The group name is a local label; it does not determine the response format. In v2rayNG, open subscription group settings from the menu, add a group and URL, return to the node list, and update the subscription. Manage sources through the subscription group entry in v2flyNG as well, but do not assume that both apps recognize exactly the same node types. Menu labels may vary by version. Check that the source was saved, a fetch was performed, and the list actually added or refreshed entries.
Check the request, parsing, and selection in that order
After updating, check that the group contains entries, then verify the active node. New nodes appearing does not mean the client switched to one of them; a refresh may also replace existing entries and invalidate the previously selected item. Start by testing a node explicitly provided by the service with complete settings. If you only have a shared link, use an import method supported by the client to add it to the right group; you do not need to create a subscription first. Keep manually maintained entries separate from auto-updated ones so a refresh does not wipe out changes you expected to keep.
If an update fails, identify the type of failure first. For a request timeout, check the current network and the path used for the update. For a rejected response, check whether the URL has expired or access permissions changed. A parsing error may mean the server returned a login or error page, or a format the client does not support. If existing nodes connect but the update fails, the proxy data path is at least partly working; that does not prove the subscription service is healthy. Likewise, a successful update only proves that the subscription endpoint responded, not that every node in the list can connect.
Keep the last working node. Only investigate a circular dependency in the update path if the old node has stopped working and the update depends on that node. Repeatedly clearing the list is not a substitute for troubleshooting.
Choose an update strategy that will not overwrite manual changes
If the client offers updates through or outside the proxy, determine which path can reach the subscription URL. If the old node no longer works and subscription requests still go through it, try updating outside the proxy, provided the local network can reach the subscription endpoint. Conversely, if a direct local request fails but an existing node works, try updating through the proxy. For certificate errors, check the system clock and certificate trust; for DNS failures, check the current resolver. Do not bypass certificate errors to continue. Set the automatic update interval according to the service operator's refresh schedule. If manual and automatic updates happen around the same time, record when each was triggered so you can tell which one changed the list.
After an update, compare the group, active node, and result of an actual request. If you select nodes by their labels, do not use the label as the only identifier; different entries can have the same name. You can record the protocol type, selected group, and a non-sensitive node label, but do not include full node or subscription contents in shared logs. For specific troubleshooting of automatic updates, system DNS issues, and update paths, see subscription update failures and automatic update settings. Do not change routing yet; the next section verifies one selected node through one entry point.
05 Traffic Entry Points
System Proxy, Global Routing, and Direct Connections
The system proxy determines which requests can reach the core
On desktop, v2rayN's “Set system proxy” option mainly writes proxy settings that apps can read from the operating system. Browsers and other apps that follow those settings may then send requests to the local entry point. Not all programs use system settings: some command-line tools read only environment variables, some apps use their own saved proxy settings, and some browsers are controlled by organizational policies or extensions. If the system proxy is enabled but just one app fails, first check whether the app is using it and whether the proxy protocol is correct. Do not immediately change the core's outbound rules.
“Clear system proxy” removes or resets system-level proxy settings; whether existing settings are changed depends on the client and operating system. It does not stop the core, nor prevent apps from using a local port configured manually. If the system proxy option says “Do not change system proxy,” it means the client will leave that setting alone, not automatically restore a direct connection. If you have manually changed the system proxy, check the proxy address and bypass list in system settings before and after switching. On managed networks, take care not to remove a proxy required by organizational policy.
Global and rule-based modes describe what happens after traffic enters the core
Global proxy usually means that traffic entering the core, unless handled by a more specific condition first, goes through a proxy outbound. It does not mean every connection on the device is being intercepted. Bypassing mainland China rules usually means that a rule set routes some domains and addresses directly; it does not measure a server's actual location or analyze page content. A direct policy sends matching requests straight to their destination from the local device after they have entered the core, so they may still pass through the local entry point and core. To tell whether a problem is with the system entry point or routing, first check whether the core can see the request, then which outbound it selected. For how the two settings work together, see system proxy and routing modes compared.
Test an explicit proxy without relying on system settings
If you have confirmed that the local SOCKS listener on desktop is 127.0.0.1:10808, use the command below to test that entry point directly. It uses a reserved public domain for examples and requires no account. If it is unsuitable on your network or under your rules, substitute a prepared test destination. In Windows PowerShell, you can use curl.exe to avoid the alias. If the port differs, replace it with the SOCKS port shown in the logs. If only an HTTP listener is enabled, do not enter it as a SOCKS port.
curl --socks5-hostname 127.0.0.1:10808 --connect-timeout 10 --max-time 20 --head https://example.com/
This option tells curl to pass the domain name to the SOCKS entry point rather than resolving it on the machine running curl first. Getting a response proves only that the request through this entry point got a result; check the outbound records to confirm whether it actually used a remote node. If the local connection is refused, check the port and core process first. If it times out only after connecting locally, check the outbound, remote handshake, or destination response. Some sites reject requests that fetch only response headers; compare with a normal request if needed. Do not mistake an application-level response code for a core startup failure.
Android uses system VPN permission, not the desktop “Set system proxy” steps. First test with a regular app, making sure it is not excluded by per-app routing, then check which outbound the core selected. The same principle applies on desktop: hold the entry point, node, and destination constant in this section so you can reproduce the result; change only the rules in the next section. If you switch browsers, nodes, and global mode all at once, even a temporary fix will not tell you which change helped.
06 Outbound Policies
Routing & DNS: Verify Rule Matches in Order
Define match conditions first, then assign outbound tags
Common core routing checks rules in order and selects an outbound when the first applicable rule matches. List exceptions that must be blocked or go direct first, followed by broader conditions, and put the fallback last. If a rule has both domain and address conditions, that does not mean matching either one is enough. To send a specified domain set or address set directly, use two rules. direct, proxy, and block are outbound tags referenced by the configuration; their names do not create outbounds. Before importing rules, check which outbound each tag refers to in the current configuration.
The following is a routing fragment for a core configuration. Merge it into an existing core configuration with inbounds and outbounds; all three outbound tags must already exist, and the rule set must contain the referenced groups. This is not a general-purpose import file for v2rayN or Android clients. When editing in a GUI, enter each item separately in the routing rule editor. In this example, the final rule matches only TCP and UDP, so regular proxy traffic uses it as a fallback. If your configuration uses a default outbound as the fallback, confirm that the intended outbound is actually first; an unmatched request does not automatically mean a direct connection.
{
"routing": {
"domainStrategy": "IPIfNonMatch",
"rules": [
{
"type": "field",
"domain": ["geosite:category-ads-all"],
"outboundTag": "block"
},
{
"type": "field",
"domain": ["geosite:cn"],
"outboundTag": "direct"
},
{
"type": "field",
"ip": ["geoip:private"],
"outboundTag": "direct"
},
{
"type": "field",
"network": "tcp,udp",
"outboundTag": "proxy"
}
]
}
}
Do not let a broad fallback catch addresses before they can be resolved for matching
geosite:cn matches domain groups in the rule database, while geoip:private matches address ranges marked for private or similar uses in that database. Requests with an address but no domain usually cannot match the first two domain rules. A private service accessed by domain is also not the same as one accessed by private IP address. With IPIfNonMatch, the core considers resolving a domain and matching its address when the domain request does not match a rule. The broad network fallback above catches domain requests on the first pass, so in this example the third rule mainly applies to requests that arrive as addresses. Do not expect it to classify every unfamiliar domain by address first. If you need to resolve names before matching addresses, evaluate IPOnDemand according to the active core's behavior, or remove the broad rule that matches too early and specify the default outbound explicitly. After making changes, check both DNS overhead and actual match counts.
Trace DNS along the path that actually resolves the name
First determine who resolves the destination name: the app, the system resolver, core DNS, or the remote outbound. Enabling encrypted DNS in a browser does not change system resolution, and configuring DNS in the core does not guarantee every request arrives with a domain name. If changing DNS affects only some apps, check whether they resolve names before passing requests to the core, then compare a domain request with an address request through the same entry point. Do not treat opening a certificate-protected site by IP address as an equivalent test; TLS identity and site selection may differ. If needed, test with a domain you control. Do not send sensitive internal domain names to a resolver that is not responsible for them.
After updating resources, verify that the expected groups exist and whether their members changed; do not rely on file dates alone. The same group name can cover different ranges in databases from different sources. Record at least three non-sensitive examples: a destination expected to go direct, one expected to use the proxy, and one expected to be blocked. After changing rules, make a fresh request for each and compare the destination and outbound in the available logs. If there is no clear match information, add a specific test rule in an isolated environment to verify the order. For rule database updates and match syntax, see GeoIP and GeoSite rule databases.
07 System Integration
TUN Mode: Enable It Only When the System Proxy Is Not Enough
Work out whether you are missing an entry point or proxy capability
TUN uses a virtual network interface to receive traffic routed to it by the operating system. It is useful for apps that a regular system proxy cannot cover. TUN changes how traffic enters; after that, it still depends on forwarding, DNS, and outbound policies. If a browser already fails through an explicit proxy, fix the local listener, node, or outbound first; TUN will not revive a broken node. If the browser works through the system proxy but a target app ignores proxy settings entirely, then test whether TUN can cover that app using your existing baseline.
On desktop, use the TUN support available in the current v2rayN version and interface for your platform. Before enabling it, select a working node and note the current system proxy value, network, and whether local services are reachable. To avoid mixing two entry points, disable any explicit proxy configured in apps for the initial test and undo the system proxy setting made by the client in the previous step. Do not change network settings managed by an organization without authorization. Then enable TUN and grant the permissions needed to create an interface or change routes. If the system denies permission, check the logs for the specific operation that failed; do not assume that broadly elevating your regular account is the solution.
Test public requests, private network destinations, and DNS separately
Start with a regular web request, then test an app that needs TUN, and finally try an accessible local network resource, such as a device you manage. If public sites work but the local network does not, do not immediately add a broad bypass. First check the destination address range, system route priority, and whether the client has a matching direct rule. A private-network direct rule in the core and keeping private traffic out of the virtual interface at the system level are different approaches: the first lets the core see the traffic, while the second bypasses the entry point entirely. If you access a private service by name, also check whether DNS requests still reach the correct local resolver.
If all requests stop as soon as you enable TUN, disable it and retest the original baseline first. If that restores service, check the virtual interface, default route, whether the remote node is being incorrectly routed back through the virtual interface, and whether resolving the node's domain depends on a proxy that is not yet available. If some pages load but an app hangs at login or while loading media, test regular web access, the app's connection, and its DNS or UDP dependencies separately. End-to-end UDP support also depends on the forwarding implementation, remote service, and outbound protocol settings; creating a virtual interface alone does not prove that UDP works.
On Android, check system permission and app coverage first
When you start a connection in v2rayNG or v2flyNG, Android asks for permission to establish a system network tunnel. If it fails, check whether permission was granted, whether the system already has a similar persistent service, and whether connections in other apps were stopped first. If just one app does not work, check whether per-app proxying is enabled and whether the current list includes or excludes that app. If the app was already running in the background, start a new connection after changing the rules before testing; do not use an old connection to judge new rules. You can test once on mobile data and once on Wi-Fi, but keep the node and test destination the same to distinguish a system interception issue from a network-specific reachability issue.
Have a clear way to exit TUN: disable it, check that the virtual interface is removed, then retest the same app on the original network. If a regular proxy works but TUN does not, you do not need to rebuild the subscription.
Consider starting TUN automatically only after it has proved stable. After switching between wired and wireless networks, moving from Wi-Fi to mobile data, or waking from sleep, use the same test destination to distinguish a brief reconnect from a persistent failure. If the failure persists, save the network type, client logs, and whether per-app routing was enabled, then exit and restore the connection. If the problem occurs only with traffic interception enabled, you can keep a working path with an explicit proxy; there is no need to also change existing routing, nodes, or subscriptions.
08 Maintenance
Routine Maintenance: Layered Troubleshooting and Safe Rollback
Make updates independently reversible
The client, core, rule database, and subscription nodes are four different things that can change. A client update may change the interface or how configuration is generated; a core update may affect field compatibility; a rule database update may change classifications; a subscription refresh may replace remote parameters. Do not update all four during one maintenance window and then test connectivity. Record which layer changed, the active node, and the local listening port. After each change, check the entry point, outbound, and destination. If one fails, undo only the reversible change you just made, then retest the same destination.
When backing up, prefer the export or backup method provided by the client. If you have to back up the data directory, confirm its location and exit normally first so the configuration is not rewritten partway through. Backups, like subscriptions, may contain credentials and should not be uploaded publicly. Before restoring, save a record of the current state as well. A new version may not be able to read an old directory completely after the configuration format changes. Import the nodes needed for basic access first, then restore custom routing, local ports, and per-app lists. Check system entry points afterward, since system proxy settings and network permissions may not be included in the client backup.
Choose the next step based on where the failure occurs
- Core did not start. Read the earliest startup error first. Check dependencies, file paths, port conflicts, and configuration parsing. Do not focus first on the generic final failure message. If the port cannot start, check which process is using it; if the configuration has a syntax error, undo the section you edited most recently.
- The core started, but no matching request appears. Test with an explicit proxy request. If that succeeds but the usual app has no record, check the system proxy, the app's own proxy settings, or the per-app list. If the current log level does not show access records, do not assume “no log” means the request never reached the core.
- A request arrived, but the remote handshake failed. Check the active node, system time, server name, and transport options. See whether another known-good node behaves the same way on the same network. If one node fails, focus on that node; if several fail at once, check the shared network and DNS.
- The handshake succeeded, but some destinations fail. Check routing order, name resolution, and the destination's response. If you see a refusal or another application-level error from the destination, the connection reached an endpoint able to respond. Check the outbound record too, to confirm that the response came from the expected service.
When recording an error, include the time, network type, steps taken, error category, and outbound tag. Before sharing a screenshot, hide subscription URLs, account identifiers, private domains, and connection parameters; do not publish the full configuration. After reproducing the issue, restore the original log level to avoid continuously recording destinations. For intermittent timeouts, first distinguish a slow initial connection from slow repeated requests or an old connection that failed to recover after a network switch. Use one test tool and one destination for the first comparison; do not compare latency scores from different clients directly.
Restore the system entry point before client settings
To restore ordinary network access, first stop TUN or disconnect on mobile, then check any system proxy changed by the client, and finally restore proxy addresses entered manually in apps. Closing a desktop window does not necessarily exit the app, and exiting the process does not prove that operating system settings were cleared. If the device had an existing proxy configuration, restore its original value rather than always setting it to a direct connection. Once ordinary network access is restored, re-enable the client using the original baseline. If the issue involves account permissions, node settings, or the installation environment, use the relevant category in Frequently Asked Questions instead of clearing every setting again.
After the network is restored, document the changes made before the failure, the rollback point, and the test results together. For example, write “the same destination went direct again after restoring the old rules,” not just “it works now.” If you have isolated the issue only to a shared component, note what remains unconfirmed so the next person does not mistake a hypothesis for a proven cause. A record that can reproduce the issue, roll back one change, and verify the result is more useful than a one-time recovery.
09 Advanced
Advanced Workflow: Rule Testing, Cross-Platform Checks, and Migration
Start with a minimal rule test
Advanced configuration is not about piling on rules; start by being able to explain why each rule exists. Choose a destination you manage or are authorized to test, and create experimental rules separately from your everyday setup. Keep the node, network, and entry point fixed. Add one exact-match rule and one known default outbound, then test one matching and one non-matching request. Gradually expand the conditions to domain suffixes, address ranges, and rule database groups. If behavior changes after an expansion, compare it with the previous exact-match rule to determine whether the scope widened, the priority changed, or the address form passed to the core changed.
For every test case, record the request form, expected outbound, actual outbound, and response. Verify rule matching and service success separately: a direct match can still be refused by the destination, and a proxy match can still fail during the remote handshake. To test a block rule, use a destination you know was reachable beforehand so the comparison is meaningful. During testing, do not let browser cache or existing long-lived connections stand in for new requests. After editing the configuration, confirm the core has applied the changes, then make a request that opens a new connection. If you cannot see a specific match, temporarily narrow the rule set rather than inferring routing from load speed.
Account for platform differences in cross-platform tests
Being able to import the same subscription on desktop and Android does not mean both use the same effective configuration. First, make a request from desktop through an explicit local entry point. On mobile, use an app you know is included in the per-app list to access the same destination, and confirm both platforms use the same node. Record each platform's routing capabilities, whether it uses a system virtual interface, where DNS is resolved, and which destinations are expected to go direct. If one platform supports only preset rules while another allows custom rules, migrate the intended behavior instead of copying every field exactly. For background on the relevant fields, see protocol, core, and routing terminology.
During migration, restore the subscription, active node, local entry point, and custom routing in that order, then restore automation. Do not copy a desktop loopback port into mobile app settings or assume one platform's default is the other platform's global mode. For each task, specify what failure is acceptable; for example, only a particular site should use the proxy while local network resources remain direct. When testing across platforms, include a destination that matches no rule, one explicitly expected to go direct, and one ordinary proxy destination. “Both can open it” is not enough to prove the migration is complete unless the expected outbound is documented.
Keep regression test cases and limit custom configuration
Keep examples for five common scenarios: a regular proxy request, a destination that should go direct, a destination that should be blocked, a subscription update, and ordinary network access after exit. For each change, note which scenarios could be affected and run them before using the new configuration. If your work environment has special DNS requirements, record Wi-Fi, mobile, and organizational networks separately; do not treat a result that works in only one environment as a default policy. For troubleshooting, prefer read-only checks, gather enough evidence with the lowest practical log level, then restore the original configuration.
A configuration that is maintainable over time should make clear where traffic enters, which outbound a rule selects, who handles DNS, and how to return to the last working state.
Consider custom configuration only when the GUI cannot express a clear requirement and the client and core explicitly support it. The client may regenerate temporary runtime files, so direct edits to those files can be overwritten on the next launch. Store maintainable configuration in a supported location, and keep a baseline that starts without custom settings. If a new rule has no business need, test case, or rollback plan, leave it out of your everyday configuration. Installation, subscriptions, system entry points, routing, and traffic interception are all independently testable layers. When a new issue appears, return to the relevant section instead of repeating the entire installation process.