HelloVPN

HelloWG vs WireGuard: What's the Difference and Which Should You Use?

Published 10 min read

Open the protocol list in Hello VPN and you'll see both HelloWG and WireGuard. They are two separate things. WireGuard is an open VPN protocol created by Jason A. Donenfeld, known for being small and fast. HelloWG is Hello VPN's own protocol: a new implementation written in Go that works on similar principles to WireGuard and runs in user space, as part of the app, rather than in the operating system kernel.

Short version: use WireGuard for everyday speed, and try HelloWG on networks where other protocols have trouble connecting. Or leave the app on Auto and let it choose. Most of this guide is about WireGuard itself, because once you know how it works, the rest is easy to follow.

What is WireGuard?

WireGuard is a VPN protocol and also the name of the software that implements it. It was designed by Jason A. Donenfeld and merged into the Linux kernel in version 5.6, released in 2020. Being accepted into the kernel was a big moment: it meant the people who maintain Linux considered the code good enough to ship to everyone.

The idea behind WireGuard was to do less. Older protocols such as IPsec and OpenVPN grew over many years and carry a lot of options. WireGuard has very few. The Linux kernel module is roughly 4,000 lines of code, small enough for one person to read in full. Fewer lines means fewer places for mistakes to hide, and it makes independent review realistic.

If you want the longer story of how VPN protocols got here, see our history of VPN.

How does WireGuard work?

WireGuard sets up an encrypted tunnel between two devices, called peers. On a VPN service, one peer is your phone and the other is the VPN server. Here is what happens under the hood.

Keys instead of usernames

Every peer has a private key and a public key. There are no usernames, passwords or certificates inside the protocol. Each side is told the other's public key in advance, a bit like exchanging SSH keys. A VPN app does this for you in the background.

The handshake: Noise_IK

Before any data flows, the two peers run a short handshake to agree on temporary session keys. WireGuard builds this handshake on the Noise protocol framework, using a pattern called Noise_IK. "IK" means the side that starts the connection already knows the other side's long-term public key.

The handshake takes one round trip: one message there, one message back. After that, data can flow. The session keys are replaced every couple of minutes while the tunnel is in use, so a key that leaked later would not open old traffic. This property is called forward secrecy. WireGuard also lets two peers add an optional pre-shared key on top as an extra layer.

One fixed set of cryptography

Many VPN protocols let the two sides negotiate which ciphers to use. WireGuard doesn't. It always uses the same set:

  • Curve25519 for key exchange.
  • ChaCha20-Poly1305 to encrypt data and detect tampering.
  • BLAKE2s for hashing.

With nothing to negotiate, there is no way to be talked down to a weaker cipher. The trade-off is that if one of these algorithms ever needs replacing, the answer is a new version of the protocol, not a settings change. ChaCha20 is also quick on phones, including ones without special hardware for encryption.

Cryptokey routing

This is WireGuard's most distinctive idea. Each peer's public key is tied to a list of IP addresses that peer is allowed to use inside the tunnel. That one table does two jobs:

  • Sending: WireGuard looks at where a packet is going, finds the peer that owns that address, and encrypts the packet with that peer's key.
  • Receiving: after decrypting a packet, WireGuard checks that its source address is one that peer is allowed to use. If not, the packet is dropped.

So the key is the identity, and the routing table is the access list.

Roaming

Because peers are identified by keys and not by network addresses, a peer can change address without breaking the tunnel. When a valid, encrypted packet arrives from a new address, WireGuard simply starts replying there. On a phone, this is why moving from Wi-Fi to mobile data usually doesn't interrupt a WireGuard connection.

UDP only, and quiet when idle

WireGuard sends everything over UDP. It has no TCP mode. It also has no fixed port, although 51820 is a common choice.

WireGuard is not a chatty protocol. If you aren't sending data, it sends nothing, unless a keepalive is switched on to hold a connection open through a home router or mobile network. A WireGuard server also doesn't answer packets that don't come from a peer it knows. On a phone, less background chatter helps battery life.

Kernel WireGuard vs user-space WireGuard

You'll often read that WireGuard runs "at kernel level". That's true in some places and not in others, so it's worth being precise.

What "kernel" and "user space" mean

The kernel is the core of an operating system. It talks directly to the hardware, including the network card. User space is where ordinary apps run, with fewer privileges and a safety barrier between them and the kernel.

A VPN protocol can live in either place:

  • In the kernel, packets are encrypted right where the network traffic already is. Nothing has to be handed back and forth to an app, so it's very efficient. The cost is that kernel code is harder to install and update, and a bug there affects the whole system.
  • In user space, the protocol is part of a normal program. Each packet takes a short extra trip between the kernel and the app. That adds some overhead, but the software is easy to ship, update and run on systems that have no kernel version.

wireguard-go and other user-space implementations

The original WireGuard is the Linux kernel module. For systems where a kernel module isn't available, the WireGuard project also publishes wireguard-go, an official implementation written in the Go programming language that runs entirely in user space. There are independent ones too, such as boringtun, a user-space implementation written in Rust by Cloudflare.

All of these speak the same protocol. A phone running user-space WireGuard can connect to a server running the kernel module, and neither side can tell the difference.

What runs on your phone

This is the part many articles get wrong. On phones, WireGuard usually runs in user space:

  • iPhone and iPad: Apple doesn't let apps load code into the kernel. VPN apps run their tunnel in an app extension, in user space. The official WireGuard app for iOS uses wireguard-go.
  • Android: the official WireGuard app can use the kernel module when the device makes it available to the app, and otherwise uses a user-space Go implementation. On most phones, that means user space.

