Restic

What Restic actually is

Restic is a free, open-source backup program — a single binary you run on the machine you want to protect. It encrypts your data on your own machine, deduplicates it, and stores it on whatever backend you point it at: local disk, an SFTP server, an S3-compatible object store, Backblaze B2, Azure Blob, Google Cloud Storage, or a restic REST server. There is no Restic service, no Restic account, and no Restic cloud. You run the tool; the storage is yours.

The project was started by Alexander Neumann in 2015 and is written in Go, which gives it the deployment property that matters for backup software: one static binary that runs the same on Linux, macOS, Windows, and BSD, with no runtime to install on the machine you are trying to recover. It is licensed under the BSD 2-Clause license, permissive enough for commercial embedding, and the repository format is documented openly rather than hidden behind a vendor.

The design is content-addressed. Files are split into variable-size chunks using content-defined chunking; each chunk is identified by the SHA-256 hash of its content; identical chunks are stored once. Every file in a repository is written once and never modified, so multiple machines can write to the same repository concurrently, and any stored file can be verified against its own name because the name is its hash. Snapshots reference the chunks, so an incremental backup after a small change transfers only what changed, and two machines backing up similar data (say, similar base images) share the deduplicated pool.

Encryption is not optional and not an add-on. Everything except the small keys and data directory bookkeeping is encrypted with AES-256 in counter mode and authenticated with a Poly1305-AES message authentication code; each file gets a fresh random IV, and the total encryption overhead is 32 bytes per file. The practical consequence: the storage provider sees opaque blobs. Lose the repository password and nobody — including the storage vendor, including us, including you — can read that repository. That cuts in both directions, and we will come back to it.

The feature set covers the operational lifecycle: backup, snapshots, restore, mount (FUSE), check for repository verification, forget with keep policies for retention, and prune to reclaim space. Compression (zstd) has been included since version 0.16. The current stable line is 0.18.x (0.18.1 was released in September 2025), and despite pre-1.0 version numbers the repository format is stable and forward-compatible — a point the project is careful about because backup formats must outlive the software that wrote them.

Pricing: what you really pay

The software costs nothing. $0, forever, for every feature — there is no paid tier, no seat count, no "Pro" binary. The BSD 2-Clause license means no one can retroactively put a tollbooth on the copy you are running. What you pay for is storage and the electricity of running the tool, and this is where restic's economics get interesting.

Because deduplication and compression shrink what you store, and because restic talks to whatever backend is cheapest, your effective cost per protected gigabyte is usually well below list price for raw storage. Third-party write-ups put a fully automated 500 GB setup on Backblaze B2 at around $3 per month in storage fees, with restic doing client-side encryption and rclone bridging to any of dozens of providers. We have not independently verified that figure — it depends entirely on your dedup ratio and data mix — but the shape of it is right: the software line item is zero, and you shop for storage on price.

Compare that with the commercial backup suites this category also contains. Enterprise backup products price per server, per terabyte, or per workload, and the bill scales with exactly the things restic gives you for free. The trade is labor: nobody answers a support ticket for you, and the responsibility for testing restores is yours. We consider that trade favorable for anyone who already has a sysadmin, and dangerous for anyone who does not.

One honest footnote on cost: restic's deduplication means the first backup is the expensive one. Budget storage for the initial full set plus growth, remember that prune reclaims space only when you run it, and know that some object stores bill per API request — restic's --pack-size option exists precisely to reduce request counts on such backends.

Performance & infrastructure

There is no vendor infrastructure to review here — the "infrastructure" is the repository design plus whatever backend you choose. That design is unusually well documented: restic publishes its format (storage IDs, pack files, tree objects) and its cryptography (AES-256-CTR with Poly1305-AES, keys derived per repository with support for multiple keys) rather than asking you to trust a black box. For backup software, we treat that transparency as a feature on par with speed, because the alternative is a restore you cannot inspect until the day you need it.

On speed, restic is generally I/O-bound rather than CPU-bound. Community comparisons against BorgBackup and Kopia report the tools in the same performance band, with restic typically faster at restore and slightly behind Borg at first backup on some datasets, and dedup ratios in the same 3-8x range on mixed workloads. Those are third-party numbers on third-party hardware, and we would not treat any of them as promises — but the consensus that "none of these tools has a significant performance advantage" matches what we would expect from similar chunking approaches. Memory use during backup is commonly reported in the 200-500 MB range, and concurrency knobs (--read-concurrency, GOMAXPROCS, backend parallelism) let you trade speed against a laptop's battery.

