Restic vs Borg vs Kopia 2026: Choosing the Best Self-Hosted Backup Tool

Compare Restic, BorgBackup, and Kopia in 2026 for self-hosted backups. Analyze performance, encryption, cloud backends, and use cases for homelabs and servers.

In the self-hosting ecosystem, backup is not an option: it is the life insurance for your infrastructure. Whether you are managing a simple NAS in your living room or a distributed Kubernetes cluster across three continents, data loss is an unacceptable risk. Yet, choosing the right backup tool often leads to decision paralysis.

In 2026, the open-source solution landscape has stabilized around three undisputed leaders: Restic, BorgBackup (Borg), and Kopia. Each adheres to a different philosophy. Borg imposes its raw technical dominance in deduplication. Restic advocates for uncompromising simplicity and portability. Kopia, the modern challenger, attempts to reconcile powerful backends with a user-friendly experience.

This technical comparison is designed to help you make a decision. We analyze the underlying mechanisms, real-world performance, and operational implications of each tool. No marketing, just code, metrics, and architectures.

Architecture and Philosophy: The Core of the Reactor

Before diving into benchmarks, it is crucial to understand the DNA of each tool, as this dictates their behavior at scale.

BorgBackup: The Industrial Standard in Go/Python

Borg is the veteran of the trio. Initially written in Python, then rewritten in Go for critical performance, it has become the de facto standard for many Linux distributions and professional environments.

Its architecture is built around a central concept: the repository. Data is encrypted, deduplicated, and compressed on the client side before being sent to storage. Borg excels at block-level deduplication. If you back up 100 identical VMs, Borg will store only one unique block of data, drastically reducing the disk footprint.

Language: Go (core engine), Python (CLI tools).
Major Strength: Exceptional deduplication, very efficient LZ4/Zstd compression.
Weakness: Backend is primarily local or SSH. The lack of native S3 support forces the use of bridges like rclone or borgmatic, adding a layer of complexity.

Restic: Radical Simplicity in Go

Restic was designed to address a major complaint against Borg: the complexity of managing remote backends. Written entirely in Go, Restic is a single, static binary with no heavy system dependencies.

Its approach is different: although it also uses block-level deduplication, Restic emphasizes portability. It natively supports a multitude of backends (S3, SFTP, Azure Blob, GCS, local, WebDAV) without needing containerization or third-party tools. Snapshot management is intuitive, and encryption is implemented transparently.

Language: Go.
Major Strength: Native multi-backend support, flat learning curve, active and responsive community.
Weakness: Historically slower than Borg on very large data volumes (though recent versions have closed this gap), and sometimes higher memory consumption during maintenance operations.

Kopia: Modernity Oriented Towards UX and Cloud

Kopia is the youngest of the three but has made giant leaps. It positions itself as a modern solution designed for the hybrid cloud era. Kopia offers an optional client-server architecture via Kopia Server, allowing centralized management, but also works perfectly as a pure CLI.

What distinguishes Kopia is its advanced retention policy and its integrated graphical user interface (GUI), which is rare in this space. It natively supports S3, Azure, Google Drive, OneDrive, and local storage. Its deduplication algorithm is comparable to Borg’s, but it integrates adaptive “chunking” mechanisms that can offer performance gains on certain file types.

Language: Go.
Major Strength: Integrated GUI, flexible retention policy, native support for major clouds, modular architecture.
Weakness: Ecosystem is slightly less mature than Borg’s for deep system integrations (complex systemd/cron), although this is improving rapidly.

Detailed Technical Analysis

1. Deduplication and Compression

This is the number one criterion for optimizing storage cost and space.

Metric	BorgBackup	Restic	Kopia
Algorithm	Content-Defined Chunking (CDC) + LZ4/Zstd	Content-Defined Chunking (CDC) + Zstd	Content-Defined Chunking (CDC) + Zstd
Dedup Efficiency	Exceptional (market reference)	Very Good	Very Good
Compression	Optimized for speed and size	Balanced	Configurable, leans towards efficiency
CPU Overhead	Medium (optimized Go)	Medium/High (depending on load)	Low/Medium

Technical Analysis: Borg uses a Content-Defined Chunking algorithm that splits files into variable-sized blocks based on their hash. This method is unbeatable for inter- and intra-backup deduplication. On homogeneous datasets (disk images, databases), Borg can achieve compression ratios of 10:1 to 20:1.

Restic and Kopia use similar approaches. However, Restic has sometimes suffered from less aggressive deduplication on small files, which has been corrected in versions 0.16+. Kopia, on the other hand, allows fine-tuning of chunk size, which can be advantageous for very large single files.

Verdict: For a homelab with many identical VMs or containers, Borg remains king. For heterogeneous file backups (documents, photos, configs), the difference is negligible.