On computers it varies: Linux uses the kernel module, Windows has its own kernel driver, and the macOS app runs in user space.

Does it matter for you?

On a busy server that moves traffic for many people at once, running in the kernel makes a clear difference. On a phone, the limit is usually your Wi-Fi or mobile signal, not where the encryption code runs. A user-space VPN on a modern phone is fast enough for normal use. So "kernel level" is a real advantage of WireGuard on Linux servers, but it isn't something you'll notice when choosing a protocol in a mobile app.

WireGuard's strengths and limits

Strengths:

  • Fast to connect and fast in use. A one-round-trip handshake and efficient encryption.
  • Small and reviewable. The design has been studied by researchers, including formal analysis of the protocol.
  • Good on mobile. It roams between networks and stays quiet when idle.
  • Simple. No cipher settings to get wrong.

Limits:

  • UDP only. Some strict networks (certain hotel, airport, office or campus Wi-Fi) only allow normal web traffic. If a network doesn't pass UDP, WireGuard can't connect there, and you need a different protocol.
  • Static addresses, kept in memory. By design, each peer has a fixed internal IP address, and the server keeps that address and the last IP address the peer connected from in memory. VPN providers deal with this in their own ways, so it's a fair thing to look at when comparing services.
  • No built-in sign-in system. WireGuard only knows keys. Accounts, key distribution and address assignment are left to the app or service around it.

Compared with older protocols such as IKEv2 or OpenVPN, WireGuard is the simpler and usually the quicker option, while the older ones offer more settings and, in some cases, a TCP mode. We compare two of those in OpenVPN vs OpenConnect.

What is HelloWG?

HelloWG is Hello VPN's own protocol. It is a new implementation written in Go that works on similar principles to WireGuard, and it runs in user space, as part of the app, rather than in the operating system kernel.

We offer it for one reason: some networks are hard for other protocols to connect on. If WireGuard or another option won't connect where you are, HelloWG is one more thing to try.

HelloWG is made by Hello VPN. It is a separate protocol from WireGuard, and it is not made, reviewed or endorsed by the WireGuard project. You'll only find it in the Hello VPN app.

HelloWG vs WireGuard at a glance

HelloWGWireGuard
Who makes itHello VPNJason A. Donenfeld and the WireGuard project
What it isHello VPN's own protocol; works on similar principles to WireGuardAn open VPN protocol with a public specification
ImplementationA new implementation written in GoLinux kernel module (C), plus user-space versions such as wireguard-go
Where it runsUser space, as part of the appIn the kernel on Linux; in user space in most phone apps
Network behaviourOffered for networks where other protocols have trouble connectingUDP only; can't connect where UDP isn't allowed
Track recordNewerIn the Linux kernel since 2020; widely used and studied
Where you can use itThe Hello VPN appMany apps, routers and operating systems
Best forWhen other protocols have trouble connectingEveryday speed

Which one should you use?

  • Choose WireGuard for everyday use. It's fast, light on battery and has years of public review behind it. On a normal home, mobile or café network, it's the one to start with.
  • Choose HelloWG when other protocols have trouble connecting on the network you're on.
  • Not sure? Leave it on Auto. The app picks a protocol for you, and you only need to change it if you have trouble connecting.

Whichever you pick, the job of the VPN is the same: it protects your connection on networks you don't control and from your internet provider. It doesn't make you anonymous, and it doesn't hide who you are from websites you sign in to. Our guide to what a VPN does and doesn't protect against covers those basics.

HelloWG and WireGuard in Hello VPN

Hello VPN for iOS and Android offers six protocol options: Auto, WireGuard, HelloWG, VLESS (with Reality), OpenConnect and IKEv2. Auto chooses for you. To pick one yourself, open the app's protocol settings, select a protocol and connect again.

A simple way to work through a difficult network: start on Auto, then try WireGuard, then HelloWG, then one of the others. Our guides on OpenConnect vs WireGuard and VLESS vs WireGuard explain how those options differ. You can test all of them during the 3-day free trial.

Frequently asked questions

Is HelloWG the same as WireGuard?

No. HelloWG is Hello VPN's own protocol, a new implementation written in Go that works on similar principles to WireGuard. It is a separate protocol and is not made or endorsed by the WireGuard project. Both are available as separate options in the Hello VPN app.

What is WireGuard, in one sentence?

WireGuard is a small, fast, open VPN protocol created by Jason A. Donenfeld that uses a fixed set of modern cryptography over UDP and has been part of the Linux kernel since version 5.6 in 2020.

What is wireguard-go?

wireguard-go is the WireGuard project's official user-space implementation, written in Go. It's used on systems where the kernel module isn't available. The official WireGuard app for iOS uses it, for example.

Is user-space WireGuard slower than kernel WireGuard?

On servers handling a lot of traffic, yes, the kernel version is more efficient. On a phone, your Wi-Fi or mobile connection is usually the limit, so the difference is hard to notice in normal use.

Is WireGuard safe?

Yes. It uses modern, well-regarded cryptography, its code is small enough to review in full, and its design has been analyzed by security researchers. Like any VPN protocol, it protects your connection, not what you do after you sign in to a website.

Does WireGuard use UDP or TCP?

UDP only. There is no TCP mode in WireGuard. That keeps it fast, and it's also why it can't connect on networks that don't allow UDP.

“WireGuard” is a registered trademark of Jason A. Donenfeld.

“OpenVPN” is a registered trademark of OpenVPN Inc.