Primary question: Does a single out-of-band token you fully trust beat a full control plane for the two machines you are connecting?
RepoDaily adoption score
RepoDaily rates this as 88/100 (strong) for adoption: evidence, installation path, production risk, differentiation, license clarity, and AI/agent fit are scored from the article sources and adoption notes.
4 source(s) across 4 source category/categories, plus a RepoDaily-specific evidence module when available.
6 workflow step(s), 4 next-action step(s), and 2 command/install signal(s) were detected.
Trending momentum is +790 stars, with maintenance/release/issue signals counted when present.
Risk is marked medium, with 6 security note(s) and 5 explicit skip condition(s).
3 opportunity lens item(s), 5 alternative(s), and 3 type-specific section(s) support differentiation.
License source or license wording is present.
1 AI/agent-related signal(s) were detected in the article text and metadata.
Project overview
tailcat is a remix of Tailscale open source pieces that behaves like netcat but runs over Tailscale's data plane while skipping the control plane entirely. The README tagline "Tailscale without Tailscale, by Tailscale" is the fastest way to grasp it: magicsock (Tailscale's internal userspace transport) gives point-to-point WireGuard-encrypted tunnels between two machines, with DERP acting as the NAT-hole-punching communication side channel and the relay of last resort when traversal fails. What is deliberately absent is the coordination server - all connection metadata is exchanged out of band, in whatever channel you choose.
Operationally it is a two-party handshake. The tailcat CLI lives in cmd/tailcat and is built on a Go library importable as github.com/tailscale/tailcat (listed on pkg.go.dev). One side runs the server/listener and receives a short connection token; the other side passes that token to the client. Traffic is end-to-end encrypted with WireGuard, bootstraps through a DERP server, and then magicsock attempts NAT traversal to upgrade to a direct peer-to-peer UDP connection "when possible (usually!)", as the README puts it. There is no Tailscale account, no root or admin access required, and no modification of routing tables or DNS - it is a userspace library plus CLI.
The project is BSD 3-Clause (Copyright (c) 2020 Tailscale Inc & contributors), so vendoring it into your own tooling is straightforward. A free rate-limited set of DERP relays ships as the default map at https://tailcat.dev/derpmap.json, or you can run your own relay using cmd/derper from the tailscale/tailscale repository. There is also an experimental in-browser demo at tailscale.github.io/tailcat - tailcat compiled to WebAssembly - that can send and receive files or text and interoperate with the CLI, though browser traffic is DERP-relay-only until WebRTC support lands (issue #4). All of this arrived publicly and immediately picked up 790 stars in the trend window at rank 6.
Why it is trending now
- 790 stars in a single trend window and rank 6 for a brand-new repository under the Tailscale organization.
- The tagline "Tailscale without Tailscale, by Tailscale" - the vendor itself open-sourcing a tool that removes its own coordination product from the picture.
- Zero account and zero root: a userspace Go binary that never touches routing tables or DNS.
- A netcat-shaped interface: token in, pipe out, plus --serve port forwarding and an ssh subcommand.
- An in-browser WebAssembly demo at tailscale.github.io/tailcat that interoperates with the CLI for file and text transfer.
Problem it solves
- Running plain netcat between machines on different networks means exposing TCP to the internet or building a VPN first.
- Full Tailscale solves the encryption but requires an account, a coordination server, and a tailnet to manage.
- One-off tasks - grabbing a log, exposing a dev port for an hour, getting a five-minute shell - rarely justify VPN setup and key distribution.
- NAT and CGNAT make direct machine-to-machine connections unreliable without a relay fallback.
- Embedding encrypted mesh transport into your own Go program previously meant forking Tailscale internals rather than importing a library.
How it works
- Install on both machines: go install github.com/tailscale/tailcat/cmd/tailcat@latest, or nix run github:tailscale/tailcat / nix profile install github:tailscale/tailcat.
- On machine A, run tailcat with no arguments. It selects a bootstrap DERP relay (the README example shows region 302, San Francisco) and prints an ephemeral address such as tcomFwWCCcjS5nKNqAod034nWoJZW0LZqDhhC8U_dKdnDRYQ8uNGFpGQEu.
- Deliver that token out of band - chat, email, whatever channel you already trust. This manual handoff is what replaces Tailscale's control plane.
- On machine B, run tailcat <token>. stdin/stdout are now piped between the two machines (echo hello | tailcat <token> produces hello on the server side), encrypted end-to-end with WireGuard.
- magicsock attempts NAT traversal and upgrades to a direct UDP connection when possible; DERP remains the relay of last resort. tailcat ping --until-direct reports which path each pong took, e.g. pong in 42.1ms via DERP(sfo).
- Beyond stdio: --serve=8080,8443 (or --serve=all) exposes local TCP ports through the tunnel, and --serve=no-auth-ssh paired with tailcat ssh <token> [cmd] provides a shell on Linux and macOS without SSH keys.
Command surface: the exact interface, from the README
- tailcat with no arguments: start the listener, print the ephemeral address, and block waiting for a client.
- tailcat <token>: connect to a peer and pipe stdin/stdout between the machines.
- tailcat --serve=8080,8443 or --serve=all: forward local TCP ports; the client dials with tailcat tcXXXXXXXXX 8080 and can speak raw HTTP through the tunnel.
- tailcat --serve=no-auth-ssh (Linux and macOS) plus tailcat ssh tcXXXXXXXXX or tailcat ssh tcXXXXXXXXX ls -la; for real authentication the README suggests tailcat --serve=22 proxying to the system SSH server.
- tailcat ping --until-direct <token>: each pong reports whether it arrived via DERP or a direct path (sample output: pong in 42.1ms via DERP(sfo)); --timeout defaults to 10s and the command exits non-zero if no direct path is found.
- Install paths documented in the README: go install github.com/tailscale/tailcat/cmd/tailcat@latest, nix run github:tailscale/tailcat, nix profile install github:tailscale/tailcat.
Architecture read: which Tailscale parts survived the remix
- Data plane kept: magicsock's userspace WireGuard stack, point-to-point encrypted tunnels, DERP as both the NAT-hole-punching side channel and relay of last resort.
- Control plane removed: no coordination server, no tailnet, no node registry - connection metadata travels with the token, out of band.
- Library/CLI split: the CLI lives in cmd/tailcat; the library is importable as github.com/tailscale/tailcat and documented on pkg.go.dev.
- Userspace only: no root/admin and no routing-table or DNS changes; go.mod pulls gvisor.dev/gvisor, consistent with a userspace network stack doing the tunneling.
- Relay configuration: the default DERP map is https://tailcat.dev/derpmap.json (free, rate-limited); the README links to cmd/derper in tailscale/tailscale for self-hosting your own relay.
- Browser demo: tailcat compiled to WebAssembly at tailscale.github.io/tailcat, interoperable with the CLI; browser traffic is DERP-only with no direct connections until WebRTC support (issue #4).
Maintenance risk: read go.mod before depending on this
- Hard dependency on tailscale.com v1.101.0-pre.0.20260720143344-246c82a658b3 - a pre-release snapshot, not a tagged release.
- Requires Go 1.26.5 per go.mod; other pins include gvisor.dev/gvisor v0.0.0-20260224225140-573d5e7127a8 and github.com/tailscale/gliderssh for the SSH path, plus golang.org/x/crypto v0.54.0.
- The README itself labels the in-browser WebAssembly demo "experimental", and direct browser connections are blocked on issue #4.
- License is BSD 3-Clause (Copyright (c) 2020 Tailscale Inc & contributors) - permissive, vendoring-friendly, standard attribution conditions.
- Default operation leans on Tailscale-operated free rate-limited DERP relays unless you deploy derper yourself; the source pack contains no release notes or changelog yet.
Who should pay attention?
Good fit if
- Two machines you control that need an encrypted pipe right now: logs, database dumps, quick file moves.
- Ephemeral or locked-down hosts where installing a VPN client or obtaining root is not possible.
- Temporarily exposing a dev server through NAT without a public IP, via --serve and a client that dials in with the token.
- One-off interactive shells through tailcat ssh when token sharing is easier than key distribution.
- Go programs that want WireGuard-encrypted transport embedded directly, via the importable github.com/tailscale/tailcat library.
- Moving files or text from the WebAssembly browser demo to a CLI peer across restrictive networks.
Skip for now if
- Persistent site-to-site connectivity - Tailscale proper, with its control plane and ACLs, is the right shape for that job.
- Anywhere token leakage is plausible: possession of the token is the entire auth model, and no-auth-ssh means token equals shell.
- Environments where traffic must never transit third-party relays: the default DERP map points at Tailscale-run relays (self-hosting derper is the mitigation).
- Production services that need a pinned, tagged dependency chain; go.mod currently pins a -pre tailscale.com snapshot.
- Compliance contexts that require identity binding, audit logs, and revocable per-user access.
Risks and cautions
The crypto core is the same code Tailscale ships, but tailcat itself is a young remix with a pre-release dependency pin and an auth model that collapses to a single shared token.
- go.mod pins tailscale.com v1.101.0-pre.0.20260720143344-246c82a658b3, a pre-release snapshot rather than a tagged version.
- --serve=no-auth-ssh runs an SSH server with no authentication; the connection token is the only gate to command execution.
- The default DERP map (https://tailcat.dev/derpmap.json) points at Tailscale-operated free, rate-limited relays whose terms can change.
- The browser demo is explicitly experimental; direct browser paths wait on issue #4 (WebRTC).
- No releases or changelogs appear in the source pack - the maturity signals are vendor authorship and 790 stars, not versioning history.
- All traffic is encrypted end-to-end with WireGuard; DERP relays see encrypted packets, and post-traversal connections are direct point-to-point UDP.
- No root or admin access is required, and the tool does not alter routing tables or DNS - the host-side blast radius of a userspace Go binary is small.
- The ephemeral token is a bearer credential: whoever holds it connects. The out-of-band channel you pick for it becomes part of your security boundary.
- no-auth-ssh mode grants command execution to token holders (tailcat ssh <token> ls -la); the README's own mitigation is --serve=22 proxying to your system SSH server for real auth.
- Browser demo traffic relays over DERP only, with no direct connections, until WebRTC support lands in issue #4.
- Self-hosting cmd/derper from tailscale/tailscale removes dependence on Tailscale's free rate-limited relay infrastructure.
Alternatives to compare
| Approach | When to use | Trade-off |
|---|---|---|
Tailscale (full product) | You want persistent identity-based networking with ACLs, a tailnet, and device management instead of one-off pipes. | Free for personal use; paid plans for organizations |
| You mainly need to move a file between two parties once, with relay fallback and no manual token routing. | Open source, free | |
netcat (nc) | Both machines already share a network or VPN and you just need a raw TCP/UDP pipe. | Free; preinstalled on most Unix-like systems |
ngrok | You need a stable public HTTPS endpoint for demos or webhooks rather than peer-to-peer piping. | Freemium; commercial tiers |
SSH + rsync/scp | You control both endpoints, key distribution is already solved, and you need proven file transfer tooling. | Free; standard system tooling |
What this trend reveals
Embed encrypted transport inside a Go binary
The library is importable as github.com/tailscale/tailcat, and go.mod shows the heavy lifting rides on tailscale.com plus gVisor - so a program can gain WireGuard tunnels with DERP fallback without shipping a VPN installer or touching the host's routing tables.
Write a two-file Go program that pipes a local reader through the tailcat library to a peer, then confirm with tailcat ping --until-direct whether the path upgrades from DERP(sfo) to direct.
Replace screen-share file sends with a browser drop
The WebAssembly demo at tailscale.github.io/tailcat already sends files and text to a CLI peer; pointing a non-technical user at a web page beats walking them through SSH key setup.
Open the demo on one machine, run a tailcat server on the other, transfer a 100 MB file, and record throughput given that browser traffic stays relay-bound until issue #4.
Self-hosted relay as the trust boundary
The default DERP map is https://tailcat.dev/derpmap.json, and the README links to cmd/derper for running your own relay, keeping all bootstrap traffic inside infrastructure you audit.
Stand up derper on one host, point both peers at it with a custom DERP map, and verify direct-path upgrade with tailcat ping --until-direct.
RepoDaily verdict
tailcat is the rare vendor remix that deletes the vendor's own product from the stack: Tailscale's WireGuard data plane, a netcat-shaped token exchange, no accounts, no root. Use it for ad-hoc encrypted pipes; think twice before routing no-auth SSH or anything long-lived through it while go.mod pins a pre-release tailscale.com snapshot.