restic.net

restic follows Semantic Versioning, and the repository plus the data structures stored inside it are treated as the "Public API" for that purpose. In practice: once version 1.0.0 is released, all repositories within one major version are guaranteed to be backward compatible — as long as the major version is not incremented, saved data can be read and restored. Before 1.0.0, maintainers and developers do their utmost to keep backward compatibility and stability, but breaking changes are possible without a major version bump.

The core guarantee

The reason restic commits to this is stated directly on the site: backward compatibility for backups matters so that users are always able to restore saved data. A backup tool that can't restore older repositories is not much of a backup tool, so compatibility is framed as a promise about restorability, not just about the software running.

The mechanism is versioning the data, not the binary:

What this means at each stage

After 1.0.0

• All repositories within one major version are backward compatible.
• As long as the major version is not incremented, data can be read and restored.
• A major version increment is the signal that compatibility may break.

Before 1.0.0 (initial development)

• Maintainers and developers "will do their utmost" to keep backward compatibility and stability.
• Breaking changes are still possible without increasing the major version.
• The site also states the project strives to be fully backward compatible to all prior versions.

So the pre-1.0.0 period is best-effort, while the post-1.0.0 period is a guarantee. If you are planning long-term archival storage, that distinction is the one to weigh.

How to apply this when choosing a version

• Long-lived archives: prefer a release line at or beyond 1.0.0, where the same-major-version guarantee applies, and avoid jumping major versions without checking.
• Testing or short-term use: pre-1.0.0 builds are usable, but treat the possibility of a breaking change as real and keep independent copies of anything critical.
• Upgrading: staying within the same major version is the safe path by design; a major version change is the point at which you should verify restorability rather than assume it.
• Verification: restic's own description emphasizes being "verifiably" able to restore, so the compatibility promise is meant to be checked by actually restoring, not just trusted.

Where to confirm details

The compatibility statement lives on the restic homepage, with installation and usage details in the manual (released version and latest development version), and the design document describing the on-disk data structures. For questions about a specific version or repository, the project points users to its forum for usage and support questions and to GitHub issues for bugs or feature suggestions.

restic is an open-source project, and contributions are welcome. The project's own site states that contributions are welcome and points to the restic contribution guidelines for details. If you want to contribute, the practical starting point is to read those guidelines, then use the project's GitHub presence for code, issues, and collaboration. The site also notes a design document that describes restic's design and the data structures it stores on disk — useful reading before changing anything that touches repository formats or backup logic.

Where contributions happen

The restic website lists GitHub as the project's code home and links to a contribution guidelines document. It also mentions a design document covering restic's design and on-disk data structures. Those two documents are the natural first stop: the guidelines tell you how the project expects contributions to be made, and the design document gives you the background needed to make changes that fit the existing architecture.

Ways to contribute

The site's contribution section is brief, but the surrounding structure of the project suggests several concrete paths:

• Code — via the GitHub project, following the contribution guidelines.
• Documentation — the site links to both a released-version manual and a development-version manual, so documentation changes are part of the project's surface area.
• Bug reports and feature suggestions — the site explicitly invites opening a GitHub issue for bugs or feature ideas, and asks that you fill out the issue template you are shown.
• Design and data-structure work — the design document is the reference for how restic is built and how it stores data, which matters for any change affecting repositories.

Before you start: compatibility matters

restic follows Semantic Versioning, and the project treats the repository and the data structures inside it as the "Public API." The site states that once version 1.0.0 is released, backward compatibility of all repositories within one major version is guaranteed — as long as the major version is not incremented, data can be read and restored. The project also says it strives to be fully backward compatible with all prior versions. During initial development (versions before 1.0.0), maintainers and developers do their utmost to keep backward compatibility and stability, though breaking changes are possible without a major version increase.

That context matters for contributors: changes that affect how backups are stored or restored carry compatibility implications, so the design document and contribution guidelines are not optional background reading.

Getting help and asking questions

The site separates support from development:

• Usage or support questions go to the forum.
• Bugs or feature suggestions go to GitHub issues, using the issue template.
• Contact — the site lists several ways to reach the project and its community, with the forum and GitHub issues being the two named channels for questions and bug reports respectively.

If you are unsure whether something is a bug or a usage question, the split above is the project's own guidance: usage questions to the forum, defects and ideas to GitHub.

A practical first contribution path

1. Read the contribution guidelines linked from the restic site.
2. Read the design document if your change touches how data is stored or restored.
3. Check the compatibility rules above so you understand what can and cannot change within a major version.
4. Open a GitHub issue for a bug or feature idea, filling out the template.
5. Ask usage questions in the forum rather than the issue tracker.

The site does not describe a more detailed contribution workflow beyond pointing to the guidelines, so the guidelines themselves are the authoritative next step.

Install restic as a single executable, then run restic init to create a repository and restic backup to store your first snapshot. This guide covers the whole path from download to verification, using the official quickstart, installation, and compatibility guidance from restic.net.

What restic Is and Why It Matters for Getting Started

restic is a modern backup program that backs up files from Linux, BSD, Mac, and Windows to many storage types, including self-hosted and online services. It is a single executable that runs without a server or complex setup, transfers only the parts of files that actually changed, uses cryptography throughout, and lets you verify that files can be restored. It is entirely free to use and completely open source.

That single-binary design is what makes the first run simple: there is no daemon to configure and no database to install before your first backup.

Step 1: Install restic

Follow the Installation Instructions page in the user manual, or download the latest native binary from the GitHub Download Page.

• Manual route: use the installation instructions for your platform so dependencies and paths are handled correctly.
• Binary route: download the native binary and place it somewhere on your PATH.

Verify the install before continuing:

restic version

Expected result: the command prints the restic version. If it is not found, the binary is not on your PATH.

