Downloads
Grab the latest build from the Releases page:
| Platform |
Download |
| Windows (x64) |
kite-windows-amd64.exe |
| Linux (x64) |
kite-linux-amd64 |
| macOS (Apple Silicon) |
kite-macos-arm64 |
Every platform ships as a single portable executable — no installer, no admin rights
required (the macOS build is the raw binary pulled out of the .app bundle Wails produces;
see Known gaps for the Gatekeeper prompt this means, and how to
get past it). Once installed, it checks for new releases on startup and can update itself
in one click.
Features
- Link formats:
vmess://, vless://, trojan://, ss:// — paste a share link and it's parsed and saved
- Subscription URLs — paste an
http(s):// subscription link (the base64 link-list format used by V2RayN/V2RayNG/Shadowrocket) and every server it contains is imported at once, folded into one collapsible group in the list (subscriptions can carry hundreds of servers). The group shows plan/traffic/expiry info when the provider reports it (via the Subscription-Userinfo header, or the fake "info" entries some providers mix into the link list), and has its own sync button to re-fetch and refresh its servers
- sing-box, embedded as a Go library (not a shelled-out binary) — full lifecycle control, no parsing stdout for stats
- Transports: TCP, WebSocket, and gRPC, with TLS/REALITY security detection straight from the link
- System proxy integration — Connect/Disconnect toggles the OS HTTP proxy automatically (per-user registry on Windows, no elevation needed)
- TUN mode (Windows) — routes all system traffic through a virtual network adapter (WinTun, bundled), instead of just apps that honor a proxy setting. Needs administrator privileges; Kite can relaunch itself elevated with one click
- Kill switch (Windows) — blocks all outbound traffic except Kite's own while connected, via a Windows Firewall rule pair, so an app that ignores the system proxy (or a crashed xray process) can't leak traffic outside the tunnel. Same admin requirement as TUN mode
- System tray — closing the window hides it to the tray instead of quitting, so an active connection keeps running; the tray menu has Show Kite, Disconnect, and Quit Kite
- Built-in diagnostics — a Test button makes a real request through the tunnel and reports the actual result; a log viewer surfaces sing-box's own debug log inline
- Self-updating — checks GitHub Releases on launch, one click downloads, swaps, and relaunches (About panel shows both Kite's and the embedded sing-box's version)
- Dark / light themes, with a searchable server list, inline rename, and one-click remove
- 7 languages — English (default), 中文, فارسی, Türkçe, العربية, Français, Deutsch, switchable from the sidebar (Persian uses the bundled Vazirmatn font)
Building from source
- Go 1.27+ — https://go.dev/dl/. Windows also needs a C compiler for CGO
(Wails and some of its dependencies use it) — install
TDM-GCC or
winget install -e --id GoLang.Go
plus MSYS2's mingw-w64-x86_64-gcc.
- Node.js (LTS) — https://nodejs.org, or
winget install OpenJS.NodeJS.LTS.
- Wails CLI:
go install github.com/wailsapp/wails/v2/cmd/wails@latest
wails doctor # confirms platform dependencies (WebView2 etc.) are present
Run it
go mod tidy # resolves dependencies into go.sum
cd frontend && npm install && cd ..
wails dev # generates frontend/wailsjs/*, hot-reloading dev build
Build a release binary
wails build -tags webkit2_41 # Linux only needs the webkit2_41 tag; omit on Windows
Architecture
kite/
├── main.go / app.go Wails entrypoint + the App struct (Go methods
│ exposed to the frontend via the JS bridge)
├── internal/
│ ├── xray/ sing-box lifecycle (package/dir keeps the
│ │ │ historical name from when it wrapped
│ │ │ xray-core -- see CHANGELOG)
│ │ ├── manager.go Start/Stop/Restart a real box.Box
│ │ ├── config.go Server profile -> sing-box JSON config,
│ │ │ decoded via sing-box's own registry-aware
│ │ │ JSON decoder (see include.Context)
│ │ ├── stats.go Traffic counters (stub, see below)
│ │ └── tun_windows.go Writes the embedded wintun.dll next to the
│ │ exe (TUN mode needs it alongside the binary)
│ ├── profile/ vmess/vless/trojan/ss link parsing +
│ │ JSON-file server storage
│ ├── system/ per-OS HTTP/SOCKS system proxy toggling +
│ │ │ TUN-mode support (Windows)
│ │ ├── proxy_windows.go HKCU Internet Settings (no admin needed)
│ │ ├── proxy_darwin.go networksetup
│ │ ├── proxy_linux.go gsettings (GNOME)
│ │ ├── elevate_windows.go Check/request administrator privileges
│ │ ├── route_windows.go Exception route so xray's own upstream
│ │ │ connection doesn't loop through the TUN
│ │ │ adapter it's feeding (see that file's docs)
│ │ └── wintun/ Embedded Wintun driver DLL (dual GPLv2/MIT,
│ │ see WINTUN_LICENSE.txt in that directory)
│ └── update/ self-update: check GitHub Releases, download
│ + swap the running executable, relaunch
├── frontend/ Vite + React + Tailwind (CSS-variable theming
│ for dark/light), talks to app.go via Wails
└── .github/workflows/ CI: builds + publishes GitHub Releases on
release.yml any pushed `v*` tag
Every bound Go method on App (in app.go) becomes a callable JS function in
the frontend once wails dev/wails build generates frontend/wailsjs/go/main/App.js.
Known gaps / next steps
- No
type=tcp&headerType=http links — sing-box (which Kite switched to from
xray-core) has no equivalent of that raw-TCP-disguised-as-HTTP transport; its
transports are ws/http/grpc/httpupgrade/quic only. A share link relying on that
specific obfuscation won't connect. Everything else Kite supported under xray-core
(tcp, ws, grpc, tls, REALITY) still works.
- Live traffic stats are a stub again — the "Show more" panel's numbers always read
0B/s after the sing-box migration. xray-core exposed a stats manager with per-outbound
counters directly; sing-box only tracks traffic when its
experimental.clash_api (or
v2ray_api) is enabled, via trafficcontrol.Manager — wiring that up is a follow-up.
- macOS is Apple Silicon (arm64) only — no Intel build. If that's needed, add a
darwin/amd64 matrix entry in .github/workflows/release.yml alongside the
darwin/arm64 one.
- TUN mode is Windows-only and IPv4-only for now — the exception route that keeps
the engine's own upstream connection from looping through the TUN adapter
(
internal/system/route_windows.go) only covers resolved IPv4 addresses; a server
that's only reachable over IPv6 won't work in TUN mode yet. Linux/macOS TUN support is
possible (sing-box's own tun package already supports both) but isn't wired up here.
- Linux system proxy only covers GNOME (
gsettings) — other desktop environments
need their own backend in internal/system/proxy_linux.go.
- Kill switch is Windows-only — implemented via
netsh advfirewall rules
(internal/system/killswitch_windows.go); Linux/macOS need their own backend
(iptables/pfctl) and are unimplemented for now (the toggle is hidden there,
same as TUN mode).
- The native minimize button still just minimizes to the taskbar — Wails v2 doesn't
expose a hook for the OS-level minimize event, only window close (
OnBeforeClose,
which the tray feature uses). Only closing the window hides it to the tray.
- No automated tests yet.
- No code-signing — Windows SmartScreen and macOS Gatekeeper will both warn on an
unsigned binary; this is expected for now. On macOS, running the downloaded binary the
first time needs
xattr -d com.apple.quarantine kite-macos-arm64 (or right-click →
Open) to get past Gatekeeper, since it isn't notarized. On Windows, antivirus software
(including Defender) sometimes quarantines wintun.dll right after Kite writes it next
to itself for TUN mode, since a kernel-adjacent networking DLL like this gets flagged
heuristically — the same thing WireGuard, v2rayN, and other Wintun-based apps run into.
If TUN mode fails with a file-not-found-style error, add Kite's folder to your
antivirus's exclusions.
Contributing
Issues and PRs welcome. See Known gaps above for what's
actually left to do.
License
MIT