Dropbox Got Expensive. Your Data Left the Building.
You opened your email, saw the “we’re updating our plans” subject line, and did the math. Forty bucks a month for files that live on someone else’s server, indexed by someone else’s crawler, and subject to someone else’s terms of service. Cool.
There are three serious self-hosted alternatives worth your time: Syncthing, Resilio Sync, and Seafile. They each solve the same problem differently — and picking the wrong one will have you re-migrating in six months. Let’s save you the pain.
The Architecture Difference (It Actually Matters)
Before the benchmarks and compose files, you need to understand what these tools fundamentally are, because the architecture determines everything else.
Syncthing is a pure P2P mesh. Every device talks directly to every other device. There’s no central server, no account, no company in the middle. When your laptop and NAS sync, they negotiate a direct connection. If they’re behind NAT, Syncthing falls back to community-run relay servers — but your data is end-to-end encrypted before it ever touches a relay. The relay sees encrypted bytes and nothing else.
Resilio Sync (née BitTorrent Sync) is also P2P but uses a DHT (Distributed Hash Table) for device discovery — the same mechanism that powers BitTorrent. It’s clever, and it scales beautifully for large files. The catch: Resilio is closed source and proprietary. You’re trusting a company you can’t audit.
Seafile is the odd one out. It’s a proper client/server application — you run a central Seafile server, and all clients connect to it. This makes it less “sync mesh” and more “self-hosted Dropbox.” Libraries, user accounts, sharing links, fine-grained ACLs — it’s the grown-up option when you need to share files with people who can’t configure a peer.
Setup: Docker Compose for All Three
Syncthing
Two-device pair: laptop and NAS. No account needed, just IDs.
services: syncthing: image: syncthing/syncthing:latest container_name: syncthing hostname: my-syncthing environment: - PUID=1000 - PGID=1000 volumes: - /home/user/sync:/var/syncthing ports: - 8384:8384 # Web UI - 22000:22000/tcp # Sync protocol - 22000:22000/udp - 21027:21027/udp # Discovery restart: unless-stoppeddocker compose up -d# Open http://localhost:8384# Add Remote Device → paste the device ID from your other machine# Share a folder → enable for the new deviceThat’s genuinely it. The web UI is clean. Syncthing auto-discovers devices on the same LAN via mDNS; for remote devices you paste the device ID once and you’re done. Per-folder versioning is a checkbox away — simple, staggered, or trash can mode.
Resilio Sync
Three-device setup with a read-only share to a friend.
services: resilio-sync: image: lscr.io/linuxserver/resilio-sync:latest container_name: resilio-sync environment: - PUID=1000 - PGID=1000 - TZ=America/New_York volumes: - ./config:/config - /data/resilio:/sync ports: - 8888:8888 # Web UI - 55555:55555 # Sync port restart: unless-stoppeddocker compose up -d# Open http://localhost:8888# Add folder → generates a secret key (read-write or read-only)# Share the read-only key with your friend — they paste it in their client# They get the files, can't push changes backThe read-only share is the killer feature for “here’s my media library, pull from it.” Your friend doesn’t need an account. They paste a key, they get the files. Done.
Seafile
Family file sharing with a web UI. This one needs a bit more infrastructure.
services: db: image: mariadb:10.11 container_name: seafile-db environment: - MYSQL_ROOT_PASSWORD=changeme - MYSQL_LOG_CONSOLE=true volumes: - ./seafile-db:/var/lib/mysql restart: unless-stopped
memcached: image: memcached:1.6-alpine container_name: seafile-memcached entrypoint: memcached -m 256 restart: unless-stopped
seafile: image: seafileltd/seafile-mc:11.0-latest container_name: seafile ports: - 80:80 volumes: - ./seafile-data:/shared environment: - DB_HOST=db - DB_ROOT_PASSWD=changeme - SEAFILE_ADMIN_PASSWORD=changeme - SEAFILE_SERVER_LETSENCRYPT=false - SEAFILE_SERVER_HOSTNAME=files.yourdomain.com - TIME_ZONE=America/New_York depends_on: - db - memcached restart: unless-stoppeddocker compose up -d# Wait ~60s for first-run init# Open http://localhost → log in as admin# Create users for family members# Create a Library → share with specific users or via linkPut Caddy or Nginx Proxy Manager in front of this for TLS. Seafile does not love being behind a reverse proxy at a subpath — use a subdomain.
Performance: Where Each One Shines
Large files (ISOs, video, backups): Resilio wins. BitTorrent-style chunking means a file can pull from multiple peers simultaneously, and Resilio is frankly excellent at saturating a link on big transfers. Syncthing is no slouch, but single-source transfers are single-source.
Many small files (code repos, dotfiles, notes): Syncthing is the better fit. Its per-file tracking handles churn well. Resilio can get chatty with metadata overhead on directories with thousands of tiny files.
Web access while traveling: Seafile is the only real option here. Syncthing and Resilio are desktop-first; Seafile has a proper web file browser, drag-and-drop uploads, and a drive client that FUSE-mounts your libraries.
The Feature Scorecard
Conflict Resolution
Syncthing creates .sync-conflict-YYYYMMDD-HHMMSS-MACHINEID files when two devices modify the same file before syncing. You resolve manually. It’s annoying but honest — you always know when a conflict happened.
Resilio handles conflicts similarly, renaming the older version. No automatic merge; it just preserves both and lets you sort it out.
Seafile tracks file history per-library (like Git, kind of). Last-write wins by default, but you can roll back to any previous version from the web UI. This is the most capable conflict story of the three.
Encryption
In transit: All three encrypt in transit. Syncthing uses TLS with device certificate pinning — you actually verify device identity, not just “some valid cert.” Resilio and Seafile use TLS.
At rest: Syncthing stores files on disk as plain files — encryption is your job (LUKS, ZFS native encryption, etc.). Resilio does the same. Seafile has encrypted libraries — you set a passphrase, the client encrypts before upload, the server never sees plaintext. This is the standout feature for threat models involving “I don’t fully trust my VPS host.”
Mobile Clients
All three have iOS and Android apps. Syncthing’s official Android app is solid; the iOS situation has historically been awkward (third-party apps, variable quality), though Möbius Sync has filled that gap adequately. Resilio’s mobile apps are polished and actually good. Seafile’s mobile apps are functional but feel like an afterthought compared to the desktop experience.
Multi-User Sharing
Syncthing: not designed for it. You can share a folder with another device, but there are no user accounts, no permission levels, no sharing links. It’s your devices talking to your other devices.
Resilio: read-write vs read-only keys, plus “owner” mode in Pro. Workable for small groups. No user accounts — just keys.
Seafile: proper multi-user from day one. Create accounts, set quotas, share libraries with individuals or groups, generate time-limited download links. This is the Dropbox replacement for households and small teams.
Versioning / File History
Syncthing: configurable file versioning per folder — none, trash can (deleted files go to .stversions), simple (keep N versions), staggered (more copies recent, fewer old). Set it and forget it.
Resilio: selective sync plus 30-day file history in the free tier, longer in Pro. Decent.
Seafile: Git-style per-file history with diffs viewable in the web UI. Roll back to any version. Best in class here.
Selective Sync
Syncthing: ignore patterns (.stignore file, gitignore syntax). No “sync only this subfolder” without creating separate sync shares.
Resilio: proper selective sync — you can choose which subfolders to sync on each device. Huge win for “I want the photos on my phone but not the 4K originals.”
Seafile: selective sync via the drive client. Libraries are the granularity — you choose which libraries to sync locally.
Resource Usage
Syncthing is remarkably lean. On a Raspberry Pi 4, it idles at ~30MB RAM and near-zero CPU when nothing is changing. It’s the choice if your NAS is a Pi or an old NUC.
Resilio is similarly light on its own, though the web UI process adds overhead.
Seafile needs MariaDB (or PostgreSQL in the community edition), and optionally memcached for caching. Budget 512MB RAM minimum, 1GB comfortable. This isn’t a complaint — it’s appropriate for what it does — but don’t spin it up on a Pi Zero and expect happiness.
The Trust Question
Syncthing is fully open source (MPL-2.0). You can read every line, compile it yourself, run your own relay. The community-run relay infrastructure is optional and your data is always encrypted before it touches a relay.
Resilio Sync is closed source and proprietary. You’re trusting a company to not do anything sketchy with the DHT traffic and sync protocol. The personal tier is free, Pro is ~$60/year. For huge-file workflows it may be worth it, but go in with eyes open about what you can and can’t verify.
Seafile is open source (AGPL for the community edition, commercial license for pro features). The server you run is the server your files go to — you own the whole stack.
When to Pick What
Pick Syncthing if:
- You want to sync your own devices (laptop, desktop, NAS, maybe a VPS)
- Open source is non-negotiable
- You don’t need user accounts or web-based file browsing
- You want something that works forever without depending on any company
Pick Resilio Sync if:
- You’re syncing very large files across many peers and want BitTorrent-style chunked transfers
- You need clean selective sync on mobile
- You can live with closed source in exchange for excellent performance
- The read-only key sharing model fits your use case (sharing a media library with a friend)
Pick Seafile if:
- You want a proper Dropbox replacement with user accounts and a web UI
- You’re sharing files with less technical family members who need browser-based access
- You want encrypted libraries where the server never sees your plaintext
- You’re comfortable running a database alongside the app
The Verdict
For syncing your own devices: Syncthing. Open source, dead simple, runs on everything, zero ongoing cost, zero company dependency. It should be your default.
For scaling huge-file transfers across many peers and you’re okay with closed source: Resilio. The BitTorrent engine genuinely performs.
For self-hosted family cloud storage with web UI, accounts, and sharing links: Seafile. It’s the one you deploy when your spouse asks “can I access our photos from my browser.”
The three tools barely compete — they serve different use cases. You might run Syncthing for your own config/code/notes mesh and Seafile for shared family photos. That’s not overthinking it, that’s just picking the right tool.
Your data. Your server. Your rules. Dropbox can keep the invoice.