Step 2: Create a Repository

A repository is where restic stores snapshots. Initialize one against the storage backend you plan to use:

restic init --repo /path/to/repo

You will be prompted to set a repository password. restic encrypts data in every part of the process, so this password is required to read or restore anything later. Store it somewhere safe and separate from the backup itself.

Expected result: restic reports that the repository was created successfully.

Step 3: Run Your First Backup

Point restic at the files you want to protect:

restic -r /path/to/repo backup /path/to/data

Expected result: restic scans the path, uploads the changed data, and prints a snapshot ID when finished.

Because restic only transfers the parts of files that actually changed, the first backup is the slowest and later runs are much faster.

Step 4: Verify You Can Restore

A backup you cannot restore is not a backup. restic is designed to be verifiable, so confirm the snapshot exists and inspect it:

restic -r /path/to/repo snapshots
restic -r /path/to/repo ls latest

Expected result: snapshots lists your snapshot with its ID and timestamp, and ls latest lists the files inside it. To restore files to a directory:

restic -r /path/to/repo restore latest --target /path/to/restore

Learn More from the Official Manual

The quickstart demo and full documentation are the fastest way to go deeper:

• Manual (released version): matches the stable release you installed.
• Manual (latest development version): includes features not yet in a release.

Use the released manual unless you specifically need an unreleased feature.

Compatibility: What You Can Rely On

Backward compatibility matters because you must always be able to restore saved data. restic follows Semantic Versioning, and the repository and its data structures are treated as the "Public API" in that sense.

restic also aims to be fully backward compatible with all prior versions.

Where to Get Help

• Usage or support questions: post in the forum.
• Bugs or feature suggestions: open a GitHub issue, and fill out the issue template you are shown.
• Contributing: see the contribution guidelines; the design document describes restic's design and on-disk data structures.

Common Sticking Points

• Forgetting the repository password: there is no recovery path described in the source material, so treat the password as essential from the first init.
• Skipping verification: run snapshots and ls after the first backup so you know the repository is readable.
• Mixing versions carelessly: check the compatibility table above before upgrading across a major version.

restic is a modern, open-source backup program that backs up files from Linux, BSD, Mac, and Windows to many different storage types, including self-hosted and online services. It runs as a single executable with no server or complex setup, transfers only the parts of files that actually changed, encrypts data throughout the process, and lets you verify that backups can be restored. It is entirely free to use and completely open source.

What restic does

restic is a command-line backup tool. You point it at files and a storage destination, and it creates encrypted, deduplicated snapshots that you can restore later. According to the project, it is designed to be:

• Easy — a single executable you can run without a server or complex setup.
• Fast — only the parts that actually changed in your files are transferred.
• Secure — cryptography is used carefully in every part of the process.
• Verifiable — you can make sure your files can be restored when needed.
• Free — entirely free to use and completely open source.

Where it runs and where it stores data

restic backs up files from Linux, BSD, Mac, and Windows to many different storage types, including self-hosted and online services. The site does not enumerate every supported backend on this page; the manual covers installation and configuration details.

Compatibility and versioning

Backward compatibility matters for backups, because you need to be able to restore saved data later. restic follows Semantic Versioning, and the repository plus the data structures inside it are treated as the "Public API" in that sense.

• Once version 1.0.0 is released, all repositories within one major version are guaranteed backward compatible: as long as the major version is not incremented, data can be read and restored.
• The project strives to be fully backward compatible with all prior versions.
• During initial development (versions before 1.0.0), maintainers do their utmost to keep backward compatibility and stability, but breaking changes are possible without a major version increase.

Getting started

The site's Quickstart section includes a short recorded demo. For step-by-step use, the project points to the user manual, available in two versions:

• Manual for the released version
• Manual for the latest development version

To install, follow the Installation Instructions page in the manual, or download the latest native binary from the GitHub Download Page.

Getting help and contributing

• Usage or support questions → post in the forum.
• Bug reports or feature suggestions → open a GitHub issue, and fill out the issue template you are presented with.
• Contributions → see the restic contribution guidelines; the design document describes restic's design and the data structures stored on disk.

Quick reference

Use the forum for usage or support questions, and GitHub Issues for bugs or feature suggestions. restic's own Contact section lists these as the two primary channels, and it explicitly asks that bug reports and feature requests be filed through the issue template you are shown when opening an issue.

Which channel should you use?

The distinction matters because the project routes support traffic to the forum and defect/feature traffic to GitHub. Posting a support question as a GitHub issue, or a bug report in the forum, is likely to get redirected.

Filing a bug or feature request

The site gives one concrete instruction beyond "open an issue": fill out the issue template you are presented with. That template appears automatically when you start a new issue, so the practical steps are:

1. Go to the restic GitHub project.
2. Open a new issue.
3. Complete the template fields rather than deleting them.
4. Submit.

The expected result is a report the maintainers can act on without a round-trip asking for basics. The site does not describe what fields the template contains, so check the template itself when you open it.

Other ways to reach the project

The Contact section also points to the contribution guidelines and the design document for people who want to contribute or understand restic's internals — these are documentation, not support channels. The page excerpt ends mid-sentence after the GitHub issue guidance, so any additional contact methods (mailing lists, chat, etc.) are not confirmed by the available material. Treat the forum and GitHub as the two verified routes.

Before you post

• For support questions, the manual is the first stop: restic publishes a manual for the released version and one for the latest development version. Many usage questions are answered there.
• For bugs, note that restic follows Semantic Versioning, and the repository and its data structures are treated as the "Public API." If your issue involves restoring older backups, mentioning your restic version helps, since backward compatibility is guaranteed within a major version once 1.0.0 is released.
• For anything involving a specific backup or repository, include the restic version and the command you ran — the site does not require this, but it is the kind of detail a template typically asks for.