Technical Capabilities

Features Deep Dive

Deskdrop focuses on absolute local privacy, timeline-first clipboard control, and deep hardware continuity. Explore the technical details that power our local mesh network.

Timeline-First Clipboard UX

Traditional cross-device clipboards silently hijack your local OS pasteboard, exposing your clipboard history to race conditions and accidental overwrites. Deskdrop completely redesigns this flow by isolating incoming copies in a sandboxed, visual Activity Feed.

✓Explicit Approval: Preview text, links, or images before pushing them into the OS pasteboard.
✓Type Safety: Filter and reject unsupported clipboard data structures at the protocol level.
✓Origin Tracking: See exactly which trusted device sent the content and at what timestamp.
✓Clipboard Pinning: Save frequent snippets or code blocks for rapid re-applying.

Hardware Continuity

By bypassing sluggish web wrappers, Deskdrop communicates directly with operating system low-level APIs via a unified Rust core. This guarantees responsive background tasks and seamless state synchronization.

Platform Profile

macOS Bindings

Deep integration with Apple Silicon system Nap controls and native menu bar UI elements for sub-second synchronization.

Core ArchitectureRust Engine + Swift App wrapper

OS IntegrationNative AppKit / Swift Event Loop

Power PolicyApp Nap Prevention (ProcessInfo)

Interactive Hooks Matrix

macos_bridge_hooks.swift

// macOS Native App Nap and Status Menu Core
import Foundation
import AppKit

func preventAppNap() -> NSObjectProtocol {
    let reason = "Active Peer-to-Peer file pipeline stream"
    return ProcessInfo.processInfo.beginActivity(
        options: [.idleSystemSleepDisabled, .suddenTerminationDisabled],
        reason: reason
    )
}

func syncClipboardWithCore() {
    let pboard = NSPasteboard.general
    if let contents = pboard.string(forType: .string) {
        // High-speed JNI/FFI Fused Core Call
        deskdrop_bridge_send_clipboard(contents)
    }
}

Resumable File Pipelines

Deskdrop implements a chunk-based transfer architecture designed to survive network disruption. Files are parsed into 256KB block sizes and streamed peer-to-peer over encrypted sockets.

Failsafe Progress Tracking: Senders and receivers continuously exchange index block hashes. If a link drops mid-stream, progress resumes at the last acknowledged chunk index.
Resource Safeguards: Transfers are bounded at a maximum payload threshold of 512MB per individual item to completely prevent socket heap attacks.
Path Traversal Defense: Native storage routines verify and sanitize file basenames before routing downloads directly into standard user-space Download roots.

Cryptographic Identity & Parity

We are actively developing security enhancements to make local discovery entirely anonymous before trust authentication takes place.

Opaque mDNS discovery

Moving from friendly-name discovery in plaintext local broadcasts to cryptographically generated UUIDs to protect network fingerprint privacy.

Windows IPC Contract Parity

Correcting Windows socket IPC bindings to support active diagnostic state relays and precise file progress telemetry identical to our macOS client.

Adaptive Link Telemetry

Wiring real-time bandwidth and signal metrics into active socket paths to dynamically adjust file transfer chunk sizes under shifting Wi-Fi conditions.

Proof-Based Onboarding

Upgrading device authorization workflows to require explicit cryptographic key exchanges and signature verification before establishing network state synchronizations.

See our engineering milestones

Our features map directly to our 4-phase core reliability roadmap. Check out exactly what is being tested right now in our live tracker.

Explore the Roadmap

// macOS Native App Nap and Status Menu Core import Foundation import AppKit func preventAppNap() -> NSObjectProtocol { let reason = "Active Peer-to-Peer file pipeline stream" return ProcessInfo.processInfo.beginActivity( options: [.idleSystemSleepDisabled, .suddenTerminationDisabled], reason: reason ) } func syncClipboardWithCore() { let pboard = NSPasteboard.general if let contents = pboard.string(forType: .string) { // High-speed JNI/FFI Fused Core Call deskdrop_bridge_send_clipboard(contents) } }