The backend story is restic's strongest infrastructure argument. Native support for S3, B2, GCS, Azure Blob, SFTP, and the restic REST server covers most shops; the rclone bridge covers essentially everything else. This matters strategically: you can start on cheap archival-grade storage and move providers by copying a repository — the format does not change. Lock-in is a property of backup products more often than anyone admits, and restic simply does not have it.

Operations get real tooling: check verifies repository integrity (worth scheduling; it is the backup equivalent of a fire drill), forget --keep-* expresses retention policies (hourly/daily/weekly/monthly/yearly), prune compacts, and caching keeps restores fast on repeat access. Multiple machines can share one repository with separate keys, which makes a household or small-team setup straightforward.

Where it falls short

The password is the whole security model, and the failure mode is absolute. There is no recovery path, no escrow, no "forgot password" link. Every serious restic deployment needs a password stored somewhere safer than the machine it protects — a password manager, a safe, an envelope — and every serious restic deployment note should say what happens if the person who knows it is unavailable. We have seen this go wrong, and it is not restic's fault, but it is restic's design.

The second gap is operational surface. Restic is command-line only: no web UI, no dashboard, no hosted console with a green checkmark. Scheduling is external (cron, systemd timers), monitoring is external, and alerting on a failed backup is something you build. Community front-ends exist (Backrest and others), but they are separate projects with their own maturity curves. For a solo developer this is fine; for a team that wants a backup status page, it is homework.

Then the usual open-source caveats: support means GitHub issues, discussions, and reading documentation — excellent documentation, but documentation nonetheless. Repository maintenance needs discipline: prune costs time and API calls, check should be run regularly, and repositories containing many small files can slow down on high-latency backends. Version numbers remain pre-1.0, which we read as caution about interface churn rather than about data safety — the format is stable — but it is a fair thing for a procurement checklist to notice.

Who should pick this

Our pick for developers and sysadmins who want encrypted, deduplicated, off-site backups and are comfortable owning the outcome. If you run a handful of Linux servers, a homelab, or a small fleet, and you want backups that no storage vendor can read and no vendor can price-gouge, restic is the tool we reach for first. It pairs especially well with cheap object storage and with rsync.net-style SSH targets (see /category/backup-solutions) precisely because it does not care where the bytes live.

We would look at commercial alternatives when the requirement is centralized management, compliance reporting, or an accountable support contract — an agency managing fifty client servers, or a company whose auditors want a vendor name on the backup policy, is better served by a product that sells those things. Kopia is the closest free comparison (built-in policies and a UI), and BorgBackup remains excellent for single-host, SSH-backed setups; restic wins on backend flexibility and cross-platform reach.

Whatever you choose, keep our standing rule: a backup you have never restored is a hypothesis. Schedule restic check, do periodic test restores, and keep the repository password in at least two safe places.

Key takeaways

• Free, BSD 2-Clause, single-binary backup tool (Go) with client-side AES-256-CTR encryption and Poly1305 authentication — the storage provider never sees plaintext.
• Content-addressed deduplicated repositories: incremental forever, multiple machines per repository, verifiable chunks (SHA-256).
• Native backends for local disk, SFTP, S3, Backblaze B2, GCS, Azure Blob, and restic REST; rclone covers everything else — no vendor lock-in.
• $0 software; you pay only for storage, and dedup plus compression usually keeps that well under raw list prices.
• Command-line only: scheduling, monitoring, and alerting are your job; support is community-driven.
• Zero password recovery — key management is the deployment risk that deserves the most planning.

Sources

• https://restic.readthedocs.io/en/v0.18.0/100_references.html
• https://github.com/restic/restic/blob/987caba4/doc/design.rst
• https://github.com/restic/restic/blob/master/LICENSE
• https://selfhosting.sh/compare/borgbackup-vs-restic
• https://selfhosting.sh/compare/restic-vs-kopia
• https://hivebook.wiki/wiki/restic-fast-encrypted-deduplicating-backup-go
• https://botmonster.com/self-hosting/set-up-automatic-encrypted-backups-restic-rclone
• https://pkg.go.dev/github.com/viric/restic