{"id":165101,"date":"2026-03-30T18:40:48","date_gmt":"2026-03-30T15:40:48","guid":{"rendered":"https:\/\/computingforgeeks.com\/?p=165101"},"modified":"2026-03-31T10:47:42","modified_gmt":"2026-03-31T07:47:42","slug":"borg-restic-kopia-comparison","status":"publish","type":"post","link":"https:\/\/computingforgeeks.com\/borg-restic-kopia-comparison\/","title":{"rendered":"Borg vs Restic vs Kopia: Backup Tools Benchmarked"},"content":{"rendered":"\n<p>Three backup tools dominate the open-source Linux backup space: BorgBackup, Restic, and Kopia. All three offer deduplication and encryption. All three have loyal communities insisting theirs is the best. The internet is full of opinions, but few comparisons include actual benchmark numbers. This one does.<\/p>\n\n\n\n<p>We installed all three on the same Ubuntu 24.04 VM, pointed them at the same 370 MB test dataset, and measured first backup speed, incremental performance, restore time, memory usage, and repository efficiency. The results reveal clear strengths for each tool, which should make your decision easier. If you already use one of these tools, check our dedicated guides for <a href=\"https:\/\/computingforgeeks.com\/borgbackup-borgmatic-linux\/\" target=\"_blank\" rel=\"noreferrer noopener\">BorgBackup with Borgmatic<\/a>, <a href=\"https:\/\/computingforgeeks.com\/backup-to-s3-sftp-server-using-restic\/\" target=\"_blank\" rel=\"noreferrer noopener\">Restic with S3\/SFTP<\/a>, and <a href=\"https:\/\/computingforgeeks.com\/backup-linux-windows-kopia\/\" target=\"_blank\" rel=\"noreferrer noopener\">Kopia on Linux and Windows<\/a>.<\/p>\n\n\n\n<p><em>Current as of <strong>March 2026<\/strong>. Benchmarked on Ubuntu 24.04.4 LTS with BorgBackup 1.2.8, Restic 0.16.4, and Kopia 0.22.3<\/em><\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Test Setup<\/h2>\n\n\n\n<p>Every benchmark ran on the same machine to keep things fair: Ubuntu 24.04.4 LTS, 2 vCPU, 4 GB RAM, 30 GB SSD. The test dataset was 370 MB spread across 1,957 files in four categories:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>Small files<\/strong>: 1,000 files (1 to 10 KB each), 7.3 MB total<\/li>\n\n\n\n<li><strong>Medium files<\/strong>: 100 files (100 KB to 1 MB), 51 MB total<\/li>\n\n\n\n<li><strong>Large files<\/strong>: 10 files (10 to 50 MB each), 306 MB total<\/li>\n\n\n\n<li><strong>Mixed<\/strong>: a copy of <code>\/etc<\/code> (839 regular files, 232 directories, 634 symlinks), 6.1 MB<\/li>\n<\/ul>\n\n\n\n<p>Each tool used its default encryption setting. All backups went to a local filesystem repository to eliminate network variables. Every tool got a fresh, empty repository with no prior data. Wall-clock time was measured with <code>\/usr\/bin\/time -v<\/code>, which also captured peak memory (maximum resident set size).<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Tools and Versions Tested<\/h2>\n\n\n\n<p>Each tool was installed on the same Ubuntu 24.04 VM. For complete installation and usage instructions, see the dedicated guides:<\/p>\n\n\n\n<ul class=\"wp-block-list\">\n<li><strong>BorgBackup 1.2.8<\/strong> (Python + C) &#8211; <a href=\"https:\/\/computingforgeeks.com\/borgbackup-borgmatic-linux\/\" target=\"_blank\" rel=\"noreferrer noopener\">BorgBackup with Borgmatic setup guide<\/a><\/li>\n\n\n\n<li><strong>Restic 0.16.4<\/strong> (Go, single binary) &#8211; <a href=\"https:\/\/computingforgeeks.com\/restic-backup-s3-linux\/\" target=\"_blank\" rel=\"noreferrer noopener\">Restic backup to S3 setup guide<\/a><\/li>\n\n\n\n<li><strong>Kopia 0.22.3<\/strong> (Go, single binary) &#8211; <a href=\"https:\/\/computingforgeeks.com\/backup-linux-windows-kopia\/\" target=\"_blank\" rel=\"noreferrer noopener\">Kopia backup setup guide<\/a><\/li>\n<\/ul>\n\n\n\n<p>All three tools were configured with their default encryption enabled and pointed at local filesystem repositories to eliminate network variables from the benchmarks.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">First Backup Speed<\/h2>\n\n\n\n<p>The first backup is the most expensive. Every file must be read, chunked, compressed, encrypted, and written to the repository. This is where raw throughput matters.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">BorgBackup: 7.81 seconds<\/h3>\n\n\n\n<p>Initialize a new encrypted repository, then back up the test data:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>export BORG_PASSPHRASE=\"benchmarktest\"\nborg init --encryption=repokey \/tmp\/borg-repo\n\/usr\/bin\/time -v borg create \/tmp\/borg-repo::backup1 \/home\/testuser\/testdata 2&gt;&amp;1 | grep -E \"wall clock|Maximum resident\"<\/code><\/pre>\n\n\n\n<p>Borg finished in 7.81 seconds wall clock. The archive summary shows the dedup engine at work:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>Duration: 7.06 seconds\nNumber of files: 1957\n                       Original size      Compressed size    Deduplicated size\nThis archive:              381.05 MB            379.81 MB            379.78 MB<\/code><\/pre>\n\n\n\n<p>With no prior data in the repo, deduplication saved almost nothing on the first run. The small gap between original and compressed size (0.3%) is expected because the test data is mostly random bytes.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Restic: 8.10 seconds<\/h3>\n\n\n\n<p>Initialize and run the first backup:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>export RESTIC_PASSWORD=\"benchmarktest\"\nrestic init --repo \/tmp\/restic-repo\n\/usr\/bin\/time -v restic backup --repo \/tmp\/restic-repo \/home\/testuser\/testdata 2&gt;&amp;1 | grep -E \"wall clock|Maximum resident\"<\/code><\/pre>\n\n\n\n<p>Restic&#8217;s output is straightforward:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>Files:        1957 new,     0 changed,     0 unmodified\nAdded to the repository: 364.299 MiB (362.204 MiB stored)\nprocessed 1957 files, 363.401 MiB in 0:07\nsnapshot 60f9c70c saved<\/code><\/pre>\n\n\n\n<p>Total wall-clock time including overhead: 8.10 seconds. Very close to Borg.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Kopia: 4.65 seconds<\/h3>\n\n\n\n<p>Create a filesystem repository and run the backup:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>kopia repository create filesystem --path \/tmp\/kopia-repo --password benchmarktest\n\/usr\/bin\/time -v kopia snapshot create \/home\/testuser\/testdata 2&gt;&amp;1 | grep -E \"wall clock|Maximum resident\"<\/code><\/pre>\n\n\n\n<p>Kopia was noticeably faster:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>Created snapshot with root k20adeb0165392df3c7971e12d47e2b12 in 4s<\/code><\/pre>\n\n\n\n<p>4.65 seconds. Kopia&#8217;s Go implementation with parallel hashing gives it a real edge on initial backups. It processed the same data nearly twice as fast as Borg and Restic.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">First Backup Verdict<\/h3>\n\n\n\n<p>Kopia wins by a clear margin. Borg and Restic are nearly tied, with Borg slightly faster. On larger datasets (tens of GB), the gap would widen further because Kopia parallelizes hashing across CPU cores while Borg&#8217;s Python layer adds overhead per chunk.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Incremental Backup Speed<\/h2>\n\n\n\n<p>A second backup with zero file changes tests pure metadata scanning speed. This is the operation that runs most often in production, because most backup windows see only a small fraction of files changed.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">BorgBackup: 0.70 seconds<\/h3>\n\n\n\n<p>Run a second backup against the same unchanged data:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>\/usr\/bin\/time -v borg create \/tmp\/borg-repo::backup2 \/home\/testuser\/testdata 2&gt;&amp;1 | grep -E \"wall clock|Maximum resident\"<\/code><\/pre>\n\n\n\n<p>Borg recognized every file was unchanged and stored only 645 bytes of new metadata:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>Duration: 0.28 seconds\n                       Original size      Compressed size    Deduplicated size\nThis archive:              381.05 MB            379.81 MB                645 B\nAll archives:              762.11 MB            759.62 MB            379.93 MB<\/code><\/pre>\n\n\n\n<p>645 bytes for a duplicate snapshot. That is deduplication working exactly as designed.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Restic: 0.81 seconds<\/h3>\n\n\n\n<p>Same test with Restic:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>\/usr\/bin\/time -v restic backup --repo \/tmp\/restic-repo \/home\/testuser\/testdata 2&gt;&amp;1 | grep -E \"wall clock|Maximum resident\"<\/code><\/pre>\n\n\n\n<p>Restic shows zero new data added:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>Files:           0 new,     0 changed,  1957 unmodified\nAdded to the repository: 0 B   (0 B   stored)\nprocessed 1957 files, 363.401 MiB in 0:00<\/code><\/pre>\n\n\n\n<p>0.81 seconds total. Slightly slower than Borg because Restic walks the file tree and checks each file&#8217;s metadata before deciding nothing changed.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Kopia: 0.28 seconds<\/h3>\n\n\n\n<p>Kopia&#8217;s incremental run:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>\/usr\/bin\/time -v kopia snapshot create \/home\/testuser\/testdata 2&gt;&amp;1 | grep -E \"wall clock|Maximum resident\"<\/code><\/pre>\n\n\n\n<p>The output shows everything served from cache:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>0 hashing, 0 hashed (0 B), 2594 cached (381.1 MB), uploaded 0 B\nCreated snapshot in 0s<\/code><\/pre>\n\n\n\n<p>0.28 seconds. Kopia&#8217;s aggressive caching means it barely touches the filesystem on unchanged data.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Incremental Verdict<\/h3>\n\n\n\n<p>Kopia is fastest again, but all three are sub-second. In practice, the difference between 0.28s and 0.81s is irrelevant for nightly backups. What matters is that all three correctly detected zero changes and stored essentially nothing new.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Restore Speed<\/h2>\n\n\n\n<p>Backup speed gets all the attention, but restore speed is what matters when your data is gone and your boss is watching. We restored the full snapshot to a temporary directory and timed it.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">BorgBackup: 0.16 seconds<\/h3>\n\n\n\n<p>Restore with Borg:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>mkdir \/tmp\/restore-borg\ncd \/tmp\/restore-borg\n\/usr\/bin\/time -v borg extract \/tmp\/borg-repo::backup1 2&gt;&amp;1 | grep -E \"wall clock|Maximum resident\"<\/code><\/pre>\n\n\n\n<p>0.16 seconds. Borg&#8217;s streaming archive format reads sequentially through the repository, which is extremely fast for full restores.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Restic: 3.67 seconds<\/h3>\n\n\n\n<p>Restore with Restic:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>\/usr\/bin\/time -v restic restore latest --repo \/tmp\/restic-repo --target \/tmp\/restore-restic 2&gt;&amp;1 | grep -E \"wall clock|Maximum resident\"<\/code><\/pre>\n\n\n\n<p>3.67 seconds. Restic must reassemble files from individual content-addressed blobs, which adds overhead compared to Borg&#8217;s sequential read.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Kopia: 4.39 seconds<\/h3>\n\n\n\n<p>Restore with Kopia:<\/p>\n\n\n\n<pre class=\"wp-block-code\"><code>\/usr\/bin\/time -v kopia restore k20adeb0165392df3c7971e12d47e2b12 \/tmp\/restore-kopia 2&gt;&amp;1 | grep -E \"wall clock|Maximum resident\"<\/code><\/pre>\n\n\n\n<p>4.39 seconds. Similar to Restic. Both Go-based tools use a content-addressed object store that requires more random reads during restore.<\/p>\n\n\n\n<h3 class=\"wp-block-heading\">Restore Verdict<\/h3>\n\n\n\n<p>Borg dominates here. It restored the entire 370 MB dataset in 0.16 seconds, roughly 23x faster than Restic and 27x faster than Kopia. Borg&#8217;s archive format stores data in a sequential stream optimized for full restores. Restic and Kopia store data as individual content-addressed objects, which is more flexible (better for partial restores and cloud backends) but slower for full restores from local disk.<\/p>\n\n\n\n<p>If fast disaster recovery from local repos is your priority, Borg has a commanding advantage.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Memory Usage<\/h2>\n\n\n\n<p>Peak resident set size (RSS) tells you how much RAM each tool actually needs. This matters on small VMs, containers, or shared hosts where memory is limited.<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Operation<\/th><th>BorgBackup<\/th><th>Restic<\/th><th>Kopia<\/th><\/tr><\/thead><tbody><tr><td>First backup<\/td><td>75 MB<\/td><td>111 MB<\/td><td>176 MB<\/td><\/tr><tr><td>Incremental (no changes)<\/td><td>75 MB<\/td><td>54 MB<\/td><td>118 MB<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Borg is the most memory-efficient overall. Its peak stayed at 75 MB regardless of operation, which makes sense because its Python runtime allocates a relatively fixed working set. Restic dropped to 54 MB on incremental backups because it skipped all the chunking buffers. Kopia consistently used the most memory, peaking at 176 MB for the first backup.<\/p>\n\n\n\n<p>None of these numbers are concerning on a modern server with 4+ GB of RAM. But on a resource-constrained system (1 to 2 GB RAM, a Raspberry Pi, a small container), Borg is the safest choice. Kopia&#8217;s memory appetite could become a problem if you&#8217;re backing up very large datasets on tight hardware.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Repository Efficiency<\/h2>\n\n\n\n<p>How much disk space does each tool&#8217;s repository consume? We compared repo sizes after one snapshot and after two snapshots (with no file changes).<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Metric<\/th><th>BorgBackup<\/th><th>Restic<\/th><th>Kopia<\/th><\/tr><\/thead><tbody><tr><td>Repo size (1 snapshot)<\/td><td>363 MB<\/td><td>364 MB<\/td><td>365 MB<\/td><\/tr><tr><td>Repo size (2 snapshots, no changes)<\/td><td>363 MB<\/td><td>364 MB<\/td><td>365 MB<\/td><\/tr><tr><td>Compression savings<\/td><td>0.3%<\/td><td>0.6%<\/td><td>0.1%<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>All three are within 2 MB of each other. Deduplication works perfectly across the board: the second snapshot added essentially zero bytes to every repository. The minimal compression savings (under 1%) are expected because our test data is mostly random bytes generated with <code>dd if=\/dev\/urandom<\/code>. Random data doesn&#8217;t compress.<\/p>\n\n\n\n<p>With real-world data (log files, configuration files, source code, database dumps), compression savings would be dramatically higher. Borg defaults to lz4 compression, Restic uses zstd, and Kopia supports multiple algorithms including zstd and s2. For text-heavy workloads, expect 40 to 70% compression ratios from all three tools.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Benchmark Results Summary<\/h2>\n\n\n\n<p>The full results in one table. Green highlights indicate the best performer in each row.<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Metric<\/th><th>BorgBackup 1.2.8<\/th><th>Restic 0.16.4<\/th><th>Kopia 0.22.3<\/th><\/tr><\/thead><tbody><tr><td>First backup (wall clock)<\/td><td>7.81s<\/td><td>8.10s<\/td><td><strong>4.65s<\/strong><\/td><\/tr><tr><td>Incremental, no changes<\/td><td>0.70s<\/td><td>0.81s<\/td><td><strong>0.28s<\/strong><\/td><\/tr><tr><td>Restore (wall clock)<\/td><td><strong>0.16s<\/strong><\/td><td>3.67s<\/td><td>4.39s<\/td><\/tr><tr><td>Repo size (1 snapshot)<\/td><td><strong>363 MB<\/strong><\/td><td>364 MB<\/td><td>365 MB<\/td><\/tr><tr><td>Repo size (2 snapshots)<\/td><td><strong>363 MB<\/strong><\/td><td>364 MB<\/td><td>365 MB<\/td><\/tr><tr><td>Peak memory, first backup<\/td><td><strong>75 MB<\/strong><\/td><td>111 MB<\/td><td>176 MB<\/td><\/tr><tr><td>Peak memory, incremental<\/td><td>75 MB<\/td><td><strong>54 MB<\/strong><\/td><td>118 MB<\/td><\/tr><tr><td>Compression saved<\/td><td>0.3%<\/td><td><strong>0.6%<\/strong><\/td><td>0.1%<\/td><\/tr><tr><td>Encryption<\/td><td>repokey (AES-256)<\/td><td>AES-256 in CTR mode<\/td><td>AES-256-GCM<\/td><\/tr><tr><td>Dedup method<\/td><td>Content-defined chunking<\/td><td>Content-defined chunking<\/td><td>Content-defined chunking (BUZHASH)<\/td><\/tr><tr><td>Language<\/td><td>Python + C<\/td><td>Go<\/td><td>Go<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>Kopia leads in backup speed, Borg leads in restore speed and memory efficiency, and all three are nearly identical in storage efficiency. No single tool dominates every category.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">Feature Comparison<\/h2>\n\n\n\n<p>Benchmarks only tell part of the story. The right tool depends on what features you need beyond raw speed. This matrix covers the capabilities that matter most in production.<\/p>\n\n\n\n<figure class=\"wp-block-table\"><table class=\"has-fixed-layout\"><thead><tr><th>Feature<\/th><th>BorgBackup<\/th><th>Restic<\/th><th>Kopia<\/th><\/tr><\/thead><tbody><tr><td>Encryption<\/td><td>Yes (AES-256)<\/td><td>Yes (AES-256-CTR)<\/td><td>Yes (AES-256-GCM)<\/td><\/tr><tr><td>Deduplication<\/td><td>Yes<\/td><td>Yes<\/td><td>Yes<\/td><\/tr><tr><td>Compression<\/td><td>lz4, zstd, zlib, lzma<\/td><td>zstd (auto)<\/td><td>zstd, s2, pgzip, none<\/td><\/tr><tr><td>Cloud backends<\/td><td>No (SSH only)<\/td><td>S3, B2, Azure, GCS, SFTP<\/td><td>S3, B2, Azure, GCS, SFTP, Rclone<\/td><\/tr><tr><td>SSH backup<\/td><td>Yes (native)<\/td><td>Via rclone<\/td><td>Via SFTP<\/td><\/tr><tr><td>Append-only mode<\/td><td>Yes<\/td><td>Yes<\/td><td>ACL-based<\/td><\/tr><tr><td>GUI<\/td><td><a href=\"https:\/\/vorta.borgbase.com\/\" target=\"_blank\" rel=\"noreferrer noopener\">Vorta<\/a> (desktop client)<\/td><td>No<\/td><td>Yes (web UI on :51515)<\/td><\/tr><tr><td>Wrapper tool<\/td><td>Borgmatic<\/td><td>None needed<\/td><td>Built-in policies<\/td><\/tr><tr><td>Active development<\/td><td>Yes (Borg 2.0 in development)<\/td><td>Yes<\/td><td>Yes<\/td><\/tr><tr><td>Language<\/td><td>Python + C<\/td><td>Go<\/td><td>Go<\/td><\/tr><tr><td>Mount as filesystem<\/td><td>Yes (FUSE)<\/td><td>Yes (FUSE)<\/td><td>Yes (FUSE)<\/td><\/tr><tr><td>Windows support<\/td><td>No (WSL only)<\/td><td>Yes<\/td><td>Yes<\/td><\/tr><tr><td>Built-in scheduling<\/td><td>No (use systemd\/cron)<\/td><td>No (use systemd\/cron)<\/td><td>Yes (kopia server)<\/td><\/tr><tr><td>Retention policies<\/td><td>Manual (borg prune)<\/td><td>Built-in (forget &#8211;keep-*)<\/td><td>Built-in (policy set)<\/td><\/tr><\/tbody><\/table><\/figure>\n\n\n\n<p>The biggest differentiator is backend support. <a href=\"https:\/\/www.borgbackup.org\/\" target=\"_blank\" rel=\"noreferrer noopener\">BorgBackup<\/a> only talks to SSH remotes. <a href=\"https:\/\/restic.net\/\" target=\"_blank\" rel=\"noreferrer noopener\">Restic<\/a> speaks natively to every major cloud provider. <a href=\"https:\/\/kopia.io\/\" target=\"_blank\" rel=\"noreferrer noopener\">Kopia<\/a> matches Restic&#8217;s backend support and adds a built-in web UI, scheduling, and policy management that the other two lack.<\/p>\n\n\n\n<h2 class=\"wp-block-heading\">When to Pick Each Tool<\/h2>\n\n\n\n<p>Pick <strong>BorgBackup<\/strong> when SSH is your only transport, you want the fastest restores, and memory is tight. It&#8217;s the oldest and most battle-tested of the three. Pair it with <a href=\"https:\/\/computingforgeeks.com\/borgbackup-borgmatic-linux\/\" target=\"_blank\" rel=\"noreferrer noopener\">Borgmatic<\/a> for automated scheduling and retention, because Borg itself has no built-in scheduler. If you prefer a graphical interface, <a href=\"https:\/\/github.com\/borgbase\/vorta\" target=\"_blank\" rel=\"noreferrer noopener\">Vorta<\/a> is an open-source desktop client for macOS and Linux that wraps Borg with profiles, scheduled backups, and point-in-time restore browsing (<a href=\"https:\/\/vorta.borgbase.com\/install\/\" target=\"_blank\" rel=\"noreferrer noopener\">install instructions<\/a>). Borg&#8217;s restore speed advantage is significant enough that disaster recovery scenarios alone can justify the choice.<\/p>\n\n\n\n<p>Pick <strong>Restic<\/strong> when you need native cloud storage support (S3, Backblaze B2, Azure Blob, Google Cloud Storage) without extra tools or wrappers. Restic has the simplest CLI of the three. One binary, straightforward commands, no configuration files required. The <a href=\"https:\/\/computingforgeeks.com\/backup-to-s3-sftp-server-using-restic\/\" target=\"_blank\" rel=\"noreferrer noopener\">Restic community<\/a> is large and active, so finding help is easy.<\/p>\n\n\n\n<p>Pick <strong>Kopia<\/strong> when you want a single binary that handles everything: scheduling, retention policies, a web UI, and cloud backends. It&#8217;s the fastest for initial backups and the most feature-complete out of the box. No wrapper scripts, no systemd timers, no third-party tools needed. The tradeoff is higher memory usage and a younger project with a smaller (but growing) community.<\/p>\n\n\n\n<p>All three are production-grade. They all encrypt, deduplicate, and compress. They all support FUSE mounting for browsing snapshots. You won&#8217;t regret choosing any of them. The benchmarks show that performance differences exist, but they&#8217;re small enough that features and workflow preferences should drive your decision more than raw speed numbers. If you want a fourth option that prioritizes a GUI-first experience, consider <a href=\"https:\/\/computingforgeeks.com\/backup-linux-mac-windows-systems-using-duplicati\/\" target=\"_blank\" rel=\"noreferrer noopener\">Duplicati<\/a>, though it lacks the dedup performance of these three.<\/p>\n\n","protected":false},"excerpt":{"rendered":"<p>Three backup tools dominate the open-source Linux backup space: BorgBackup, Restic, and Kopia. All three offer deduplication and encryption. All three have loyal communities insisting theirs is the best. The internet is full of opinions, but few comparisons include actual benchmark numbers. This one does. We installed all three on the same Ubuntu 24.04 VM, &#8230; <a title=\"Borg vs Restic vs Kopia: Backup Tools Benchmarked\" class=\"read-more\" href=\"https:\/\/computingforgeeks.com\/borg-restic-kopia-comparison\/\" aria-label=\"Read more about Borg vs Restic vs Kopia: Backup Tools Benchmarked\">Read more<\/a><\/p>\n","protected":false},"author":15,"featured_media":165102,"comment_status":"open","ping_status":"closed","sticky":false,"template":"","format":"standard","meta":{"footnotes":""},"categories":[299,50,75,663,81],"tags":[],"class_list":["post-165101","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-how-to","category-linux-tutorials","category-security","category-storage","category-ubuntu"],"_links":{"self":[{"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/posts\/165101","targetHints":{"allow":["GET"]}}],"collection":[{"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/users\/15"}],"replies":[{"embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/comments?post=165101"}],"version-history":[{"count":5,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/posts\/165101\/revisions"}],"predecessor-version":[{"id":165157,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/posts\/165101\/revisions\/165157"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/media\/165102"}],"wp:attachment":[{"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/media?parent=165101"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/categories?post=165101"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/computingforgeeks.com\/wp-json\/wp\/v2\/tags?post=165101"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}