The drop-in, open-source Go alternative to ngrok.
Start instantly on free public relays with zero config and zero signups, or graduate to your own self-hosted relay on a $5 VPS in a single <10MB binary. Zero lock-in.
Install via Homebrew:
brew install kernelshard/tap/exposeTunnel your local server (e.g. port 3000):
expose tunnel 3000When you run an app on http://localhost:3000, only your laptop can access it. Expose creates a temporary public HTTPS URL that connects directly to your local server:
- πͺ Webhook Testing: Give Stripe, GitHub, or Twilio a live HTTPS URL to test webhook callbacks locally.
- π± Mobile & Device Testing: Open your local website on a physical smartphone or tablet over 4G/5G.
- π₯ Instant Previews: Send a live demo link to a friend or client without deploying to cloud servers.
- π Private Self-Hosting: Route traffic through your own private VPS instead of commercial SaaS relays.
| Feature | π Expose | ngrok | Cloudflare Tunnel | LocalTunnel (Node) |
|---|---|---|---|---|
| Zero Signup Required | β Instant | β Mandatory account | β Mandatory account | β Instant |
| Single Static Binary | β (<10MB) | β (~30MB) | β (~50MB) | β (requires Node.js) |
| Open Source | β Apache 2.0 | β Proprietary | β Apache 2.0 | β MIT |
| Self-Hostable Relay | β
expose server |
β SaaS only | β Cloudflare network | |
| Language & Runtime | Pure Go (zero CGO) | Go / C | Go daemon | Node.js (V8 heap) |
| Free Custom Domains | π‘ Partial (Self-Hosted) | π² Paid plan | β Cloudflare DNS | β Not supported |
| Memorable Subdomains | β
Auto-assigned (swift-falcon-4821) |
β Random hex (free tier) | β Random hex |
Expose your local development server in seconds without creating an account:
# Public relay (default)
expose tunnel 3000
# Or via Cloudflare Quick Tunnels
expose tunnel 3000 --provider=cloudflareWant permanent custom subdomains, full privacy, and zero rate limits? Run your private relay on any $5 VPS:
# 1. On your VPS (Turnkey Docker + Caddy Auto-TLS)
git clone https://github.com/kernelshard/expose.git && cd expose/deploy
cp .env.example .env && docker compose up -d
# 2. On your laptop
expose tunnel 3000 --server=tunnel.yourdomain.com:7890 --subdomain=apibrew install kernelshard/tap/exposecurl -fsSL https://raw.githubusercontent.com/kernelshard/expose/main/install.sh | shPin a specific version or install to a custom path:
# Pin version
VERSION=v0.6.4 curl -fsSL https://raw.githubusercontent.com/kernelshard/expose/main/install.sh | sh
# Custom directory
BINDIR=~/.local/bin curl -fsSL https://raw.githubusercontent.com/kernelshard/expose/main/install.sh | shDownload the latest pre-compiled binary for your architecture (macOS, Linux, Windows) from the Releases Page.
go install github.com/kernelshard/expose/cmd/expose@latestgit clone https://github.com/kernelshard/expose.git
cd expose
go build -o expose ./cmd/expose
./expose --versionNeed complete privacy, permanent custom subdomains, and zero third-party relay dependence? Run your own private tunnel gateway on any $5 VPS (DigitalOcean, Hetzner, AWS Lightsail).
The fastest path to production with automated TLS termination and edge reverse-proxying:
git clone https://github.com/kernelshard/expose.git
cd expose/deploy
cp .env.example .env
# Set DOMAIN=tunnel.yourdomain.com in .env
docker compose up -dSee deploy/README.md for DNS setup and configuration options.
Run the native compiled binary directly on bare metal:
# Start your private relay server (open by default)
expose server --domain=tunnel.mysite.com --control-port=7890 --public-port=8080
# Or protect with an auth token (recommended for public VPS)
expose server --domain=tunnel.mysite.com --token=mysecret# Standard connection
expose tunnel 3000 --server=tunnel.mysite.com:7890 --subdomain=my-app
# If your server requires an auth token
expose tunnel 3000 --server=tunnel.mysite.com:7890 --token=mysecretSave defaults per project so you can just type expose tunnel:
# Create .expose.yml in current directory
$ expose init
β Config created: .expose.ymlproject: expose
port: 3000Manage and query configuration values:
expose config list
expose config get portexpose/
βββ cmd/expose/ # CLI entry point (Cobra)
βββ internal/
β βββ cli/ # Cobra subcommands & flag parsing
β βββ config/ # YAML config management
β βββ pool/ # sync.Pool 32KB buffer recycling (0 allocs/op)
β βββ provider/ # Tunnel backends (LocalTunnel, Cloudflare, Self-Hosted)
β βββ server/ # Self-hosted relay control plane & TCP proxy
β βββ tunnel/ # Core service orchestration & connection lifecycle
β βββ version/ # Build metadata & version injection
βββ .expose.yml # Local project configuration
[ Public Visitor ]
β 1. Connects to https://demo.tunnel.com
βΌ
[ Expose Relay Server (VPS) ]
βββ 2. Fast L7 Peek: Read initial bytes to extract `Host:` header
βββ 3. Drop to Layer 4: Spliced directly to standby client data socket
β
β (Bidirectional raw TCP stream via sync.Pool 32KB buffers)
βΌ
[ Expose Client (Laptop) ]
βββ 4. Forward raw byte stream to http://localhost:3000
- Layer 4 Raw Socket Splicing: Rather than incurring full HTTP/2 or JSON parsing overhead on every packet, Expose inspects only the initial bytes to extract the
Host:header for subdomain routing. Once matched, it immediately drops down to raw bidirectional Layer 4 TCP streaming (io.CopyBuffer). - Zero-Allocation Buffer Recycling (
sync.Pool): Recycles 32KB copy buffers using slice pointers (*[]byte) to eliminate Go interface boxing allocations on the heap. - Bounded Concurrency Brakes: The relay server advertises connection limits (
MaxConnections) during handshake; the client bounds worker goroutines and runs proxy forwarding synchronously to prevent 100% CPU dial spin-loops. - Graceful Socket Teardown: Coordinates bidirectional stream termination, guaranteeing both reader and writer sockets close cleanly on
io.EOFwithout leaking goroutines or file descriptors. - Modular Provider Abstraction: Decoupled
Providerinterface cleanly isolates CLI and service lifecycles from underlying network transports (LocalTunnel, Cloudflare, and Self-Hosted relays).
Bidirectional network proxying performance on the self-hosted relay gateway:
| Implementation | Memory Allocations | Heap Churn (B/op) | Throughput Delta |
|---|---|---|---|
| Standard Unpooled Buffers | High GC Pressure | ~34,209 B/op | Baseline |
Expose 32KB sync.Pool |
0 allocs during stream | 1,444 B/op (-95.8%) | +26% Throughput |
Reproduce benchmark locally:
go test -bench=BenchmarkCopy ./internal/pool -benchmem# Run all unit tests with Go race detector
go test ./... -v -race -cover
# Package-specific coverage
go test ./internal/tunnel -cover
go test ./internal/server -cover
go test ./internal/provider -coverContributions are welcome! Please check out CONTRIBUTING.md for branch strategy, test requirements, and code style guidelines.
Distributed under the Apache License 2.0. See LICENSE for details.
Made with β€οΈ by @kernelshard
