Start your 3-day free trial
Sign up to experience all premium features at no cost.
*Available only to new users. Each user is limited to one trial.


Xray and V2Ray are software cores that process and forward network traffic using configured proxy protocols and supporting modules. They are not names for a single VPN protocol, and a graphical client that uses one of them adds its own interface and integration choices around the core.[1][2]
Key Takeaways:
- A core is software; a protocol defines how communicating peers exchange messages.
- Inbounds accept traffic, routing selects a path, and outbounds send it onward.
- A client interface, a loaded core, and an active connection profile have different identities.
- Xray and V2Ray have related origins but are not universally compatible substitutes.
A core is the engine that interprets configuration and carries out networking work. It can combine entry interfaces, forwarding protocols, routing decisions, and supporting services in one process. A core may run on your device, on a remote server, or at more than one point along a connection; the word “core” describes its software role, not its physical location.[2][3]
The diagram is a responsibility map, not a compatibility chart or a complete configuration. The client interface sits outside the conceptual core flow. Within the core, an inbound receives a request, routing makes a forwarding decision, and an outbound uses the selected connection method to send traffic onward.
A graphical application may manage profiles, start a core process, set a system proxy preference, or integrate traffic capture. Those functions are useful, but the interface's name is not sufficient evidence of which core release or connection method is active. Some applications can use different engines across versions or selected profiles.
The VPN fundamentals explanation distinguishes application proxying from device routing. A connect button can hide several decisions behind one action; to understand the resulting connection, identify the traffic entry, loaded configuration, and onward path separately.
A management panel is another layer: it may generate profiles, enroll users, and manage the core's lifecycle. Its account database and permissions are separate from the forwarding protocol. A working panel page proves neither a running core nor an authorized peer exchange.
In the proxy core vs protocol distinction, the core is an implementation that can understand several sets of wire rules. A protocol specifies the messages and behavior peers must agree on. Changing the core binary is a software change; changing a profile's protocol is a connection-contract change. Either can affect behavior, but they answer different questions.
A profile may name a forwarding protocol alongside a transport, a security layer, and a flow-control option. Reading these as one interchangeable list loses the job each performs. A routing rule is not encryption, and a transport choice does not itself state how an application is authorized to use a server.
For examples of actual forwarding protocols, the Trojan definition and TLS path and Shadowsocks application-proxy model describe peer exchanges rather than client brands. A core supporting a protocol does not mean every active profile uses that protocol.
The separate protocol, transport, and obfuscation layers provide vocabulary for reading a profile. Avoid translating “supports” into “enabled”: an available capability, a configured capability, and an observed working path are different forms of evidence.
NaiveProxy illustrates a different implementation choice: its Chromium-based client uses HTTP/2 or HTTP/3 CONNECT tunnels with padding. HTTP CONNECT describes the proxy exchange; “NaiveProxy” names the implementation, not another label for Xray or V2Ray.[5]
An inbound accepts traffic through a configured entry. Routing evaluates the information available for that request and selects an outbound path. An outbound sends data toward a remote proxy or another configured destination; direct forwarding can also be an outbound choice. The architecture places these responsibilities in separate components.[2][3]
On a device, an inbound might accept a local application's proxy request. On a remote server, an inbound can accept the corresponding remote protocol. The server's outbound then handles the onward path. “Inbound” therefore means entry into that process, not always traffic arriving from the public Internet.
Likewise, “outbound” means leaving that process, not necessarily using a paid remote proxy. A profile can choose a direct route for some requests and a proxy route for others. To understand a destination's path, inspect the routing outcome instead of assuming that starting the core sends every request through one remote server.
Routing may use domains, addresses, ports, or other supported information; the available fields and resolution behavior depend on the implementation and configuration. A rule that relies on a domain also needs the relevant domain information to be available. The presence of a rule does not prove every application request exposes the same inputs.[4]
In Xray, sniffing can extract supported protocol/domain hints. destOverride selects eligible hints; routeOnly: true uses a sniffed domain for routing without replacing the original destination address, while destination override can change that target. Encrypted metadata such as ECH limits what is visible. Sniffing is neither decryption nor a guarantee that every request exposes its real hostname.[6]
If the application never sends traffic to the inbound, changing a remote protocol cannot explain that missing local entry. If traffic enters the core but selects a direct outbound, the selected remote proxy may be healthy yet unused. If the expected outbound is selected and fails, the next question concerns that path's identity, authentication, or reachability.
This is a conceptual way to organize evidence, not a prescription to alter routing policy. Keep permitted network use and organizational restrictions in view when interpreting a profile. A configuration should be understood before it is changed, particularly when several applications share the same client.
An inbound fallback is also different from outbound failover: Xray's documented fallback can select a local destination from initial connection characteristics such as name, ALPN, or path. It does not by itself monitor remote outbound health and switch to a backup server.[7]
The Xray core originally branched from v2ray-core. Project X's current introduction explicitly describes independent evolution and warns against treating Xray as a fully compatible drop-in replacement. Similar-looking configuration sections are evidence of related design, not a guarantee that all fields, environment variables, APIs, or features are interchangeable.[1]
A V2Ray core profile needs to match the schema and capabilities of the release actually running it. The same principle applies to Xray. Successful parsing is only one dimension: the remote peer must also agree on protocol behavior, authentication, transport, and relevant security options.
Consider an application that imports a profile without an error. That observation establishes that the importer accepted something, but it may normalize fields, omit unsupported options, or select a different engine. It does not establish that every intended option reached the running core or that the remote server accepts the result.
Similarly, a protocol name appearing in both projects' documentation does not prove all extensions or combinations are common to both. Verify the precise feature and release in each project's current documentation. Do not copy a feature list from one project and label it as the other's supported capabilities.
The VLESS, REALITY, and Vision layer explanation develops those names in their own context. It is a separate reference, not a general promise that a profile mentioning them can be moved between all clients or cores.
Two migration boundaries need explicit checks. sing-box has its own configuration schema; similarly named inbounds/outbounds do not make an Xray/V2Ray JSON file interchangeable with it. Translate documented roles for the exact release rather than swapping binaries.[8] Moving VMess to VLESS also changes the wire/authentication contract: retaining a UUID does not migrate server authorization, transport, security, or flow requirements. Coordinate both peers and preserve a known-safe recovery route; do not treat a protocol-name edit as a completed migration.[9][10]
A core processes the traffic delivered to it. Device-wide coverage additionally depends on application integration, system routing or capture, DNS handling, and the selected policy. A local proxy entry can be appropriate for one application without automatically covering a second program that ignores the system proxy preference.
A client may add an operating-system VPN or TUN interface to collect packets, then translate that traffic into the core's forwarding path. The local interface explains capture; it does not rename the remote exchange. Equally, a remote protocol's encryption does not demonstrate that every device packet entered that interface.
If you use AethoVPN's global-mode setting, its documented on/off traffic scope is the relevant client-level fact; a low-level core label is a different kind of information, and the protocol choice overview helps keep software identity separate from coverage and trust. Do not infer a service's underlying implementation from generic client terminology. If keeping the core, panel, and server lifecycle current is no longer appropriate for an internet-exit task, compare VPS and managed VPN maintenance responsibilities; changing the maintenance model does not replace private-network connectivity.
The question of whether VLESS/REALITY is a VPN protocol examines that classification more closely. It separates a protected proxy exchange from additional components that can make an application feel like a device-wide VPN.
This table is an interpretation aid. It assigns responsibility without assuming a particular graphical application, operating system, or complete feature set. The decisive evidence is the actual loaded software and path, rather than a marketing label attached to a profile.
| Component | Typical responsibility | What its name alone cannot establish |
|---|---|---|
| Client interface | Profile management, process controls, and integration choices | Exact running core version or every effective setting |
| Core executable | Configuration interpretation and supported networking modules | Which available protocol is active for a request |
| Inbound | Accept traffic into that process through an entry contract | Every device application uses that entry |
| Routing | Choose a path using supported rules and available request information | Encryption, anonymity, or successful remote authentication |
| Outbound | Forward through the selected direct or proxy path | All other requests use the same path |
| Protocol, transport, and security settings | Define the peer exchange and protected remote connection | Local traffic capture, service privacy policy, or universal compatibility |
Each role has its own maintenance task: upgrading Xray with a rollback path, a local sing-box client on Linux, NaiveProxy behind Caddy as a separate HTTP CONNECT implementation, and keeping Xray running on Windows Server.
A useful description includes the client name, core name and release, active profile's documented layers, affected application, and last established connection stage. When sharing evidence, remove credentials, private keys, subscription addresses, account identifiers, and sensitive destinations. A screenshot can be helpful, but visible names are not a substitute for effective configuration.
If an issue appears after an update, separate the changed interface, importer, core, and server components. A before-and-after observation is stronger when the same application task and network conditions are held constant. Without that separation, attributing the result to “Xray” or “V2Ray” can hide the actual owner of the change.
Start with the project's official installation documentation and linked release or installer, then check the target OS, architecture, core version, and configuration path. Xray's official Linux installer targets systemd; Windows release archives provide an executable, whose launch, restart, and boot behavior depend on how you run it or a separately configured service. Closing a terminal or copying a binary is not a service-lifecycle plan.[11][12]
Before running a script, inspect its actual download origins, required privileges, file/unit changes, and recovery procedure. Confirm backups and management access survive the change; stop if the origin or effects cannot be verified. A panel's install button does not remove those responsibilities. This is a documentation-based checklist, not a report of an installation tested here.
Xray and V2Ray are software cores, not single VPN protocols. They can implement proxy protocols and supporting networking modules. A client may add device-wide capture, but that integration does not turn a core's name into the wire protocol used by a profile.
Xray originally branched from v2ray-core, but the projects evolved independently. Current Project X documentation warns against assuming full drop-in compatibility. Check the exact configuration, feature, release, and remote peer requirements instead of replacing an executable based only on related names.
The interface and core have different responsibilities. An interface can import profiles and manage integration while a core handles the networking exchange. The application name alone does not establish the running core version or the effective settings of an active request.
An inbound is an entry into the particular core process. On a client device it may accept a local application request; on a server it may accept a remote proxy exchange. Its role is relative to the process, not automatically to the public Internet.
Routing selects a forwarding path using supported rules and available request information. Encryption belongs to the connection's protocol and security layers. A route can select direct forwarding or a protected proxy path, so a routing rule alone is not an encryption guarantee.
Profile import proves only that the importer accepted the input. The running core must support the effective settings, and the remote peer must agree on the connection contract. Imported profiles can still fail before authentication or forwarding, or omit intended behavior.
Running a core does not automatically send every application's traffic into it. Coverage depends on proxy preferences, capture, system routing, DNS handling, and policy. Identify the application's actual entry and outbound path before concluding that all device traffic uses the selected connection.
Disclaimer: This is a component-level explanation, not a configuration or migration guide. Capabilities vary by release and client integration; follow applicable laws and network policies and consult each project's current documentation.
Sources checked 9 October 2026.
Sign up to experience all premium features at no cost.
*Available only to new users. Each user is limited to one trial.