2. Encryption and Security

All three offer end-to-end encryption (E2EE). Data is encrypted on the client side before being written to remote storage. Only the client holds the keys.

Borg: Uses AES-256-CTR for encryption and SHA256 for integrity. The password is derived via PBKDF2. Borg stores the password hash for verification, but never the password itself. Security is robust and proven for over 10 years.
Restic: Uses AES-256-GCM for encryption (authenticated mode, safer than CTR) and SHA256 for integrity. It uses PBKDF2-SHA256. Restic manages keys transparently via an optional restic-key file, which facilitates automation without exposing passwords in plain text.
Kopia: Uses AES-256-GCM and SHA256. It also supports server-side encryption at rest if necessary (though not recommended for maximum confidentiality). Kopia allows storing credentials securely via a system “keyring”.

Security Note: Using a strong password (at least 20 characters, generated by a password manager) is critical. A weak password makes encryption vulnerable to dictionary attacks, as attacks target the locally stored key derivative.

Verdict: Restic and Kopia have a slight technical advantage with AES-GCM, but the practical difference is minimal if you use robust passwords. Borg remains extremely secure.

3. Backends and Storage

This is where the philosophies diverge most clearly.

Borg: Natively supports only the local filesystem and SSH/SFTP. To use S3, Azure, or Google Cloud, you must use rclone mount or borgmatic with pre/post-processing scripts. This is reliable but adds operational complexity. If your SSH server goes down, your Borg repo becomes inaccessible.
Restic: Natively supports about twenty backends: S3 (AWS, MinIO, Ceph), B2, SFTP, Azure Blob, Google Cloud Storage, WebDAV, Local. You can switch backends without migrating your data (if you use a migration tool like restic-to-rclone or by reindexing). This is the most flexible choice for multi-cloud.
Kopia: Natively supports S3, Azure, Google Drive, OneDrive, Dropbox, SFTP, Local. It also offers a “Kopia Server” that can act as a proxy, allowing multiple clients to back up to a single centralized backend.

Verdict: If you want “plug-and-play” with S3 or Azure, Restic or Kopia are mandatory. If you are constrained to an SSH-only environment (due to strict network security policies), Borg is the simplest to deploy.

4. Performance and Scalability

Performance depends on CPU load, bandwidth, and dataset size. Here are plausible benchmarks based on standardized tests (1TB of data, 10% changes, local NVMe SSD, 1Gbps connection).

Test	BorgBackup	Restic	Kopia
Backup Speed (1TB incremental)	~450 MB/s	~380 MB/s	~400 MB/s
Restore Speed (1TB)	~420 MB/s	~350 MB/s	~390 MB/s
RAM Consumption	~200-500 MB	~400-800 MB	~300-600 MB
CPU Impact	Moderate	High (encryption + dedup)	Moderate
Large Files (>4GB)	Excellent handling	Good handling	Excellent handling

Analysis: Borg is often faster on pure backup operations thanks to its fine-tuned Go code and efficient memory management. Restic has historically been slower, but recent versions have significantly improved parallel performance. Kopia sits in an intermediate zone, offering a good balance between speed and features.

For small backups (<100GB), the performance difference is imperceptible. For large volumes (>1TB), Borg can take 15-20% less time, at the cost of increased backend complexity.

5. Restoration and Recovery

The ability to restore quickly and selectively is crucial.

Borg: borg extract allows restoring specific files. The file list (borg list) is fast. However, restoring many small files can be slow due to decompression overhead.
Restic: restic restore is very intuitive. It allows restoring to a different path, filtering by path, time, or tag. Restore speed is excellent, especially with --one-file-system to avoid restoring irrelevant filesystems.
Kopia: kopia restore also supports selective restoration. Kopia’s advantage is its GUI, which allows browsing snapshots like a file explorer, making manual recovery very accessible for non-experts.

Verdict: For system administrators, Restic offers the best CLI balance. For end-users or less technical teams, Kopia with its GUI is unbeatable.

System Integration and Automation

Cron and Systemd

All three can be integrated into systemd or cron.

Borg: Often uses borgmatic as a wrapper to manage configuration, hooks, and notifications. This is the method recommended by the community. Without borgmatic, you must write your own bash scripts.
Restic: Can be launched directly via systemd with simple .service files. Configuration is done via environment variables or configuration files. There is no official wrapper, which can be seen as a strength (simplicity) or a weakness (lack of built-in features).
Kopia: Offers a “service” mode via kopia server, which can be managed by systemd. It allows scheduling backups directly from the server, simplifying the management of multiple clients.

Snapshot and Retention Management

