Rsync shows up in almost every serious backup discussion, yet it is often dismissed as old, unfriendly, or outdated compared to modern backup tools with polished interfaces. I have tried a lot of those tools over the years, and they work, right up until the moment something goes wrong, and you need to understand what actually happened.

The appeal of backup GUIs is obvious. They offer schedules, progress bars, and friendly labels that suggest everything is being handled for you. The problem is that they also tend to hide the mechanics of how files are copied, skipped, or deleted. When a backup fails, or files do not land where you expected them to, you are left digging through logs and settings screens to reconstruct the tool’s internal logic.

Rsync avoids this entire class of problems by refusing to abstract the process away. You tell it exactly what the source is, where the destination lives, and how changes should be handled, and it does nothing beyond that. It's boring, but you get to keep your data safe.

Rsync hands you the control

You also get customizability and transparency

Rsync ships with dozens of command-line options that let you control everything from filters and file attributes to sync behavior, network transport, bandwidth usage, permissions, and metadata. It is often described as “the mother of all file-copying tools,” and that feels accurate once you start using it seriously. You can tell rsync exactly what to include or exclude, whether to preserve ACLs and resource forks, how to behave when files disappear from the source, and how aggressive or conservative it should be when updating the destination. That level of control is one of the main reasons I prefer it over any other tool.

GUI backup tools take a very different approach. Apps like ChronoSync expose many options through polished interfaces, and to their credit, they are among the best in that category. You can exclude folders with a click, schedule backups, target network volumes, and encrypt destinations without touching Terminal. The problem is that every GUI is opinionated by design. When something goes wrong, you end up digging through logs, settings screens, and documentation trying to reconstruct what the tool decided to do on your behalf.

That transparency matters more than people realize. A folder full of normal files on an APFS or HFS+ volume can be read by almost anything that understands that filesystem. Even without rsync, you can mount the disk, inspect it manually, and copy files out with basic tools. That dramatically increases your odds of recovery when things go sideways. Compare that with Time Machine, which stores data inside a sparsebundle that relies on hard links and metadata that only macOS really understands. When Time Machine fails, it often fails completely, with little opportunity for partial recovery.

It is also worth noting that many GUI tools are effectively wrappers around rsync or similar engines. Carbon Copy Cloner bundles its own rsync binary internally for file-level operations, and ChronoSync uses a custom copy engine built on similar principles.

Rsync also offers better performance and automation

GUI tools are nowhere close

Performance is often cited as a reason to prefer GUI tools, and there is some truth to that, especially for initial backups. Rsync works file by file and compares metadata or checksums to decide what to transfer, which means the first run on a large volume can be slow. Most GUI tools can perform block-level copies for initial clones by reformatting the destination disk and copying raw blocks sequentially. That is significantly faster for the first pass. Once that clone exists, updates switch back to file-level behavior, at which point rsync and GUI tools are much closer in performance.

For incremental backups, rsync is often extremely efficient. It transfers only changed files, can resume partial copies, and can even update only the changed parts of large files when configured to do so. On mostly static datasets, this makes it very fast. Network backups are similar. Rsync typically runs over SSH, which adds encryption overhead, but on modern devices, this is rarely a bottleneck. On very old hardware, cipher choice can matter, but that is a tuning problem rather than a design flaw. In terms of memory usage, rsync is lightweight. GUI tools consume more resources simply because they are full applications.

Reliability over time is where rsync’s reputation really comes from. It has been around for decades, and its behavior is well understood. The main caveat on macOS is that Apple ships an outdated version of rsync by default, which historically lacked full support for modern Mac metadata. You can usually solve this by installing the current version via Homebrew or MacPorts and using the correct flags to preserve everything that matters. GUI tools handle this for you, which is a genuine advantage, and they tend to update quickly when Apple changes filesystem behavior.

Automation is another area where rsync shines. It is designed to be scripted. You can wrap it in shell scripts, schedule it with launchd, pipe output into logs or email, and integrate it into larger workflows that check disk health, verify copies, and prune old backups. The entire system lives in text files you can audit and version-control. GUI tools also support automation, but in more constrained ways.

Rsync is a backup tool you should stick to

Rsync is not user-friendly, and it is not modern in the way polished apps are. It does not hold your hand, and it will happily do destructive things if you tell it to, but that is also the point. Backups are not about aesthetics or comfort. If you are looking for more options to back up your data, check out these open-source backup options.