Quick Answer: To speed up inflight Wi-Fi on geostationary (GEO) flights, route traffic through a persistent non-443 TCP tunnel to a ground server near the satellite downlink. This skips the cabin's :443 proxy and removes repeated satellite round-trips during setup. The open-source satmux project reports 2–5× faster page loads on Inmarsat GX links.
Most people blame the bandwidth when inflight Wi-Fi feels broken. Pages stall, GitHub times out, and a simple npm install hangs for minutes. The bandwidth is often fine. The problem is what happens before any payload moves. Here's what's actually going wrong, and what you can do about it on your next flight.
Why Inflight Wi-Fi Breaks Before Bandwidth Runs Out
Non-Starlink inflight Wi-Fi tends to fail for three reasons unrelated to raw speed. The satmux README lists them clearly:
- Onboard :443 middleboxes and DNS interception. Cabin gateways intercept DNS on port 53 and run a transparent :443 split-TCP proxy, often called a PEP (performance-enhancing proxy). Its state table drops connections under load, which shows up as
Connection reset by peeror TLS timeouts ongithub.comand package registries. - Handshake round-trips. Each new origin normally needs DNS, TCP, and TLS exchanges across the satellite before a single byte of content arrives.
- Congestion collapse. Packet loss on cabin Wi-Fi makes standard Cubic TCP halve its congestion window again and again. Your per-seat allowance goes unused.
Most guides only address the third point, usually by suggesting a faster VPN. That misses the first two, which are the ones that actually break sessions.
The Physics You Can't Engineer Away
Here's the constraint that no tool changes. A geostationary satellite sits about 35,786 km above the equator. A signal travelling up to it and back down to a ground station covers roughly 72,000 km per leg. At the speed of light, that's about 240 ms one way, so a single bent-pipe round trip takes roughly 480 ms before any queuing or processing.
Real links add more. The satmux team measured about 620 ms RTT on an Inmarsat GX Ka-band link through a SITA ground station in Amsterdam, and they put the practical floor at 580–650 ms per hop. Any tool that promises sub-100 ms latency from a GEO seat is selling you something.
So the goal isn't to beat physics. It's to stop paying the satellite toll more often than necessary. Every extra handshake costs you a full hop, and that's where most of the waste lives.
How satmux Routes Around the Cabin Proxy
satmux is a pure Python 3 standard-library project with zero external dependencies. It runs as two pieces: a client on your laptop and a server on a small Linux VM near the ground station. Its main components are:
- A persistent carrier pool on port 8444. The client keeps 12 pre-warmed TCP connections open to the ground VM. Because this traffic uses a non-443 port, it passes the cabin proxy untouched.
- Local 0-RTT stream open. SOCKS5 on
127.0.0.1:1080or HTTP CONNECT on127.0.0.1:8080answers locally in under a millisecond. The client sends the open frame and the TLS ClientHello in the same burst, so your end-to-end TLS session with the origin still begins without waiting a satellite RTT. - A 1-RTT ground fetch on port 8081. For requests that can be handled on the ground, the VM performs DNS, verified TLS 1.3, and redirects over fiber (roughly 2–5 ms). It then compresses plaintext responses with
zlibbefore they cross the satellite link. - BBR with a 1280-byte MSS. Ground-to-cabin sockets use
TCP_CONGESTION=bbrandTCP_MAXSEG=1280.
Streams are scheduled onto whichever carrier has the lowest recent byte load. That matters because an idle browser keepalive shouldn't queue behind a large download.
The Benchmark, Read Carefully
The README reports a 6-origin parallel burst on the same flight link. Raw cabin Wi-Fi took 19.13 seconds with 3 of 6 requests failing. The satmux path took 5.35 seconds with 0 failures, a 3.6× improvement and a 76% reduction in time to first byte.
| Origin | Raw cabin Wi-Fi | satmux (1-RTT BBR + zlib) | Speedup |
|---|---|---|---|
| GitHub Repo | Timeout | 4.66 s | Fixed (previously failing) |
| MDN Docs | 12.01 s | 2.30 s | 5.2× |
| PyPI JSON API | 7.09 s | 2.64 s | 2.7× |
| Cloudflare | 2.97 s | 1.40 s | 2.1× |
Two things stand out. The largest gains come on origins that the cabin proxy was breaking, not on origins that were merely slow. And the Cloudflare result is the smallest gain, which fits the mechanism: if an origin was already fast, fewer handshakes buy you less.
That said, this is one author's measurements on one route, with one ground-station setup. Your numbers will vary with the airline, aircraft, and time of day.
Where BBR and Compression Help, and Where They Don't
BBR (Bottleneck Bandwidth and Round-trip propagation time) estimates the link's delivery rate and minimum RTT rather than treating packet loss as a signal to back off. On a lossy cabin link, that's why it outperforms Cubic here. Cubic reads each dropped packet as congestion and shrinks its window, which is exactly the collapse the satmux README describes.
The trade-off is fairness. BBR can take more than its share when it shares a bottleneck with loss-based flows. On a single seat's allocation, that's a minor concern. On a congested shared link, it isn't.
Compression is the other lever, and it's uneven. HTML, JSON, source code, and API responses compress well with zlib, so their effective throughput can exceed the seat's shaper rate. Already-compressed files such as .mp4 and .zip gain nothing. Those stay bounded by the cabin's roughly 4–5 Mbps per-seat cap. Parallel range downloads with satmux-get help them approach that ceiling, but they won't exceed it.
Here's the counter-intuitive part. Opening more parallel TCP connections on the raw cabin link usually makes things worse, because each one re-pays the handshake cost and feeds the PEP's state table. satmux works because it opens a small, fixed set of connections once and reuses them.
The Trust Trade-Off You're Accepting
Before you route anything through a server you rent, understand what it can see. On the SOCKS5 and HTTP CONNECT paths, TLS runs end to end from your laptop to the origin, so the ground VM only relays encrypted bytes. On the 1-RTT ground-fetch path, the VM performs the TLS handshake with the origin itself, which means it sees the decrypted response before compressing and forwarding it.
satmux authenticates its tunnel with a pre-shared key, using a BLAKE2b-512 keystream and HMAC-SHA256. That protects the tunnel from tampering, but it doesn't change the fact that the ground VM is a trusted hop on the fetch path. Use it for traffic you'd be comfortable sending through any VPS, and avoid sending banking sessions or credentials over the 1-RTT path. Also check your airline's terms of use. satmux does not bypass captive portals, and it works only within the paid session you already have.
How to Set It Up Without Losing Your Afternoon
You'll need a small Linux VM close to the satellite downlink, an open TCP port 8444, and Python 3.9 or later. Check your egress country and ASN from the cabin network first with curl ipinfo.io. Then follow these steps:
- Generate a pre-shared key on your laptop. Run
openssl rand -hex 32 > mux.pskand set its permissions withchmod 600 mux.psk. - Start the server on the ground VM. Copy
satmux.pyand the key over, then launchsatmux.py server --port 8444withSATMUX_PSKset from the key file. - Start the client and enable routing. Run
satmux.py client --host <SERVER_IP> --port 8444 --carriers 12, then./bin/satmux-macos on <SERVER_IP>to set the macOS Wi-Fi proxy andgitandghrouting. - Pause UDP VPNs. Turn off Tailscale or WireGuard during the flight. Blocked UDP retries compete for the same limited airtime.
- Benchmark before you rely on it. Run
./bin/satmux-benchand compare the results with your raw connection.
When you land, run ./bin/satmux-macos off to restore your Wi-Fi proxy settings, ~/.gitconfig, the gh socket configuration, and your launchctl environment variables. Then destroy the VM. Leaving it running costs little, but it's still a server holding your key.
Frequently Asked Questions
What is satmux and how does it speed up inflight wifi?
satmux is an open-source TCP multiplexer that keeps 12 warm connections on port 8444 between your laptop and a ground VM. It bypasses the cabin's :443 proxy and avoids repeated satellite handshakes. The project reports 2–5× faster loads on Inmarsat GX links, measured on a single route.
How do I fix github timeouts on airplane wifi?
GitHub timeouts on airplane Wi-Fi are often caused by the cabin's :443 proxy dropping connections under load. Routing git and gh through a non-443 tunnel, such as satmux on port 8444, avoids that proxy. Pausing UDP VPNs during the flight also reduces competing retry traffic.
Why is airplane wifi so slow even with good bandwidth?
Geostationary satellites add a round trip of about 580–650 ms per hop, and each new connection pays that cost several times for DNS, TCP, and TLS. Packet loss also makes standard TCP shrink its window repeatedly. Bandwidth is usually not the bottleneck, which is why reducing handshakes helps more than buying a faster plan.
Is it safe to route inflight traffic through a ground VM?
It depends on the path. Over SOCKS5 or HTTP CONNECT, TLS runs end to end and the VM only relays encrypted data. On the 1-RTT fetch path, the VM terminates TLS to the origin and can see plaintext. Avoid sending sensitive logins over that path.
Speeding up inflight Wi-Fi comes down to cutting the satellite round trips you don't need, not chasing more bandwidth. Try a single flight with ./bin/satmux-bench before and after you turn it on, and note the GitHub and package-registry results. Pass this to anyone who keeps losing git push mid-flight.