Xray vs. V2Fly Core: Protocol Support, XTLS, and Configuration Compatibility

Compare Xray and V2Fly core support for VLESS, XTLS, and REALITY, and learn what to check when migrating configurations between them.

At a glance

If you already have a subscription or custom JSON config, start by checking the server's required protocol, transport, security settings, and flow control before choosing a core. Configs that explicitly specify REALITY or xtls-rprx-vision require Xray. Standard VMess configs can be recreated with either core, but a successful import doesn't guarantee that the handshake, DNS, and routing will work the same way.

How Xray and V2Fly are related: shared origins don't mean compatible configs

Project V was an early name for the V2Ray ecosystem. The V2Fly community continues to maintain v2ray-core, while Xray-core branched off from the same codebase and evolved independently. The two share many concepts, including inbound and outbound connections and routing tags. Shared concepts don't mean they parse the same JSON or that a server will accept the same connection parameters.

Keep clients and cores distinct, too. v2rayNG is an Android client that uses the Xray core; v2flyNG uses the V2Fly core. v2rayN is a desktop client, so when troubleshooting, check which core the current config actually runs. You can't determine that from the client name alone. If a subscription displays node names, that only confirms the client recognized some of its contents.

Xray Core

Recommended

If the server requires REALITY or XTLS Vision, choose an Xray build that supports the corresponding fields. For a standard VMess config, you can also keep the existing protocol and test it with Xray first.

Best for: connecting to servers that specifically require REALITY or Vision

V2Fly Core

If you have a stable VMess + WebSocket + TLS setup, you can keep using that protocol combination. For custom configs, regenerate them in a format supported by your target version.

Best for: continuing to use a tested V2Fly and VMess configuration

What VMess, VLESS, REALITY, and Vision each do

VMess and VLESS are proxy protocols, WebSocket is a transport, and TLS and REALITY are connection security settings. xtls-rprx-vision is an Xray flow-control value for VLESS. Two nodes labeled VLESS can still use different transports or security layers. VLESS doesn't encrypt the connection by itself, and encryption: none is no substitute for checking the outer connection settings.

Check compatibility by feature
FeatureCompatibilityWhat to check
VMess + WebSocket + TLSThis common combination works with both branches, but the exact config structure depends on the target version.Server address and port, user ID, WebSocket path and host, and TLS server name.
VLESSSupported by Xray. For V2Fly, check the specific version, build, and config format; whether a link imports successfully isn't a reliable compatibility test.Check the protocol, transport, security layer, and flow control separately. Don't assume one test result applies to every VLESS node.
REALITYThe Xray REALITY config discussed here can't be imported into V2Fly as a standard TLS config.Keep the server name, public key, short ID, and other parameters provided by the server. Enter them using the field format supported by your Xray build.
XTLS VisionXray flow-control feature. Legacy XTLS flow-control values aren't interchangeable with Vision.Check flow in the connection config and compare it with the value set for that user on the server.

REALITY and Vision can be used together, but they're not the same setting. REALITY determines how the connection's security layer is established; Vision changes how eligible traffic is handled during forwarding to avoid redundant processing of already encrypted traffic. Enabling Vision doesn't disable connection protection, and it doesn't guarantee faster performance on any particular device.

Migrating JSON: move the node first, then check inbound settings, DNS, and routing

The numbers below refer to version milestones, remote connection ports, and local listening ports. Port numbers are troubleshooting examples, not client defaults or speed-test results.

1.8.0
The Xray version milestone that introduced REALITY; not an installation recommendation
443
A common remote TLS port; use the value configured on the server
10808
Example local SOCKS listening port; check the desktop client's actual setting
  1. Keep the original config and recreate one outbound. Start by adding a single node in the target client, or importing a known-good share link from the clipboard. Don't change the server, transport, and routing all at once. Check the server address and port first, then verify account fields, the transport path, and security settings. In legacy VMess AEAD configs, alterId is commonly 0; don't set it to a nonzero value just to try to fix a timeout.
  2. Let the target client create its own inbound. If the desktop client uses a local proxy, make sure the app's proxy type matches the listening port. If an app points to the example port 10808, the target client must actually provide the corresponding service on that port. On Android, if the system VPN handles traffic, also confirm that VPN access is authorized and that per-app rules haven't excluded the app you're testing.
  3. Restore routing rules one at a time. Check that each rule's outboundTag still points to an outbound that exists in the target config. Preserve the order of rules that need priority matching. If you use geoip or geosite, check that the target client has data files containing the categories referenced by the original rules. Don't just check whether the rule names can be saved.
  4. Restore DNS last. First test basic connectivity with a domain you know is reachable, then restore custom DNS and domain-matching rules. If the connection works but specific domains fail, check the DNS results and which outbound was selected before investigating the server. With a desktop proxy, an app resolving DNS itself may match different rules than when it sends the domain to the proxy. Confirm which behavior you're testing.
Don't try to migrate protocols by deleting fields

Changing streamSettings.security from reality to tls, or removing flow from a user entry, only changes how the client initiates the connection; it doesn't change the server. If the server doesn't provide another compatible endpoint, keep the original protocol and switch to a suitable core.

Using one subscription on desktop and Android: test a single node first

The same subscription URL can return nodes with different protocol combinations. Even if both clients update successfully, they may recognize different nodes or preserve different fields. Test one node first, then compare the subscription results. The number of nodes in the list doesn't tell you whether the configs are compatible.

Test one node on both desktop and Android

Desktop: v2rayN
  • Check the protocol, transport, and security settings in the node editor. For REALITY or Vision, confirm that the client actually starts the Xray core.
  • Go to Settings → Parameter Settings to check the local listening port. Send a real request from an app using the proxy, then check the core logs.
Android: v2rayNG or v2flyNG
  • On the v2rayNG home screen, tap + in the upper-right corner → Import config from clipboard. Import a single link first, then open the node editor to check the parsed settings.
  • To test a VMess setup supported by both cores in v2flyNG, keep the same server parameters and confirm the test app's traffic is routed through the VPN.

First confirm that the same compatible node works in both clients, then update the full subscription. If only some nodes disappear after the update, check the subscription format and supported fields before changing system network settings.

Common errors after switching cores and how to troubleshoot them

The node imports, but connecting returns an “unknown security type” error. Why?

Open the node editor and check whether the security type is REALITY, then confirm which core and version actually started. If the error occurs while reading the config or starting the core, recreate the node with a core that supports that security type. Changing the remote port won't fix a config parsing error.

It keeps timing out after I switch cores. Is the UUID wrong?

First determine whether the client can't reach the server or whether the handshake fails after connecting. For the former, check address resolution, the remote port, and your current network. For the latter, check the UUID, WebSocket path, TLS server name, and the server's security requirements. If you see a certificate error, also check the device's clock. Don't disable certificate verification to hide a config problem.

A speed test shows latency. Why can only some apps connect?

A speed test request may not follow exactly the same route as the app that's failing. On Android, go to Settings → Per-app proxy and check the app list and bypass mode. If the app is routed through the VPN, check outbound tags, DNS results, and rule order. Change one setting at a time, then test the same domain in the same app again.

Can I give the other client the full JSON generated by this one?

First distinguish a share link from a full JSON config. Full JSON may include local listeners, data files, and DNS settings. Recreate the outbound on the target client and verify the connection first, then migrate only the fields you need, one section at a time. Note the first error and the related field. Before sharing logs, remove sensitive details such as user IDs and subscription URLs.

Clients and Downloads