Whether you already have nodes, are choosing a client, or plan to switch cores, first check whether your nodes use REALITY or Vision, then verify the transport and security layer. This guide includes a field-by-field comparison, steps for migrating a single node, and ways to distinguish import, handshake, and routing failures.
How Project V, V2Fly, and Xray are related
Project V is the starting point for understanding these names, with V2Ray as its core software. The V2Fly community carries on V2Ray's development, while Xray-core is maintained independently after forking from V2Ray. The two share some configuration structures and protocol foundations, but later additions to transport, security, and flow control are not guaranteed to stay in sync. Seeing “V2Ray” in an interface does not tell you which core is actually running.
- The core parses configuration, establishes connections, and applies routing rules. When troubleshooting compatibility, note the name and full version of the core that's running.
- The client manages subscriptions, generates core configuration, and controls the system proxy or virtual network adapter. v2rayN is a desktop client. On Android, v2rayNG uses Xray, while v2flyNG uses V2Fly. Client and core version numbers are separate.
- A subscription provides a list of nodes. If the list downloads and the nodes appear, only the first two steps have succeeded. The client still needs to convert the fields correctly, and the core must support the connection method those fields specify.
VLESS, XTLS Vision, and REALITY compatibility
Don't judge whether a node can be migrated just by the scheme at the start of its share link, such as vmess:// or vless://. The protocol may be the same while the transport, security layer, or flow control differs. The table below covers common combinations; check the bundled core version and importer for actual support.
| Node combination | Xray | V2Fly | Key fields |
|---|---|---|---|
| VMess + WebSocket + TLS | Supported | Supported | UUID, WS path, Host, TLS server name |
| VLESS + WebSocket + TLS, without flow control | Supported | Check version and client import support | Protocol, transport, and security layer must each match |
| VLESS + TLS + Vision | Use a version that supports Vision | Don't migrate using an Xray Vision configuration | flow: xtls-rprx-vision |
| VLESS + REALITY + Vision | Use a version that supports this combination | Don't migrate using an Xray REALITY configuration | security: reality and flow |
protocol specifies the protocol, streamSettings.network selects the transport, and streamSettings.security selects the security layer. Vision is a flow-control option set by flow in the VLESS user configuration; it does not mean setting the security layer to xtls. REALITY is a security-layer configuration, not another name for Vision. You also can't simply rename xtls-rprx-direct in an old configuration to xtls-rprx-vision. First confirm the combination used by the server, then update the client.
Choosing a core: start with your nodes, then consider maintenance
Xray core
RecommendedIf your subscription explicitly includes REALITY or Vision nodes, choose an Xray version that supports those configurations. On Android, use v2rayNG. On desktop, verify that v2rayN actually runs Xray for the node; having a core file in the program directory isn't enough.
Best for: Nodes that require REALITY or Vision, or subscriptions that combine these nodes with standard VMess nodes.
V2Fly core
You can stick with V2Fly if your VMess, WebSocket, and TLS configurations are already verified and don't require Xray-specific fields. On Android, use v2flyNG and test your actual nodes with the installed version. A successful import alone doesn't prove compatibility.
Best for: Setups and troubleshooting workflows built around V2Fly, with no need to change node features.
If you only use nodes supported by both cores, protocol lists alone aren't enough for a meaningful comparison. To compare latency or throughput, test the same node on the same device and network, keeping the system proxy or TUN state, test URL, and routing rules consistent. Record the first request separately from subsequent ones. A single latency test can be affected by DNS resolution, handshakes, and caching, so it can't prove that one core is always faster.
Migrate configuration: verify one node before restoring split routing
Don't use an entire JSON configuration from an old core as the starting point for a new one. Even when inbounds, outbounds, and routing have the same names, field values, client-generated defaults, and rule assets can differ. Keep the original configuration and core version, then run an A/B test with one working node.
- Check the local proxy ports. In v2rayN, open Settings → Parameter Settings and verify the local listening configuration against the startup log. The ports above are examples, not fixed defaults for every version. If your version uses a mixed inbound, HTTP and SOCKS can share a listening port. Local ports are client-side entry points; don't enter them as the remote server port.
- Compare the node fields. Start with the address, remote port, and UUID, then check the transport, security layer, and flow control. For WebSocket, compare the path and Host separately. The TLS server name and WebSocket Host serve different purposes; don't substitute one for the other just because they look like the same domain. For REALITY, verify the server name, public key, and Short ID provided by the server, and make sure none of these fields were lost during import.
- Test startup and connectivity separately. First confirm that the core can load the configuration and listen on the local port. Then use an app through that entry point to access a test URL. If the log shows a configuration parsing error, fix the fields first. If listening fails, check for a port conflict. Troubleshoot the remote handshake only after the local entry point works.
- Restore DNS and routing last. Start with the fewest rules needed to verify proxy egress, then restore your rule sets. Check that
outboundTagmatches an existing outbound, and that the current core can loadgeoip.dat,geosite.dat, and the referenced categories. Once the rules load, test one destination expected to connect directly and another expected to use the proxy to confirm each is routed correctly.
Sharing a subscription between desktop and Android: verify each generated configuration
Test both platforms: same node, different local entry points
Desktop (v2rayN)
- Start with one node and check the startup log to confirm which core is running and which local port it listens on.
- Verify the node first with an app explicitly configured to use the proxy. Test the system proxy and TUN afterward, rather than changing both entry points at once.
Android (v2rayNG or v2flyNG)
- Choose a client based on the node's security layer and flow control. After importing it, open the node editor and check the key fields.
- Connect first and confirm system authorization, then check that per-app proxying includes the app you're testing.
You can use the same subscription on both platforms, but verify the client-generated configuration, system entry point, and per-app routing rules separately.
Common questions about switching cores
Why do my nodes stop working after switching cores if the subscription still updates?
Open the original node and the newly imported node in the editor, then compare the protocol, transport, security layer, and flow control. If the subscription includes both VMess and REALITY, test one of each. If only the REALITY node fails, first check whether the core and importer preserve and support its REALITY fields. Don't keep refreshing the entire subscription.
Can I change REALITY to TLS to use the node with V2Fly?
Changing the client configuration alone won't work. The security layer must match the remote inbound. If you need to use V2Fly, choose another node that the server provides and that you've confirmed is compatible, such as VMess + WebSocket + TLS. Import it using the address, port, and path specified for that node.
Why can I see a node's latency, but still can't open websites in my browser?
The latency test and browser may not use the same local entry point. First check whether the browser uses the system proxy or a manually configured proxy port, then see whether its requests appear in the core log. If there are no requests, check the entry point. If requests use the wrong outbound, check routing. If there's a DNS resolution error, check the relevant DNS settings.