Guides, Nov 22, 2026

# TUIC vs Hysteria2: comparing the two QUIC proxy protocols

Hysteria2 and TUIC v5 both relay TCP and UDP over QUIC, and both stop working when UDP cannot reach the server. Hysteria2 adds tools for hostile networks: an HTTP/3 masquerade, a Chrome-like QUIC handshake, Salamander and Gecko obfuscation, port hopping and the fixed-rate Brutal congestion control. TUIC v5 is a small, frozen spec with none of those, standard congestion control and several independent servers. Pick Hysteria2 when the network fights you or the link is lossy, and TUIC when you want the simplest QUIC proxy inside an existing sing-box or Mihomo setup.

ST Muntaha, 10 min read

I wrote separate explainers for [Hysteria2](https://tunnelhq.com/blog/hysteria2-protocol-explained/) and [TUIC v5](https://tunnelhq.com/blog/tuic-v5-explained/). This post puts them side by side. The facts come from the [Hysteria 2 protocol spec](https://v2.hysteria.network/docs/developers/Protocol/), the [TUIC spec](https://github.com/tuic-protocol/tuic/blob/master/SPEC.md) and the current releases: Hysteria 2.13.0, sing-box 1.14.4 and Mihomo v1.19.33. I give no speed numbers, because I have no benchmark I would trust on your network. I explain how each one behaves instead, and how to measure it yourself.

## What do Hysteria2 and TUIC have in common?

Quite a lot. Both run on QUIC with TLS 1.3 over UDP. Both carry each TCP connection as its own QUIC stream, so one slow download does not block the others. Both send UDP inside QUIC datagrams by default. Both run their congestion control in user space, which costs more CPU than kernel TCP on small servers.

They also share the main weakness. If a network blocks or throttles UDP, both fail together. Neither protocol can fall back to TCP by itself. And both are supported by the two big multi-protocol cores, sing-box and Mihomo, so many clients can use either one.

## How do Hysteria2 and TUIC differ?

|  | Hysteria2 | TUIC v5 |
| --- | --- | --- |
| Spec and reference code | One project; the spec and the official `hysteria` binary come together | Spec only (`tuic-protocol/tuic`); no official implementation |
| Wire format | One protocol across 2.x; new optional layers need matching versions | Version `0x05`, unchanged since June 2023 |
| Authentication | Password in an HTTP/3 `POST /auth`; server answers status 233 | UUID plus a token from the TLS exporter; no answer |
| Failed login looks like | A normal web server (404 or the masquerade) | The connection closes (in sing-box; the spec leaves it to implementations) |
| Disguise | HTTP/3 masquerade; Chrome QUIC fingerprint by default since 2.11.0 | None in the spec |
| Obfuscation | Salamander; Gecko (experimental) | None in the spec |
| Port hopping | Built in | Not in the spec, sing-box or Mihomo options |
| Congestion control | Brutal (fixed rate) when bandwidth is set; otherwise BBR or Reno | `cubic`, `new_reno` or `bbr` |
| TCP setup | Client waits for the server's reply (optional `fastOpen` skips it) | No reply; data goes out at once |
| UDP relay | QUIC datagrams, fragmented when large | `native` (datagrams) or `quic` (streams) |
| Share link | `hysteria2://`, defined in the official docs | `tuic://`, a convention between clients |

## How does authentication differ?

Hysteria2 authenticates with an HTTP/3 request. The client sends `POST /auth` with the credentials in a `Hysteria-Auth` header, inside the TLS connection. A correct password gets the status `233 HyOK`. A wrong one gets whatever a web server would return, usually a 404. The server side is flexible: one shared password, a `userpass` map, an HTTP backend that you write, or an external command.

TUIC authenticates without sending the password at all. The client sends its UUID and a 32-byte token computed with the TLS keying material exporter, with the UUID as the label and the password as the context. The server computes the same token and compares. Nothing comes back either way.

For operators, the practical difference shows up in logs. A Hysteria2 client with a wrong password prints `authentication error, HTTP status code: 404`, so the user can tell you "wrong password" without help. A TUIC client with a wrong password only sees its connection close, which looks a lot like a network problem. The answer is in the server log: sing-box writes `authentication: token mismatch` or `authentication: unknown user`.

## How does congestion control differ, and what happens on lossy links?

This is the biggest technical difference.

Hysteria2's Brutal sends at the rate you set. It does not slow down when packets are lost. If it falls short of the target, it measures the loss and sends more to make up for it. On a lossy link with a known capacity, that keeps throughput close to the target where a loss-based algorithm would back off. The cost is that you must know the capacity. Set it too high and the connection becomes slow and unstable, as the Hysteria docs warn. If you set no bandwidth, Hysteria2 uses BBR (or Reno, if configured), and `ignoreClientBandwidth` on the server forces that for everyone.

TUIC uses standard algorithms. `cubic` (the sing-box default) and `new_reno` treat every loss as congestion and slow down, which hurts on mobile and long international paths with random loss. `bbr` models bandwidth and round-trip time instead, and suffers much less from random loss. There is no fixed-rate mode.

So on a clean path with BBR on both sides, I would not expect the protocol choice to matter much. On a lossy path, Hysteria2 with a correct Brutal value is designed to hold its rate, and TUIC with `bbr` is the closest it gets. Do not trust my expectation; measure on your own path:

```
# Hysteria2: the server needs speedTest: true
hysteria speedtest -c client.yaml

# TUIC (or anything with a local SOCKS5 port): bytes per second,
# downloading a large file from a fast host you control
curl --socks5-hostname 127.0.0.1:1080 -s -o /dev/null -w '%{speed_download}\n' https://yourdomain.com/test-100mb.bin
```

The Hysteria speed test runs 10 seconds in each direction by default. Run both tests from the networks your users actually use, at the hours they use them.

## Which one is harder to detect?

I can describe what each one shows to an observer. I cannot tell you which one a particular national firewall blocks this month, because that changes, and the only real answer comes from a test inside that network. The [post on checking whether a server IP is blocked](https://tunnelhq.com/blog/check-vpn-server-ip-blocked/) covers how to run one.

What Hysteria2 shows, by default: QUIC traffic whose handshake imitates Google Chrome (since 2.11.0), a server name in the first packets like any QUIC connection, and, to anyone who probes the server, an HTTP/3 website. With Salamander, the observer sees no QUIC structure at all, only random-looking UDP packets, and a prober gets no website. Port hopping moves the flow between ports; the docs explain that users in China sometimes report ISPs blocking or throttling long-lived UDP flows, often only on the port in use. Mimic, on Linux, makes the traffic look like TCP for networks that restrict UDP.

What TUIC shows: plain QUIC from whatever QUIC library the implementation uses, the server name, and the ALPN you configured. A prober that completes the QUIC handshake gets no website; sing-box closes the connection when no valid authentication arrives within `auth_timeout`. There is no obfuscation layer to turn on.

Neither protocol hides that one client sends a lot of UDP to one server. If you need a protocol that survives where UDP is blocked, look at TCP-based options such as VLESS with REALITY or Trojan.

## How do Hysteria2 and TUIC relay UDP?

Hysteria2 always uses QUIC datagrams. A packet larger than the datagram limit is split into fragments, and if one fragment is lost, the whole packet is dropped. The server opens a UDP port per session and closes it after `udpIdleTimeout` (60 seconds by default). You can switch UDP off with `disableUDP`.

TUIC lets the client choose. In `native` mode, packets travel as datagrams, lossy like real UDP. In `quic` mode, each packet travels on a QUIC stream, so QUIC retransmits it if it is lost, at the cost of more overhead. The client picks a 16-bit associate ID per session, which gives full cone NAT behaviour, and ends the session with a `Dissociate` command.

For DNS, games and voice, both work. TUIC's `quic` mode only matters in the rare case where you need lossless UDP through the proxy.

## Which clients and servers support each one?

|  | Hysteria2 | TUIC v5 |
| --- | --- | --- |
| Reference server | Official `hysteria` | None; `Itsusinn/tuic` calls itself the successor |
| Other servers | sing-box, Xray-core | sing-box, Mihomo |
| Clients | Official client, sing-box, Mihomo, Xray-core, NekoBox, v2rayN, Hiddify, Shadowrocket, Streisand | sing-box, Mihomo, NekoBox, v2rayN, Shadowrocket, `tuic-client` |

The line that matters for many fleets is Xray-core. It has a Hysteria2-compatible protocol (it calls it `hysteria`, version 2), and [its docs](https://xtls.github.io/en/config/outbounds/hysteria.html) split the options between the protocol and the transport settings. It has no TUIC at all. If your panel and your users' apps are Xray-based, Hysteria2 fits in and TUIC does not.

Third-party Hysteria2 implementations can also lag behind the official one, as the Hysteria docs warn. Gecko obfuscation and the Chrome QUIC fingerprint came to sing-box in 1.14.0; an older client cannot connect to a Gecko server. With TUIC, any v5 client should talk to any v5 server, because the wire format does not move. The usual problems are config mismatches, such as a missing ALPN in a `tuic://` link.

## Which project is better maintained?

Both are maintained, in different ways.

Hysteria is one team moving fast. The [changelog](https://v2.hysteria.network/docs/Changelog/) and GitHub releases show at least ten releases between May and October 2026, from 2.9.1 to 2.13.0. Releases 2.8.2 and 2.9.2 were both marked as important security fixes. New features arrive often: Realms, ECH, Chrome fingerprinting, mimic, Gecko. The price is that you must keep servers and clients close in version. For example, the changelog notes that from 2.8.2, UDP forwarding fails when a new client talks to an older server.

TUIC's spec has not changed since June 2023, and the reference implementation was removed from the spec repository. The servers are maintained by their own projects: sing-box 1.14.4 (24 October 2026), Mihomo v1.19.33 (21 October 2026), and Itsusinn/tuic, whose stable line is 1.8.11 (July 2026) while 2.0.0 is in development builds. A frozen protocol with active implementations is a fine place to be. Just do not install a `tuic-server` binary from an old guide that points at the original repository.

## Which one should I pick?

-   **Users on networks that block QUIC or throttle UDP per port:** Hysteria2. Salamander and port hopping exist for exactly this. TUIC has no answer here.
-   **Lossy mobile or long-distance links, and you can measure capacity:** Hysteria2 with Brutal. If users set their own numbers badly, set `ignoreClientBandwidth` and fall back to BBR.
-   **An Xray-based panel or Xray clients:** Hysteria2, because Xray-core does not speak TUIC.
-   **A sing-box or Mihomo setup, and you want the least tuning:** TUIC with `bbr`. There is no bandwidth to set and fewer options to get wrong.
-   **UDP blocked completely:** neither. Use a TCP protocol, or Hysteria2's mimic on Linux if you control both ends.

You can also run both on one server. They cannot share UDP 443, so put Hysteria2 on 443 and TUIC on another UDP port such as 8443, or define both as inbounds in one sing-box config. Give users both links and let their clients fail over.

## How do I monitor Hysteria2 and TUIC servers?

The rule is the same for both: a UDP port probe tells you nothing, because neither server answers random packets. A check has to complete the QUIC handshake, authenticate, and send a real request through the tunnel, from outside your own network.

The difference is in what a failure tells you. A failed Hysteria2 check can report "server answered, password rejected" (the 404), which separates a credentials problem from a network one. A failed TUIC check usually looks like a timeout or a closed connection either way, so for TUIC I always pair the outside check with the server log.

Full disclosure: [TunnelHQ](https://tunnelhq.com/hysteria2-monitoring/) does this for both protocols. You paste a `hysteria2://` or `tuic://` link, or a subscription URL that contains them, and the servers behind it stay in sync. Every 1 to 5 minutes, depending on plan, a checker completes the real handshake and sends traffic through the tunnel, and incidents open and close on their own from the results. The [TUIC page](https://tunnelhq.com/tuic-monitoring/) and the [free tester](https://tunnelhq.com/test/) are there if you want to try one link first.

Source: https://tunnelhq.com/blog/hysteria2-vs-tuic/
