Key Takeaways
- Platform hooks decide the work. IKEv2 runs natively on iOS, macOS, Windows, and Android 11+, while WireGuard and OpenVPN need your own tunnel code.
- Apple caps tunnel memory. A packet tunnel extension on recent iOS versions runs under a 50 MiB ceiling.
- Licenses differ sharply. WireGuard client libraries ship under MIT and Apache 2.0, while the OpenVPN 3 core is AGPLv3.
- WireGuard needs a control plane. Key distribution and address assignment are out of scope for the protocol itself.
- FIPS buyers need AES suites. WireGuard primitives are not FIPS-approved, so regulated deployments lean on IKEv2 or OpenVPN.
- Ship a default plus a fallback. WireGuard as the default, with OpenVPN over TCP 443 for blocked networks, covers most products.
Most protocol guides answer one question: which VPN feels fastest on a laptop. Engineering teams building an embedded VPN product face a harder one. WireGuard vs OpenVPN vs IKEv2 is a choice about where the tunnel runs and what code ships with it. It also decides which licenses and audits come with your product.
However, these choices are hard to undo after launch. In 2024, Microsoft researchers disclosed four vulnerabilities in OpenVPN that could be chained together. Three sat in the Windows service around the protocol, and one sat in a network driver. In other words, none of them were in the cryptography itself. The lesson for embedded products is direct. The code that hosts a protocol on a device carries as much risk as the protocol does.
This guide compares the three protocols from an integration view. It covers platform hooks, licensing, identity models, roaming, and compliance limits.
Why Consumer Comparisons Miss the Embedded Question
Consumer reviews rank protocols by speed, streaming, and battery life. Those metrics matter, but they assume someone else already solved integration. In contrast, an embedded product team has to solve integration itself.
Four questions decide the protocol stack for an embedded product:
- Platform hooks: Whether the operating system runs the protocol natively, or your code must host it.
- License terms: Whether the client library can ship inside closed-source firmware or apps.
- Control plane: Which system issues keys, addresses, and credentials to each device.
- Compliance scope: Whether a regulated buyer will accept the cipher suite.
The rest of this guide works through each question for all three protocols.
WireGuard vs OpenVPN vs IKEv2 at a Glance
The table below summarizes how each protocol behaves inside an embedded product. Each row is covered in detail later in the post.
| Factor | WireGuard | OpenVPN | IKEv2/IPsec |
|---|---|---|---|
| Transport | UDP only | UDP or TCP | UDP |
| Native OS support | Linux kernel | None built in | iOS, macOS, Windows, Android 11+ |
| Embeddable client license | MIT (Apple), Apache 2.0 (Android) | AGPLv3 core library | Built into the OS |
| Key and address setup | Your control plane | Server pushes config | Server assigns address |
| Network roaming | Built in | Reconnects | Mobility extension |
| FIPS cipher path | No | Yes, with AES suites | Yes, with AES suites |
| Linux kernel data path | Yes | Yes, since Linux 6.16 | Yes |
The table shows no single winner. Instead, each protocol solves a different integration problem well. As a result, most production stacks ship more than one.
Where the Tunnel Runs on Each Platform

The first decision is where the tunnel code runs. The operating system either hosts the protocol for you, or your product must host it. That choice shapes memory limits, review effort, and maintenance.
Apple Devices
On iOS and macOS, IKEv2 runs natively through Apple’s Personal VPN feature. Your app creates a configuration, and the system runs the tunnel. You ship no protocol code at all.
By contrast, WireGuard and OpenVPN work differently on Apple devices. Each needs a packet tunnel extension that your team builds and ships. That extension runs under a strict memory ceiling. Apple engineers report a packet tunnel limit of 50 MiB on recent iOS versions. Apple also notes that these limits have changed before. A lean protocol stays far below that ceiling, while a heavy one leaves little room for your own features.
Android Devices
Android 11 added a built-in platform VPN profile for IKEv2. With it, the operating system runs the tunnel. Your app does not need to stay running in the background.
On the other hand, WireGuard and OpenVPN on Android run inside your app’s own VPN service. Your code owns the tunnel lifecycle, reconnection, and crash recovery. That gives more control, but it also adds more code to maintain.
Linux Firmware, Routers, and Gateways
On Linux-based hardware, by comparison, the kernel matters most. WireGuard lives inside the Linux kernel, so packets never cross into user space. OpenVPN historically ran in user space, which cost throughput on low-power chips. That changed when its data channel offload driver merged in Linux 6.16. Router platforms on newer kernels can now run OpenVPN traffic in kernel space too.
Battery life and keepalive traffic add a further layer on constrained hardware. Our guide on battery and bandwidth covers that math for connected devices.
Licensing: The Question Architects Ask Too Late

