rustic: one tool, four install paths and three different names
rustic - fast, encrypted, and deduplicated backups powered by Rust
At a glance
- What is it?
- Rustic is a Rust rewrite of the restic backup format, and the packaging tells a more interesting story than the feature list does: the binary, the crate and the package managers all use different names, two of the three internal libraries arrive over git rather than crates.io, the default feature set links a web server and a terminal UI, and the container image covers exactly two architectures.
- Who is it for?
- Rustic suits an operator who already has restic repositories and wants to read them with something that moves faster, and it does not suit someone who needs a documented restore procedure rather than a documented install. Verify three things first.
- Can I use it commercially?
- Yes. Apache-2.0 is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 5 days ago.
- What is it written in?
- Mainly Rust, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 22, 2026, and from our analysis. They are not legal advice.
Star history
- rustic-rs/rustic3,447 ★ · +171
| Repository | 2026-09-24 | 2026-11-22 |
|---|---|---|
| rustic-rs/rustic | 3.3k | 3.4k |
171 Stars in the last 59 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
The binary is rustic, the crate is rustic-rs, and the managers each pick one
Four installation routes are offered and they do not agree on what to ask for.
cargo binstall rustic-rsscoop install rusticbrew install rusticdocker pull ghcr.io/rustic-rs/rusticThe Cargo routes want the crate name rustic-rs, which is what the manifest declares as the package name. The two native package managers want rustic, which is the binary name declared separately in the same manifest. The container registry path uses the repository name. So the artifact you install is called rustic in two places and rustic-rs in the two places Cargo cares about.
The distinction matters for anyone scripting a rollout. A command typed into a terminal resolves the binary, so rustic works after a Homebrew or Scoop install and does not obviously work after a Cargo one. Cargo, by contrast, only ever sees the crate name, and the two crates.io routes in the document both use it.
Those two Cargo routes also differ in a way worth noticing. The crates.io line is `cargo install --locked rustic-rs`, while the from-git line is `cargo install --git https://github.com/rustic-rs/rustic.git rustic-rs`, carrying no lock flag and a warning that it installs the latest development version, which might be unstable. The reproducibility guarantee is attached to the published crate, not to the repository checkout.
The backend library comes from the core repository, not its own
The manifest splits the project across dependencies in a way that does not match how the overview describes it.
rustic_backend = { git = "https://github.com/rustic-rs/rustic_core", features = ["cli"] }
rustic_core = { git = "https://github.com/rustic-rs/rustic_core", features = ["cli"] }Both point at the same repository. The crate called rustic_backend is pulled from rustic_core, so the backend library has no separate source location of its own, even though the overview presents the project as split into multiple crates and gives rustic-backend its own crates.io entry alongside rustic-core.
Neither dependency carries a version constraint. There is no tag and no revision pinned in either line, so a build from source resolves whatever the default branch of that repository holds on the day it runs. A manifest that pins its own published version at 0.11.4 therefore depends on two unpinned inputs, which is the opposite of what the locked install implies.
The project also depends on abscissa_core, a framework for command line applications, declared with default features turned off and only the application feature enabled. So the command surface is generated by a framework rather than parsed by hand, which is consistent with a tool that offers subcommands across a wide range of backends.
Default features link a web server, a terminal interface and a metrics stack
The default feature set is five entries long: jq, prometheus, opentelemetry, tui and webdav. Every one of them is on unless you turn it off.
The webdav feature is the largest. It enables a server library, an async web framework, an async runtime, a byte-handling crate and a futures library, which together mean a default build contains an HTTP server capable of serving a WebDAV endpoint. The tui feature adds a terminal widget set, a cross-platform terminal library and a text-area widget. opentelemetry adds the tracing library, an OTLP exporter and its SDK. prometheus adds a metrics client and a base64 encoder. jq adds a JSON query engine in three parts.
So the default artifact of a deduplicating backup tool is also a web server, a terminal interface, a metrics endpoint and a JSON filter. That is a defensible design for a tool meant to be driven from scripts and dashboards, and it is also the thing to know before choosing features: opting out means naming the features you want, because the default is not a minimal build.
The release variant is defined as default plus self-update, so published binaries carry the same surface plus the ability to update themselves. Two optional allocator features let you swap the memory allocator at compile time, and a rhai feature adds an embedded scripting engine that is off by default.
The container build handles two architectures and no others
The Dockerfile does not compile anything. It downloads a prebuilt release archive and copies the binary into an empty base image.
FROM alpine AS builder
ARG RUSTIC_VERSION
ARG TARGETARCH
RUN apk add --no-cache ca-certificates && \
if [ "$TARGETARCH" = "amd64" ]; then \
ASSET="rustic-${RUSTIC_VERSION}-x86_64-unknown-linux-musl.tar.gz";\
elif [ "$TARGETARCH" = "arm64" ]; then \
ASSET="rustic-${RUSTIC_VERSION}-aarch64-unknown-linux-musl.tar.gz"; \
fi; \
wget https://github.com/rustic-rs/rustic/releases/download/${RUSTIC_VERSION}/${ASSET} && \
tar -xzf ${ASSET} && \
mkdir /etc_files && \
touch /etc_files/passwd && \
touch /etc_files/group
FROM scratch
COPY --from=builder /rustic /
COPY --from=builder /etc_files/ /etc/
COPY --from=builder /etc/ssl/certs/ca-certificates.crt /etc/ssl/certs/ca-certificates.crt
ENTRYPOINT ["/rustic"]Three things follow from those lines. Only amd64 and arm64 are handled, and both are musl targets, so the image set is two architectures wide and statically linked throughout. For any other TARGETARCH the variable is never assigned, the download runs with an empty filename, and the build fails at that step rather than skipping.
Neither build argument has a default. RUSTIC_VERSION has to be supplied explicitly, so a build without it constructs a download URL containing an empty version segment.
The final image is built from scratch with three copies: the binary, a pair of empty placeholder files for the system user and group databases, and the CA certificate bundle pulled across from the builder stage. That last copy is why outbound TLS works at all, and it means the trust store is a build artifact rather than something the base image supplies.
Format compatibility is hedged in one sentence and absolute four lines later
Two statements about repository compatibility sit close together and do not carry the same confidence.
The first says the tool reads and writes the restic repo format described in restic's design document, and that it can be used as a restic replacement in most cases. The hedge is in the last three words.
The second, further down, says both projects implement the identical repository format and that you can access every repository with restic as well as with rustic, giving the concrete case of verifying backups made with one tool using the other. That claim has no qualifier on it.
Between them sits a third statement that reframes the choice as a matter of preference rather than capability: the advice given is to test both and see which better fits your requirements, and a comparison page is linked for exactly that purpose.
The framing of restic itself is also worth reading as a claim. It is described as older and more mature than rustic, slow with new developments and conservative with changes, and rustic as created by a heavy restic contributor who was at some point annoyed about that speed. That is an account of motivation rather than a technical comparison.
What the feature list does commit to is a set of design properties: append-only operation by default, concurrent multi-client access through lock-free operations, safe abortion and resumption, and follow-up backups that reprocess only changed files while still producing a complete snapshot.
No backup, snapshot or restore command appears anywhere in the document
This is a backup tool, and the document contains installation commands and no usage commands.
The Getting started section is two sentences and both point elsewhere, at documentation hosted on the project's own site. There is no example of creating a snapshot, no example of restoring one, no example of listing what a repository holds, and no example of checking a backup.
That omission is sharper than it would be elsewhere, because restore is the operation a backup tool is judged by and the one whose correctness a user most needs to see demonstrated. The feature list claims in-place restore only modifies files which are changed, and claims operations can be safely aborted and efficiently resumed, but neither claim is illustrated.
What the document does offer is a pointer to a folder of example configuration files, and the reason those examples ship inside the crate is visible in the manifest, where the published file list includes the configuration directory alongside the sources, the license files and the readme. So the configuration surface is something you can read before installing, even though the command surface is not.
There is also a nightly channel alongside the tagged releases, with separate binaries published for it, which means there are two streams of builds to choose between and no stated policy on which one a production backup should run.
Minimum Rust 1.91 on edition 2024, with a policy about raising it
The manifest declares edition 2024, resolver 3, and a minimum supported compiler of 1.91.0, and the README states the same minimum in prose before explaining how it may move.
The stated policy is that the minimum required to use the crate can be increased in minor version updates. The worked example is careful about the distinction: if a crate at 1.0 required Rust 1.20.0, then every 1.0.z would keep that floor, while a later 1.y might require something newer. The intent is that patch-level upgrades stay installable on an older toolchain and the floor moves at minor versions.
The project is currently at 0.11.4, so the 1.x branch of that policy has not been reached. The section closes by saying the project will be conservative about raising the minimum, which is a statement of intent rather than a constraint anyone can check.
The surrounding tree suggests how much of the repository is build and release machinery rather than the tool itself: a just file for build dependencies, a shell build script, a maskfile, a changelog generator configuration, a dependency-policy file, a formatter configuration, a typos configuration, a release automation file, a coverage directory, a Cargo directory, and an ecosystem document. Two directories sit side by side at the root with similar names, one called test and one called tests, which is the kind of thing a first-time reader has to work out from the contents rather than the names.
The manifest adds a little more of the same picture. The package declares a single category, command-line-utilities, and a keyword list that names the format it speaks, since restic appears alongside backup, deduplication, encryption and cli. Documentation is pointed at the generated API pages rather than at the project's own site, and the author field is a team name rather than a person.
The publish file list is also narrower than the repository. Only the sources, the two license files, the readme and the configuration directory are packaged, so the documentation, tests, scripts and tooling present in the checkout are not part of what a Cargo install receives. That is why the example configuration files can be read from an installed crate while the command documentation cannot.
The published API documentation is built with every feature switched on
The manifest carries a docs metadata block that changes what the generated documentation describes:
[package.metadata.docs.rs]
all-features = true
rustdoc-args = ["--document-private-items", "--generate-link-to-definition"]Enabling all features means the published pages describe a build containing the webdav server, the terminal interface, the OpenTelemetry stack, the metrics endpoint, the JSON filter, and also the ones that are off by default: the FUSE mount command, the embedded scripting engine, both alternative allocators, and self-update.
The argument that documents private items goes further, so internals are rendered alongside the public surface rather than being left out.
The result is a documentation set that describes a strict superset of what most people run. A default build has five of those features. The published release binaries add self-update and stop there, which is still short of all-features. So a flag or subcommand visible in the generated documentation tells you the codebase supports it, not that the build you installed contains it.
The binary stanza is configured without feature gating, which is consistent with that. It points at the source file for the binary and turns on the test, bench, doc and harness machinery, while the line that would restrict it to particular features is present but commented out.
Editorial conclusion
Rustic suits an operator who already has restic repositories and wants to read them with something that moves faster, and it does not suit someone who needs a documented restore procedure rather than a documented install. Verify three things first. Which crate name you actually want, since the binary, the package and the package managers disagree and cargo install takes the crate. Whether your existing repositories open cleanly, since compatibility is stated as hedged in one sentence and absolute in another, and a comparison page exists precisely because the two tools differ. And which architectures you need to cover, because the container image builds for two of them and silently produces nothing for the rest.
Frequently asked questions
Is rustic a drop-in replacement for restic?
It reads and writes the restic repository format and is described as usable as a restic replacement in most cases. The document also states that both projects implement the identical repository format, so a repository written by one can be read and verified with the other, and it links a comparison page.
How do I install rustic?
Five routes are given: cargo binstall rustic-rs, scoop install rustic, brew install rustic, docker pull ghcr.io/rustic-rs/rustic, and cargo install --locked rustic-rs from crates.io. A further route installs from the git repository with cargo install --git and is marked as possibly unstable.
Which Rust version does rustic require?
The manifest sets a minimum of 1.91.0 and uses edition 2024. The stated policy is that the minimum may be raised in minor version updates, while patch releases keep the same floor, and that the project will otherwise be conservative about raising it.
What license is rustic released under?
Dual licensed at your option: the README lists the Apache License 2.0 and the MIT license, the manifest records Apache-2.0 OR MIT, and the repository root contains both LICENSE-APACHE and LICENSE-MIT.
Which crates make up the rustic project?
Three are named: rustic-rs as the main binary, rustic-core as the core library, and rustic-backend for backend support. The main crate depends on the latter two over git rather than from crates.io, and both are taken from the rustic_core repository.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/rustic-rs-rustic)Star history chart for your README
[](https://hysenlabs.com/projects/rustic-rs-rustic)Was this useful?