Last verified: October 2026 against the rclone documentation (current release v1.75.1); the filter and symlink behaviour was tested with rclone v1.75.1.
Here's how to get rclone doing what rsync was doing, but with real parallelism. ### 1. Install it ```bash sudo -v ; curl https://rclone.org/install.sh | sudo bash ``` or via a package manager (`dnf install rclone`, `apt install rclone`, `brew install rclone`, etc.). The rclone docs note that distribution packages are often out of date, so the install script or the official binaries are the better way to get the current version. ### 2. Configure a remote Rclone needs a "remote" config pointing at your server. For an SSH target the **SFTP backend** is the simple option: it works over your existing SSH setup, no extra service needed. ```bash rclone config ``` Walk through the prompts: - `n` for new remote - name it, e.g. `myserver` - type: `sftp` - host: `server.example.com` - user: `root` - port: 22 (default) - leave the rest default, use SSH agent or key auth if you have it set up Or skip the wizard and write it directly to `~/.config/rclone/rclone.conf`: ```ini [myserver] type = sftp host = server.example.com user = root ``` Or use the inline command to create the config file Run this single command (replace YOUR.SERVER.IP with the real IP or hostname): ```bash rclone config create myserver sftp host=YOUR.SERVER.IP user=root pass=$(rclone obscure 'YOUR_PASSWORD') ``` After it finishes, test the connection (`lsd` lists only the top-level directories; `ls` would list every file on the server recursively): ```bash rclone lsd myserver:/ ``` ### 3. Run the sync ```bash rclone sync /path/to/source/ myserver:/path/to/dest/ \ --progress \ --transfers=32 \ --checkers=32 ``` Key flags, and why: - **`sync`** — makes the destination match the source, including **deleting** extra files on the destination (like `rsync -a --delete`). Use `copy` instead if you don't want deletions, and try `--dry-run` first. - **`--transfers=32`** — number of files transferred in parallel. This is the big one for many-small-files workloads; rsync can't do this natively. Tune based on file count/CPU — 16–64 is a common range. - **`--checkers=32`** — parallel workers for comparing file existence/size/hash before transfer. - **`--progress`** — live stats, like rsync's `-P`. ### 4. Useful additions ```bash rclone sync /path/to/source/ myserver:/path/to/dest/ \ --progress \ --transfers=32 \ --checkers=32 \ --stats=5s \ --stats-one-line \ --exclude ".git/**" \ --dry-run ``` - `--dry-run` — test first, see what would change without touching anything - `--stats=5s --stats-one-line` — periodic compact progress instead of a wall of text - `--exclude` — same idea as rsync's exclude patterns - `--checksum` — only if you need content-based comparison instead of size+mtime (same cost tradeoff as rsync's `-c`) Pulling a Synology share to a local disk, with settings for a LAN and for a WAN link. To skip Synology's system folders (such as `@eaDir` and `#recycle`), exclude the folder *and its contents* with `/**`; a bare `--exclude "#recycle"` only matches a file with that name, so the folder's contents would still be copied. ```bash #LAN rclone sync myserver:/mnt/volume1/data_syno /mnt/volume1/data/ \ --exclude "@*" \ --exclude "@*/**" \ --exclude "#recycle/**" \ --multi-thread-streams=16 \ --buffer-size=128M \ --transfers=16 \ --progress \ --checkers=32 \ --sftp-concurrency=128 \ --log-level=INFO \ --stats=10s ``` ```bash #WAN rclone sync myserver:/mnt/volume1/data_syno /mnt/volume1/data/ \ --exclude "@*" \ --exclude "@*/**" \ --exclude "#recycle/**" \ --multi-thread-streams=4 \ --buffer-size=64M \ --transfers=8 \ --progress \ --checkers=16 \ --sftp-concurrency=64 \ --bwlimit=20M \ --log-level=INFO \ --stats=30s ``` Each continued line must end with a backslash `\`. `--fast-list` is left out because the SFTP backend does not support the ListR feature it relies on, so it has no effect there. `--sftp-concurrency=64` is already the default. ### 5. If SFTP itself is the bottleneck SFTP-over-SSH still has per-file protocol overhead. For raw speed on a trusted LAN, rclone also supports: - **`type = local`** on both ends if you mount the remote filesystem (NFS/etc.) — no protocol overhead at all - Running an `rclone serve` daemon on the destination for a lighter native protocol But for your use case (SSH between two Linux boxes), the SFTP backend with high `--transfers` is usually the easy win — try it and compare wall-clock time against your rsync run. ### Multiple excludes Repeat the `--exclude` flag once per pattern: ```bash rclone sync /path/to/source/ myserver:/path/to/dest/ \ --progress \ --transfers=32 \ --checkers=32 \ --exclude "Revision/**" \ --exclude "ftpDataSite/**" \ --exclude "Backups/**" ``` The `/**` matches the folder and everything under it, anywhere in the tree. If these folders only live at the top level (not nested elsewhere), you can anchor them: ```bash --exclude "/Revision/**" --exclude "/ftpDataSite/**" --exclude "/Backups/**" ``` (leading `/` means "relative to the sync root only") If the list grows, it's cleaner to use a file instead of repeated flags: ```bash # excludes.txt Revision/** ftpDataSite/** Backups/** ``` ```bash rclone sync /path/to/source/ myserver:/path/to/dest/ \ --progress --transfers=32 --checkers=32 \ --exclude-from excludes.txt ``` You can test what's actually getting matched with: ```bash rclone sync ... --exclude-from excludes.txt --dry-run -vv ``` ### Symlinks This is the part worth being careful about — rclone's symlink behaviour differs from rsync's. By default, rclone **does not copy symlinks**: it skips them and logs a notice for each one ("Can't follow symlink without -L/--copy-links"). Your options: **Follow symlinks and copy the actual file/directory contents** (like rsync's `-L`): ```bash --copy-links ``` Use this if you want the symlink target's real content transferred instead of a symlink pointer — e.g., if the destination server can't resolve the same symlink targets your source can. **Store symlinks as .rclonelink files** (`-l` / `--links`): ```bash --links ``` With an SFTP destination this does **not** create real symlinks. Each link is stored as a small text file named `