Reference Field-by-field guides to inbounds, routing, and outbounds

Download v2rayNand V2Ray Configuration Reference

Client downloads for four platforms, with real configuration fields explaining subscription imports, proxy modes, and routing rules.

Open source Xray / V2Fly cores JSON configuration reference

V2Ray client downloads

Check your operating system and processor architecture before choosing a client and installer.

Windows v2rayN · Desktop / WPF

For desktop use, start with v2rayN. Desktop offers a cross-platform interface, while WPF keeps the classic desktop workflow. Both organize tasks around server lists, subscription groups, and routing settings. Choose the interface that suits you, then check the installation requirements.

After launching for the first time, import an existing subscription or share link, then select an active server. Before enabling the system proxy, check the local listening port. Restore the previous proxy settings when you exit to avoid sending apps to a local service that is no longer running.

Get the download
macOS v2rayN · Apple Silicon / Intel

Use the v2rayN desktop interface to manage your configuration. Check About This Mac for the processor: Apple Silicon uses arm64, while Intel uses x64. The same installer format can come in different architectures, so identify your processor before downloading.

After importing a configuration, test the regular system proxy first. Check the TUN requirements only if you need to cover apps that ignore system proxy settings. System permissions, network services, and the client core are separate areas to check; avoid changing them all at once.

Get the download
Android v2rayNG / v2flyNG

Start with v2rayNG, which uses the Xray core. If you need compatibility with V2Fly configurations, consider v2flyNG. Most recent phones use arm64. If you’re unsure of your device’s architecture, check its specifications or choose the larger universal installer.

On the first connection, approve the system VPN request. Another app using the VPN interface at the same time may interfere. If a background connection drops, check battery management and background activity permissions before assuming the server is at fault.

Get the download
Linux v2rayN · deb / rpm

Use the v2rayN graphical interface to manage servers and subscriptions. Debian- and Ubuntu-based distributions generally use deb packages; distributions with RPM package management use rpm. Check whether your system is x64 or arm64 as well—the package format does not determine the architecture.

System proxy support varies between desktop environments. If your browser works but another app cannot connect, check whether that app reads the desktop proxy settings. TUN also involves permissions, routing, and DNS, so a successful installation alone does not confirm that traffic is being captured.

Get the download

V2Ray configuration structure

Follow traffic from the local listener to the remote outbound, and learn what each field does along the way.

inbounds: where application traffic enters

Inbounds define how the core receives traffic. A common local setup listens for SOCKS connections and binds to the loopback interface. Apps must use this proxy address and port for their traffic to reach the routing stage. If the port is already in use, check for another client or a duplicate process before changing the remote server. Looking at inbound fields also helps distinguish between an app that never sent traffic to the proxy and a proxy that received traffic but failed to connect outbound.

{
  "inbounds": [{
    "tag": "socks-in",
    "listen": "127.0.0.1",
    "port": 10808,
    "protocol": "socks",
    "settings": { "udp": true }
  }]
}

Start with inbounds: identify where apps send their connections, then see how routing chooses an outbound, and finally check the remote protocol and DNS behavior. Subscription management, speed tests, and system proxy controls in the client interface are management or system integration features; they do not necessarily correspond to fields with the same names in the core configuration. Distinguishing these layers helps you decide whether to change an interface setting, runtime configuration, or operating system setting.

The Project V, V2Fly, and Xray core ecosystem

The client provides the interface; the core handles protocols, routing, and DNS. They update separately and can affect compatibility in different ways.

Project V: the foundations of modular proxy configuration

Project V is a useful starting point for understanding the V2Ray ecosystem. Instead of putting every function into a single server address, its configuration separates connection intake, rule matching, outbound connections, and DNS handling. A single running instance can define multiple inbounds and outbounds and link them by tags. A graphical client hides most of these details in everyday use; when troubleshooting, those boundaries provide a clear order for checking each stage.

“V2Ray client” is a category, not a guarantee that every app uses the same core or configuration format. When a client imports a share link, it first identifies the protocol and its extra parameters, then converts them into a runtime configuration. If importing fails, check whether the link format is supported. If the import succeeds but the core won’t start, check whether that core recognizes the generated fields. This gets closer to the source of the problem than repeatedly switching proxy modes.

V2Fly and Xray: shared roots, different paths

V2Fly continues the community-maintained V2Ray line, while Xray grew from related code into its own implementation and extensions. They share many core concepts, such as inbounds, outbounds, and routing tags, but support for protocol extensions, transport options, DNS behavior, and configuration fields does not always evolve in sync. A configuration that works with one core may not behave the same way when copied directly into another.

