DashBeam

Sending a large file from a phone to another device still involves a surprising amount of compromise. Each familiar route has a cost: an attachment cap, a cloud account, or a server that keeps a copy on terms the sender never reads. DashBeam, from developer Tony Antony, takes the server out of the picture. Files and folders move directly from one device to another over a peer-to-peer connection, encrypted end to end with TLS 1.3. The app asks for no account, shows no ads, runs no tracking and stores nothing in the cloud.

The project began as AltSendme before taking its current name. Its networking is built on the iroh library, with encryption handled as TLS 1.3 over QUIC. On top of that foundation sit a relay fallback for networks that won’t allow a direct link and a device-identity model that lets a transfer survive a change of network. That second detail matters more on a phone than anywhere else, and it is one reason the Android build deserves attention on its own terms.

DashBeam is free and open source, and it reaches well beyond Android. There are versions for Windows, macOS and Linux, plus a command-line tool and a web client. The official site lists an iOS app as coming, but it has not shipped.

The open-source community has noticed. The GitHub repository carries a substantial following, and Softpedia gave it 5/5. Commenters on AlternativeTo, Lemmy and tech news sites keep praising the same things: no cost, no account, no file size limit, real encryption and speed. Their main complaint is just as consistent. The share “tickets” are too long to read aloud or type by hand.

That makes the positioning unusually clear. DashBeam is for people who want file transfer to behave like plumbing. Bytes leave one device and arrive verified on another, and the only record lives in a local history on the user’s own hardware. The pitch is trust, and the architecture is designed to earn that trust instead of simply asking for it.

• Direct, encrypted transfers: Data travels peer-to-peer with end-to-end TLS 1.3 encryption, built on the iroh networking library. There is no account, no ads, no tracking and no cloud storage.
• Relay fallback with self-hosting: When a direct connection fails, traffic falls back to a relay server. Users who don’t want to depend on someone else’s relay can host their own.
• Single-use tickets: Adding a file or folder produces a one-time ticket that can be shared as a code, a link or a QR code.
• Browser receiving: Recipients can collect files in a web browser without installing anything.
• No size limit, verified and resumable: There is no file size cap, BLAKE3 hashing checks every transfer, and interrupted transfers resume where they stopped.
• Local discovery: Devices on the same Wi-Fi network find each other automatically.
• Trusted device pairing: Paired devices can send to each other over the internet without a ticket and can accept incoming files automatically.
• Identity-based connections: Connections follow each device’s identity rather than its IP address, so a transfer continues when the network changes.
• Quality-of-life extras: Sending to several devices at once, file previews, a local transfer history, background operation with notifications, and an optional debug mode.

The Ticket Model

DashBeam’s central design decision is the single-use ticket. There are no addresses, usernames or contact lists. Every ad-hoc share produces a credential that works once. That is a sound security choice. A leaked ticket from yesterday opens nothing today, and nobody needs an identity in a central directory to receive a file.

The cost falls on usability. A ticket has to carry enough information to locate a device and authenticate a connection, so it is long. Commenters’ main complaint is that it can’t be read aloud or typed by hand. DashBeam responds by offering the ticket in three forms, each suited to a different situation:

• The link suits messaging apps.
• The QR code suits two devices in the same room.
• The raw code is the fallback nobody wants to transcribe.

The code format is the weak link by design. It exists for the cases where the other two fail, such as dictating over a phone call or typing on a machine with no messaging app and no camera. Those are exactly the cases where its length hurts most. A shorter, human-readable mode for that situation is the most obvious improvement available.

Integrity and Resilience

The data handling is unusually careful for a free utility. BLAKE3 hashing verifies every transfer, so a corrupted file is detected instead of passing as the real thing. Resumable transfers mean an interruption doesn’t send a job back to zero.

Because there is no file size limit, those two features carry real weight. They are what make multi-gigabyte transfers practical over imperfect connections. Removing the cap without verification and resume would be an empty promise. DashBeam pairs it with both.

