Compare

ForestVPN vs WireGuard: measured, Oct 2026

ForestVPN against the WireGuard protocol and the three ways to run it, on the same hardware: throughput, CPU, memory, latency, and where we lost.

Last updated October 30, 2026

On this page (10)

ForestVPN keeps WireGuard's handshake, Noise_IKpsk2, unmodified inside its own tunnel engine, Quantum. On Linux virtual machines on 2026-10-30, Quantum with as many threads as vCPUs carried 1.3 to 2.7 times wireguard-go's single-stream traffic where the link was not the limit, tied at a 2.5 Gbit/s link, and lost on latency under load to the kernel module.

How we compared

How we compared. Our own numbers are measured, on the hardware and software named below, and the Linux method is on this page, in the setup blocks of the 2026-10-30 virtual-machine and OpenVPN runs and, for the earlier build, the 2026-10-16 run and the 2026-10-17 thread sweep. The router method is in the throughput post. Everything about WireGuard is quoted from its own pages, with the date we read them. WireGuard is a protocol and open-source software you run yourself; ForestVPN is a service with apps that uses the same handshake. The fair comparison is the implementation, not the product, so the measurements compare our tunnel core with the WireGuard implementations. We did not run any WireGuard service.

The router figures are dated 2026-09-01, the virtual-machine figures 2026-10-30, and the earlier-build Linux figures 2026-10-16 and 2026-10-17. They are different platforms, machines and builds, and are not combined: no figure from one run is divided by one from another. The harness and the raw results are not public; the post says so and says which part of the thread-count trap anyone can reproduce with public tools.

Comparison matrix

What each one is, checked against WireGuard's own pages. The measured results are charted under Architecture and performance.

FeatureForestVPNWireGuardChecked
What it isA VPN service: apps for iPhone, iPad, Mac, Apple TV, Android, Android TV, Windows and Linux, plus a router containerA protocol and open-source software; you run both ends2026-10-08 [1]
HandshakeNoise_IKpsk2, unmodifiedNoise_IKpsk2_25519_ChaChaPoly_BLAKE2s2026-10-08 [2]
Platforms with an official clientiPhone, iPad, Mac, Apple TV, Android, Android TV, Windows, LinuxWindows, macOS, iOS, Android, Linux, FreeBSD, OpenBSD, OpenWrt2026-10-08 [1]
RoutersA RouterOS 7 container, live. See the router featureOpenWrt is on its install page; RouterOS 7 ships its own WireGuard-protocol server, which we measured2026-10-08 [1]
PriceFree; Premium from $7.99 a month (pricing)You pay for the server you run it on2026-10-08
What is keptAn itemised list on the security pageWireGuard is software: what is logged depends on whoever runs your server2026-10-08
Independent auditNone published on this siteThe protocol has been formally verified by several groups2026-10-08 [3]

Architecture and performance

Quantum is ForestVPN's own tunnel engine. It keeps the WireGuard handshake as it is and adds what surrounds it: roaming, MTU handling and fallback transports. The exits it talks to are ours.

WireGuard

  1. Your device You generate a key pair per device and keep the configuration yourself
  2. A server you run You set up the server, its firewall and its addresses, and pick the machine and the country

ForestVPN

  1. The ForestVPN app Connects with no configuration
  2. A ForestVPN exit Run for you: our public locations are ones we run
The handshake in the middle is the same in both. What differs is who runs each end and what surrounds the handshake.

We measured the core against the implementations people actually run: the Linux kernel module, wireguard-go, and boringtun, and in one run OpenVPN. The longer write-up of the 2026-10-30 runs is the Linux benchmark.

  1. Routers Two MikroTik routers

    Over a real gigabit LAN: our core against RouterOS’s own tunnel

  2. Earlier build Linux servers on Scaleway

    The build before the 2026-10-30 changes, at one data-plane thread

  3. Earlier build Thread sweep on Scaleway

    The same build with --threads from 1 to 16

  4. Current build Linux virtual machines

    Throughput, CPU, memory and latency against wireguard-go, kernel WireGuard and boringtun

  5. Current build OpenVPN run

    A separate run that adds OpenVPN 2.7.0

Where we lost, in the open

  • Round-trip time on the routers was 1.22 ms for our core against 0.92 ms for the kernel tunnel.
  • On the Linux virtual machines, ping under load was higher than the kernel module's and boringtun's, the 2.5 Gbit/s link was a tie, and our CPU target against wireguard-go was met in 2 of 12 measurements (details below).
  • With 16 peers on one endpoint, Quantum shared traffic less evenly than wireguard-go and dropped frames wireguard-go did not.

Linux virtual machines, 2026-10-30

With as many threads as vCPUs, Quantum carried 1.33 to 2.67 times wireguard-go's single-stream traffic on one VM and 1.35 to 1.79 times between two VMs on one host; at one thread it carried 0.94 times on one VM at 4 vCPUs. Over a 2.5 GbE link all three reached about 95 percent of the link.

