Complete Guide · From Installation to Maintenance

Complete V2Ray Configuration Guide

For your first connection, follow the Quick Start Guide to import a profile and verify it works. Return to this guide to understand how each setting handles traffic or add routing rules to an existing setup. If you're new, follow the chapters in order; when troubleshooting, jump to the stage where the problem occurs.

Traffic entryHow an app's requests reach the client
RulesHow the core selects an outbound route
VerificationCheck the result with the same request
01 Trace the Traffic Path

Core Concepts: Client, Core, and Node

The GUI handles settings; the core handles connections

v2rayN, v2rayNG, and v2flyNG are graphical clients. When you import a list, select a node, or switch proxy modes, you're using the GUI. The proxy core called by the client is what listens on local ports, matches routing rules, and establishes connections. Project V provides the background for this family of tools; V2Fly continues V2Ray development, while Xray is a core project that evolved from the same codebase. Shared configuration syntax does not mean both cores support exactly the same features. Whether a node works after switching cores depends on whether the required protocol, transport, and security layer are supported.

An open window only confirms that the GUI has launched. After selecting a node, check the core logs to see whether initialization completed and it began listening; on Android, check whether the system VPN status appears after startup. If the log reports an error while binding a port, the connection has not reached the remote server, so checking the server address won't help. Conversely, if the log shows an inbound request followed by a failed remote handshake, reinstalling the GUI usually won't fix incorrect node settings or a network path problem.

Three questions connect entry, rules, and exit

First, how does an app's request get in? Desktop apps may use the system proxy, or only their own proxy settings; TUN routes selected connections into the client at the system routing layer. Second, how is an outbound route chosen? The core checks the destination address, port, or network type against its rules and selects the first match. Third, what happens next? A direct outbound connects to the destination, a proxy outbound connects to a node first, and a block outbound drops or rejects the request as configured. These are three distinct steps—entry, decision, and outbound—and shouldn't be reduced to a single “connection successful” status.

For example, a browser might load a page while a chat app sends a message. If the browser follows the system proxy, the core may log the page request. If the chat app ignores the system proxy, its connection may never reach the core. Switching the client to global routing won't make that app start using the proxy. Likewise, one browser page may request several different domains; the page loading doesn't mean its images and API calls all used the same outbound route. Troubleshoot a specific request rather than noting only which window opens.

What nodes, subscriptions, and protocols each contain

A node stores a set of connection parameters, commonly including a remote address, port, identity credentials, transport, and security layer. Its name is just for identification: a region or protocol abbreviation in the name is no substitute for checking the actual fields. A subscription is an address used to retrieve a group of nodes. Updating it fetches the list again; it doesn't automatically route traffic from every app. Even if the subscription address is reachable and the list parses correctly, the selected node may still fail to connect because of authentication or network issues. Keep these three outcomes separate when troubleshooting.

VMess and VLESS both use user identity parameters, but they differ in their requirements for security layers and transports. VLESS does not provide encryption on its own and is often paired with compatible TLS or REALITY settings. Here, REALITY is a security-layer option, not a node type that can be used without an outbound protocol. Trojan uses its own authentication fields; don't copy parameters from another node type. If a handshake fails, first compare the settings with those provided by your provider rather than changing the protocol or disabling certificate verification based on the node name alone. See VMess vs. VLESS: The Basics for more.

02 Choose by Device

Choosing a Client: v2rayN for Desktop

Check the operating system first, then the processor architecture

For desktop devices, start with v2rayN; for Android, start with v2rayNG. v2flyNG is another Android client, suited to users who specifically need the V2Fly core and have node configurations compatible with it. A node labeled V2Ray doesn't mean you must install a particular client. First check which software your device can run, then confirm its core supports the required protocol and transport, and only then compare interface and management preferences. This reduces installation trial and error and helps avoid mistaking a connection issue for a platform issue.

PlatformClientHow to choose a package
Windowsv2rayNThe download page offers an x64 desktop edition and a classic WPF edition.
macOSv2rayNChoose arm64 for Apple Silicon or x64 for Intel.
Androidv2rayNG; v2flyNG as an alternativeChoose the matching package if arm64 is supported; otherwise, select the universal build based on your device and OS.
Linuxv2rayNCheck both the distribution's package format and the device architecture.

