Restic vs Borg vs Kopia: Best Self-Hosted Backup Solutions 2026

If you run any kind of self-hosted infrastructure — whether it is a home server, a VPS fleet, or a NAS — your data is only as safe as your last verified backup. Cloud backup services have their place, but they come with ongoing subscription costs, potential privacy concerns, and vendor lock-in. Modern open-source backup tools solve all three problems while giving you full control over where your data lives and how it is encrypted.

This guide compares the three leading open-source, deduplicating backup solutions: Restic, BorgBackup (Borg), and Kopia. We will cover architecture, performance, storage backends, encryption models, and practical docker-based setups so you can pick the right tool and have it running in minutes.

Why Self-Host Your Backups

Running your own backup infrastructure offers concrete advantages that managed services struggle to match.

Total data ownership. Your encrypted backup archives sit on storage you control. No vendor can read your data, throttle your restores, or change pricing on you mid-contract.

Cost efficiency at scale. The marginal cost of storing an extra terabyte on your own hardware or a budget object storage bucket is a fraction of what commercial backup SaaS charges per user per month.

Privacy by design. All three tools covered here use client-side encryption. Data is encrypted before it ever leaves your machine, and the server-side storage backend sees only opaque, encrypted blobs.

No vendor lock-in. These tools support multiple storage backends with the same command syntax. Switching from local disk to S3, SFTP, or Backblaze B2 is a one-line config change.

Full auditability. Open-source means the encryption, deduplication, and compression logic can be inspected, audited, and verified by anyone.

Quick Comparison Table

Restic: The Portable Powerhouse

Restic is written in Go and compiles to a single static binary. It supports more storage backends than any competitor, making it the most portable option. Its design prioritizes correctness and simplicity over raw speed.

Key Strengths

• Broadminioackend support: S3, MinIO, Backblaze B2, Azure Blob, Google Cloud Storage, OpenStack Swift, SFTP, REST server, local disk, and more.
• Single binary: No runtime dependencies. Drop it on any Linux, macOS, or Windows machine and it works.
• Mount command: Mount any snapshot as a FUSE filesystem to browse and restore individual files without extracting.
• Strong community: Active development, extensive documentation, and a large ecosystem of wrapper scripts and GUI tools.

When to Choose Restic

Pick Restic if you need maximum backend flexibility, a single cross-platform binary, or plan to back up across heterogeneous operating systems. It iskubernetesrong default for Kubernetes environments where the single-binary model simplifies containerization.

Installation and Configuration

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22

# Install on Debian/Ubuntu
sudo apt install restic

# Initialize a repository on local disk
restic init --repo /mnt/backup/restic-repo

# Initialize on S3-compatible storage (MinIO, Backblaze B2, etc.)
export AWS_ACCESS_KEY_ID="your-access-key"
export AWS_SECRET_ACCESS_KEY="your-secret-key"
restic init --repo s3:s3.us-west-000.backblazeb2.com/my-bucket

# Backup a directory
restic backup --repo /mnt/backup/restic-repo /etc /home/user/documents

# List snapshots
restic snapshots --repo /mnt/backup/restic-repo

# Restore a snapshot
restic restore --repo /mnt/backup/restic-repo latest --target /restore/path

# Prune old snapshots (keep 7 daily, 4 weekly, 12 monthly)
restic forget --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --prune --repo /mnt/backup/restic-repo

Docker Setup

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16

services:
  restic-backup:
    image: mazzolino/restic:latest
    container_name: restic-backup
    environment:
      RUN_ON_STARTUP: "true"
      BACKUP_CRON: "0 2 * * *"
      RESTIC_REPOSITORY: /data/restic-repo
      RESTIC_PASSWORD: "your-strong-password"
      RESTIC_BACKUP_SOURCES: /mnt/volumes
      RESTIC_COMPRESSION: auto
      RESTIC_FORGET_ARGS: "--keep-daily 7 --keep-weekly 4 --keep-monthly 12"
    volumes:
      - /mnt/backup:/data
      - /srv/app-data:/mnt/volumes:ro
    restart: unless-stopped

For S3-based backups, swap the volume mount for environment variables:

1
2
3
4
5
6
7
8
9

    environment:
      RUN_ON_STARTUP: "true"
      BACKUP_CRON: "0 2 * * *"
      RESTIC_REPOSITORY: s3:s3.amazonaws.com/my-backup-bucket
      RESTIC_PASSWORD: "your-strong-password"
      AWS_ACCESS_KEY_ID: "${AWS_ACCESS_KEY_ID}"
      AWS_SECRET_ACCESS_KEY: "${AWS_SECRET_ACCESS_KEY}"
      RESTIC_BACKUP_SOURCES: /mnt/volumes
      RESTIC_FORGET_ARGS: "--keep-daily 7 --keep-weekly 4 --keep-monthly 12"

