Syncthing vs rsync for Keeping a Second Copy: Continuous Sync or a Scheduled Mirror
Colin Dyer
November 20, 2026
You have files on a laptop, a desktop or a phone, and you want a second copy of them on a NAS or a small server at home. Two free tools keep coming up: Syncthing, which keeps folders matched across devices all the time, and rsync, the decades-old command that copies only what changed and is usually run on a timer. Both can produce a second copy. They produce very different kinds of second copy, and the difference matters most on the day something goes wrong.
Two different ideas of a “copy”
Syncthing is a continuous, peer-to-peer sync program. Each device runs it, the devices find each other, and a shared folder is kept identical on all of them. Per the Syncthing documentation, changes are picked up by a filesystem watcher that is on by default, backed by a full rescan that runs about once an hour. The watcher batches changes for 10 seconds (the fsWatcherDelayS setting), and deletions are held for an extra minute before they are announced. After that, every connected device applies the change. The current release line is 2.1; version 2.0, released in August 2025, moved Syncthing’s internal database from LevelDB to SQLite.
rsync is a one-way copy tool. You run it, it compares a source with a destination, sends whatever is different, and exits. By default it decides what to transfer with a “quick check” of file size and modification time, and for files that did change it can send only the changed parts. It is normally run over SSH to another machine and scheduled with cron or a systemd timer. Nothing happens between runs. The project’s site lists rsync 3.5.2, released in November 2026, as current; recent releases have been heavy on security fixes, so keep both ends updated.
So Syncthing gives you a copy seconds behind, in every direction; rsync gives you a copy as old as your last run, in one direction.
Why a live mirror is not a backup
The feature that makes Syncthing pleasant, that changes show up everywhere almost immediately, is also its weakness as a safety net. If you delete a folder on the laptop by mistake, Syncthing deletes it on the NAS too, about a minute later. If ransomware encrypts your documents, Syncthing faithfully syncs the encrypted files. A plain two-way sync protects you from a dead disk or a stolen laptop. It does not protect you from yourself, from a buggy app that corrupts files, or from malware.
A naive rsync job has the same problem in a slower form. Run rsync -a --delete every night and the destination becomes an exact mirror each night, including that day’s accidental deletion. Your only protection is noticing the mistake before the job fires.
Making Syncthing safer: folder types and file versioning
Syncthing lets you set a folder type per device. The documentation describes three main ones:
- Send & Receive is the default. Changes flow both ways.
- Send Only ignores changes coming from other devices. If the folder drifts out of sync, an “Override Changes” button forces the local state onto the others.
- Receive Only applies changes from the other devices but does not send local changes back out. If something changes locally, a “Revert Local Changes” button restores the cluster’s version.
There is also a Receive Encrypted type, meant for a device you do not fully trust, such as a rented server: it stores the data encrypted and cannot read it.
For a laptop-to-NAS copy, a sensible layout is Send Only on the laptop and Receive Only on the NAS. You set it in the folder’s edit dialog under the Advanced tab (the type attribute in config.xml takes values such as sendonly and receiveonly). This stops changes made on the NAS from leaking back to the laptop. It does not stop a deletion on the laptop from reaching the NAS.
For that you need file versioning, which is off by default. Syncthing offers four types, set under the folder’s File Versioning tab:
- Trash Can moves replaced or deleted files into a
.stversionsfolder, optionally cleaned out after a number of days. - Simple keeps a fixed number of old versions of each file.
- Staggered keeps versions at thinning intervals up to a maximum age you set (the docs use 365 days as an example).
- External hands the old file to a script of your choice.
One detail in the documentation is easy to miss and important: versioning only applies to changes received from other devices. Syncthing cannot archive the old version of a file you edit or delete locally on that same device. So you enable versioning on the NAS, not on the laptop. When the laptop deletes a file, the NAS receives the deletion and moves its copy into .stversions instead of discarding it.
Even with that set up, the versions live on the same disk as the synced folder and are reachable through the same path. It is a recovery bin, not an independent backup. If the NAS itself fails or is encrypted by malware with access to that share, the versions go with it.