On Windows, go to Settings → System → About to check the system type, then compare it with the package architecture on the download page. The v2rayN desktop edition uses a cross-platform interface, while the classic WPF edition retains the traditional Windows interface; if you're used to the older menus, WPF may be a better fit. Menu locations and some settings differ, but that doesn't mean the same node will be faster in one edition. On macOS, open About This Mac from the Apple menu and check whether it lists Apple silicon or an Intel processor, then choose one of the two disk image downloads.

On Linux, the distribution and machine architecture are separate requirements. Distributions using the deb package system generally need the deb package; those using rpm generally need rpm. Then check your system information: x86_64 corresponds to x64 on the download page, and aarch64 to arm64. Both must match before you install. A package with the right format but wrong architecture will usually be rejected during installation. If the architecture matches but a dependency is missing from your software sources, resolve it through the distribution's package manager; switching nodes won't help.

On Android, compare the cores—not just the appearance

v2rayNG uses the Xray core and is a good starting point on Android. v2flyNG uses the V2Fly core and suits users with specific compatibility requirements. Both download pages offer arm64 and universal packages. Most recent devices can use arm64, but a capable processor doesn't guarantee that the OS provides the corresponding app runtime. If you can't confirm the system details, check the device documentation or choose the universal package. The universal package supports a wider range of architectures; it doesn't support more node protocols or remove OS version requirements.

To compare the two clients, don't run their VPN services at the same time. Choose a node you can retest in the first client, record the network and point of failure, then disconnect and test the same destination on the same network with the second client. If one client imports a share link but the other imports it and then fails the handshake, the most useful details are the core and security-layer settings each uses—not two speed readings taken under different conditions. Check the Client Comparison page to find the right use case before deployment.

Make client selection a repeatable decision

For each device, record the OS, architecture, client, and core in use. When several devices use the same subscription, their menus and rules don't have to match exactly. Just confirm that each can import the list, select a compatible node, and verify its traffic path. When setting up another device, use that client's import function instead of copying a desktop program folder to a phone. If the subscription contains different node types, start with one you know is compatible, then check the others one by one. Don't judge a client's suitability by how the whole list behaves.

03 Establish a Startup Baseline

Installation and First Launch

Install the desktop client before changing network settings

Choose a platform and package from the Download Center. On Windows, if you downloaded an archive, extract it fully to a directory your user account can write to; don't run it from the archive preview. If you downloaded an installer, complete the setup and open v2rayN from the Start menu or installation location. Don't copy new files over a running old installation. An older tray process may still occupy the listening port or be changing the system proxy. Running two copies at once can combine installation issues with process conflicts.

On macOS, open the disk image, follow its instructions to move the app to Applications, then launch it from there rather than running it from the disk image. If the system displays a restriction, read the message carefully and distinguish an architecture mismatch from an administrator policy or app-opening permission; check with your administrator on managed devices. On Linux, open the package using the system software installer or package manager. If dependencies are missing, note the package name and software source status, resolve the dependencies, and try again. If no window appears after installation, check the system app menu and any launch messages first.

After launching the desktop client, confirm the window displays correctly and settings can be saved. Leave both system proxy and TUN disabled for now. On a device migrated from an older setup, check whether the system proxy still points to a local port whose client has exited. If the client reports a port conflict, close the old client or stop the service you've confirmed is conflicting. If you need to change the local port, update any proxy addresses manually configured in apps as well. Widening the listening address at random won't resolve a port conflict and may expose the port to other devices on your LAN.

On Android, distinguish install permission from connection permission

When installing on Android, the system may ask you to authorize the source of the package being opened. For example, if you opened it from a file manager, the permission applies to that file manager, not the client. Complete the installation in the system dialog, then return to settings and disable that source permission if desired. If installation is blocked, first determine whether the cause is an architecture mismatch, a device policy, or a conflict updating an app with the same name. Before removing an old app, make sure you have a configuration you can import again. Uninstalling shouldn't be the first step: node groups and custom rules may be deleted with the app's data.