In WireGuard vs OpenVPN vs IKEv2, license terms decide if a client library can ship in a closed product. Teams often discover this during a legal review, after the integration work is done.
Each protocol carries a distinct license profile:
- WireGuard: The kernel module is GPLv2. The Apple client library ships under the MIT License. The Android tunnel library ships under Apache 2.0. Both permissive licenses suit closed-source apps.
- OpenVPN: The modern client core library is distributed under AGPLv3 and the Mozilla Public License. The older OpenVPN 2 branch is GPLv2. Copyleft terms can require you to publish source for modified versions.
- IKEv2: When you use the built-in client on iOS, macOS, Windows, or Android, you ship no client library. The license question disappears on those platforms.
Each license carries specific obligations. Route the final decision through your legal team before the architecture freezes. A license problem found after launch costs far more than one found during design.
Identity and Configuration: What Each Protocol Leaves to You
Every embedded VPN needs a way to give each device credentials, keys, and a tunnel address. Each of the three protocols splits that work in its own way.
WireGuard Needs a Control Plane
WireGuard keeps its core small by design. Its own documentation states that key distribution and pushed configurations are out of scope. Each peer is defined by a public key and a list of allowed tunnel addresses.
For example, a product with thousands of devices needs a system to generate keys and assign addresses. Someone must also rotate keys and revoke lost devices. That control plane is real software with its own uptime and security needs.
OpenVPN and IKEv2 Carry More Session Logic
OpenVPN servers push configuration to clients after authentication. That includes routes, DNS settings, and tunnel addresses. IKEv2 servers assign a virtual address during the key exchange. Both protocols support username-and-password or certificate authentication.
As a result, OpenVPN and IKEv2 are easier to plug into existing account systems. The tradeoff is a larger protocol surface on both ends of the tunnel.
Roaming, Network Changes, and Restrictive Networks
Mobility is where WireGuard vs OpenVPN vs IKEv2 differ most in daily use. Embedded products rarely sit on one stable network. Phones switch between Wi-Fi and cellular, and vehicles move between towers. Each protocol handles those changes in its own way.
Handling Network Switches
IKEv2 handles address changes through a mobility extension standardized in 2006. A mobile client can keep its tunnel alive while moving from one address to another. WireGuard supports full IP roaming on both ends as part of its core design. OpenVPN has no matching mobility standard. Client apps handle network changes with their own reconnect logic.
Crossing Restrictive Networks
Transport choice also matters on hotel, campus, and corporate networks. WireGuard runs over UDP only. IKEv2 also depends on UDP ports that some networks block. OpenVPN can run over TCP on port 443, so its traffic looks like regular web traffic. For products sold into restrictive markets, that fallback keeps users connected when other protocols fail.
Compliance Constraints: FIPS and Patch Surface
Beyond technical fit, regulated buyers add a separate filter. Government agencies, healthcare providers, and financial firms often require FIPS-validated cryptography.
WireGuard uses one fixed cipher suite, built on ChaCha20, Poly1305, Curve25519, and BLAKE2s. None of those primitives are FIPS-approved. Red Hat engineers proposed disabling the WireGuard kernel module entirely in FIPS mode for that reason. IKEv2 and OpenVPN can both run AES suites on a crypto library operating in FIPS mode.
However, patch surface is a second compliance factor. A fixed cipher suite removes downgrade risk and shrinks the code to audit. A configurable protocol needs careful defaults on every device. The Microsoft findings above show that host services and drivers need patching too. Our post on patch ownership explains who carries that duty in a partner model. For a refresher on cipher terms, see these encryption basics.
A Decision Framework for Engineering Teams

