Website review
This review may include AI-generated content and is not individually verified. Domain, certificate and other facts come from the observed data on this page.
What is duplicity?
Duplicity is a command-line backup tool that combines two ideas: it stores backups as encrypted tar-format volumes, and it uses the rsync algorithm (via librsync) so that each run records only the parts of files that changed since the last backup. The archives are encrypted and/or signed with GnuPG, which means the server holding your backups cannot read or silently alter them. Backups can go to a local filesystem or to a remote file server.
What that means in practice
- Bandwidth- and space-efficient incrementals. If you change a few bytes in a large file, duplicity doesn't re-upload the whole file; it records a delta. This matters most for large, slowly changing files such as databases dumps, disk images or mailbox archives.
- Untrusted storage is acceptable. Because encryption happens before upload, you can use commodity object storage or a shared server without handing over readable data.
- Tar-format volumes. The output is a set of archive volumes rather than a proprietary repository format, which some people find easier to reason about and move around.
- Deleted files, Unix permissions, directories, symlinks, FIFOs and device files are supported; hard links are not. If your data relies heavily on hard links (some mail spools, some build trees, some photo libraries), that is a real limitation to plan around.
Typical users
A sysadmin backing up a server to object storage over ssh or S3-style protocols; a developer keeping an encrypted offsite copy of a home directory; a small organisation wanting restorable, encrypted archives without running its own backup server. The project describes itself as mature and in use for large personal and corporate backups, while noting that bugs can still exist—so treat it as production-capable but test your restores.
Where it sits among alternatives
| Approach | Strength | Trade-off |
|---|---|---|
| Duplicity | Encrypted, bandwidth-efficient incrementals to many backends | Command-line oriented; no hard links; restore workflow takes learning |
| Plain rsync to a server | Simple, fast, familiar | Server sees plaintext; no archive history |
| rdiff-backup | Similar delta approach, keeps a mirror plus reverse deltas | Not the same encryption model; different repository layout |
| tar + gpg scripts | Fully transparent, no dependencies beyond tar/gpg | You build and maintain the incremental logic yourself |
A concrete starting scenario
Suppose you run a small web server and want an encrypted copy in cheap object storage. You would install duplicity, create a GnuPG key, and run a full backup to the remote target, then schedule incremental runs. The first run is the slow one; later runs upload only changed blocks. The critical step is practising a restore to a scratch directory before you need it, since a backup you have never restored is an assumption rather than a fact.
Next step
Read the official documentation and requirements pages to confirm which backends and protocol helpers your system needs, then run one full backup and one restore of a small test directory. The project is at duplicity; its GitLab project hosts the bug tracker and source, and the manual covers backend-specific setup.
How does duplicity's incremental backup work with the rsync algorithm?
Duplicity combines two mechanisms: it uses the rsync algorithm to find what changed, then stores the result as encrypted tar-format volumes on a local or remote server. The rsync side is what keeps each incremental archive small — it records only the parts of files that differ from the previous backup rather than re-uploading whole files.
That matters most when you back up large, slowly changing files (mail stores, virtual disk images, database dumps). A pure "copy everything changed" tool re-sends the entire file when a few bytes change; duplicity's use of librsync lets it transmit only the changed portions. The trade-off is that building and comparing signatures costs local CPU and temporary space, and restoring requires walking the chain of incremental archives rather than reading one self-contained snapshot.
H3 What this looks like in practice
- First run: a full backup, written as encrypted tar volumes and uploaded.
- Later runs: duplicity computes librsync signatures/deltas, produces a new incremental volume set, and uploads just that.
- Server side: the storage provider only ever sees encrypted, signed archives, so it cannot read or silently alter your data — encryption and signing are handled locally via GnuPG.
- Restore: you need the full chain (or the relevant sequence of volumes) to reconstruct a given point in time.
H3 Practical decision criteria
- Choose duplicity if you want encryption-by-default, bandwidth-efficient incrementals, and flexibility in where archives land — the project lists many supported backends, including Amazon S3, Backblaze B2, Google Drive, Microsoft OneDrive, rclone, rsync, ssh/scp, WebDAV and local filesystems.
- Look elsewhere if you need hard-link preservation (duplicity supports deleted files, permissions, directories, symlinks, fifos and device files, but not hard links) or if you want every backup to be a standalone, instantly mountable snapshot.
- Watch the upgrade path: the project warns that mixing a distribution-packaged install with the tarball version can put files in different locations, so purge one before installing the other.
A concrete next step: run a full backup, then change a single large file slightly and run again — compare the bytes uploaded on the second run against the file's size. That single test tells you whether the rsync-based incrementals are delivering the savings your data profile needs. You can check current release details and supported backends at duplicity.
Which cloud storage services can duplicity back up to?
Duplicity's own documentation lists a broad set of backends it says have been written for it: Amazon S3, Backblaze B2, Dropbox, FTP, GIO, Google Docs, Google Drive, HSI, Hubic, IMAP, the local filesystem, Mega.co, Microsoft Azure, Microsoft OneDrive, par2, Rackspace Cloudfiles, rclone, rsync, Skylabel, ssh/scp, SwiftStack, Tahoe-LAFS and WebDAV. So if your question is "can it reach my storage?", the practical answer is that most mainstream object stores, consumer file-sync services, and plain server transports are covered, and rclone widens that further because rclone itself fronts many providers.
A useful way to think about the list is by the kind of destination rather than by brand:
- Object storage: Amazon S3, Backblaze B2, Rackspace Cloudfiles, SwiftStack, Microsoft Azure, Google Docs/Drive-style stores.
- Consumer sync services: Dropbox, Google Drive, Microsoft OneDrive, Mega.co, Hubic.
- Plain server transports: ssh/scp, rsync, FTP, WebDAV, local filesystem.
- Indirect or specialist routes: rclone (which can proxy to providers duplicity has no native backend for), Tahoe-LAFS, IMAP, par2 for redundancy, GIO for mounted locations.
Two caveats matter when choosing. First, the page says many protocols "in theory" could be supported and then lists those "so far" written — that is a statement about backends existing, not a guarantee that every one is equally maintained or equally fast. Second, duplicity encrypts and signs archives with GnuPG before upload, so the storage provider never needs to be trusted with plaintext; that is the main reason to pick duplicity over a provider's own sync client.
As a next step, decide based on how you will restore, not just how you will upload. If you want a provider-agnostic escape hatch, an rclone or ssh/scp target keeps your data in ordinary files you can retrieve without duplicity. If you want the cheapest cold storage, an object store backend fits, but test a restore from a small directory before committing a large backup set. The project's documentation and FAQ pages are the place to confirm the current backend list, since it changes over time.
How do I install and set up duplicity for the first time?
Duplicity is a command-line backup tool that creates encrypted, incremental tar archives and uploads them to local or remote storage. Because it uses librsync, it only records changed parts of files after the first full backup; because it uses GnuPG, the server holding your backups cannot read or alter them. First-time setup therefore has two parts: get the software installed, then create a GPG key and a backup target before you run your first job.
Install it
Pick the method that matches how you manage software on the machine:
- Distribution package — fastest route on most Linux systems, and the version is maintained alongside your OS. The project warns that if you later move between a distribution package and the tarball/snap build, you should remove or purge the distribution version first, because the two may install in different locations and produce confusing results.
- Snap — the project documents
sudo snap install duplicity --classicfor the stable build, with an--edgevariant for the latest builds. This is useful when your distribution's version is old. - Tarball — the current release is 3.2.1. Use this if you want the newest code or need to build against specific libraries.
Whichever you choose, verify the install by running duplicity --version, then check duplicity --help to confirm which backends your build actually includes. Backend support varies by build and by the Python libraries present.
Prepare the two things duplicity needs
A GnuPG key. Duplicity encrypts and/or signs archives with GnuPG, so create or select a key pair before backing up. If you encrypt to a passphrase-less key you lose protection; if you encrypt to a key whose private key you lose, you lose the backups. Decide now whether you are encrypting to a key you hold (you can restore anywhere) or to a recipient key (safer if the backup host is untrusted but you must keep the private key safe).
A destination. Duplicity supports many protocols, including local filesystem, ssh/scp, rsync, ftp, WebDAV, IMAP, Amazon S3, Backblaze B2, Dropbox, Google Drive, Microsoft Azure and OneDrive, Rackspace Cloudfiles, rclone, Tahoe-LAFS and others. For a first run, a local directory or an ssh target is the least fiddly because credentials are already handled by your system. Remote object stores require you to supply credentials and often a bucket name.
Run a first backup
The shape of the command is: source directory, then destination URL.
duplicity /home/me/Documents scp://user@host//srv/backups/docs
The first run is a full backup. Subsequent runs are incremental and only store changed parts of files. Duplicity records full Unix permissions, directories, symbolic links, fifos and device files, and handles deleted files, but it does not support hard links — worth knowing before you point it at a tree that relies on them.
Set PASSPHRASE in the environment (or use --encrypt-key / --sign-key) so the job can run unattended. Then test a restore immediately, before you trust the setup:
duplicity restore scp://user@host//srv/backups/docs /tmp/restore-test
A backup you have never restored is a guess, not a backup.
Make it repeatable
Once the manual run works, put it in cron or a systemd timer. Keep a retention policy (--full-if-older-than plus remove-older-than) so the archive chain does not grow forever, and store the passphrase somewhere you can reach when the machine you are backing up is gone. For background on the algorithm and the file format, the project's own documentation and FAQ are the primary references: duplicity. If you want to compare approaches before committing, rdiff-backup is a related tool with a different model for keeping history.
A practical decision rule: use a local or ssh destination for your first setup because it removes credential variables, then switch to object storage once restores are proven.
What are the limitations of duplicity, such as hard links or file permissions?
Duplicity handles most Unix metadata well but deliberately skips hard links. Its own documentation states it supports deleted files, full Unix permissions, directories, symbolic links, fifos and device files — but not hard links. In practice, a hard-linked set of files is stored as separate copies, which wastes space and breaks the link relationship on restore.
Two other trade-offs follow from its design:
- Archive format, not a browsable mirror. Backups are encrypted tar-format volumes, so restoring means running duplicity rather than simply copying files back from the server.
- Server-side trust is limited by GnuPG. Archives can be encrypted and/or signed so the storage provider cannot read or silently alter them — but if you lose the passphrase, the backup is effectively gone.
- Incremental chains. Because it uses librsync, only changed parts of files are recorded, which is space-efficient but makes long chains more sensitive to corruption or missing volumes.
Practical decision guide
| Need | Duplicity fit |
|---|---|
| Preserve permissions, symlinks, fifos, device files | Yes |
| Preserve hard links | No |
| Encrypted, bandwidth-efficient offsite backup | Yes, core strength |
| Restore by browsing files directly on the server | No — use the duplicity client |
| Very large numbers of hard-linked files (e.g. some mail or VM stores) | Poor fit; consider another tool |
Example
A sysadmin backing up /etc, /home and a web root to object storage gets permissions and symlinks restored correctly. If /home contains hard-linked maildir files or deduplicated build trees, those links become independent copies, inflating storage and changing behaviour after restore.
Next step
List your hard-linked files first (find /path -samefile or find /path -links +1) and estimate their size. If the total is small, duplicity's encryption and incremental efficiency usually outweigh the hard-link gap; if it is large, choose a backup tool that preserves hard links and keep duplicity for the rest. The project's FAQ and documentation at duplicity cover restore procedures and supported backends in more detail.
How can I restore files from a duplicity backup?
Restoring from a duplicity backup means pointing the duplicity command at the same backend location and telling it which files and which point in time you want back. Duplicity stores encrypted tar-format volumes, so the restore process also needs the GnuPG key or passphrase that was used when the backup was made.
The page describes duplicity as producing encrypted tar-format volumes and uploading them to a remote or local file server, using librsync so incremental archives record only changed parts of files. It also lists many supported backends, including local filesystem, ssh/scp, rsync, Amazon S3, Backblaze B2, Google Drive, Microsoft OneDrive, WebDAV, and rclone. That matters for restore because the first argument you supply is the source URL — the same kind of URL you used for backup.
What a restore looks like in practice
A typical restore command follows this shape:
duplicity restore <source-url> <target-directory>
For example, if you backed up to a local mounted drive, the source URL might be file:///mnt/backup, and the target might be /home/you/restored. If you used a remote backend, the URL will look different depending on the protocol, but the principle is the same: duplicity reads the archive volumes from that location and reconstructs the files into the target directory.
To restore a specific point in time rather than the latest state, use the time options. Duplicity supports restoring as of a given date, for example with --time or -t followed by a date, or by using --restore-time. This is useful when a file was deleted or corrupted after a later backup, and you need the version from before the damage.
To restore only certain files or directories, add --path-to-restore or pass a file pattern. Duplicity can also list what is in the archive before restoring, which is a sensible first step if you are unsure of paths or dates. The page notes that duplicity currently supports deleted files, full unix permissions, directories, symbolic links, fifos, and device files, but not hard links — so a restore will bring back symlinks and permissions, but hard-link relationships will not be preserved as hard links.
A practical decision path
If you are restoring after accidental deletion, start by listing the archive contents and available backup times, then restore the smallest path you need into a temporary directory. Copy the recovered files into place only after you have confirmed they are the right versions. This avoids overwriting newer work with an older snapshot.
If you are restoring an entire system, restore to a separate location first, check ownership and permissions, and then move or sync the data into production. Because duplicity preserves unix permissions and special files, restoring directly over a live system can change permissions on files that are currently in use.
If the backup is encrypted and you do not have the passphrase or private key, the restore cannot proceed. The page is explicit that GnuPG is used to encrypt and/or sign the archives, which protects them from spying or modification by the server — but it also means the key is required to read them.
Where to check details
The duplicity project site at duplicity includes documentation, a FAQ, and the current release information. The page also points to a mailing list for questions and a GitLab project for bug reports. If your restore fails because of a version mismatch, note the page's warning about mixing distribution packages and tarball installs: remove or purge the distribution version before switching, since the two may install in different locations and produce confusing results.
For a concrete next step, run a listing command against your backup URL before restoring anything. That confirms the archive is reachable, the passphrase works, and the date you want is actually present — all before you write files to disk.
User reviews (0)