LAN File Transfer Desktop App with Drag-and-Drop Sharing

Moving large files between lab computers still means USB drives, email attachments or uploading to the cloud and downloading again — slow, and every hop leaves a copy somewhere else. On a local network, machines can talk to each other directly at full LAN speed, but students rarely get to build that path themselves: socket programming, peer discovery, chunked transfers with integrity checks, and resume logic are usually just theory. This project turns them into a working desktop app. Files are split into 1 MiB chunks, each hashed with SHA-256, streamed over a TLS-encrypted TCP connection to a peer discovered on the LAN, and reassembled at the other end. If the connection drops, the transfer resumes from the last confirmed chunk instead of starting over. The demo shows the full experience: a device list, a send queue with per-file progress and an aggregate speed chart, incoming transfer requests, a history log, and a settings panel covering ports, chunk size and bandwidth limits.

1. On launch, the app broadcasts its presence on the LAN (mDNS-style discovery) and listens for other instances, building the device list.
2. The user drops files into the send queue and selects a destination device from the sidebar.
3. Each file is split into 1 MiB chunks; a manifest with file name, size and chunk hashes is sent first over a TLS 1.3 TCP connection on the configured port.
4. Chunks stream to the peer, which acknowledges each one and verifies its SHA-256 hash before writing it to disk.
5. If the connection breaks, both sides remember the last acknowledged chunk and resume from there on reconnect.
6. The receiver gets an accept/decline prompt (unless the sender is a trusted device with auto-accept on), and completed files land in the configured save folder.
7. Every transfer — sent or received — is recorded in the history log with timestamps for the report.

Tech stack:

• Python 3 · PyQt / Tkinter desktop UI
• TCP sockets · TLS 1.3
• mDNS-style LAN discovery
• SHA-256 chunk integrity
• Matplotlib-style live charts
• Single-file web demo (HTML/CSS/JS)
• Git

• [Drag-and-drop send queue] Drop files into the app or browse for them; each file queues with a per-file progress bar, live speed, chunk counter and pause/cancel controls.
• [LAN device discovery] Peers appear automatically with names and IP addresses, the way mDNS/Bonjour discovery works — no manual IP entry needed.
• [Chunked, checksummed transfer] Files move in 1 MiB chunks with a per-chunk SHA-256 hash, so corruption is detected before a single bad byte lands on disk.
• [Auto-resume] If a transfer is interrupted, it restarts from the last acknowledged chunk instead of from zero.
• [TLS encryption] All transfer traffic runs over TLS 1.3, so files cannot be sniffed on shared lab or hostel networks.
• [Live speed graph] An aggregate throughput chart plus per-session totals shows exactly how the network behaves under load.
• [Receive requests & history] Incoming transfers need an explicit accept, and every completed transfer is logged with peer, size, direction and timestamp.
• [Configurable settings] Device name, port, chunk size, bandwidth cap, save location and auto-accept rules are all adjustable from the settings panel.

• Complete desktop application source code (Python)
• Protocol design document (framing, discovery, chunk format, resume logic)
• Working demo replicating the full UI and transfer flow
• Project report PDF (background, networking concepts, methodology, testing procedure)
• PPT presentation for final review
• Viva Q&A preparation document (sockets, TCP vs UDP, TLS, hashing, discovery)

• Transfers work only between devices on the same local network — there is no internet relay or NAT traversal.
• Discovery depends on the network allowing LAN broadcast/multicast; some locked-down college networks block it.
• Throughput figures are expected ranges on a Gigabit LAN, not measured claims — the report includes a buyer-run speed-test procedure.
• The demo simulates transfers in the browser; actual socket code ships in the Python application.
• Mobile apps are out of scope — this is a desktop-to-desktop utility.