How this run was measured
Date
2026-10-30, every comparison inside one run with its own no-tunnel control
Machines
x86_64 virtual machines on AMD Ryzen 7 8845HS hosts (Proxmox); other projects’ virtual machines shared the hosts
System
Ubuntu 26.04.1, kernel 7.0.0-38
Load
iperf3 3.20, one and four TCP streams for 15 s, median of 5 runs in shuffled order
Quantum
The fv run Linux daemon built from our source on 2026-10-30 (commit 1b2e632533; a glibc build, not the packaged binary), at one thread (its default) and with --threads N, the optional extra key exchange off
Beside it
wireguard-go v0.0.20250522 with as many Go threads as vCPUs; boringtun 0.7.0 (Cloudflare’s userspace WireGuard in Rust) with --threads equal to the vCPU count; kernel WireGuard as a reference
Setups
One VM with two network namespaces, each side held to 1, 2 or 4 vCPUs; two VMs of 2 or 4 vCPUs on one host, where CPU cycles were counted host-wide (iperf3 and the kernel network stack included); two 4-vCPU VMs on two hosts over a 2.5 GbE link
What this run does not cover

No phone, tablet, Mac, Windows PC or router was measured. The raw runs and harness are in our private repository. As of 2026-10-30 no published release contains these changes.

Which tunnel carried more traffic?

With as many threads as vCPUs, Quantum carried more than wireguard-go in every setup where the link was not the limit, and the ranges do not overlap. The three setups share one scale, so bar lengths compare across tabs.

The one setting that separates the two Quantum columns
# threads = vCPUs on a 4-vCPU VM; without --threads, fv run uses one thread
fv run --iface fvpn0 --config fvpn0.conf --threads 4
Setup

One VM

  • Quantum, 1 thread
  • Quantum, threads = vCPUs
  • wireguard-go

1 vCPU per sideMbit/s

  • Quantum, 1 thread10717 10645–10807
  • Quantum, threads = vCPUssame as 1 thread
  • wireguard-go4016 3731–4139

2 vCPUs per sideMbit/s

  • Quantum, 1 thread10529 10436–10585
  • Quantum, threads = vCPUs12308 11648–12469
  • wireguard-go7358 7193–7438

4 vCPUs per sideMbit/s

  • Quantum, 1 thread10525 10437–10620
  • Quantum, threads = vCPUs14911 11693–15230
  • wireguard-go11194 10816–11354
One VM, each side held to 1, 2 or 4 vCPUs: one TCP stream, Mbit/s, median with min–max. With threads = vCPUs Quantum carried 2.67, 1.67 and 1.33 times wireguard-go; at one thread on 4 vCPUs, 0.94 times. Kernel WireGuard is a reference only here: its encryption cannot be held to the same vCPUs, so we compare nothing with it.
Show the data
GroupSeriesValue, Mbit/sRange
1 vCPU per sideQuantum, 1 thread1071710645–10807
1 vCPU per sideQuantum, threads = vCPUssame as 1 thread
1 vCPU per sidewireguard-go40163731–4139
2 vCPUs per sideQuantum, 1 thread1052910436–10585
2 vCPUs per sideQuantum, threads = vCPUs1230811648–12469
2 vCPUs per sidewireguard-go73587193–7438
4 vCPUs per sideQuantum, 1 thread1052510437–10620
4 vCPUs per sideQuantum, threads = vCPUs1491111693–15230
4 vCPUs per sidewireguard-go1119410816–11354

Two VMs

  • Quantum, 1 thread
  • Quantum, threads = vCPUs
  • wireguard-go
  • Kernel WireGuard

2 vCPUs eachMbit/s

  • Quantum, 1 thread7638 7503–7739
  • Quantum, threads = vCPUs8822 8623–9084
  • wireguard-go4929 4599–5095
  • Kernel WireGuard5402 4917–5588

4 vCPUs eachMbit/s

  • Quantum, 1 thread7553 7521–7593
  • Quantum, threads = vCPUs10030 8934–10182
  • wireguard-go7438 7415–7607
  • Kernel WireGuard4513 4358–4533
Two VMs on one host, one TCP stream, Mbit/s, median with min–max. With threads = vCPUs Quantum carried 1.79 and 1.35 times wireguard-go, and it tied at one thread on 4 vCPUs. It carried more than the kernel module at both sizes, 1.6 times at 2 vCPUs with 2 threads (1.4 times at one thread). The kernel module carried less at 4 vCPUs than at 2 here and in the OpenVPN run; we have not found why.
Show the data
GroupSeriesValue, Mbit/sRange
2 vCPUs eachQuantum, 1 thread76387503–7739
2 vCPUs eachQuantum, threads = vCPUs88228623–9084
2 vCPUs eachwireguard-go49294599–5095
2 vCPUs eachKernel WireGuard54024917–5588
4 vCPUs eachQuantum, 1 thread75537521–7593
4 vCPUs eachQuantum, threads = vCPUs100308934–10182
4 vCPUs eachwireguard-go74387415–7607
4 vCPUs eachKernel WireGuard45134358–4533

Over 2.5 GbE

  • Quantum, 1 thread
  • Quantum, threads = vCPUs
  • wireguard-go
  • Kernel WireGuard
  • No tunnel: 2272

4 vCPUs eachMbit/sTie

  • Quantum, 1 thread2164 2149–2167
  • Quantum, threads = vCPUs2166 2165–2167
  • wireguard-go2170 2162–2172
  • Kernel WireGuard2168 2155–2171
Two 4-vCPU VMs on two hosts over a 2.5 GbE link, one TCP stream, Mbit/s, median with min–max. With no tunnel the link carried 2272. All three reached about 95 percent of the link: a tie, so there is no ordering.
Show the data
GroupSeriesValue, Mbit/sRange
4 vCPUs eachQuantum, 1 thread21642149–2167
4 vCPUs eachQuantum, threads = vCPUs21662165–2167
4 vCPUs eachwireguard-go21702162–2172
4 vCPUs eachKernel WireGuard21682155–2171