Making rsync safer: backup directories and hard-linked snapshots
rsync has two well-documented ways to keep history.
The simple one is --backup with --backup-dir. Per the rsync manual, when a file on the destination would be overwritten or deleted, it is moved into the backup directory instead. Pair it with --delete and a dated directory name, and every run leaves behind a folder of whatever that run replaced or removed.
The more popular approach is --link-dest, which builds a full-looking snapshot per run while only storing changed files. Files that are unchanged since the previous snapshot are hard-linked to it rather than copied. The manual notes that files must match in all preserved attributes, such as permissions and possibly ownership, to be linked, and that a relative --link-dest path is resolved relative to the destination directory. A minimal nightly job looks like this:
rsync -a --delete --link-dest=/srv/backup/laptop/2026-11-19 /home/you/Documents/ backup@nas:/srv/backup/laptop/2026-11-20/
Here -a (archive mode) recurses and preserves almost everything, the trailing slash on the source copies the contents of Documents rather than the folder itself, and --delete only affects the new dated snapshot, so yesterday’s snapshot still holds anything you deleted today. In a real script you would compute the dates and point --link-dest at the newest existing snapshot. The manual’s own advice before using --delete on a new job is worth following: run it first with --dry-run (-n) and read what it plans to remove.
This pattern gives you browsable, point-in-time folders that need no special tool to restore from: you copy files back with any file manager. Pruning old snapshots is your job, and a snapshot is only as safe as the server it sits on. If you want encryption, deduplication across machines and off-site copies handled for you, a dedicated tool is a better fit; the comparison of homelab backup tools such as restic, Kopia and Borg covers that layer.
Scenario: laptop documents to a home NAS
If the laptop is a Linux or macOS machine that is usually on the home network, a nightly rsync job with --link-dest snapshots is hard to beat for simplicity. It is one-way by design, so nothing on the NAS can ever flow back and damage the laptop, and every night produces a restore point. The cost is that work since the last run is unprotected, and a laptop that is asleep when the timer fires misses that night.
Syncthing suits the laptop that roams. It reconnects whenever both machines can see each other, including from outside the house, and copies changes within seconds. With Send Only on the laptop, Receive Only plus Staggered versioning on the NAS, you get near-real-time protection against disk failure and a reasonable undo window for deletions. Many people end up running both: Syncthing to get the files onto the NAS quickly, and a real backup job on the NAS that takes snapshots and sends them somewhere else.
Scenario: two computers you actually work on
If you edit the same files on a desktop and a laptop, rsync is the wrong tool. It has no notion of two-way sync, so running it in both directions invites one machine’s old copy to overwrite the other’s new work. This is Syncthing’s home ground.
Conflicts still happen. Per the Syncthing docs, when the same file changes on two devices before they sync, the version with the older modification time loses and is renamed to filename.sync-conflict-<date>-<time>-<device>.ext. Conflict copies are synced like normal files, so you see them on every device and resolve them by hand. Nothing is silently lost, but you do need to look. If your choice is between Syncthing and a fuller file platform for this job, the futurion comparison of Syncthing vs Nextcloud for two laptops goes deeper.

Scenario: phones and the Android app situation
rsync is not a practical phone tool. Syncthing is the usual way to get photos and documents off an Android phone without a cloud service, but the app picture changed. The official Syncthing Android app was discontinued in late 2024; its repository is archived and it received no releases after December 2024. The community fork, Syncthing-Fork, carries on. Its repository has moved to researchxxl/syncthing-android under new maintainers, and the project points users to GitHub releases and F-Droid for builds. Treat it as a community project and check its release activity before you depend on it.
On iOS there is no official Syncthing app; Möbius Sync is a third-party client built on Syncthing, free to try with a small storage cap and a paid unlock.
Phones are where Receive Only on the NAS earns its keep: a phone that wipes or mangles its camera folder cannot push that damage anywhere if the NAS refuses to treat itself as a source, and versioning on the NAS keeps the previous copies of anything the phone deletes.
Lots of small files, big files and first runs
Syncthing splits each file into blocks between 128 KiB and 16 MiB, depending on file size, and hashes every block with SHA-256. When a file changes, it compares block lists and only fetches blocks that differ, and it can reuse matching blocks from other local files. The trade-off is that it has to read and hash a file completely to learn what changed, and it keeps an index of every file and block on every device. Folders with hundreds of thousands of small files, such as source trees with dependency folders, photo library caches or mail stores, mean a big index and long initial scans. Version 2.1 added an option to turn off block indexing per folder, which helps where block reuse is not worth the cost.
rsync keeps no state between runs. Each run walks both trees and compares sizes and timestamps, which is cheap per file but adds up across very large trees. With --link-dest it also creates a hard link per unchanged file per snapshot, so years of snapshots of millions of files mean a very large number of directory entries to walk and prune.
For either tool, exclude what you do not need. Syncthing uses an .stignore file per folder; rsync uses --exclude and --exclude-from.
Networks, firewalls and relays
rsync over SSH needs exactly one thing: the source can reach the destination’s SSH port. That makes it easy to reason about and easy to lock down with a dedicated user and key. It also means a laptop outside your home network needs a VPN or an exposed SSH port to reach the NAS.
Syncthing handles reachability for you. Its firewall documentation lists port 22000 on TCP and UDP (QUIC) for the sync protocol and 21027/UDP for local discovery. Devices outside the LAN find each other through global discovery servers, and if no direct connection can be made, traffic goes through a community relay. Per the docs, relayed data stays end-to-end encrypted, but relays are much slower than a direct link, and the relay operator can see device IDs, IP addresses and how much traffic passes. Syncthing keeps retrying a direct connection and drops the relay when one works. If you want no third parties involved, you can disable global discovery and relaying in the settings and connect devices by address, typically over your own VPN.
Picking a tool for your second copy
Choose rsync on a schedule when the copy only ever needs to flow one way, from a machine that is reliably on the network to a server you control, and you want dated snapshots you can browse with no special software. It is the closer of the two to a backup out of the box, as long as you use --link-dest or --backup-dir rather than a bare --delete mirror.
Choose Syncthing when devices roam, when you edit on more than one machine, or when a phone is involved. Then do the extra setup that turns it from a mirror into a safety net: Receive Only on the NAS, Staggered or Trash Can versioning on the NAS, and ignore patterns for junk folders. If you are weighing it against a commercial peer-to-peer option, see Syncthing vs Resilio Sync for laptops and a NAS.
Whichever you pick, the second copy still lives in your house. A fire, a theft or ransomware that reaches the NAS takes both copies at once. Treat Syncthing or rsync as the step that gets data onto the NAS, and add a versioned, preferably off-site backup behind it. Then test a restore before you need one: pick a file, delete it, and bring it back from last week.