Case Study

NearSend File Share

Ultra-fast local file sharing without the cloud. Transfer gigabytes in seconds using direct device-to-device connections.

The Challenge

Understanding the Problem

Existing file sharing solutions either required cloud uploads (slow, privacy concerns) or used outdated protocols (AirDrop limitations, Windows nearby share unreliability). Users needed instant device discovery and multi-gigabit transfer speeds.

Our Approach

We built a hybrid discovery system using mDNS and custom UDP broadcasts, combined with a high-performance TCP transfer engine written in Rust for maximum throughput.

Phase 1

Multi-device Group Broadcasting

Phase 2

Cross-subnet Sharing via Relay

Phase 3

Pause/Resume Support

Phase 4

Cloud Relay for Remote Transfers

The Solution

High-speed UDP discovery protocol with TCP for reliable multi-gigabit streams. Near-instant device discovery on both 2.4GHz and 5GHz WiFi bands.

450Mbps+ Transfer Speed
<1s Discovery Time
AES-256 Encryption

The Outcome

Achieved stable 450Mbps+ transfer speeds on WiFi 6, making NearSend faster than most cloud-based alternatives while keeping all data local.

Impact: 450Mbps+ Transfer Speed

Technical Deep Dive

Engineering Excellence

A comprehensive look at the technical architecture and implementation details that power this solution.

discovery

Utilizes mDNS (Multicast DNS) and custom UDP broadcast packets for near-instant device discovery on 2.4/5GHz bands with zero configuration.

performance

Stable 450Mbps+ speeds on Wi-Fi 6 with zero packet loss buffer management. Optimized memory usage for transferring files larger than available RAM.

encryption

AES-256-GCM encryption with ephemeral key exchange and forward secrecy. All transfers are encrypted by default with no performance penalty.

System Architecture

Sender Device

Flutter Client

mDNS/UDP Discovery

Device Broadcast

Key Exchange

ECDH Ephemeral Keys

TCP Stream

Rust Transfer Engine

Receiver Device

Decryption + Save

Broadcast: device1 → discovery

Respond: discovery → device2

Initiate: device1 → handshake

Secure Channel: handshake → stream

Encrypted Data: stream → device2

Development Journey

From Concept to Launch

3 weeks

Protocol Research

Analyzed LocalSend, AirDrop, and Nearby Share protocols to identify weaknesses, designed custom hybrid discovery using mDNS + UDP broadcast for maximum compatibility, and established security requirements for E2EE file transfers.

6 weeks

Rust Core Engine

Built high-performance transfer engine in Rust with zero-copy optimizations, implemented custom TCP streaming protocol with pipelining for maximum throughput, and developed memory-efficient chunking for files larger than RAM.

8 weeks

Cross-Platform Clients

Created unified Flutter UI for Android, iOS, Windows, macOS, and Linux, implemented native platform bridges (FFI) to Rust core for performance, and built responsive adapters for desktop, tablet, and phone form factors.

2 weeks

Security Hardening

Integrated AES-256-GCM encryption with ephemeral ECDH key exchange, implemented certificate pinning and forward secrecy guarantees, and conducted third-party security audit with penetration testing.

3 weeks

Beta Testing

Launched community beta program with 5000+ testers across platforms, optimized transfer speeds based on real-world network conditions, and fixed edge cases in NAT traversal and firewall configurations.

Measurable Impact

Key Results

Primary Outcome

450Mbps+ Transfer Speed

Direct business value delivered.

450Mbps+

Transfer Speed

On WiFi 6 networks

<1s

Discovery Time

Device appears instantly

AES-256

Encryption

Military-grade security

Impact Analysis

Discovery Time

Before

5-10s

After

<1s

10x Faster

Transfer Speed

Before

50Mbps

After

450Mbps

9x Improvement

Connection Success

Before

70%

After

98%

Reliable Discovery

Technology Stack

Tools & Frameworks

FlutterRustUDP/TCPZero-TiermDNSAES-256macOSWindowsAndroid

Implementation

UDP Device Discovery

Hybrid mDNS + UDP broadcast for instant device discovery on local networks.

logic.js

rust

1use std::net::UdpSocket;
2
3fn discover_devices() -> Vec<Device> {
4    let socket = UdpSocket::bind("0.0.0.0:54321")?;
5    socket.set_broadcast(true)?;
6    
7    // Send broadcast packet
8    let message = b"NEARSEND_DISCOVER";
9    socket.send_to(message, "255.255.255.255:54321")?;
10    
11    // Listen for responses
12    let mut devices = Vec::new();
13    socket.set_read_timeout(Some(Duration::from_secs(2)))?;
14    
15    loop {
16        let mut buf = [0u8; 1024];
17        match socket.recv_from(&mut buf) {
18            Ok((size, addr)) => {
19                if let Ok(response) = parse_response(&buf[..size]) {
20                    devices.push(Device {
21                        name: response.name,
22                        ip: addr.ip(),
23                        platform: response.platform,
24                    });
25                }
26            }
27            Err(_) => break, // Timeout
28        }
29    }
30    
31    devices
32}

Performance

Performance Audits

Performance

SEO

Accessibility

100

Best Practices

"Finally, file sharing that just works. No accounts, no cloud, no waiting."

Product Manager, Design Studio

View All Projects