How much CPU did each gigabit cost?

wireguard-go spent more CPU per gigabit than Quantum in all 12 measurements, but our 2.5-times target was met in only 2 of them.

CPU per gigabit
CPU per gigabit is the busy CPU time of both VMs per gigabit delivered, minus the same figure with no tunnel. "wireguard-go spent 2 times Quantum's" means wireguard-go's figure divided by Quantum's. Our target was 2.5 times, scored in one setting per measurement: Quantum at one thread or at as many threads as vCPUs, whichever used less CPU while carrying at least wireguard-go's traffic.

Target: 2.5 times

One TCP streamOne VM, 1 vCPU: 1.75, below the targetOne VM, 2 vCPUs: 2.10, below the targetOne VM, 4 vCPUs: 2.04, below the targetOver 2.5 GbE: 1.72, below the targetTwo VMs, 2 vCPUs: 1.97, below the targetTwo VMs, 4 vCPUs: 2.02, below the target
Four TCP streamsOne VM, 1 vCPU: 2.12, below the targetOne VM, 2 vCPUs: 2.63, worst run 2.61, meets the targetOne VM, 4 vCPUs: 2.38, below the targetOver 2.5 GbE: 2.22, below the targetTwo VMs, 2 vCPUs: 2.37, below the targetTwo VMs, 4 vCPUs: 2.57, worst run 2.44, meets the target
How many times Quantum's CPU per gigabit wireguard-go spent, in each of the 12 measurements. The 2.5-times target was met twice, both with four streams (worst runs 2.61 and 2.44), never on one stream. More threads cost up to 22 percent more CPU per gigabit than one thread.
Show the data
GroupMeasurementValue, timesNote
One TCP streamOne VM, 1 vCPU1.75
One TCP streamOne VM, 2 vCPUs2.10
One TCP streamOne VM, 4 vCPUs2.04
One TCP streamOver 2.5 GbE1.72
One TCP streamTwo VMs, 2 vCPUs1.97
One TCP streamTwo VMs, 4 vCPUs2.02
Four TCP streamsOne VM, 1 vCPU2.12
Four TCP streamsOne VM, 2 vCPUs2.63worst run 2.61
Four TCP streamsOne VM, 4 vCPUs2.38
Four TCP streamsOver 2.5 GbE2.22
Four TCP streamsTwo VMs, 2 vCPUs2.37
Four TCP streamsTwo VMs, 4 vCPUs2.57worst run 2.44
  • Quantum, 1 thread
  • Quantum, threads = vCPUs
  • wireguard-go

2 vCPUs eachcycles per byteWe ledLower is better

  • Quantum, 1 thread13.1
  • Quantum, threads = vCPUs12.7
  • wireguard-go22.8

4 vCPUs eachcycles per byteWe ledLower is better

  • Quantum, 1 thread13.8
  • Quantum, threads = vCPUs15.0
  • wireguard-go25.5
CPU cycles per delivered byte, two VMs on one host, counted host-wide (iperf3 and the kernel network stack included).
Show the data
GroupSeriesValue, cycles per byteRange
2 vCPUs eachQuantum, 1 thread13.1
2 vCPUs eachQuantum, threads = vCPUs12.7
2 vCPUs eachwireguard-go22.8
4 vCPUs eachQuantum, 1 thread13.8
4 vCPUs eachQuantum, threads = vCPUs15.0
4 vCPUs eachwireguard-go25.5

How much memory did each tunnel use?

Quantum's process peaked at 5.5 to 6.8 MB between VMs, against 116 to 434 MB for wireguard-go; on one VM boringtun was smaller than Quantum.

Between VMs, single-stream window

  • Quantum5.5 to 6.8 MB
  • boringtun7.1 to 7.4 MB
  • wireguard-go116 to 434 MB

One VM, whole run

  • Quantum5.6 to 7.0 MB
  • boringtun4.2 to 4.6 MB
  • wireguard-go1070 to 1409 MB

Each square’s area is proportional to its value.

Peak resident memory of each tunnel process, MB, drawn at the top of each range. Between VMs it is the single-stream window; on one VM, a whole run.
Show the data
GroupSeriesValue, MB
Between VMs, single-stream windowQuantum6.8 (5.5 to 6.8 MB)
Between VMs, single-stream windowboringtun7.4 (7.1 to 7.4 MB)
Between VMs, single-stream windowwireguard-go434 (116 to 434 MB)
One VM, whole runQuantum7.0 (5.6 to 7.0 MB)
One VM, whole runboringtun4.6 (4.2 to 4.6 MB)
One VM, whole runwireguard-go1409 (1070 to 1409 MB)

What happened to latency under load?

This is where we lost: ping p99 under one stream between two VMs on one host was 4.72 and 4.74 ms for Quantum at one thread (2 and 4 vCPUs), against 2.27 and 3.12 for the kernel module, 1.83 and 1.61 for boringtun and 10.0 and 6.28 for wireguard-go. Each was measured at its own throughput.

  • Quantum, 1 thread
  • Kernel WireGuard
  • boringtun
  • wireguard-go