The right answer to WireGuard vs OpenVPN vs IKEv2 depends on the product, not the protocol. Match the default protocol to the device class and buyer, then add a fallback.
Use these defaults as a starting point:
- Mobile apps on iOS and Android: Start with WireGuard for speed and a small memory footprint. Add IKEv2 when you want the operating system to own the tunnel.
- Desktop apps on Windows and macOS: WireGuard as the default, with OpenVPN over TCP for blocked networks.
- Routers, gateways, and Linux firmware: WireGuard in the kernel, plus a control plane for keys and addresses.
- Regulated or government buyers: IKEv2 or OpenVPN with AES suites inside a validated crypto module.
- Users in restrictive regions: OpenVPN over TCP on port 443 as the fallback path.
Integration style also shapes the choice. An SDK or API path changes who hosts the protocol on each device. Decide that early, because it fixes which of the platform hooks above apply.
Testing a WireGuard vs OpenVPN vs IKEv2 Stack Before Launch
A protocol choice on paper still needs proof on real hardware. Each test below targets one of the integration risks covered earlier. Run them on your lowest-spec supported device, not your newest one.
Memory and Lifecycle Tests
Start with the limits the operating system enforces:
- Memory ceiling: Profile the packet tunnel extension on iOS under sustained traffic. Watch how close it runs to the 50 MiB limit.
- Background survival: Lock the phone for an hour, then send traffic. Confirm the tunnel is still up without user action.
- Crash recovery: Kill the tunnel process on purpose. Measure how long traffic leaks or stalls before recovery.
Network and Compliance Tests
Next, test the conditions your users will meet in the field:
- Network switch: Move a device from Wi-Fi to cellular mid-download. Record whether the session survives or drops.
- Blocked transport: Block UDP on a test network. Confirm the fallback protocol connects within your timeout.
- FIPS mode: Boot a test system with FIPS mode enabled. Verify that only approved cipher suites negotiate.
- License scan: Run a software bill of materials check on the final build. Confirm no copyleft code entered by accident.
Teams that run these tests before launch catch platform limits while fixes are still cheap.
What the Evidence Shows
Two published partner integrations show how protocol hosting plays out in real products. Both are self-reported vendor case studies, not independent audits.
First, a router manufacturer embedded VPN protection directly into its Wi-Fi hardware through APIs. The integration covered devices with no native VPN app, such as smart TVs and gaming consoles. Each router protects up to 15 connected devices at once. The router case study estimates an in-house build would have taken about a year. The same integration reports 9x ARPU growth and over 110,000 monthly active users.
In contrast, a large eSIM platform took the opposite path. It used iOS and Android SDKs, so VPN activation happens inside its own app. The eSIM integration provisions the tunnel automatically during eSIM setup. Users never see a separate VPN configuration step.
One product hosts the tunnel in firmware, and the other hosts it in an app SDK. In both cases, the WireGuard vs OpenVPN vs IKEv2 decision followed the device class.
How PureWL Supports All Three Protocols
PureWL gives engineering teams all three protocols without building each stack in-house. The API documentation lists IPsec, IKEv2, OpenVPN, and WireGuard for tunnel creation. Native VPN SDKs cover iOS, Android, Windows, and macOS. The API path covers routers and other hardware.
PureWL runs the server network on a no-log network certified by KPMG. Partners keep the brand, the customer relationship, and the billing. Teams weighing vendors can compare SDK providers side by side on platforms, limits, and protocol support.
Conclusion
WireGuard vs OpenVPN vs IKEv2 is not a speed contest for embedded products. It is a set of integration decisions. Platform hooks decide where the tunnel runs. Licenses decide what code you can ship. The control plane decides how devices get their keys. Compliance scope decides which buyers you can serve. Most teams end up with WireGuard as the default and a second protocol as the fallback. Settle these questions at the design stage, before the first device ships.
Request API sandbox access for a 20-minute integration walkthrough.