BorgBackup: The Speed and Efficiency Champion

BorgBackup (commonly called Borg) is the performance king among deduplicating backup tools. Written in Python with critical paths in C, it offers built-in compression, fast deduplication, and excellent storage efficiency.

Key Strengths

• Built-in compression: LZ4 (fastest), Zstd (balanced), and LZMA (maximum compression) are built in. This can reduce storage usage by 30-60% compared to uncompressed alternatives.
• Append-only repositories: Protect against ransomware by mounting repositories in append-only mode over SSH.
• BorgBase: A managed hosting service specifically designed for Borg, with integrity monitoring and web dashboards.
• Vorta GUI: A mature desktop GUI (Linux and macOS) makes point-and-click backups accessible to non-technical users.
• Fastest prune/compact: Borg’s compaction model is significantly faster than Restic’s full-rewrite pruning on large repositories.

When to Choose Borg

Borg is the right choice when storage efficiency matters most, when you have SSH access to a remote server, or when you want a polished desktop GUI experience. It is especially popular among Linux homelab users.

Installation and Configuration

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30

# Install on Debian/Ubuntu
sudo apt install borgbackup

# Install Vorta GUI (optional)
sudo apt install vorta
# Or via Flatpak
flatpak install flathub io.borgbase.Vorta

# Initialize a repository over SSH
borg init --encryption=repokey user@backup-server:/path/to/repo

# Create a backup
borg create --stats --progress \
  user@backup-server:/path/to/repo::'{now:%Y-%m-%d_%H:%M}' \
  /etc /home/user/documents \
  --compression zstd,8 \
  --exclude '*.cache' \
  --exclude '/home/*/.local/share/Trash'

# List archives
borg list user@backup-server:/path/to/repo

# Extract a single file
borg extract user@backup-server:/path/to/repo::2026-04-12_02:00 etc/nginx/nginx.conf

# Prune with retention policy
borg prune --keep-daily 7 --keep-weekly 4 --keep-monthly 12 \
  --keep-yearly 2 \
  --stats \
  user@backup-server:/path/to/repo

Automated Backup Script

A production-ready wrapper for cron or systemd timers:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32

#!/bin/bash
# /usr/local/bin/borg-backup.sh
set -euo pipefail

REPO="user@backup-server:/srv/borg-repo"
EXCLUDES="/etc/borg/excludes"
LOG="/var/log/borg-backup.log"

exec >> "$LOG" 2>&1

echo "=== Backup started: $(date -u) ==="

# Ensure lock is not stale
borg break-lock "$REPO" 2>/dev/null || true

# Create backup
borg create --stats --progress \
  --compression zstd,6 \
  --exclude-caches \
  --exclude-from "$EXCLUDES" \
  "$REPO::$(hostname)-{now:%Y-%m-%d_%H:%M:%S}" \
  /etc /home /var/lib/docker/volumes

# Prune old archives
borg prune --keep-daily 7 --keep-weekly 4 --keep-monthly 12 --keep-yearly 2 \
  --stats "$REPO"

# Verify repository integrity (lightweight)
borg check --verify-data --progress "$REPO"

echo "=== Backup finished: $(date -u) ==="
echo ""

Docker Setup

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

services:
  borg-backup:
    image: ghcr.io/borgbackup/borg:latest
    container_name: borg-backup
    environment:
      BORG_RSH: "ssh -i /root/.ssh/id_ed25519 -o StrictHostKeyChecking=no"
      BORG_PASSPHRASE: "your-strong-passphrase"
    volumes:
      - /root/.ssh:/root/.ssh:ro
      - /srv/app-data:/mnt/source:ro
      - ./scripts:/scripts:ro
    entrypoint: ["/scripts/borg-backup.sh"]
    restart: "no"

Kopia: The Modern All-in-One

Kopia is the newest of the three, but it has quickly gained adoption thanks to its modern architecture. Written in Go, it offers multi-threaded backups, a built-in web UI, policy-based retention, and the broadest set of storage backends including WebDAV and Google Drive.

Key Strengths