2 vCPUs eachmsWe lostLower is better

  • Quantum, 1 thread4.72
  • Kernel WireGuard2.27
  • boringtun1.83
  • wireguard-go10.0

4 vCPUs eachmsWe lostLower is better

  • Quantum, 1 thread4.74
  • Kernel WireGuard3.12
  • boringtun1.61
  • wireguard-go6.28
Ping p99 under one TCP stream, two VMs on one host, ms, with Quantum at one thread.
Show the data
GroupSeriesValue, msRange
2 vCPUs eachQuantum, 1 thread4.72
2 vCPUs eachKernel WireGuard2.27
2 vCPUs eachboringtun1.83
2 vCPUs eachwireguard-go10.0
4 vCPUs eachQuantum, 1 thread4.74
4 vCPUs eachKernel WireGuard3.12
4 vCPUs eachboringtun1.61
4 vCPUs eachwireguard-go6.28

What else did this run show?

  • boringtun: with one vCPU and one thread each it carried 3422 Mbit/s against Quantum's 10717. Its other figures in this run fell with more threads (2168 at 2, 1847 at 4) and between VMs (712 to 761), which we have not explained, so we use only that cell.
  • Many peers: with 16 peers on one endpoint, Quantum at 4 threads shared traffic less evenly than wireguard-go and dropped frames wireguard-go did not. We publish no figure from that run.
  • Against our previous build, same run: 2.2 to 3.1 times the single-stream traffic on one VM and between two VMs on one host, no retransmissions where it had 35000 to 42000 per window, and 14 to 25 percent less CPU per gigabit at one thread; but ping p99 under load rose from about 0.4 ms to 3.3 ms (the old build dropped packets instead of queueing them), CPU per gigabit rose 6.6 percent on one stream over 2.5 GbE, and memory at one thread is 0.7 to 0.9 MB higher.

OpenVPN run, 2026-10-30

Quantum carried 2.5 and 2.8 times OpenVPN with DCO and 16 and 14 times userspace OpenVPN, at about 1.7 to 1.8 times fewer cycles per byte than DCO. OpenVPN won on latency, in both modes. Figures from this run are never compared with the main run's, and say nothing about OpenVPN 2.6. For the two protocols side by side, see WireGuard vs OpenVPN.

How this run was measured
Date
2026-10-30, a separate run on the same machines
Machines
Two VMs of 2 or 4 vCPUs on one host (AMD Ryzen 7 8845HS), and two 4-vCPU VMs on two other hosts over 2.5 GbE
OpenVPN
OpenVPN 2.7.0 over UDP with AES-256-GCM, in userspace and with the Linux 7.0 kernel’s own DCO driver
Beside it
Quantum (--threads equal to the vCPU count), wireguard-go and kernel WireGuard
Load
One TCP stream for 15 s, median of 5 runs
Threads
OpenVPN moves one stream through one process or one kernel path, so it got no extra threads: this is each tunnel as it runs, not a matched-cores test
  • Quantum, threads = vCPUs
  • wireguard-go
  • Kernel WireGuard
  • OpenVPN with DCO
  • Userspace OpenVPN

2 vCPUs eachMbit/s

  • Quantum, threads = vCPUs9449 9162–9679
  • wireguard-go5034 4976–5135
  • Kernel WireGuard5544 5031–5556
  • OpenVPN with DCO3754 3173–3776
  • Userspace OpenVPN588 586–589

4 vCPUs eachMbit/s

  • Quantum, threads = vCPUs10203 9259–10485
  • wireguard-go7535 7418–7696
  • Kernel WireGuard4618 4379–4630
  • OpenVPN with DCO3622 3475–3721
  • Userspace OpenVPN740 577–753
OpenVPN run, two VMs on one host, one TCP stream, Mbit/s, median with min–max. Quantum ran with threads equal to the vCPU count.
Show the data
GroupSeriesValue, Mbit/sRange
2 vCPUs eachQuantum, threads = vCPUs94499162–9679
2 vCPUs eachwireguard-go50344976–5135
2 vCPUs eachKernel WireGuard55445031–5556
2 vCPUs eachOpenVPN with DCO37543173–3776
2 vCPUs eachUserspace OpenVPN588586–589
4 vCPUs eachQuantum, threads = vCPUs102039259–10485
4 vCPUs eachwireguard-go75357418–7696
4 vCPUs eachKernel WireGuard46184379–4630
4 vCPUs eachOpenVPN with DCO36223475–3721
4 vCPUs eachUserspace OpenVPN740577–753
  • Quantum, threads = vCPUs
  • OpenVPN with DCO
  • Userspace OpenVPN

CPU cycles per byte, 2 vCPUscycles per byteWe ledLower is better

  • Quantum, threads = vCPUs12.7
  • OpenVPN with DCO22.6
  • Userspace OpenVPN154

CPU cycles per byte, 4 vCPUscycles per byteWe ledLower is better

  • Quantum, threads = vCPUs14.2
  • OpenVPN with DCO23.6
  • Userspace OpenVPN155

Ping p99 under load, 2 vCPUsmsWe lostLower is better

  • Quantum, threads = vCPUs5.52
  • OpenVPN with DCO1.43

Ping p99 under load, 4 vCPUsmsWe lostLower is better

  • Quantum, threads = vCPUs3.92
  • OpenVPN with DCO1.85

Each group has its own scale.