Identity-based connections complete the picture. A connection is tied to a device’s identity rather than its IP address, so moving from Wi-Fi to mobile data does not break the session. On a desktop that is an edge case. On a phone carried out of the house mid-transfer, it is the normal case, and DashBeam handles it by design rather than with a retry button.

Pairing: Convenience With a Trust Boundary

Tickets solve the stranger problem. Pairing solves the repetition problem. Once two devices trust each other, they can exchange files over the internet without a ticket and accept incoming files automatically. For someone moving photos from a phone to a home machine every day, this turns DashBeam from a sharing tool into a private pipe between their own devices.

Auto-accept is the feature to handle with care. It is the right choice for devices that belong to one person and a questionable one for anything less personal. A trusted device that can push files without confirmation is only as safe as the decision to pair it. The setting rewards users who keep their trusted list short.

Local discovery covers the middle ground. Devices on the same Wi-Fi find each other without exchanging any ticket. Combined with sending to several devices at once, that makes DashBeam practical for distributing a file across a household or a small office.

The Relay Question

Some users have flagged the relay fallback, and the concern deserves a direct answer. Not every pair of networks allows a direct connection, and without a relay those transfers would simply fail. Because encryption is end to end, a relay forwards encrypted traffic rather than readable files.

The real objection is dependency. A transfer that falls back runs over infrastructure the user didn’t choose. Letting users host their own relays is the correct response. It turns the relay from an assumption of trust into a configuration choice, which is what an open-source privacy tool should offer.

Privacy as Architecture

No accounts, no ads, no tracking, no cloud storage and a local transfer history: each of these follows from the design rather than from a policy added on top. There is no cloud archive of transferred files to breach, because the product never builds one. Open-source code means these claims can be checked instead of taken on faith.

DashBeam’s interface is organized around one object, the ticket. The user adds a file or folder, gets a code, link or QR code, and hands it over. That loop is short, and the QR option suits a phone screen well because the recipient only has to scan it with a camera. The visual layer shares the protocol’s weakness, though. The raw code is too long to present as something a person can comfortably read.

The supporting features address real friction:

• File previews reduce the guesswork of accepting an unfamiliar file.
• The local transfer history provides a record without a cloud account.
• Background operation with notifications means a long transfer doesn’t require the app to stay on screen.

The optional debug mode serves the technical users who make up much of the audience.

Commenters describe DashBeam as fast, and the architecture supports that expectation. A direct peer-to-peer link skips the upload-then-download round trip of cloud sharing. Throughput should depend on the two endpoints and the path between them, not on a storage service. Transfers that fall back to a relay add a hop and depend on that relay’s capacity, which is another reason to self-host when speed matters. BLAKE3 was designed as a fast hash, so verification should not be the bottleneck.

This review covers the Android release, and several design choices matter more on a phone.

• Touch input: On a touchscreen, adding a file means selecting it rather than dragging it. QR codes are the natural way to share a ticket on mobile. Typing a long code on a phone keyboard is the worst case of the whole ticket model.
• Network switching: Identity-based connections pay off most on a device that moves between Wi-Fi and mobile data. Users on capped data plans should keep an eye on large transfers once they leave Wi-Fi, since the session carries on regardless.
• Background operation: Notifications and background transfers suit a platform where users constantly switch between apps.
• Cross-platform reach: Versions for Windows, macOS, Linux, the command line and the web mean an Android phone can pair with most desktop setups. iOS is the gap. Until the promised app arrives, iPhone owners can’t use pairing or auto-accept and can at best be reached through browser receiving.
• Pricing: Free, with no ads.

DashBeam gets the hard parts right. Encryption is end to end, BLAKE3 verifies integrity, interrupted transfers resume, network changes don’t kill transfers, and there is no size cap and no account to create. Those guarantees come from the architecture, and the open-source code lets anyone check them.

The rough edges are at the human interface. Tickets are too long to speak aloud, auto-accept demands careful pairing, and the missing iOS app limits who an Android user can pair with. None of these break the main proposition, but they narrow the audience: a free, verifiable, direct path between devices with no company in the middle is a specific kind of value, and it suits people who will put up with a clumsy handoff to get it. For Android users who want exactly that, DashBeam is a reasonable pick.