For example, when using REALITY or XTLS Vision parameters, check that the current core supports them and that the combination matches the server’s requirements. Choose a core based on the features your configuration needs and how it is integrated with the client, not just its product name. Before troubleshooting, note the client, the core actually in use, and where its settings are configured. This avoids using documentation for one implementation to explain errors from another.

Three clients: platforms and cores

v2rayN, v2rayNG, and v2flyNG are all open-source graphical clients. Use v2rayN on desktop to manage servers, subscriptions, and routing. For Android, start with v2rayNG, which uses the Xray core; v2flyNG is an option when you need the V2Fly core. Choose first by operating system, then by protocol support and configuration compatibility—not by ranking all three against the same performance criteria.

v2rayN interface settings can also affect which components run. After choosing a server, check that its protocol is supported by the core the client actually uses. On mobile, also account for the system VPN interface, per-app routing, and background restrictions. Copying a desktop SOCKS port into a phone app does not replace the mobile operating system’s traffic-capture process; the same server settings must work with each platform’s network entry point.

The client selection guide compares these three apps by platform, configuration approach, and intended use. If your current setup works, there’s no need to change the client, core, and routing setup all at once just to get a consistent interface. Change one thing at a time and keep the original settings so you can identify what caused any difference.

Open-source licenses: review clients and cores separately

Open source means a project publishes its source code and terms of use under a license, but clients, cores, and bundled components may have different licenses. The V2Fly core uses the MIT License, while the Xray core uses MPL-2.0. Check the license texts included with each client release as well. Personal use, modifying source code, and redistribution are different cases; the label “open source” alone does not define all your rights and obligations.

For ordinary installation and use, check the software name, platform, and component information. If you plan to redistribute or modify software for an engineering project, read each applicable license and retain any required notices. Open-source status also does not replace configuration review: routing determines where traffic goes, subscriptions determine which servers are updated, and the configuration determines which addresses can access a local listening port. Verify these settings in the actual runtime environment.

Updates: manage the app, core, subscriptions, and rules separately

Client updates change the interface and configuration-generation logic; core updates affect protocol implementations; subscription updates refresh server entries; and rule-resource updates affect domain or address classification. Each solves a different problem. If a new protocol field is unrecognized, check core support. If a subscription server address has changed, update that group. If a rule file is missing, check resource settings and runtime logs instead of simply reinstalling the client.

Before making changes, keep a copy of your existing configuration and custom rules. After updating, check that the active server starts, verify that the system proxy or TUN captures traffic as expected, and then test common apps and local network access. If you change the core, clear subscriptions, and rewrite DNS at the same time, even a restored connection won’t tell you which change fixed it. A clear sequence is easier to maintain than repeatedly toggling unrelated settings.

Connection checks: distinguish speed tests, handshakes, and real requests

A test result in the server list reflects only one set of test conditions. A successful connection to a port does not prove the protocol handshake will succeed; a successful handshake does not prove that DNS and routing to the destination are correct. Before using V2Ray server speed tests, check the test target and method, then verify with a real request. Don’t treat a single test result as proof that every app can connect.

Verify in a consistent order: check that the client starts the core, send a request from an app explicitly configured to use the proxy, check the system proxy, and test TUN last. Keep the relevant logs at each step. For a timeout, identify where the request stopped; for a handshake error, check identity, security, and transport fields. Local ports, outbound tags, and destination domains in the logs are usually more useful for troubleshooting than a generic “connection failed” message.

Proxy modes: traffic coverage and routing strategy are different

The system proxy setting controls whether apps that honor it send connections to the local proxy; routing determines which outbound handles traffic that reaches the core. “Global” in the interface usually refers to a routing choice and does not necessarily cover every process. If an app ignores the system proxy, its connections may never reach the core, even when global routing is selected. To cover more traffic, evaluate TUN instead of repeatedly changing routing rules.

For “the browser works, but other apps fail,” check how traffic enters the proxy first. For domains taking the wrong route, check rule order and DNS. On desktop, start with the system proxy and global proxy guide; on mobile, use the v2rayNG guide to check system permissions and app coverage. Find answers to common issues in the FAQ. The configuration reference explains fields, defaults, and how they relate, section by section.

Guides to protocols, configuration, and everyday use

Explore topics by what you need to do next: identity fields, client setup, or choosing a protocol.