Relayium vs croc: encrypted file transfer from the terminal

Last updated: 2026-07-09

croc is one of the best-loved tools for sending a file from one terminal to another: a short, memorable code phrase, a PAKE key exchange, and it just works. Relayium's CLI sets out to do the same job and is built the same way — free, open source, and encrypted end to end, with no account required for any of it.

This isn't a takedown; croc earned its reputation. It's a straight comparison of what the two share, where Relayium's CLI does more because it also talks to servers you already run, and the case where croc is honestly the simpler pick.

What Relayium and croc have in common

Start with the overlap, because it's substantial: both are single small binaries you install once, both are completely free with no paid tier, and both are open source under a permissive license so you can read every line that touches your files.

No account for a transfer — a short code known only to the two ends is enough to find each other and agree on a key.
Encrypted in transit end to end: the relay or rendezvous point in the middle never sees your file's contents.
Interrupted transfers can pick back up instead of starting over, and both verify what arrived actually matches what was sent.
Cross-platform: macOS, Linux and Windows.

SSH and daemon-direct: talking to a server you already run

This is the biggest practical difference. croc is built around a single flow — code phrase in, code phrase out. Relayium's CLI adds two more ways to move files that lean on infrastructure you already have.

relayium push / pull reuses your existing SSH access, so there's nothing new to trust and no code to share. push even works against a server with no relayium installed at all, falling back to a plain tar stream over the SSH connection — that fallback is push-only; pull always needs relayium on the remote, since it acts as the sender there.

relayium serve turns any machine you own into a daemon-direct target, reachable over pinned TLS 1.3 with no SSH and no code phrase — trust is on the first connection (approved interactively, or pre-authorized for unattended use) and pinned from then on, the same idea as an SSH host key.

relayium push ./photos user@your-server:backups/

relayium serve --dir ~/incoming

relayium push ./build relayium://your-server

Folder sync and a verification code you check twice

croc sends a batch of files and exits — send it again to update the other side, with no notion of what should be removed. Relayium's CLI adds relayium sync, an incremental one-way mirror over either transport above: it only moves what changed, --delete removes files on the destination that disappeared from the source (a daemon only honors it if it was started with --allow-delete, so a receiver has to opt in), and --watch keeps re-syncing in real time as files change, with no cron job needed.

For a one-off cross-network transfer, relayium send / receive plays the same role as croc's code phrase, pairing two computers by a short code. It's direct peer-to-peer, and it prints a short verification code (a Short Authentication String) on both ends so you can visually confirm nobody sat in the middle before any bytes move — worth noting honestly: this mode is direct-only, so if the two ends can't find a direct path it fails rather than falling back to a relay.

relayium sync ./photos user@your-server:backups/photos --delete --watch

When croc is the simpler pick

There are real cases where croc is the better tool for the job, and it's worth saying so plainly.

You just want to hand one file to a friend right now with the fewest moving parts — no server to reach, nothing to set up on either end.
You're behind a strict NAT with no way to open a direct path: croc's relay carries the encrypted stream regardless, so the transfer completes either way. Relayium's send / receive is direct-only and can fail in that situation (push/pull or daemon-direct to a reachable server still work, since those don't depend on a direct P2P hop).
You don't need folder mirroring, SSH integration, or a long-running listener — croc is one ad hoc command per side and nothing else to think about.
You already trust croc's large, established community and its years of real-world use.

Feature comparison at a glance

The differences that matter most, side by side:

Talking to a server: Relayium reuses your SSH access (push/pull) or a pinned-TLS daemon; croc has no SSH integration — install croc on both ends and share a code phrase.
Folder sync: relayium sync mirrors incrementally with --delete and --watch; croc sends a batch and exits, with no mirror or delete semantics.
No direct path available: croc's relay carries the encrypted stream so the transfer still completes; Relayium's send/receive is direct-only.
Verification: both are encrypted end to end; Relayium's send/receive additionally prints a short code both sides compare before the transfer starts.
Self-hosting: both are self-hostable — croc's relay is a small standalone binary; Relayium's server also runs the web app, and the CLI's send/receive can point at your own with --server.
License and cost: both MIT-licensed, both completely free, neither requires an account.

Frequently asked questions

Is Relayium's CLI free?

Yes, completely. There's no paid tier and nothing to meter — every mode connects the two ends directly, and the CLI is MIT-licensed and open source.

Does it need an account?

No. push/pull uses your own SSH access, daemon-direct uses pinned-TLS certificate trust between your machines, and send/receive uses a short code you agree on out of band. None of it touches a Relayium account.

Can I use the CLI's pairing code with Relayium's browser app?

Not yet for a live paired transfer — the CLI's send/receive uses its own direct handshake, separate from the browser's WebRTC-based pairing flow, so the two don't interoperate today. To hand a file to someone using only a browser, use Relayium's stored download link or the browser app's own pairing-code mode.

Can I self-host it?

Yes. Relayium's server ships as a Docker image (docker compose up -d --build), and you can point the CLI's send/receive at your own instance with --server https://your-domain — the same spirit as running your own croc relay.

Install the free Relayium CLI and try push, sync or send — no account, and just as quick to start as croc.

Get the CLI