Xray vs. V2Fly Core: Features, Configuration Compatibility, and Which to Choose

Learn how V2Fly and Xray branched from Project V, compare VLESS, XTLS, and REALITY support and config compatibility, and find out whether v2rayNG or v2flyNG fits your setup.

At a glance

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.

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.

What to check for common node combinations
Node combinationXrayV2FlyKey fields
VMess + WebSocket + TLSSupportedSupportedUUID, WS path, Host, TLS server name
VLESS + WebSocket + TLS, without flow controlSupportedCheck version and client import supportProtocol, transport, and security layer must each match
VLESS + TLS + VisionUse a version that supports VisionDon't migrate using an Xray Vision configurationflow: xtls-rprx-vision
VLESS + REALITY + VisionUse a version that supports this combinationDon't migrate using an Xray REALITY configurationsecurity: 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

Recommended

If 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.

10808
Example desktop SOCKS local port
10809
Example separate HTTP inbound port
443
Common remote TLS port; use the value in your node configuration
  1. 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.
  2. 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.
  3. 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.
  4. Restore DNS and routing last. Start with the fewest rules needed to verify proxy egress, then restore your rule sets. Check that outboundTag matches an existing outbound, and that the current core can load geoip.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.

Download clients