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.
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.
- We led 10717 Mbit/s against 4016 for wireguard-go One TCP stream on one Linux VM, 1 vCPU and one thread per side (2026-10-30)
- Tie 2164 Mbit/s against 2170 for wireguard-go, 2168 for the kernel module Over a 2.5 GbE link, where all three reached about 95 percent of the link
- We lost 4.72 ms against 2.27 for the kernel module Ping p99 under one TCP stream, two VMs on one host, 2 vCPUs, one thread
- Mixed 2 of 12 against wireguard-go spent 1.7 to 2.6 times our CPU per gigabit Measurements that met our 2.5-times CPU target, never on one stream
- We led 5.5–6.8 MB against 116 to 434 MB for wireguard-go Tunnel process peak between VMs, single-stream window
- Mixed 122 Mbit/s against 66.8 for RouterOS’s own tunnel Two MikroTik routers (2026-09-01): more traffic for less CPU, but a 1.22 ms round trip against 0.92 ms
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.
| Feature | ForestVPN | WireGuard | Checked |
|---|---|---|---|
| What it is | A VPN service: apps for iPhone, iPad, Mac, Apple TV, Android, Android TV, Windows and Linux, plus a router container | A protocol and open-source software; you run both ends | 2026-10-08 [1] |
| Handshake | Noise_IKpsk2, unmodified | Noise_IKpsk2_25519_ChaChaPoly_BLAKE2s | 2026-10-08 [2] |
| Platforms with an official client | iPhone, iPad, Mac, Apple TV, Android, Android TV, Windows, Linux | Windows, macOS, iOS, Android, Linux, FreeBSD, OpenBSD, OpenWrt | 2026-10-08 [1] |
| Routers | A RouterOS 7 container, live. See the router feature | OpenWrt is on its install page; RouterOS 7 ships its own WireGuard-protocol server, which we measured | 2026-10-08 [1] |
| Price | Free; Premium from $7.99 a month (pricing) | You pay for the server you run it on | 2026-10-08 |
| What is kept | An itemised list on the security page | WireGuard is software: what is logged depends on whoever runs your server | 2026-10-08 |
| Independent audit | None published on this site | The protocol has been formally verified by several groups | 2026-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
- Your device You generate a key pair per device and keep the configuration yourself
- Noise_IKpsk2 handshake
- A server you run You set up the server, its firewall and its addresses, and pick the machine and the country
ForestVPN
- The ForestVPN app Connects with no configuration
- Quantum: the same Noise_IKpsk2 handshake, plus roaming, MTU handling and fallback transports
- A ForestVPN exit Run for you: our public locations are ones we run
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.
- Routers Two MikroTik routers
Over a real gigabit LAN: our core against RouterOS’s own tunnel
- Earlier build Linux servers on Scaleway
The build before the 2026-10-30 changes, at one data-plane thread
- Earlier build Thread sweep on Scaleway
The same build with --threads from 1 to 16
- Current build Linux virtual machines
Throughput, CPU, memory and latency against wireguard-go, kernel WireGuard and boringtun
- 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-gowas met in 2 of 12 measurements (details below). - With 16 peers on one endpoint, Quantum shared traffic less evenly than
wireguard-goand dropped frameswireguard-godid 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.
# threads = vCPUs on a 4-vCPU VM; without --threads, fv run uses one thread
fv run --iface fvpn0 --config fvpn0.conf --threads 4One VM
Two VMs
Over 2.5 GbE
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
Show the data
| Group | Measurement | Value, times | Note |
|---|---|---|---|
| One TCP stream | One VM, 1 vCPU | 1.75 | |
| One TCP stream | One VM, 2 vCPUs | 2.10 | |
| One TCP stream | One VM, 4 vCPUs | 2.04 | |
| One TCP stream | Over 2.5 GbE | 1.72 | |
| One TCP stream | Two VMs, 2 vCPUs | 1.97 | |
| One TCP stream | Two VMs, 4 vCPUs | 2.02 | |
| Four TCP streams | One VM, 1 vCPU | 2.12 | |
| Four TCP streams | One VM, 2 vCPUs | 2.63 | worst run 2.61 |
| Four TCP streams | One VM, 4 vCPUs | 2.38 | |
| Four TCP streams | Over 2.5 GbE | 2.22 | |
| Four TCP streams | Two VMs, 2 vCPUs | 2.37 | |
| Four TCP streams | Two VMs, 4 vCPUs | 2.57 | worst run 2.44 |
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.
Show the data
| Group | Series | Value, MB |
|---|---|---|
| Between VMs, single-stream window | Quantum | 6.8 (5.5 to 6.8 MB) |
| Between VMs, single-stream window | boringtun | 7.4 (7.1 to 7.4 MB) |
| Between VMs, single-stream window | wireguard-go | 434 (116 to 434 MB) |
| One VM, whole run | Quantum | 7.0 (5.6 to 7.0 MB) |
| One VM, whole run | boringtun | 4.6 (4.2 to 4.6 MB) |
| One VM, whole run | wireguard-go | 1409 (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.
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-goand dropped frameswireguard-godid 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
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.
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.
Every figure from the 2026-10-16 run
| Dedicated servers, 2026-10-16 | x86 | arm64 |
|---|---|---|
| Quantum throughput, Mbit/s | 1707 (1642-1739) | 766 (758-838) |
boringtun throughput, both at one thread, Mbit/s | 1138 (1108-1309) | 549 (529-646, n=3) |
| Quantum, userspace OpenVPN, Mbit/s | 1707 against 803 | 766 against 288 |
CPU cycles per delivered byte, Quantum / boringtun / wireguard-go | 16.4 / 35.0 / 36.0 | 39.7 / 78.8 / 68.1 |
Ping p99 under one TCP stream, Quantum / boringtun, ms | 0.69 / 1.04 | 2.03 / 2.68 |
| Header mask, Mbit/s (without / with) | 1707 / 1651 | 766 / 761 |
| Kernel WireGuard / OpenVPN DCO / userspace OpenVPN, Mbit/s | 5200 / 3602 / 803 | 2560 / 1411 / 288 |
- Throughput against
boringtun, both at one thread: 1.5x on x86 dedicated and 1.4x on arm64 dedicated.boringtunships 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,
boringtunat 5.2-5.4 MB, userspace OpenVPN at 7.9-8.8 MB andwireguard-goat 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-goor 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.
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 forboringtunat four threads: the cell has one valid run. We did not measureboringtunat 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-goalso 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-gopeaked 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-goalso 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
- WireGuard installation, read 2026-10-08.
- WireGuard protocol and cryptography, read 2026-10-08.
- WireGuard formal verification, read 2026-10-08.
- 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.