MultiPath

Use Wi-Fi, Ethernet and a USB-tethered phone at the same time, for the whole PC.

A small tray app for Windows, Linux and macOS (Apple silicon), built with Tauri v2 and Rust. Everything runs on your computer: no server, no relay, no account.

The tray popup, combining Wi-Fi and a USB-tethered phone

A download manager with several connections: about half go over Wi-Fi and half over the phone

• Spreads your PC's connections across all your networks, so they all work at once.
• Two 10 Mbps networks give you about 20 Mbps for anything that opens several connections.
• Lives in the tray as a small popup: turn it on, switch networks on or off, see each network's speed.

MultiPath balances connections. One connection always stays on one network, because splitting it would need a server on the internet.

Part	Technology
App shell	Tauri v2
Backend	Rust
Async runtime	Tokio
Traffic capture	Wintun adapter on Windows, /dev/net/tun on Linux, a utun on macOS, via the tun crate
TCP/IP stack	ipstack (userspace)
Packets, sockets	etherparse, socket2, netdev
System APIs	windows-sys, libc with netlink on Linux, and on macOS IP_BOUND_IF plus route/ifconfig/scutil (routes, sockets, elevation)
Frontend	React 19
Language	TypeScript
Build tool	Vite
Icons	Lucide
Tests	Vitest, cargo test
Packaging	NSIS, .deb and AppImage, .app and .dmg (through Tauri)

Think of your networks as checkout counters, and each connection as a customer. MultiPath is the manager at the door.

1. Catch the traffic. MultiPath adds a virtual network adapter called MultiPath. All of the PC's traffic goes through it.

2. Pick a network. For each new connection, MultiPath works out which network would give it the most speed:

   network speed ÷ (connections downloading on it + 1)

   The network with the biggest number gets the connection. Idle connections don't count.

3. Send it out. The connection is made again from that network, pinned to its adapter.

4. Keep checking. Every 5 seconds, each network is checked for internet. A network that fails twice in a row gets no new connections until it works again.

Example: two 10 Mbps networks, and fast.com opens 4 connections:

Both networks end up with half the connections and run flat out: 10 + 10 = 20 Mbps. A faster network gets proportionally more.

• Switching a network off closes its connections. Apps reconnect through the other networks.
• Switching it back on only gets new connections. Downloads already running stay where they are until they finish or reconnect.
• IPv6 is only used on networks where it actually works. Otherwise apps are told to use IPv4 straight away.
• DNS goes to 8.8.8.8, then 1.1.1.1 (some ISPs block 1.1.1.1). You can change this in Settings.
• Turning MultiPath off removes everything it added, so your system goes back to normal.

Everything is on the latest release page.

1. Run MultiPath_<version>_x64-setup.exe.
2. Click the MultiPath icon in the tray and turn it on. Windows asks for administrator permission once.

Debian, Ubuntu, Kali and anything else that uses .deb — the package gives MultiPath the two network permissions it needs, so turning it on never asks for a password:

sudo apt install ./MultiPath_<version>_amd64.deb

Anything else — the AppImage. An AppImage can't hold those permissions, so it needs sudo:

chmod +x MultiPath_<version>_amd64.AppImage
sudo ./MultiPath_<version>_amd64.AppImage

1. Open MultiPath_<version>_aarch64.dmg and drag MultiPath to Applications.
2. The build isn't notarised, so macOS blocks it the first time. Open it once, then go to System Settings → Privacy & Security and click Open Anyway (on macOS 14 and older, right-click MultiPath → Open also works).
3. Click the MultiPath icon in the menu bar and turn it on. macOS asks for an administrator password each time you turn it on: a small helper runs as root just long enough to add the adapter, routes and DNS, then hands the adapter to the app and waits to remove them again. The app itself never runs as root.

USB tethering: an iPhone shows up as iPhone USB once you trust the Mac and turn on Personal Hotspot. Android phones need USB tethering over NCM (most phones since Android 11); RNDIS-only phones don't work on Apple silicon.

Start with Windows / Start on login / Open at login (in Settings) puts MultiPath in the tray when you sign in. On Windows and Linux there's no permission prompt; on macOS the password is asked when it turns on.

On Linux, the tray icon needs a panel that shows app indicators — GNOME needs the AppIndicator extension. Only systemd-resolved systems get MultiPath's own DNS settings; elsewhere the system resolver is used, which works too.

Settings → Updates → Check. If there's a newer version, MultiPath shows what's new and waits for you to click Install and restart. It then downloads the update, checks its signature against the key built into the app, installs it and restarts. A download whose signature doesn't check out is never installed. Check for updates at start (off by default) only looks and tells you; it never installs on its own. Checking asks GitHub for latest.json. Coming from 1.1.0 or older, install 1.2.0 by hand once.

• Windows: the installer runs; MultiPath turns off first and comes back from the tray. Turn it on again (UAC).
• Linux: the .deb asks for your password to install; an AppImage replaces itself if its folder is writable.
• macOS: MultiPath in Applications replaces itself. If it was on, macOS asks for your password again.

You need:

• Rust (stable)
• Node.js 20 or newer
• Tauri prerequisites — WebView2 and MSVC build tools on Windows; libwebkit2gtk-4.1-dev, libgtk-3-dev and libayatana-appindicator3-dev on Linux; the Xcode command line tools on macOS

Run it:

git clone https://github.com/uditya-kumar/MultiPath.git
cd MultiPath
npm install
npm run tauri dev       # opens the app; run it as administrator or root, or accept the permission prompt

Build the packages:

npm run tauri build     # Windows: bundle/nsis/ · Linux: bundle/deb/ and bundle/appimage/ · macOS: bundle/macos/ and bundle/dmg/

On macOS, a build without access to Finder (SSH, an agent) needs CI=true npm run tauri build: that skips the AppleScript that only arranges the .dmg window.

Release: scripts/release.sh "what's new" builds this system's bundles, signs them for the updater with the key at ~/.config/multipath/updater.key, and adds them to release-assets/latest.json. Run it on Windows (Git Bash), Linux and the Mac in turn, carrying release-assets/ along, then attach every file in it to the GitHub release v<version>. It uploads nothing itself.

Check before committing:

npm run lint && npm test && npm run build
cd src-tauri && cargo fmt --check && cargo clippy --all-targets -- -D warnings && cargo test

Project layout:

• One connection always uses one network.
• A full-tunnel VPN takes over the routes while it's connected.
• On macOS, Tailscale and other split-tunnel VPNs keep their own routes and DNS; MultiPath only spreads what's left.
• The macOS build is ad-hoc signed (not notarised) and asks for the administrator password at every turn-on. In-app updates rely on their own signature, not Apple's. A signed, notarised release would use a privileged helper (SMAppService) or a Network Extension instead.
• Some sites sign you out if your requests come from different addresses. Turn on Keep sites on one network for those.

MultiPath is released under the MIT License.

Wintun is © WireGuard LLC. Its license is in src-tauri/resources/wintun-LICENSE.txt.