When you first connect, the system's VPN prompt grants permission to establish a connection; this is separate from the installation source permission. It's best to import and select a node before granting it, so you can tie the startup result to a specific node. If another VPN is already on the device, check which app has control of the system VPN slot, disconnect it if appropriate, then switch. If always-on VPN or an organization policy is in effect, don't keep tapping Connect and hoping for the best. Check system settings and confirm the client is allowed to start under the current policy.

What to record during the first launch

Record installation, GUI launch, and core startup as separate steps. Without an imported node, the client may not need to start the core used for remote connections; at this stage, just confirm the interface and settings work. After importing, check the core logs and note the first error related to configuration parsing, local listening, or remote connection. Error order is usually more important than the number of errors: if configuration parsing fails, the subsequent exit message is a consequence, not a separate problem to solve.

If you're reinstalling on an existing device, restore one known node first rather than all your routes, DNS settings, and app lists. Then test separately that the window opens, the node can be selected, and the original network still works when the proxy is off. If a step fails, stop there and troubleshoot it. On managed desktop devices in particular, don't raise system-wide permissions just to test one connection. Only check the client prompts and device policy if you know that writing system routes or starting a service is necessary.

04 Get and Select Nodes

Subscriptions and Node Import

Know the difference between a subscription URL and a single-node share link

Subscription URLs usually start with https://. When you update a subscription, the client fetches and parses the server's response. What you copied is a URL, not a downloaded node list. Prefixes such as vmess:// and vless:// usually indicate single-node share links, which you import from the clipboard or with a QR scanner. Base64 is a common encoding format, not a node protocol or encryption. Some subscriptions return a batch of encoded share links; individual node links may also encode parameters. To choose where to paste a link, check its intended use with the provider, then look at its prefix.

When copying a URL from a chat or email, make sure it doesn't include quotation marks, full-width punctuation, or line breaks. Don't drop query parameters: different parameters on the same path may return different subscription content. Subscription URLs may contain access credentials, so treat the full link as private even if you don't recognize the parameter names. Don't submit it to an untrusted conversion site or include it in public logs, screenshots, or bug reports. If you need help identifying the format, share only the link type, error category, and details with sensitive fields redacted.

Where to find the import option on desktop and Android

In v2rayN, open Subscription Groups in the main window, go to group settings, and add an entry. Give the group a recognizable name, enter the subscription URL, and save. Back in the main window, use the subscription menu to update the group. If the menu offers both direct and proxied updates, start by updating over your currently available network. When it finishes, switch to the new group and confirm it contains entries, then select a node as the active configuration. Adding a group and updating it are separate steps; adding it alone won't fetch the list.

In v2rayNG, open the main menu, go to Subscription Group Settings, use the add button to enter a group name and subscription URL, and save. Return to the main screen and select Update Subscription. Switch to the group, select a node, then tap the connection button. In v2flyNG, enter subscription URLs in group settings, not in the address or port fields for a single node. To import a single node, use the add menu's clipboard or QR code option. Menu labels vary by version and language. If you can't find the exact label, use the Subscription Import Options for v2rayN and v2rayNG guide to locate the relevant menu.

If the list is empty, troubleshoot in three stages

Stage one: the fetch failed. If the log shows a timeout, name resolution failure, or access denied, check that the full URL was copied, the subscription is still authorized, and the current network can reach it. If you already have a working proxy, compare the results of updating through it. If you haven't established a working connection yet, don't rely on a node that isn't working to fetch the subscription. Stage two: a response arrived, but no nodes were parsed. The URL may have returned a sign-in page, an error message, or a format the client doesn't recognize. A URL opening successfully doesn't mean its response is a node list; ask the provider to confirm the subscription format if needed.

Stage three: parsing succeeded, but the current view is empty. Clear the search, check which group you're viewing, and confirm whether you updated that group or another one with the same name. If the active node disappeared after the update, select a node that remains in the list rather than assuming its parameters are unchanged based on its name. You can keep manually configured nodes in a separate group so subscription updates don't affect them. Once entries appear, troubleshooting subscription retrieval is complete. Test node connectivity separately in the next step.