OpenVPN run, two VMs on one host: CPU cycles per byte and ping p99 under load.
Show the data
GroupSeriesValueRange
CPU cycles per byte, 2 vCPUsQuantum, threads = vCPUs12.7 cycles per byte
CPU cycles per byte, 2 vCPUsOpenVPN with DCO22.6 cycles per byte
CPU cycles per byte, 2 vCPUsUserspace OpenVPN154 cycles per byte
CPU cycles per byte, 4 vCPUsQuantum, threads = vCPUs14.2 cycles per byte
CPU cycles per byte, 4 vCPUsOpenVPN with DCO23.6 cycles per byte
CPU cycles per byte, 4 vCPUsUserspace OpenVPN155 cycles per byte
Ping p99 under load, 2 vCPUsQuantum, threads = vCPUs5.52 ms
Ping p99 under load, 2 vCPUsOpenVPN with DCO1.43 ms
Ping p99 under load, 4 vCPUsQuantum, threads = vCPUs3.92 ms
Ping p99 under load, 4 vCPUsOpenVPN with DCO1.85 ms
  • OpenVPN with DCO
  • Quantum, threads = vCPUs
  • Kernel WireGuard
  • wireguard-go

4 vCPUs eachCPU seconds per gigabitWe lostLower is better

  • OpenVPN with DCO0.48
  • Quantum, threads = vCPUs0.67
  • Kernel WireGuard0.82
  • wireguard-go0.97
OpenVPN run over 2.5 GbE between two other hosts: host CPU seconds per gigabit (whole host, no-tunnel baseline not subtracted). Every tunnel but userspace OpenVPN reached the link, so there is no throughput ordering; userspace OpenVPN carried 892 Mbit/s there.
Show the data
GroupSeriesValue, CPU seconds per gigabitRange
4 vCPUs eachOpenVPN with DCO0.48
4 vCPUs eachQuantum, threads = vCPUs0.67
4 vCPUs eachKernel WireGuard0.82
4 vCPUs eachwireguard-go0.97

Over 2.5 GbE, OpenVPN with DCO used the least host CPU per gigabit of any tunnel. Memory: Quantum 6.5 to 6.8 MB, OpenVPN 9.6 to 9.9 MB in both modes.

Two MikroTik routers, 2026-09-01

Over a real gigabit LAN, our core carried 122 Mbit/s against 66.8 Mbit/s for the router's own tunnel, at 0.53 against 1.10 percent of CPU per Mbit/s, and lost on round-trip time.

  • ForestVPN core
  • RouterOS’s own tunnel

ThroughputMbit/sWe ledHigher is better

  • ForestVPN core122
  • RouterOS’s own tunnel66.8

CPU per Mbit/spercentWe ledLower is better

  • ForestVPN core0.53
  • RouterOS’s own tunnel1.10

Share of its own no-tunnel ceilingpercentWe ledHigher is better

  • ForestVPN core65
  • RouterOS’s own tunnel30

Round-trip timemsWe lostLower is better

  • ForestVPN core1.22
  • RouterOS’s own tunnel0.92

Each group has its own scale.

Two MikroTik routers, 2026-09-01. The two sides used different traffic generators because no single one runs on both, so each is also shown against its own no-tunnel ceiling.
Show the data
GroupSeriesValueRange
ThroughputForestVPN core122 Mbit/s
ThroughputRouterOS’s own tunnel66.8 Mbit/s
CPU per Mbit/sForestVPN core0.53 percent
CPU per Mbit/sRouterOS’s own tunnel1.10 percent
Share of its own no-tunnel ceilingForestVPN core65 percent
Share of its own no-tunnel ceilingRouterOS’s own tunnel30 percent
Round-trip timeForestVPN core1.22 ms
Round-trip timeRouterOS’s own tunnel0.92 ms

Round-trip time was 1.22 ms for our core against 0.92 ms for the kernel tunnel, because our path pays a container network hop and a scheduling turn that an in-kernel path does not. The method is in the throughput post.

The earlier build

The two runs below measured the build before the 2026-10-30 changes, on Scaleway servers, and are kept as dated history. Their losses were real for that build; no figure in them is compared with the virtual-machine figures above.

Linux run, 2026-10-16

Where we lost. On dedicated servers Quantum was not the fastest. On x86 dedicated, kernel WireGuard carried 5200 Mbit/s, wireguard-go 4858 and OpenVPN with DCO 3602, against Quantum's 1707. On arm64 dedicated they carried 2560, 2239 and 1411 against 766. That is about three times Quantum for the two WireGuard implementations and about twice for OpenVPN DCO, with Quantum at one thread. With more threads (2026-10-17, next section) the gap to the two WireGuard implementations narrowed to about 2 to 2.4 times, and no further.

How this run was measured
Date
2026-10-16
Machines
Two Scaleway instances of one type on a private network. x86 dedicated is COMPUTE3-X8C-16G (AMD EPYC 9555P, 8 vCPU); arm64 dedicated is STANDARD2-A16C-64G (Ampere Neoverse-N1, 16 vCPU)
System
Ubuntu 24.04.5, kernel 6.8.0-142
Load
iperf3 3.16, one TCP stream for 20 s, median of 5 runs (3 for boringtun on arm64), with min-max
Quantum
fv run at its default single data-plane thread with its optional quantum-resistant key option off
Beside it
boringtun 0.7.0 pinned to one thread (its default is four); wireguard-go, kernel WireGuard and OpenVPN 2.6.19 at their defaults. OpenVPN uses AES-256-GCM, the WireGuard family uses ChaCha20-Poly1305
What this run does not cover