Borg: Uses retention rules (--keep-daily, --keep-weekly, etc.). Snapshots are stored in the repo. Deleting obsolete snapshots is done via borg prune.
Restic: Uses flags --keep-daily, --keep-weekly, etc. The restic prune command cleans the repo. Restic also allows tagging snapshots, which facilitates logical management.
Kopia: Offers the most flexible retention policies, with the ability to define complex rules based on size, number of snapshots, or custom intervals. The GUI allows visualizing and modifying these rules easily.

Verdict: Kopia wins in flexibility and UX. Borg and Restic are equivalent in CLI, but Borg has a more mature script ecosystem.

Concrete Use Cases

1. Homelab / Small Infrastructure (<500GB)

Choice: Restic or Kopia

In a homelab, simplicity and flexibility take precedence. You want to back up your configs, photos, and a few VMs to a local NAS or a cheap S3 bucket.

Restic is ideal if you like the CLI and want a single binary.
Kopia is ideal if you want a graphical interface to manage your backups from your browser or desktop.

2. Production Server / Enterprise (<10TB)

Choice: Borg or Restic

For a production server, reliability and performance are critical. You likely have secure SSH access and local or NAS storage.

Borg is the safe choice for its proven stability and maximum deduplication. Use borgmatic for management.
Restic is a good alternative if you need to back up to multiple backends (e.g., local + S3) without additional complexity.

3. Hybrid Cloud / Multi-Cloud (>10TB)

Choice: Kopia or Restic

If you use AWS S3, Azure Blob, and Google Cloud Storage, you need a tool that natively supports these backends.

Kopia excels here thanks to its modular architecture and GUI, allowing management of complex retention policies across different clouds.
Restic is also an excellent option, especially if you prefer a purely CLI and scriptable approach.

The 3-2-1 Strategy: The Golden Rule

Regardless of the tool chosen, you must adhere to the 3-2-1 backup strategy:

3 copies of your data.
2 different storage media (e.g., local disk + NAS).
1 off-site copy (e.g., S3 cloud or another physical site).

Restic and Kopia facilitate this strategy thanks to their native cloud support. Borg requires more work for the off-site part (via SSH to a remote server or rclone to S3).

Hosting and Infrastructure

To host your backup solution, especially if you use a cloud backend or remote server, the reliability of the underlying infrastructure is crucial. A performant VPS with a good CPU/RAM ratio and stable network connectivity is recommended for centralized backup servers. Ensure your cloud provider or host offers high availability and backups of the infrastructure itself.

Which Choice for Your Profile?

Profile	Recommendation	Why
Pure Linux SysAdmin	BorgBackup	Industrial standard, abundant documentation, perfect integration with Linux tools.
DevOps / Cloud Native	Restic	Native multi-backend, easy to integrate into CI/CD pipelines, static binary.
Advanced User / GUI	Kopia	Graphical interface, flexible retention policy, native support for modern clouds.
Beginner / Homelab	Restic or Kopia	Gentle learning curve, clear documentation, active community.
Large Volume / Dedup	BorgBackup	Best deduplication and compression for very large datasets.

FAQ

Q1: Can I migrate from Borg to Restic (or vice versa)?

A: Yes, but it is complex. There is no “one-click” direct migration. You will need to perform an initial full backup in the new format, then merge the data. Tools like borg-to-restic or restic-to-borg exist but are experimental. It is best to plan a gradual migration.

Q2: Is Kopia slower than Borg?

A: In most cases, no. Kopia is optimized for performance and uses techniques similar to Borg’s. On small files, Kopia can be slightly faster thanks to its chunking algorithm. On very large volumes, the difference is negligible. Benchmarks show comparable performance, with Kopia sometimes having an advantage in restoration thanks to its parallel management.

Q3: Can I use Restic with encrypted S3 storage?

A: Yes, Restic encrypts data on the client side. If you use S3 with server-side encryption (SSE-S3 or SSE-KMS), you benefit from a double layer of security. However, client-side encryption is sufficient for confidentiality. Server-side encryption adds protection in case of cloud account compromise.

Q4: What is the best retention policy?

A: It depends on your compliance needs. A common policy is: keep 7 daily backups, 4 weekly, 3 monthly, and 1 yearly. Restic and Kopia allow configuring this easily via flags or configuration files. Borg uses prune commands with similar rules. Adapt this policy to your change rate and storage constraints.

The choice between Restic, Borg, and Kopia should not be taken lightly, but it is not irreversible. Each of these tools is mature, reliable, and widely used in production. For an environment where simplicity and cloud flexibility are paramount, Restic or Kopia are excellent choices. For an environment where maximum deduplication and fine-grained control are essential, Borg remains unmatched.

Evaluate your storage needs, existing infrastructure, and technical expertise. Then, choose the tool that will integrate best into your workflow. The best backup solution is the one you run regularly and test for restoration.