05 Identify the Traffic Entry

Proxy Modes: Coverage and Verification

Start with a small system proxy test on desktop

In v2rayN, select an active node and enable the system proxy from the tray menu. If there's no tray icon on your desktop, find the corresponding control in the main window. Setting the system proxy points the system's proxy address to the client's local listener. Browsers and other apps that follow the system proxy will generally use it; apps with their own proxy settings, apps that bypass system network settings, or apps using a different networking method may not. First send a request from a browser known to use the system proxy, then configure individual apps as needed. There's no need to route the whole machine's traffic from the start.

When configuring an app manually, check the client settings or logs to find out whether the local listener is HTTP, SOCKS, or a mixed port, and enter the type the app supports. The address is usually the local loopback address; use the actual listening port rather than copying a number from a screenshot. Entering a SOCKS proxy in a field that accepts only HTTP will fail locally, even if the remote node works. If the app offers an option such as “resolve hostnames through the proxy,” note whether it's enabled. Sending a connection through the proxy doesn't necessarily mean DNS resolution goes through it too.

Before exiting, clear only the system proxy settings you changed—not network policies originally configured by another program or an administrator. Note the previous settings before changing them; after restoring them, reopen the same app to check whether it uses its original route. If a browser still reports that it can't connect to a proxy after v2rayN closes, check for a leftover system entry pointing to a local port, and see whether the browser has its own proxy settings. Changing just one may not affect the settings the app actually uses.

Don't confuse “system proxy” with “global routing”

The system proxy determines which apps send requests to the local listener. Routing modes such as global, rules, or direct determine which outbound handles requests that have already reached the core. The two settings are independent and can be changed separately. For example, with the system proxy on and a rule sending a site to direct, the request still passes through the core, but not through a remote node. Conversely, setting the client to global proxy won't make an app that ignores the system proxy start using the local listener. When recording settings, note the entry method and routing policy separately; that's clearer than simply writing “global is on.”

On Android, regular connections in v2rayNG and v2flyNG use the system VPN to receive traffic. Select a node on the main screen, tap Connect, and approve the system prompt if needed. Whether an app participates depends on the client's app list and list mode. Allow and exclude lists work in opposite ways: an allowlist routes only selected apps, while an exclude list keeps selected apps on their normal route. If the browser works but another app doesn't respond, checking the list and connection state after reconnecting is more useful than changing protocols right away.

Compare three outcomes with one request

Choose a test destination you're authorized to access and that responds reliably. Before enabling traffic capture, open it once and note whether it was already reachable. Then enable the system proxy or Android connection and send a new request to the same destination. Don't rely on an old page that's still open in the browser; cached content and existing connections can skew the result. Check whether the new log shows the destination and the expected outbound. If there's no inbound record, check the app settings and listener. If there is one but the outbound is wrong, check routing. If the outbound is correct but the request times out or the handshake fails, investigate the remote connection.

Change only one setting per test. When comparing proxy modes, keep the node, destination, and network the same. When comparing nodes, keep the proxy mode and destination the same. Record the before-and-after results, then decide whether to keep the setting. This makes it easier to tell whether a later change in network affected traffic entry or node connectivity.

06 Write and Verify Rules

Routing: Rule Order and Outbound Tags

Set the match order before adding conditions

V2Ray-family cores generally check routing.rules from top to bottom. After the first usable match, the core selects its outbound and doesn't continue to later rules. Put exceptions for individual services before broader rules that would cover them. In the client interface, “direct,” “proxy,” and “block” are convenient labels; in the configuration, direct, proxy, and block are outbound tags that must point to existing outbound entries. In particular, don't assume unmatched traffic goes direct: in common configurations for these cores, the first outbound handles traffic that doesn't match a rule.

In v2rayN, open Routing Settings from the settings menu to manage rules. Copy or back up the current policy before adding a domain rule. If the interface lets you move rules, check that you're editing the active policy after changing their order. If an Android client offers custom routing or split tunneling, first check whether it expects a domain list, individual rule entries, or a full configuration block; these formats aren't interchangeable. Client-generated configuration may be rewritten after restart or a node switch. Make routine changes in rules saved by the GUI rather than only editing a temporary core file.