This is the fv run Linux daemon on servers, not the phone or desktop apps. The raw runs and harness are in our tree, which is not public, so the dataset is described here rather than linked.

  • Kernel WireGuard
  • wireguard-go
  • OpenVPN with DCO
  • Quantum, 1 thread
  • boringtun, 1 thread
  • Userspace OpenVPN

x86 dedicatedMbit/sWe lost

  • Kernel WireGuard5200
  • wireguard-go4858
  • OpenVPN with DCO3602
  • Quantum, 1 thread1707 1642–1739
  • boringtun, 1 thread1138 1108–1309
  • Userspace OpenVPN803

arm64 dedicatedMbit/sWe lost

  • Kernel WireGuard2560
  • wireguard-go2239
  • OpenVPN with DCO1411
  • Quantum, 1 thread766 758–838
  • boringtun, 1 thread549 529–646
  • Userspace OpenVPN288
Dedicated servers, 2026-10-16, one TCP stream, Mbit/s, with Quantum and boringtun at one thread; min–max where recorded, and boringtun’s arm64 cell is 3 runs.
Show the data
GroupSeriesValue, Mbit/sRange
x86 dedicatedKernel WireGuard5200
x86 dedicatedwireguard-go4858
x86 dedicatedOpenVPN with DCO3602
x86 dedicatedQuantum, 1 thread17071642–1739
x86 dedicatedboringtun, 1 thread11381108–1309
x86 dedicatedUserspace OpenVPN803
arm64 dedicatedKernel WireGuard2560
arm64 dedicatedwireguard-go2239
arm64 dedicatedOpenVPN with DCO1411
arm64 dedicatedQuantum, 1 thread766758–838
arm64 dedicatedboringtun, 1 thread549529–646
arm64 dedicatedUserspace OpenVPN288
Every figure from the 2026-10-16 run
Dedicated servers, 2026-10-16x86arm64
Quantum throughput, Mbit/s1707 (1642-1739)766 (758-838)
boringtun throughput, both at one thread, Mbit/s1138 (1108-1309)549 (529-646, n=3)
Quantum, userspace OpenVPN, Mbit/s1707 against 803766 against 288
CPU cycles per delivered byte, Quantum / boringtun / wireguard-go16.4 / 35.0 / 36.039.7 / 78.8 / 68.1
Ping p99 under one TCP stream, Quantum / boringtun, ms0.69 / 1.042.03 / 2.68
Header mask, Mbit/s (without / with)1707 / 1651766 / 761
Kernel WireGuard / OpenVPN DCO / userspace OpenVPN, Mbit/s5200 / 3602 / 8032560 / 1411 / 288
  • Throughput against boringtun, both at one thread: 1.5x on x86 dedicated and 1.4x on arm64 dedicated. boringtun ships with four threads; the matched-thread comparison is in the next section.
  • CPU per byte (whole host, both ends, one stream): about half of boringtun's on both platforms, and lower than wireguard-go's. The ranges do not overlap. It is not a comparison with the kernel module, which carried about three times the traffic at one thread. OpenVPN DCO used fewer cycles per byte than Quantum on arm64 (32.3 against 39.7) and tied on x86 (17.9 against 16.4, ranges overlap).
  • Memory under load, at one thread: Quantum's tunnel process peaked at 2.1-2.5 MB resident on all four platforms, boringtun at 5.2-5.4 MB, userspace OpenVPN at 7.9-8.8 MB and wireguard-go at 83-290 MB, reaching 162-503 MB by the end of a run. No ranges overlap. Kernel WireGuard and OpenVPN DCO have no comparable process.
  • Latency under load was lower than boringtun's while Quantum also carried more traffic. We make no latency claim against the kernel module, wireguard-go or OpenVPN, because each tunnel was measured at its own throughput.
  • The header mask costs no measurable throughput (inside run-to-run spread both times) and 3-7 percent more CPU cycles per byte (17.6 against 16.4, 41.1 against 39.7).
  • Handshake: the first reply through the tunnel came 3 ms after bring-up on x86 dedicated and 9 ms on arm64 dedicated, with that option off. The other WireGuard-family tunnels took 2-9 ms on the same machines.

Linux thread sweep, 2026-10-17

More threads helped, then stopped. On x86 the best count was 4, 21 percent above one thread, and 2, 4 and 8 are within 1.3 percent of each other. On arm64 the best was 8, 42 percent above one thread; 4, 8 and 16 are within 2 percent, and 2 threads was slower than 1. The arm64 one- and two-thread cells are wide, so read those medians loosely.

How this run was measured
Date
2026-10-17
Machines
A second pair of instances of the same two dedicated types, same OS, kernel and tool versions
Quantum
fv run --threads N (its default is 1), with its optional quantum-resistant key option off
Beside it
boringtun 0.7.0 at its default of four threads; wireguard-go and kernel WireGuard at their defaults, which use every core
Load
One TCP stream for 20 s, median of 5 runs with min-max
CPU cycles
perf stat -a on both hosts, so they include iperf3 and the kernel network stack
What this run does not cover

There is no OpenVPN in this run. Setting --threads is a choice on the Linux daemon, not its default, and the phone and desktop apps were not measured.