• Multi-threaded operations: Backup and upload run in parallel, making Kopia significantly faster on multi-core machines and high-bandwidth connections.
• Built-in web UI: A polished browser-based dashboard for managing backups, policies, and snapshots — no third-party GUI needed.
• Policy engine: Retention, compression, and scheduling are managed through a flexible policy system that can target specific directories with different rules.
• Snapshot mounts: Like Restic, Kopia can mount snapshots via FUSE for point-in-time browsing.
• Content-addressable storage with caching: Intelligent local caching speeds up repeated backups and restores.
• Huge backend list: S3, B2, GCS, Azure, WebDAV, SFTP, Google Drive, OneDrive, local filesystem, and more.

When to Choose Kopia

Kopia is the best choice if you want a built-in GUI, need multi-threaded performance, manage backups across many different storage backends, or prefer a modern policy-driven configuration model. It is particularly well-suited for teams that need a shared management interface.

Installation and Configuration

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37

# Install on Debian/Ubuntu
curl -s https://kopia.io/signing-key | sudo gpg --dearmor -o /usr/share/keyrings/kopia-keyring.gpg
echo "deb [signed-by=/usr/share/keyrings/kopia-keyring.gpg] https://packages.kopia.io/deb stable main" | sudo tee /etc/apt/sources.list.d/kopia.list
sudo apt update
sudo apt install kopia

# Initialize a repository on local disk
kopia repository create filesystem --path /mnt/backup/kopia-repo

# Initialize on S3
kopia repository create s3 \
  --bucket my-backup-bucket \
  --endpoint s3.us-west-000.backblazeb2.com \
  --access-key $AWS_ACCESS_KEY_ID \
  --secret-access-key $AWS_SECRET_ACCESS_KEY

# Start the built-in web UI (default: http://localhost:51515)
kopia server start

# Set a snapshot policy for /home
kopia policy set /home \
  --keep-daily 7 \
  --keep-weekly 4 \
  --keep-monthly 12 \
  --compression zstd-fastest

# Create a snapshot
kopia snapshot create /home /etc

# List snapshots
kopia snapshot list

# Restore a snapshot
kopia restore <snapshot-id> /restore/path

# Run maintenance (compaction + cleanup)
kopia maintenance run --full

Docker Setup with Web UI

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

services:
  kopia:
    image: kopia/kopia:latest
    container_name: kopia-backup
    environment:
      - KOPIA_PASSWORD=your-strong-password
    volumes:
      - /mnt/backup/kopia:/app/config
      - /srv/app-data:/data/source:ro
      - /etc:/data/etc:ro
    ports:
      - "51515:51515"
    command: >
      server start
      --address=0.0.0.0:51515
      --server-username=admin
      --server-password=your-admin-password
      --tls-generate-cert=false
    restart: unless-stopped

Automated Policy-Based Backup

Kopia’s policy system allows granular control:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19
20
21

# Global default policy
kopia policy set --global \
  --keep-daily 14 \
  --keep-weekly 8 \
  --keep-monthly 24 \
  --keep-annual 3 \
  --compression zstd \
  --upload-interval 24h

# Override for large media directories (less frequent, longer retention)
kopia policy set /data/media \
  --keep-daily 3 \
  --keep-weekly 4 \
  --keep-monthly 12 \
  --no-compression

# Override for critical configs (frequent snapshots)
kopia policy set /etc \
  --keep-daily 30 \
  --keep-weekly 12 \
  --upload-interval 6h

Performance Comparison

Based on real-world testing with a 50 GB dataset (mix of text, binaries, and media) on a 4-core VPS with gigabit networking:

Notes: Borg wins on storage efficiency due to built-in compression. Kopia wins on speed thanks to multi-threaded operations. Restic uses the most memory during large scans but remains the most consistent across different hardware profiles.

Storage Backend Recommendations

Budget-Friendly Setup

For homelab users on a budget, the best value combination is a Borg repository over SSH to a cheap VPS with large storage, or Restic/Kopia to Backblaze B2 at roughly $6/TB/month.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17

# Backblaze B2 with Kopia (cost-effective)
services:
  kopia:
    image: kopia/kopia:latest
    environment:
      - KOPIA_PASSWORD=${KOPIA_PASSWORD}
      - B2_ACCOUNT_ID=${B2_ACCOUNT_ID}
      - B2_ACCOUNT_KEY=${B2_ACCOUNT_KEY}
    volumes:
      - /srv/kopia:/app/config
      - /data:/data/source:ro
    command: >
      server start
      --address=0.0.0.0:51515
      --server-username=admin
      --server-password=${ADMIN_PASSWORD}
    restart: unless-stopped