Example rule snippet: test matching with sample domains only

The following is a complete routing section for core configuration, suitable for custom configurations that support this syntax. It is not a complete node configuration. When merging it, keep your existing inbounds and node outbounds, and make sure outbounds contains a block outbound tagged block and a direct outbound tagged direct. In cores that support the syntax below, these are commonly implemented with blackhole and freedom, respectively. If the required outbounds aren't available, create equivalent rules in the GUI instead of pasting this directly.

{
  "routing": {
    "domainStrategy": "AsIs",
    "rules": [
      {
        "type": "field",
        "domain": ["full:blocked.example.com"],
        "outboundTag": "block"
      },
      {
        "type": "field",
        "domain": ["domain:example.com"],
        "outboundTag": "direct"
      }
    ]
  }
}

The first rule matches one exact hostname; the second covers the sample root domain and its subdomains. If the first rule is matched first, that subdomain is blocked, while the root domain and other matching subdomains go direct. Reversing the order lets the broader suffix rule override the exact exception. When testing the first rule, don't mistake the sample subdomain being unresolvable for a successful block. Check the match in the logs or repeat the test with a resolvable domain you manage. Nonmatching traffic still depends on the remaining rules and default outbound.

Find out whether the core receives a hostname or an IP address

AsIs does not resolve a domain just to make it match an IP-address rule. If an app resolves the name before sending the request through the proxy and passes only a numeric address to the core, ordinary domain rules may not match. With protocol sniffing enabled, the core may be able to recover a hostname from supported traffic, but not every encrypted connection reveals one. Don't treat sniffing as a way to fill in missing request details in every case. First test the rule syntax with an app that passes hostnames, then decide whether the real app needs address-based rules or a different resolution path.

Before adding IP ranges or geolocation datasets, determine when the core triggers DNS resolution and confirm that the dataset exists and includes the addresses you expect. A website may use separate domains for its main page and static assets, and its addresses may vary with the network. If the page loads but images fail, compare the destinations and matched rules for each request before adding a targeted rule. Don't route every address or an entire shared suffix through the same outbound just to fix one asset.

07 Expand Traffic Capture as Needed

TUN Mode: Virtual Interfaces, DNS, and Rollback

When is TUN worth enabling?

TUN uses a virtual network interface and system routes to capture traffic, so apps don't need to provide their own proxy settings. It's useful for apps that explicitly ignore the system proxy but still need a specific route. TUN doesn't automatically capture all traffic: the routes and client options determine which interfaces, address families, and destination networks are included. For a browser or a few apps that support proxies, the system proxy or in-app proxy is usually easier to verify. Confirm that the problem is how traffic enters the client; don't enable TUN to fix node authentication or subscription format issues.

In v2rayN, keep an active node that has already passed a system proxy test, then look for the TUN option in the main window or tray menu. Before allowing the client to create a virtual interface or modify routes, note the current proxy and network state. If the system asks for elevated permissions, follow the client prompt and local admin policy; don't bypass restrictions with another elevation method. When enabling TUN for the first test, disable the system proxy you enabled for that test to keep the browser from using the old port and masking the result. Test a destination that worked before, then test an app that ignores the system proxy.

Android clients already receive traffic through the system VPN during a regular connection; there's no need to look for a desktop-style switch with the same name. Check the system VPN status, app list, whether the app is allowed to participate, and whether always-on VPN or block-without-VPN is enabled. If another app is also using the system VPN, check whether it has replaced the connection. After changing the app list, reconnect as prompted and test with the actual app. A checked box alone doesn't prove the current connection has applied the change.

Troubleshoot DNS and routing conflicts separately

If a destination remains reachable by IP address after enabling TUN but fails by domain name, check name resolution first: whether queries go to the system, client, or app's own resolver; what type of address is returned; and which outbound route it takes. A browser using its own resolver may get different results from system tools. If the domain resolves but the connection still times out, check whether the returned address is IPv4 or IPv6, whether it enters the virtual interface, and whether the outbound can reach it. Don't change system DNS, client DNS, and app-level resolution all at once or you'll lose your baseline.