x86 dedicatedMbit/s

  • 1 thread1776 1754–1811
  • 2 threads2126
  • 4 threads2147 2123–2173
  • 8 threads2120
  • 16 threadsnot run

arm64 dedicatedMbit/s

  • 1 thread800 745–887
  • 2 threads719 689–810
  • 4 threads1118
  • 8 threads1139 1114–1158
  • 16 threads1135
Quantum throughput by --threads, one TCP stream, Mbit/s, 2026-10-17; min–max where recorded.
Show the data
GroupSeriesValue, Mbit/sRange
x86 dedicated1 thread17761754–1811
x86 dedicated2 threads2126
x86 dedicated4 threads21472123–2173
x86 dedicated8 threads2120
x86 dedicated16 threadsnot run
arm64 dedicated1 thread800745–887
arm64 dedicated2 threads719689–810
arm64 dedicated4 threads1118
arm64 dedicated8 threads11391114–1158
arm64 dedicated16 threads1135
  • Quantum, best thread count
  • Kernel WireGuard
  • wireguard-go

x86 dedicatedMbit/sWe lost

  • Quantum, 4 threads2147 2123–2173
  • Kernel WireGuard5092 5009–5098
  • wireguard-go4183 4075–4436

arm64 dedicatedMbit/sWe lost

  • Quantum, 8 threads1139 1114–1158
  • Kernel WireGuard2658 2534–2725
  • wireguard-go2129 2074–2155
At Quantum’s best thread count (4 on x86, 8 on arm64), one TCP stream, Mbit/s, median with min–max.
Show the data
GroupSeriesValue, Mbit/sRange
x86 dedicatedQuantum, 4 threads21472123–2173
x86 dedicatedKernel WireGuard50925009–5098
x86 dedicatedwireguard-go41834075–4436
arm64 dedicatedQuantum, 8 threads11391114–1158
arm64 dedicatedKernel WireGuard26582534–2725
arm64 dedicatedwireguard-go21292074–2155

Kernel WireGuard carried about 2.4 times Quantum on x86 and about 2.3 times on arm64; wireguard-go about 2 times and about 1.9 times. With four TCP streams the gap to wireguard-go was wider: 1987 against 5181 Mbit/s on x86, 997 against 2248 on arm64. On x86 the kernel figure is at the link's limit, so its lead is at least this large.

boringtun, CPU, memory and what limits it, 2026-10-17
  • Against boringtun, both at four threads, x86 dedicated only: Quantum carried 2147 Mbit/s (2123-2173) against 1317 (1295-1363), 1.6 times, and the ranges do not overlap. It used 19.5 against 66.5 CPU cycles per delivered byte, its ping p99 under that load was 0.61 against 1.17 ms, and its process peaked at 3.7 against 5.8 MB resident. Four threads is boringtun's default and Quantum's best on that platform. We publish no arm64 figure for boringtun at four threads: the cell has one valid run. We did not measure boringtun at other thread counts, so this is not a comparison at its best.
  • CPU per byte against wireguard-go, at Quantum's best thread count: 19.5 (19.3-19.7) against 40.2 (39.7-41.1) on x86 dedicated and 37.6 (36.5-38.4) against 74.4 (74.0-74.6) on arm64 dedicated. About half, and the ranges do not overlap. wireguard-go also carried about twice the traffic, so this is cost per byte moved, not speed.
  • Memory at that thread count: Quantum's tunnel process peaked at 3.7 MB on x86 (4 threads) and 4.9 MB on arm64 (8 threads). In the same single-stream window wireguard-go peaked at 227-292 MB (x86) and 223-228 MB (arm64), and reached up to 499 and 468 MB by the end of a run. Quantum's memory rises about 0.4 MB per extra thread: 2.5 MB at one thread to 5.3 MB at 8 on x86, and 8.2 MB at 16 on arm64.
  • What limits it: throughput stopped rising after 2 to 4 threads, while at its best thread count Quantum's process used about half a core per host on x86 and under three quarters of one on arm64, on 8- and 16-vCPU machines. So the limit is not the number of cores or threads. We have not found it yet.

The 2026-10-16 and 2026-10-17 runs used different instance pairs and different builds of fv, so we compare within a run and never across them. The raw runs are in our tree, which is not public.

We also ran two 2-vCPU shared types. We publish no throughput or ranking from them: the plain, no-tunnel run sits at the instance's bandwidth cap, and on the arm64 shared type one stream through a userspace tunnel read higher than the plain run, which we have not explained.

Encryption and security

Both use the same handshake and, for the handshake, the same primitives: Curve25519, ChaCha20 with Poly1305, BLAKE2s and HKDF. We have not changed the handshake. That matters because the formal analyses of WireGuard cover that protocol and not variants of it, so keeping it unmodified keeps those results about our handshake too.

