Links are unlisted and unguessable, served over TLS, and never indexed. But anyone who has the link can read the stream, so don't pipe credentials through it.

Each stream keeps a rolling window of its output (8 MiB by default); older bytes fall off the front but the stream itself never stops. Viewers can download whatever remains.

spwn.stream — pipe any command into a live, shareable link

// how it works

A link that exists before the output does

1

Spawn a stream

Piping into spwn creates a secret upload key and a shareable watch link before a single byte is written.

# url is printed instantly, to stderr
$ long-job | spwn
▶ https://spwn.stream/Kd7fQw2mRt

2

Pipe into it

Output streams up as it happens. The page is live from the first millisecond — no "wait until it finishes", no size limits on what flows through.

$ tail -f /var/log/app.log | spwn
$ spwn run -- make release

3

Watch from anywhere

Laptop, phone, teammate's screen. Live push over SSE, autoscroll, ANSI colors, full-text search. When the command ends, the page says so — then the link expires on its own.

// examples

Things you'll actually use it for

Follow a log from your phone

$ journalctl -u myapp -f | spwn \
    --title "prod · myapp"

You're away from the desk and prod is acting up. Open the link on your phone and watch the log stream in real time.

Share a build without SSH access

$ spwn run -- make release

A colleague wants to see why the build is red. Send the link instead of a 40 MB log attachment. Exit code included.

Watch a long job from the couch

$ spwn run -- rsync -a /data backup:/mnt

Two-hour transfer, one shared link. Check progress from bed instead of babysitting a terminal.

Let cron & agents report in

# crontab — every run leaves a readable trail
0 3 * * * backup.sh 2>&1 | spwn \
    --title "nightly backup"

Each run gets its own link. Skim them over coffee instead of digging through mail logs.

// why spwn

Small tool, obsessive details

⚡

Live, not polled

Server-sent events push bytes the moment they arrive. Milliseconds, not refresh intervals.

🎨

ANSI rendered

Colors, bold, underline — 256-color too. Your colored test output stays colored.

🔍

Search & filter

Full-text search across everything the stream produced, with match highlighting.

⏳

Self-expiring

Links die after 24h by default. Nothing to clean up, nothing lingering forever.

🔒

Watch-only links

Sharing the link lets people read. Writing requires the creator's secret key.

📦

One static binary

Go, zero dependencies, the whole site embedded. Drop it on any box and go.

// faq

Questions, answered

How long do streams live?

24 hours by default, from creation. Pass --ttl 2h (or up to the server maximum) to change it per stream. After expiry the link is simply gone — no tombstones, no archive.

Who can write to a stream?

Only whoever holds the upload key — the person (or script) that created it. The watch link is read-only by design. If you can open the page, you cannot inject lines into it.

Is it private?

Links are unlisted and unguessable (58¹⁰ possibilities), served over TLS, and never indexed. But treat them like a secret URL: anyone who has the link can read the stream. Don't pipe credentials or API keys through it.

Can I use it with plain curl, nothing installed?

Yes. Two steps:

read id key <<< "$(curl -s https://spwn.stream/new)"
long-job | curl -sNT - -H "X-Spwn-Key: $key" https://spwn.stream/s/$id

Or one-shot (the link arrives when the command finishes):

long-job | curl -s --data-binary @- https://spwn.stream/

What if the server restarts mid-stream?

With disk persistence enabled, finished and interrupted streams survive restarts — links keep working. A live stream's producer would need to re-run the command; the CLI tells you if its stream was lost.

Why not tmate / asciinema / a pastebin?

tmate shares an interactive shell — overkill and risky when you just want output. asciinema records playback after the fact. Pastebins only work once the command has finished. spwn fills the gap: non-interactive output, streamed live, to a dumb link.

What are the limits?

Each stream keeps a rolling window of its output (8 MiB by default — older bytes fall off the front, the stream itself never stops). Viewers see a note when early output has scrolled out of retention, and can always download whatever remains.