How Does KEIBIDROP Compare?

Lab Setup

All benchmarks ran on the same machine, over localhost loopback, to isolate software overhead (encryption, protocol framing, I/O layers) from network variability.

Methodology: Each tool transfers a pre-allocated random file from sender to receiver over localhost. Wall-clock time is measured from "start send" to "file verified on disk at receiver." Tests run sequentially -- one tool at a time, no contention. Files are pre-generated (not counted in timing).

KEIBIDROP uses ::1 loopback, in-process mock relay, gRPC over ChaCha20-Poly1305 encrypted TCP. The FUSE benchmark additionally routes reads through the macFUSE kernel module.

croc runs with a local relay on 127.0.0.1:9009 (no internet). Encryption: XSalsa20-Poly1305 with PAKE key exchange. Built from github.com/schollz/croc v10.4.2.

wormhole-william uses the public mailbox server for SPAKE2 signaling (adds ~2-3s setup latency). Data transfer is direct localhost. Built from github.com/psanford/wormhole-william.

LocalSend protocol -- we reimplemented LocalSend's v2 transfer protocol in Go: HTTPS POST with self-signed TLS, binary body streaming. Same endpoints and flow as the real app (prepare-upload to upload). This measures the raw protocol speed, not the Dart/Flutter app. Source: github.com/localsend/localsend.

scp uses the system SSH daemon over localhost. Encryption is AES-256-GCM (negotiated by SSH, hardware-accelerated).

cp is the raw disk baseline -- no encryption, no network stack.

Results

(KEIBIDROP numbers from go test benchmarks on the same machine, same loopback. All other tools built from source and benchmarked identically.)

Isolating the Cipher: AES-GCM vs ChaCha20-Poly1305

To get an honest comparison, we ran the LocalSend protocol benchmark twice: once with Go's default TLS 1.3 (which negotiates AES-128-GCM and uses AES-NI hardware), and once forcing ChaCha20-Poly1305 -- the same cipher KEIBIDROP uses.

The AES-NI advantage is 13% -- real but not the main story. Both ciphers are fast on this CPU. The bigger factor is protocol framing.

Where the Gap Actually Is

With the same cipher (ChaCha20), the comparison becomes:

The 28% gap between LocalSend protocol and KEIBIDROP gRPC comes from three sources:

• gRPC/protobuf framing: every chunk is wrapped in a protobuf message with offset, size, and metadata fields. LocalSend streams raw bytes in a single HTTP POST body with zero per-byte framing.
• Chunk-level bitmap tracking for resume support. LocalSend does not track partial downloads.
• Bidirectional multiplexing: KEIBIDROP's gRPC connection carries file transfers, notifications, heartbeats, and rekey requests simultaneously. LocalSend uses one dedicated HTTP request per file.

These are different tools solving different problems. LocalSend is optimized for one-shot local transfers. KEIBIDROP maintains a persistent P2P connection with resume, notifications, and a virtual filesystem. The 28% overhead is the cost of those features.

What the Numbers Tell Us

Small files (1-10 MB): Protocol setup overhead dominates. Croc spends ~400ms on PAKE key exchange and relay handshake. Wormhole spends ~2.7s on SPAKE2 through the public mailbox server. scp spends ~50ms on SSH handshake. LocalSend protocol is lightweight -- an HTTPS POST with a small JSON handshake (~8ms for 1MB). KEIBIDROP has zero per-transfer setup -- the connection is already established.

Large files (1 GB): Croc tops out at 153 MB/s -- its relay-forwarding architecture adds a hop even on localhost. Wormhole hits 126 MB/s. KEIBIDROP's gRPC hits 442 MB/s, 2.9x faster than croc. LocalSend's protocol reaches 612-704 MB/s because a single HTTPS POST body has minimal framing overhead.

FUSE overhead: KEIBIDROP through FUSE (233 MB/s) vs raw gRPC (442 MB/s) shows the 48% overhead of kernel-to-userspace context switches. This is inherent to any FUSE filesystem. Even with FUSE, it's 1.5x faster than croc and 1.8x faster than wormhole. The tradeoff is that FUSE gives you a mounted filesystem where you can run git, open files in editors, etc.

Why scp Appears "Faster"

scp at 2.3 GB/s looks impossibly fast -- faster than cp. Both hit the OS page cache on localhost. The file was recently written during test setup, so it's already in RAM. scp over localhost sends through the loopback socket with AES-256-GCM at near-zero cost (AES-NI). On a real network with wire speed limits, the difference disappears.

A Note on LocalSend

Our benchmark implements LocalSend's v2 protocol in Go -- same HTTPS endpoints, same TLS, same binary POST body. At 612-704 MB/s, the protocol is well-designed. We did not benchmark the actual LocalSend Dart/Flutter app, so we cannot make direct speed claims about it. User reports online suggest 50-120 MB/s on wired LAN, but we haven't verified this ourselves. Our numbers reflect the protocol, not the app.

Architecture Differences

KEIBIDROP keeps one encrypted TCP connection open and multiplexes all operations over gRPC. There is no per-file setup. Croc does a full PAKE exchange per transfer; wormhole does SPAKE2 through a mailbox server per transfer.

The StreamFile RPC pushes all chunks server-to-client with zero per-chunk round-trips. Croc and scp use request-response patterns.

Data goes directly between peers. Croc routes through a relay process, adding an extra hop and memory copy even on localhost.

KEIBIDROP uses ChaCha20-Poly1305. On machines without AES-NI (ARM Macs, Linux ARM servers), ChaCha20 is faster than AES. On x86 with AES-NI, AES-GCM is 13% faster. We chose ChaCha20 for consistent cross-platform performance. Switching to AES-GCM would close the gap with LocalSend's protocol on x86 hardware.

Encryption Overhead

33% overhead for end-to-end encryption with ChaCha20-Poly1305. Every byte is authenticated and encrypted. Tools that terminate TLS at a relay (like WeTransfer) avoid this cost because the relay decrypts and re-encrypts, but the relay can then read the data.

Summary

KEIBIDROP at 442 MB/s (gRPC) is 2.9x faster than croc and 3.5x faster than wormhole. The difference comes from architecture: persistent connection, no relay hop, push-based streaming.

LocalSend's protocol at 612 MB/s is 28% faster with the same cipher. The gap is gRPC framing and chunk tracking. Switching to AES-GCM on x86 would narrow it to ~15%.

scp is faster on localhost because the page cache eliminates disk I/O. On real networks this advantage disappears.

The FUSE path at 233 MB/s adds 48% overhead from kernel-userspace context switches. This is the cost of mounting a virtual filesystem where you can run git, open files in editors, and browse shared directories.

The encrypted gRPC path (442 MB/s) is the speed for pure file transfer. Through FUSE, 233 MB/s.

Benchmark script and raw data: KD-Benchmarks