If a printer or local service that used to work becomes unreachable, check whether TUN is capturing LAN destinations and whether there's a “bypass LAN” or equivalent exclusion. If you also use a corporate VPN, another virtual adapter, or a container network, check for overlapping subnets. The proxy node's own connection must use a working underlying network; it must not loop back through the interface it created. If enabling TUN causes repeated attempts to connect to the remote server, turn TUN off and check whether the same node works over the underlying network, then review existing routes.

Verify each part, starting with a basic connection

After enabling TUN for the first time, verify the entry path with a regular web request, then test LAN access and any apps that specifically need TUN. If only voice, video, or another feature that may use UDP fails, don't assume the whole route is fine just because a web page loads. Check whether that traffic can enter the interface, whether the outbound supports it, and whether the remote endpoint can handle it. If needed, run the same test with TUN on and off. If the problem starts only after switching networks, check the current default network, interface status, and client logs before rewriting routing rules.

To roll back, disconnect TUN or stop the Android connection first, then check in system network settings whether the original network has recovered. If the system proxy you saved still points to a closed listening port, restore its previous value. Check the status of any other VPNs on the device as well. Once restored, retry a regular request and note whether turning off TUN was enough or whether you also had to restore proxy or interface settings. That distinction will help you target the right setting next time.

08 Keep a Repeatable Baseline

Maintenance: Updates, Backups, and Layered Troubleshooting

Update subscriptions, clients, and cores separately

A subscription update changes the node list; a client update may change the interface or how configuration is generated; a core update may change supported fields or connection behavior. Don't combine all three while troubleshooting, or it will be hard to identify which layer changed—even if the problem is still reproducible. After updating a subscription, check the current group and active node. After updating the client, confirm it can still read the existing configuration. After updating the core, test your most-used protocol and outbound with an existing node. Make one change at a time, then repeat the same test.

Use the export function provided by the current client for backups. If you need to copy a desktop data directory, exit the program first and make sure you're copying the configuration location, not an installation folder you happened to find. Confirm the backup includes subscription groups, local nodes, custom routing, listening ports, and app lists. Device permissions and system proxy settings may not be part of the app backup, so record them separately. Don't put unreviewed configuration in a shared folder; it may contain node credentials and subscription URLs. Before restoring, check compatibility with the client, then test with a known node.

Narrow down the cause based on when the error occurs

First distinguish between “no apps can connect” and “one app can't connect.” If only one app is affected, check whether it actually reaches the client and whether it has its own proxy or resolver settings, or an Android app-list restriction. If all test apps fail, confirm the client process is running and that the local listener or system VPN is active. Next, check for an inbound entry in the logs. If there isn't one, revisit the proxy entry settings. If there is, check the matched outbound first, then whether the remote connection timed out or failed authentication or the handshake.

SymptomCheck firstNext step
Configuration won't startFirst parsing or bind errorRestore the last working configuration, then reapply changes one at a time.
App has no inbound log entryLocal listener, app proxy settings, VPN app listRetry with an app that you know uses the proxy.
Some sites or features failHostname and outbound tag for the failed requestCompare with a successful request to find differences in rules or resolution.
Both new and old nodes are slowCurrent network, destination, and traffic capture methodKeep one destination fixed and retest with the same app at different times.

When a remote handshake fails, first check the current node's required address, port, transport, security layer, and identity parameters. Some protocols and authentication methods depend on the device clock, so correct the time if the date is clearly wrong. Don't disable certificate verification to turn an error into an apparent success. If the issue is slow speed, distinguish a slow initial load from consistently slow transfers: the former may point to DNS or the handshake, while the latter calls for comparing network quality and the destination service. A single latency test doesn't represent real throughput. Use the Slow Speed Troubleshooting Checklist to compare each layer.

FAQ: Why does it still fail when the icon and node list look right?

Why isn't an app using the expected outbound even though the VPN icon is visible?

