tonyantony300/dashbeam

Language: English | 中文 | Русский | Português | Español | Deutsch | Français | 日本語 | 한국어 | Polski | العربية

A free and open-source file transfer tool that harnesses the power of cutting-edge peer-to-peer networking, letting you transfer files directly without storing them on cloud servers.

Why rely on WeTransfer, Dropbox, or Google Drive when you can reliably and easily transfer files directly, end-to-end encrypted and without revealing any personal information?

• Cross-platform - Desktop, Android, CLI, and browser - no install on the web
• Any file, any size - Files or folders, BLAKE3-verified
• Multi-gigabit speeds - Saturates fast connections
• Nearby - LAN auto-discovery; Pair & Send
• Paired devices - Pair once with a code (remote) or Nearby; send without tickets
• Trusted devices - Opt a paired device into auto-accept; its files land without a prompt
• Resumable & multi-peer - Resume interrupted transfers; share to many at once
• Dial by key - Connect by device identity, not IP address
• Roaming - Switch Wi-Fi, cellular, or networks mid-transfer without dropping
• Code, Link or QR - Receiver needs no install (browser or app)
• Preview & history - See before download; local transfer log
• Advanced debug mode - Opt-in diagnostics for under the hood transparency
• Private - No accounts, tracking, or ads; direct device-to-device
• Encrypted - TLS 1.3 end-to-end; authenticated tickets
• Self-host relays - Unthrottled remote transfers via your own relay (Settings → Infra)
• Always reachable - Background tray/service, notifications, start at login
• Lightweight & free - Small installs; open source, no limits

Transfer throughput depends on your device, network, and connection path.

The easiest way to get started is by downloading one of the following versions for your respective operating system:

Platform	Recommended	Other formats	Size
💻 Windows (x64)	Setup.exe	MSI, Portable ZIP	~10 MB
💻 macOS (Universal)	DashBeam.dmg	Apple Silicon, Intel	~15 MB
💻 Linux (amd64)	DashBeam.deb	.rpm, AppImage	~13 MB
📱 Android		arm64 APK, armv7, universal	~15 MB
⌨️ CLI	Downloads	-	~4-5 MB
🌐 Web (Limited throughput)	app.dashbeam.net	-	_

More options at GitHub Releases or in Downloads page.

Running into problems? See Troubleshooting for common issues and how to collect logs.

🇺🇸 🇷🇺 🇫🇷 🇨🇳 🇩🇪 🇯🇵 🇮🇳 🇹🇭 🇮🇹 🇨🇿 🇪🇸 🇧🇷 🇸🇦 🇮🇷 🇰🇷 🇵🇱 🇺🇦 🇹🇷 🇳🇴 🇧🇩 🇭🇺 🇷🇸 🇹🇼 🇰🇭 🇺🇿

Same-network apps appear under Nearby in Settings → Devices and in the Send to a device list while you're sharing. Pick a nearby device and Pair & Send to pair and start the transfer in one step - you can also pair from Settings without sharing. First contact shows a verification code on both screens. Set who can find you in Settings → Network → Your discoverability.

Uses mDNS - often blocked on guest Wi-Fi and VPNs. See Troubleshooting if the list stays empty.

Pair in Settings → Devices with a pairing code (works remotely, over the internet) or via a Nearby request on the same network. After pairing, Send appears next to that device while sharing - no ticket to copy. The receiver gets an in-app prompt. Desktop can keep running in the background and show online paired devices in the tray (Settings → General → Startup & background). Manual tickets and the sendme CLI still work.

While sharing: QR for a camera scan, Share for the system sheet, Copy for the raw ticket. Links use https://app.dashbeam.net/receive?ticket=… - on Android they open the app; elsewhere the web app, so nothing to install (large files are better in the native app). Paste a ticket, link, or full share message into Receive.

Know more →

DashBeam is built on Iroh, a modern peer-to-peer networking stack that simplifies direct device-to-device communication. In practice, that means devices talk over encrypted QUIC, files move with content-addressed blobs, and relays help when a direct path isn’t available.

The long version: Under the hood walks the same architecture as a narrative - fingerprints instead of filenames, names instead of addresses, hole punching, roaming, and what each intermediary can and cannot see.

Files aren’t uploaded to a server. They’re published as blobs: opaque byte sequences addressed by a BLAKE3 hash.