Maximum Durability Setup

For critical data, use Kopia or Restic with S3 replication — configure your object storage to replicate across regions automatically.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11

# Restic with S3 cross-region replication
restic init \
  --repo s3:s3.eu-west-1.amazonaws.com/my-backup-bucket-primary

# Add a secondary repository for redundancy
restic init \
  --repo s3:s3.us-east-1.amazonaws.com/my-backup-bucket-secondary

# Backup to both in a script
restic backup --repo s3:s3.eu-west-1.amazonaws.com/my-backup-bucket-primary /data
restic backup --repo s3:s3.us-east-1.amazonaws.com/my-backup-bucket-secondary /data

Zero-Cost Local Setup

For users who want entirely local backups with no cloud dependency:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13

# Local Borg with append-only SSH access
services:
  borg-server:
    image: ghcr.io/borgbackup/borg:latest
    container_name: borg-server
    volumes:
      - /mnt/backup:/data
      - ./authorized_keys:/root/.ssh/authorized_keys:ro
    command: >
      serve --restrict-to-path /data --append-only
    ports:
      - "2222:22"
    restart: unless-stopped

The 3-2-1 Backup Rule with Open Source Tools

No backup strategy is complete without following the 3-2-1 rule: 3 copies of your data, on 2 different media, with 1 copy off-site.

Here is how each tool maps to this strategy:

1. Primary copy: Your live data on the production server or NAS.
2. Local backup: A Restic, Borg, or Kopia repository on an external USB drive or secondary internal disk.
3. Off-site copy: Push the same backup to an S3-compatible bucket, a remote VPS via SSH, or a cloud storage backend.

A practical implementation using Kopia:

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14

# Primary: local repository
kopia repository create filesystem --path /mnt/local-backup

# Secondary: encrypted push to Backblaze B2
kopia repository connect b2 \
  --bucket offsite-backups \
  --key-id $B2_KEY_ID \
  --key $B2_KEY

# Schedule automated snapshots
kopia policy set --global --upload-interval 12h

# Automate with systemd timer
sudo kopia install-cron

Monitoring and Alerting

Backups you do not verify are not backups. All three tools support integration with monitoring systems.

Restic outputs JSON with --json flag, making it easy to pipe into monitoring pipelines:

1

restic backup --json /data 2>&1 | jq -r 'select(.message_type=="summary") | .total_bytes_processed'

Borg supports the --log-json flag and integrates with BorgBase’s monitoring dashboard for email alerts on missed or failed backups.

Kopia has built-in notifications that can send alerts via email, Pushover, or webhook when backups fail or repositories need maintenance:

1
2
3
4
5

kopia policy set --global \
  --log-dir /var/log/kopia \
  --enable-scheduler

# The built-in web UI shows backup health, storage usage, and upcoming scheduled runs

Final Verdict

Each tool has a clear niche. The right choice depends on your priorities:

• Choose Restic if you value maximum portability, broad backend support, and a proven, battle-tested codebase. It is the safe default that works everywhere and is simple to containerize.

• Choose Borg if storage efficiency and raw speed matter most, you have SSH access to a remote server, or you want a polished desktop GUI via Vorta. Borg’s compression alone can save terabytes over time.

• Choose Kopia if you want a modern all-in-one solution with a built-in web UI, multi-threaded performance, and policy-driven configuration. It is the most feature-rich and user-friendly option for teams and individuals alike.

All three are excellent, actively maintained, and free. The worst decision is making no decision at all — pick one, set up automated snapshots today, and verify your first restore within the week. Your future self will thank you when the day comes that you actually need it.

Frequently Asked Questions (FAQ)

Which one should I choose in 2026?

The best choice depends on your specific requirements:

• For beginners: Start with the simplest option that covers your core use case
• For production: Choose the solution with the most active community and documentation
• For teams: Look for collaboration features and user management
• For privacy: Prefer fully open-source, self-hosted options with no telemetry

Refer to the comparison table above for detailed feature breakdowns.

Can I migrate between these tools?

Most tools support data import/export. Always:

1. Backup your current data
2. Test the migration on a staging environment
3. Check official migration guides in the documentation

Are there free versions available?

All tools in this guide offer free, open-source editions. Some also provide paid plans with additional features, priority support, or managed hosting.

How do I get started?

1. Review the comparison table to identify your requirements
2. Visit the official documentation (links provided above)
3. Start with a Docker Compose setup for easy testing
4. Join the community forums for troubleshooting