v1.8.0Local HTTPS. Timed tunnels. Better diagnostics.

Localhost.
Meet the world.

Great things start locally.
They don’t have to stay there.

Expose your local services through a single Go binary.
Open-source tunnels. Your infrastructure. Your rules.

Open your first tunnel Explore the source

100% GoZero dependenciesMIT licensed

THE RIFT

⌘YOUR MACHINElocalhost:3000

HELLO, WORLDmyapp.example.com

HTTP 200 OKTCP WebSocket

FIG. 01 ONE CONNECTION. EVERY POSSIBILITY.↗

your next great idea — terminalCONNECTED

$wirerift http 3000 myapp --server tunnel.example.com:4443 --token YOUR_TOKEN

HTTP tunnel established

https://myapp.tunnel.example.comhttp://localhost:3000

Web apps, previews & webhook endpointsIllustrative output · use your own server

SMALL BY DESIGN.
OPEN BY DEFAULT.

Single binarySelf-hostedYour domainsAutomatic reconnectPure Go

THE SHORTEST PATH TO OUT THERE

Your machine.
A world of connections.

No port forwarding on your router.
No moving your app somewhere else.

Follow the connection

01 / LOCAL

Your app

Right where you build it.

localhost:3000

outbound→

02 / CONNECT

WireRift client

One lightweight binary.

multiplexed streams

one connection→

03 / ROUTE

Your server

Your infrastructure. Your rules.

HTTP · TCP · WebSocket

public edge→

04 / SHARE

The world

One URL. Open possibilities.

your domain, connected

Authentication at the connection. Access control at the edge.ONE CONNECTION. MULTIPLE STREAMS.

LESS INFRASTRUCTURE. MORE BUILDING.

Everything you need.
Nothing in your way.

From a quick demo to your own tunnel infrastructure.
The good parts are already in the binary.

01 / BUILT IN

HTTP ↗TCP ↗WS ↗

Any port. New possibilities.

HTTP apps, raw TCP services and WebSocket connections. Give your local world a public address.

Explore tunnels

02 / BUILT IN

ACCESS GRANTED

Your edge. Your rules.

Self-host your server. Add TLS, Basic Auth, IP allowlists and PIN protection. Decide who gets through.

See access controls

03 / BUILT IN

One wire. Many streams.

A purpose-built binary protocol with stream multiplexing and flow control. Less connection overhead. More possibility.

Under the hood

Local HTTPS. Zero public DNS.Loopback development with a scoped local CA.Try --dev

Share it. Set its lifetime.Server-enforced expiry for HTTP, TCP and files.Add --ttl 30m

Find the broken step.DNS, TCP, TLS and login checks with fix hints.Run doctor

LESS GUESSWORK. MORE CONTEXT.

Every request.
A little less mystery.

Inspect headers and bodies. Replay a webhook.
Debug the real conversation, right from your dashboard.

Meet your traffic inspector

Traffic inspector INTERACTIVE DEMOlocalhost:4040

REQUESTS3

Listening for your next idea.

200 OK24 ms

application/json

{
  "event": "payment.completed",
  "data": {
    "id": "pay_demo_01",
    "amount": 4900,
    "currency": "USD",
    "status": "succeeded"
  }
}

Sample traffic · nothing is sent from your browser

Click a request. Inspect its response. Try a replay.Real features. Illustrative traffic.

YOUR NEXT IDEA IS ALREADY WAITING

From “it works here”
to “try this link.”

A client. A server. A connection.
Everything else is what you make of it.

Pick up a binary.

Download for your platform. No runtime, no package circus.

Bring your own server.

Run WireRift on your infrastructure, set your domain, and choose a token.

Set up your server

Open a rift.

Point the client at your server. Your localhost has a public address.

Take the full quick start

curl -fLo wirerift https://github.com/WireRift/WireRift/releases/latest/download/wirerift-darwin-arm64
chmod +x wirerift
sudo mv wirerift /usr/local/bin/

Then, connect to your server:

wirerift http 3000 myapp \
  --server tunnel.example.com:4443 \
  --token YOUR_TOKEN

Need another architecture? Find your binary

BUILD HERE. GO ANYWHERE.

Make room for
your next great thing.

A small tool for all the moments
localhost needs a little more reach.

01PREVIEWS & DEMOS

Show the work.

Share a local preview with your team or a client. Keep iterating while they explore.

02WEBHOOK DEVELOPMENT

Catch the callback.

Receive webhooks from external services on your development machine. Inspect, fix, replay.

03RAW TCP CONNECTIONS

Beyond the browser.

Connect to a database, game server or another TCP service through your own public edge.

04STATIC FILE SHARING

Share what you built.

Serve a static folder directly through a tunnel. A quick path from build output to a public URL.

A FEW THINGS, UNTANGLED

Good questions.
Clear answers.

The code is open.
So is the conversation.

Ask us on GitHub

01What exactly is WireRift?

An open-source tunnel server and client written in Go. It makes a service on your local machine reachable through a server you operate. Think web previews, webhook development, TCP services and file sharing.

02Do I need to run my own server?

Yes. WireRift is designed for self-hosting. For public tunnels, run the server on a reachable machine and configure your domain. For local-only development, v1.8.0 adds a loopback HTTPS mode with .localhost domains and a local CA. The URLs on this website are illustrative examples.

03Is it really zero dependencies?

The WireRift client and server use the Go standard library, with no third-party Go packages. Prebuilt binaries do not require a Go installation. This website is a separate Next.js project.

04Can I use my own domain and HTTPS?

Yes. Configure your tunnel domain and DNS, then enable ACME for public certificates. Self-signed certificates are also supported. Control-plane TLS is configured separately from the public HTTPS edge.

05Can I use it in commercial projects?

Yes. WireRift is MIT licensed. You can use, modify and distribute it, including commercially, subject to the license terms.

SMALL BINARY. BIG POSSIBILITIES.

There’s a whole world
outside localhost.

Open a rift. See where it takes you.

Let’s make a connection Star on GitHub

Pure Go. Zero dependencies. Entirely yours.

Localhost.Meet the world.

Your machine.A world of connections.