• A link is that 32-byte hash: if the hash matches, the content matches.
• Folders and large files use a HashSeq (a blob that points at other blobs).
• The sender is the provider; the receiver is the requester. Either side can do both.

Because that hash is a BLAKE3 tree rather than one digest over the whole file, every chunk verifies on its own against the root. That is what makes resume cheap: a receiver coming back after a dropped connection knows exactly which chunks it already holds and has verified, so it asks only for the gap. Nothing already received is re-sent, and nothing arriving is taken on trust.

A share ticket is a single token that packs:

1. The sender’s endpoint id (so you know you’re talking to the right device)
2. Enough address / relay info to dial them
3. The blob hash to download

You only connect to people you share a ticket with: no broadcasting your IP to strangers. That’s the default “cozy network” model Iroh encourages, vs. flooding discovery to the whole swarm.

Tickets that carry only an endpoint id lean on public-key discovery (Pkarr) to find current addresses. Those records are signed by the endpoint key itself, so a tampered one fails verification rather than misdirecting you - the lookup service is trusted for availability, not integrity.

When two devices need to meet:

1. Each registers with a public (or self-hosted) relay so peers can find a path through firewalls and NATs.
2. Iroh tries QUIC hole punching to upgrade to a direct peer-to-peer link.
3. If a direct path works, traffic moves over to it. If not, the relay stays in the path as a fallback UDP hop.

Those steps overlap rather than queue. The relay is already carrying your data while hole punching negotiates, so nothing waits on the direct path to succeed - the transfer just gets faster if and when it does. Roughly one transfer in ten never gets a direct path at all (symmetric NAT, locked-down corporate networks) and rides the relay start to finish.

Either way, the payload is end-to-end encrypted. Relays see ciphertext, not your files. More on Iroh relays →

A connection is bound to the peer’s key, not to its IP address, so changing networks does not end it. Switch from Wi-Fi to cellular mid-transfer and iroh notices the address change, learns the new candidates, and republishes them to the peer. The relay carries the data throughout, and hole punching simply runs again on the new path.

Addresses are disposable hints, not identity. That is the practical payoff of naming devices by key instead of by location.

QUIC (UDP-based, same foundation as HTTP/3) brings TLS 1.3 into the transport. For DashBeam that buys encryption and authentication, multiple streams with shared congestion control, and fast reconnects when you’ve talked to a peer before.

Pairing doesn’t replace tickets; it delivers them for you.

1. Devices exchange a short pairing code (the host’s endpoint id) over a dedicated control ALPN.
2. Each side proves identity by signing connection-bound keying material with its device secret, then remembers the peer locally.
3. A persistent control connection keeps presence (online/offline).
4. When you share, DashBeam still creates a normal one-time blob ticket; choosing a paired device ships that ticket as an in-app invite instead of making you copy-paste it.

Manual tickets and the sendme CLI keep working exactly as before.

On the same local network, DashBeam can advertise and browse peers with mDNS (desktop and Android; not the web app).

1. When discoverability is Everyone, the device publishes enough metadata for others to show its name in Nearby.
2. Paired only still announces presence without exposing the display name to strangers on the LAN.
3. Off stops advertising; you can still browse and send to others who remain discoverable.
4. First-contact file invites show a short verification code derived from both devices' public keys so each side can confirm they're talking to the intended peer before accepting.
5. Accepting a Nearby pair request or file invite creates the same local paired-device records as code-based pairing.

For how to run your own iroh relay and discovery server, configure DashBeam to use them, and how mixed public/self-hosted setups behave, see infra/README.md (relay: infra/relay/README.md, discovery: infra/dns/README.md).

For the illustrated version of everything above - including a full account of what a relay operator, your ISP, and the lookup service each learn from a transfer - read Under the hood.

See CONTRIBUTING.md for prerequisites, local setup, build instructions, and testing.

The best way to contribute is to join our Discord and say hi. Introduce yourself and share what skills or interests you have - whether that’s coding, testing, design, or something else. You can also raise issues, suggest fixes, or pitch ideas. Maintainers are there to guide you every step of the way.

It’s the best place to get context, align on direction, and collaborate with the community.

AGPL-3.0

See PRIVACY.md for information about how DashBeam handles your data and privacy.

Reach me here for suggestions, feedback or media related communication.

Thank you for checking out this project! If you find it useful, consider giving it a star and helping spread the word.