Inspiration
We live in a world of "walled gardens." Sending a file from an iPhone to a Mac is magic (AirDrop), and Android to Android is seamless (Quick Share). But try sending a 100GB video project from a Windows PC to an iPad, or an Android phone to a MacBook, and the magic dies. We were tired of relying on slow internet uploads, USB cables, or clunky third-party apps just to move data across the room. We wanted to build a universal bridge—one protocol that unites every device, regardless of the ecosystem.
What it does
DropTea is a blazing-fast, cross-platform file transfer tool that works entirely offline over your local network. Universal Compatibility: Connects iOS, Android, Windows, macOS, and Linux in a single mesh. High Performance: Capable of transferring massive files (100GB+) without crashing or eating up RAM. Resumable Transfers: If the Wi-Fi drops, the transfer doesn't fail; it pauses and resumes exactly where it left off. Zero Configuration: Devices automatically find each other using mDNS auto-discovery—no IP typing required.
How we built it
We adopted a hybrid architecture to balance performance with cross-platform reach: The Core (Rust): We built the heavy-lifting logic in Rust. This handles memory management, file I/O, encryption, and the network transport layer. Rust ensures memory safety and allows us to handle massive data streams efficiently. The UI (Flutter): We used Flutter to create a beautiful, native-feeling interface that runs on every platform from a single codebase. The Bridge: We utilized flutter_rust_bridge to seamlessly connect the UI to our Rust core via FFI (Foreign Function Interface), giving us "native speed" without the overhead of HTTP local servers. Networking: We implemented a custom protocol over TCP (with plans for QUIC) featuring mDNS for service discovery.
Challenges we ran into
Memory Exhaustion: Early prototypes crashed when attempting to load large files into RAM. We had to rewrite the transfer logic to use streaming buffers and chunking to handle 100GB files with minimal memory footprint. The "Walled Garden" Hardware: We realized that native protocols like Apple's AWDL (AirDrop) are hardware-locked. This forced us to innovate our own discovery layer using standard mDNS that works universally. Cross-Language Complexity: Bridging high-level UI code with low-level systems programming was tricky. Managing ownership and memory safety across the Flutter/Rust boundary required careful architectural design.
Accomplishments that we're proud of
Hybrid Architecture: Successfully separating the business logic (Rust) from the presentation layer (Flutter), making the codebase modular and future-proof. Robust Error Handling: Implementing a "resume" capability that handles network interruptions gracefully—a feature often missing in standard HTTP transfers. Performance: Achieving transfer speeds limited only by the hardware's Wi-Fi card, with near-zero CPU overhead due to Rust's optimization.
What we learned
Memory Management Matters: We dived deep into how operating systems handle memory, learning the importance of stack vs. heap and zero-copy operations for high-performance I/O. Protocol Design: We learned that TCP is reliable but suffers from Head-of-Line blocking on unstable Wi-Fi, which influenced our roadmap toward UDP-based solutions. The Power of Rust: Moving from a Python prototype to a Rust core showed us how strict compile-time checks can prevent entire classes of runtime bugs.
What's next for DropTea
QUIC Protocol: We plan to upgrade our transport layer from TCP to QUIC (HTTP/3) to eliminate Head-of-Line blocking and improve speed on unstable networks. Quick Share Integration: We are exploring reverse-engineering the Quick Share protocol to allow Android devices to send files to DropTea without needing the app installed. Mobile Release: Polishing the mobile experience to ensure background service stability on iOS and Android.
Log in or sign up for Devpost to join the conversation.