A proof about a protocol is not a proof about an implementation. No independent verification of our code is published, and we do not claim one. The name of our protocol, Quantum, does not mean it resists quantum computers. Post-quantum key exchange (ML-KEM-1024, mixed into the handshake's existing pre-shared-key slot, so the handshake messages stay unmodified) is built and running on a test server, and it rolls out across our servers as they are upgraded. We will say "post-quantum" without qualification once every server has it.

Sign-in and accounts

WireGuard has no accounts. You generate a key pair per device, exchange public keys, and keep the configuration yourself. ForestVPN has an account number instead of an email and a password; the number is what a subscription attaches to, and how it works is on its own page.

Setup and platforms

WireGuard's official clients cover the platforms in the matrix above, and running it as a service means you set up the server, its firewall and its addresses. ForestVPN's apps connect with no configuration; the exits are run for you. If you want a tunnel to a machine you own, WireGuard is the more direct tool; if you want an exit you did not have to build, that is what ForestVPN sells. What running your own server takes, step by step, is in self-hosted WireGuard vs a VPN service.

Cost

You pay for the machine you run the other end on. ForestVPN's Free plan has no card and no expiry, and Premium is priced on the pricing page.

Where WireGuard is better

  • You can read and run all of it. Its code and its design papers are public; ours are not. If your threat model needs a tunnel with no service operator in the middle, you want WireGuard.
  • Its protocol has published formal verification by several independent groups [3]. We have none for our implementation.
  • The kernel path has lower latency on a router, 0.92 ms against our 1.22 ms in the measurement above.
  • Latency under load on Linux. Between two VMs on one host (2026-10-30), the kernel module's ping p99 under one TCP stream was 2.27 ms at 2 vCPUs and 3.12 at 4, against our 4.72 and 4.74 at one thread (details). On the earlier build (2026-10-16 and 2026-10-17) the kernel module and wireguard-go also carried two to three times our throughput on dedicated servers (details).
  • More platforms are supported by the official clients: FreeBSD and OpenBSD are on its install page [1], and are not on ours.
  • You choose the exit. With WireGuard you pick the machine and the country; ForestVPN's public locations are ones we run.

The bottom line

Pick WireGuard if

  • you want the protocol itself and are ready to run both ends
  • you want a tunnel to a machine you own
  • your threat model needs a tunnel with no service operator in the middle
  • you want to pick the machine and the country of the exit
  • you need an official client on FreeBSD or OpenBSD

Pick ForestVPN if

  • you want a working tunnel without building the other end
  • you want a status you can read and a fallback when the direct path is blocked
  • you want apps for iPhone, iPad, Mac, Apple TV, Android, Android TV, Windows and Linux that connect with no configuration
  • you want exits that are run for you

If what you want is the protocol, run it. If what you want is a working tunnel, with a status you can read and a fallback when the direct path is blocked, without building the other end, that is the product. On the routers our core moved more traffic for less CPU and lost on latency. On our Linux virtual machines (2026-10-30), with as many threads as vCPUs, it carried 1.3 to 2.7 times wireguard-go's single-stream traffic where the link was not the limit, and tied at a 2.5 Gbit/s link; in its cheaper setting (mostly one thread) it used less CPU per gigabit than wireguard-go, but short of our 2.5-times target in 10 of 12 measurements, and lost on latency under load to the kernel module; we publish all of it.

Questions people ask about ForestVPN and WireGuard

Does ForestVPN use WireGuard?

It uses WireGuard’s handshake, Noise_IKpsk2, unmodified, inside Quantum, ForestVPN’s own tunnel engine, which adds roaming, MTU handling and fallback transports around it. WireGuard itself is a protocol and open-source software you run at both ends; ForestVPN is a service with apps, and the exits it talks to are ours.

Does ForestVPN carry more traffic than WireGuard?

It depends on the implementation and the setup. On Linux virtual machines on 2026-10-30, Quantum with as many threads as vCPUs carried 1.33 to 2.67 times wireguard-go’s single-stream traffic on one VM; at one thread on 4 vCPUs it carried 0.94 times. Over a 2.5 GbE link it tied with wireguard-go and kernel WireGuard.

Does ForestVPN use less memory than wireguard-go?

In the 2026-10-30 runs, Quantum’s process peaked at 5.5 to 6.8 MB between virtual machines in the single-stream window, against 116 to 434 MB for wireguard-go. On one VM over a whole run Quantum peaked at 5.6 to 7.0 MB and boringtun at 4.2 to 4.6 MB, smaller than Quantum.

Where does WireGuard do better?

Kernel WireGuard had lower latency under load: ping p99 of 2.27 ms against Quantum’s 4.72 between two 2-vCPU VMs, and a 0.92 ms round trip against 1.22 ms on two MikroTik routers. WireGuard’s code and design papers are public, its protocol has published formal verification, and you choose the exit machine.

Do these figures describe the ForestVPN apps?

No. The Linux figures measure the fv run daemon built from our source on 2026-10-30 on x86_64 virtual machines, and no published release contained those changes on that date. No phone, tablet, Mac, Windows PC or router was measured in that run; the router figures come from two MikroTik routers on 2026-09-01.

Sources

  1. WireGuard installation, read 2026-10-08.
  2. WireGuard protocol and cryptography, read 2026-10-08.
  3. WireGuard formal verification, read 2026-10-08.
  4. Throughput per CPU cycle, our measurements of 2026-09-01, with the 2026-10-30 virtual-machine runs described above and the earlier-build 2026-10-16 and 2026-10-17 runs below them.

Corrections

No corrections so far. 2026-11-07: the page was restructured into charts, with every table one click away; no figure changed, and the wording now says virtual machines. 2026-10-30: added the virtual-machine and OpenVPN runs of that date; the 2026-10-16 and 2026-10-17 runs are kept as the earlier build. If something on this page about WireGuard is wrong, write to support@fvpn.net with the source and we will check it within three working days and fix it or reply with ours.

All comparisons

Back to top

Ask us anything