The icon means the system VPN is established, not that every app is included. First check the list mode and whether the app is in the right scope, then send a new request. If the core logs show an inbound entry for it, check the matched routing rule; the VPN toggle isn't the issue at that point.

Why can't I connect to a node that's still listed after updating the subscription?

A successful update only confirms that the list was retrieved and parsed. First check whether you've selected an active node again, then identify whether the failure occurs during name resolution, remote connection, or authentication. If only one node fails, compare it with another node of the same type on the same network rather than resetting the entire setup.

When troubleshooting is done, turn off temporary verbose logging and save only the short log excerpt that explains the issue. When reporting it, include the client, OS, traffic entry method, first error, and repeatable steps. Redact subscription URLs, node authentication fields, and any unnecessary destination addresses before sharing. This gives others enough information to check the traffic path without exposing unrelated connection details.

09 Scale Beyond One Device

Advanced Configuration: Rule Maintenance, LAN, and Deployment Boundaries

Turn personal rules into a maintainable policy first

Once a single device is stable, split policies for common scenarios as needed. For example, maintain separate work and personal policies, each with direct, proxy, or block routes based on specific needs. Keep a short note for each policy: the default outbound, its exceptions, why the rules are ordered as they are, and the destination used to test them. Test each rule change on its own before merging it into your everyday policy. If something breaks, remove the rule you just added rather than guessing among many overlapping matches.

Manage rules and nodes separately. Nodes from different sources may support different fields, but the same direct-routing exceptions usually don't need to be duplicated for every node. Likewise, don't try to fix a traffic entry problem in one app by changing global rules. To compare how different cores behave, use the same test destination and compatible node, and keep the conditions consistent. If a parameter works in only one core, record that dependency instead of putting it in a template shared by every device.

Keep a small regression checklist for complex configurations. Include at least one service that should go direct, one destination that should use the proxy, a block test you manage, and a LAN service. Check them in that order after a change, taking browser cache and app lists into account. If one test fails, check which entry path it used and which rule matched instead of switching the whole policy back to global. For longer rule lists, brief notes are more reliable than trying to remember the order. Remove obsolete rules so they don't shadow new matches later.

Limit which devices can access a shared local proxy

Consider v2rayN's “Allow LAN connections” only when devices on the same trusted LAN genuinely need to share the desktop client. This controls whether other devices can reach the local listener; it doesn't automatically give the whole LAN proxy access. The client device must support the proxy type, and you need to enter the desktop's LAN address and actual port. A loopback address points to the device using the proxy, not the desktop. Confirm that both devices can communicate over the network, then follow the v2rayN LAN Proxy Sharing Guide to test with one controlled device.

When sharing a proxy, consider the listening address, firewall scope, and authorized devices separately. Allow access to the port only from the devices and networks that need it. Don't forward the port to the public internet or leave the shared listener enabled on a guest or public network. Check whether the client requires authentication; a successful connection doesn't mean only the intended devices can connect. Turn off the shared listener after testing. If it will remain enabled, regularly check for desktop address changes and firewall rules to ensure access hasn't expanded.

Test rollback before deploying a gateway; don't change the whole network at once

When you move beyond a client on one device to a soft router or Linux mini PC, the challenge is no longer just a client setting. It becomes a question of who handles the gateway, name resolution, and traffic forwarding. Map the path for one test device first: what provides the default gateway, what answers DNS queries, and which route the proxy node's connection takes. Changing DNS alone won't route every connection through the proxy if the device's traffic entry path remains unchanged. Conversely, changing the gateway while overlooking name resolution or address families may leave some devices online while other services fail. Read the Soft Router Deployment Overview first to decide whether this topology fits your needs.

Start with one test device you own; don't immediately change network-wide automatic configuration. Record how to restore the original gateway and resolver, and confirm that LAN services and common requests work after rollback. Once the test is stable, expand to other devices and plan a separate route for those that need to keep using the original network path. If you only need one app to use a specific outbound, an in-app proxy or existing desktop setup is often easier to maintain. An advanced setup is a good fit only if you can explain every part of the path, limit the impact, and return to a previously verified configuration if something fails.

Download v2rayN