Tailscale's Speed Boost: Zero-Copy, Multi-Queue & Caching in Go Network Optimization

Tailscale, founded by former Go core team members and built almost entirely in Go, published a blog post "We're making Tailscale faster" outlining four data-plane optimizations shipping in v1.104 and later.

Optimization 1: Zero-Copy Small Packet Handling

Most packets are ~1 KiB, but Linux's Generic Receive Offload (GRO) requires 64 KiB buffers. wireguard-go previously allocated a full 64 KiB buffer per packet, wasting space and copying. On Linux and Android, Tailscale now records each packet's offset/length within a shared 64 KiB buffer, letting multiple small packets coexist. This yields ~5% speedup across all Linux/Android devices and frees memory for heavy nodes like subnet routers.

Optimization 2: Multi-Queue Pipeline for Subnet Routers & App Connectors

Subnet routers, app connectors, and exit nodes previously funneled all connections through a single ordered single-threaded pipeline (Reader → 4 Crypto stages → Writer) to preserve per-flow packet order. This serialized throughput regardless of CPU cores. The new multi-queue system dynamically scales lanes to match machine resources, assigning each flow to a fixed lane. Parallel Reader-Crypto-Writer pipelines now run concurrently, merging at the device layer. Result: higher aggregate throughput, lower latency, better CPU utilization, especially for nodes serving many short-lived connections.

This means lower latency, fundamentally because processing from the moment a packet is read off the NIC to when it's handed to the OS becomes faster. — Alex Valiushko

Optimization 3: writev Vectorized System Calls

On Linux, Tailscale now uses writev to pass multiple disjoint memory buffers to the kernel in one syscall, avoiding user-space copy/concatenation. The kernel gathers the vectors, reducing memory copies, syscall count, and boosting throughput — a classic high-performance networking pattern now applied to Tailscale's data path.

Optimization 4: Netmap Caching for Lightning Fast Warm Starts

Devices normally fetch a netmap (network map) from the control plane on startup (~100 ms). In poor networks (airplane Wi-Fi, strict firewalls) this can stall. With netmap caching, each device persists the last known netmap to disk. On restart, it uses the cached map to establish peer connections immediately while asynchronously refreshing from the control plane. Connections are still negotiated directly peer-to-peer; Tailscale sees no traffic.

Constraints: requires at least one prior successful control-plane fetch, persistent disk space, and may increase writes for huge tailnets or wear-sensitive storage (SD cards).

Poor network conditions are exactly where netmap caching shines. The client says: we haven't reached the control plane yet, but we probably will soon; meanwhile you can already start doing things. — Claus Lensbøl

In tailnets with poor control-plane reachability, warm starts (using cache) make the data plane ready 10-100x faster than cold starts.

Rollout Timeline

Buffer optimization (memory reduction) : Linux / Android — target v1.104 client

Multi-queue (subnet routers, app connectors) : Linux / Android — target post v1.104

Throughput gains (incl. writev) : Linux / Android — partial in spring 2026, full post v1.104

Netmap caching : Desktop (flag-gated now); Mobile — v1.104 default (desktop); post v1.104 (mobile)

Next: Native Observability & Testing Tools

Tailscale acknowledges existing tools lack distributed testing ease, rigid workflows, QUIC/HTTP/3 support, and Tailscale-native awareness (DERP vs direct vs Peer Relay paths). They are building custom monitoring/testing tooling and soliciting user input.

Takeaway

These optimizations are classic systems engineering: reduce memory copies, parallelize bottlenecks, vectorize syscalls, cache for latency. The lesson for Go infrastructure teams: apply fundamental principles rigorously to each concrete scenario rather than chasing novelty.

Tailscale blog: We're making Tailscale faster https://tailscale.com/blog/making-tailscale-faster

Increasing TCP throughput on Linux https://tailscale.com/blog/throughput-improvements

Surpassing 10Gb/s on bare metal with wireguard-go https://tailscale.com/blog/more-throughput

4x UDP/QUIC throughput via segmentation offload https://tailscale.com/blog/quic-udp-throughput

Tailscale Peer Relays (Beta) https://tailscale.com/blog/peer-relays-beta

Peer Relays for international networks https://tailscale.com/blog/peer-relays-international-networks

NAT Traversal series: Looking ahead https://tailscale.com/blog/nat-traversal-improvements-pt3-looking-ahead

Performance testing tool survey https://tailscale.typeform.com/performance