Skip to content
STACK IT FAST
Share

RustFS vs Garage

Architecture comparison 2 projects Built from source-audited deep dives

Both are S3-compatible object stores written in Rust, but they aim at different clusters. RustFS is a MinIO-style erasure-coded store with IAM, KMS, replication and many protocols under Apache-2.0; Garage is a lean AGPL-3.0 store built to keep small, geo-distributed clusters available when nodes drop out.

RustFS Garage
RustFS
Rust · Apache-2.0
Garage
Rust · AGPL-3.0
Updated
2026-09-25

Which one should you pick?

Pick RustFS if…
  • You want a MinIO-like feature set: erasure coding, object lock, KMS encryption, replication, S3 Select
  • You need extra protocols such as FTPS, WebDAV, Swift or SFTP
  • You prefer the permissive Apache-2.0 license
Pick Garage if…
  • Your nodes are few, spread across sites and not always online
  • You want embedded metadata (LMDB, SQLite or Fjall) and a small operational footprint
  • You also want a simple key-value API (K2V) and static website hosting

Side by side

Attribute RustFS Garage
Written in RustShellPython Rust
License Apache-2.0 AGPL-3.0
Frontend Web console none
Backend & APIs RustTokiogRPCS3 Rustgarage_net
Data & persistence Erasure coding (Reed-Solomon)KMS (Vault / AWS KMS) LMDBSQLiteFjall
Infrastructure & deploy DockerHelmNixOpenTelemetryGitHub Actions DockerNixKubernetesPrometheusWoodpecker CI
Key decisions
  • Dozens of single-purpose crates behind one rustfs binary
  • Erasure-coded storage with a separate healing and scanner layer
  • Protocols beyond S3 are cargo features
  • Cluster logic is split into a dozen single-purpose Cargo crates
  • Metadata storage engine is pluggable, not fixed to one database
  • Own RPC transport instead of gRPC or plain HTTP for cluster traffic
Audited edcc81a · 2026-09-25 d50be27 · 2026-09-17

How they differ

Storage model

RustFS follows the erasure-coded design popularised by MinIO: crates/ecstore spreads objects across erasure sets, and a scanner, bitrot protection and crates/heal find and repair damage. Garage splits the cluster into crates for RPC (garage_net, garage_rpc), metadata tables (garage_table) and data blocks (garage_block), and keeps metadata in an embedded engine chosen at build or config time: LMDB, SQLite or Fjall.

Features and protocols

RustFS aims for breadth: object lock, server-side encryption with Vault or AWS KMS, lifecycle and tiering, S3 Select, bucket and site replication, OIDC, and FTPS, WebDAV and GCS in the default build, with Swift and SFTP as opt-in features. Garage keeps a smaller surface: the S3 API, its own K2V key-value API, an admin API and static website hosting.

Operating it

RustFS ships a release Docker image, a Helm chart and a Nix flake, and nodes talk gRPC. Garage ships a minimal scratch-based image, uses Nix as its main reproducible build, supports optional Kubernetes or Consul discovery, and tests distributed correctness with fuzzing and Jepsen. RustFS is Apache-2.0; Garage is AGPL-3.0.

Architecture diagrams

RustFS Open SVG
RustFS architecture diagramS3 clients → rustfs server (S3 API); Web console → rustfs server (admin API); FTPS / WebDAV / Swift → rustfs server (protocols); rustfs server → IAM & policy (authorize); rustfs server → Erasure-coded store (put / get); Erasure-coded store → Erasure sets (shards); Scanner & heal → Erasure sets (repair); Replication → Other nodes (replicate); rustfs server → KMS (SSE keys); rustfs server → Other nodes (internode)CLIENTSSERVICESWORKERS & JOBSDATA & STORAGEEXTERNALS3 clientsAWS SDKs · CLIWeb consoleport 9001FTPS / WebDAV / Swiftcargo featuresrustfs serverRust · TokioIAM & policycrates/iam · policyErasure-coded storecrates/ecstoreScanner & healcrates/healReplicationbucket · siteErasure setslocal drivesKMSVault · AWS KMSOther nodesgRPC (tonic)authorizeS3 APIadmin APIprotocolsput / getshardsrepairreplicateSSE keysinternode
Garage Open SVG
Garage architecture diagramS3 clients → garage binary (S3 API); K2V clients → garage binary (K2V API); Website visitors → garage binary (garage_web); garage binary → Metadata tables (objects · keys); garage binary → Block manager (put / get blocks); Metadata tables → Metadata DB (garage_db); Block manager → Data blocks (chunks); Metadata tables → Cluster RPC (sync); Cluster RPC → Other nodes (replicate)CLIENTSSERVICESWORKERS & JOBSDATA & STORAGEEXTERNALS3 clientsAWS SDKs · CLIK2V clientsk2v-clientWebsite visitorsstatic hostinggarage binaryhyper · S3 / K2V / adminCluster RPCgarage_netMetadata tablesgarage_tableBlock managergarage_blockMetadata DBLMDB / SQLite / FjallData blockslocal disksOther nodesreplicationsyncS3 APIK2V APIgarage_webobjects · keysput / get blocksgarage_dbchunksreplicate

Frequently asked questions

Are RustFS and Garage the same project?

No. Both are written in Rust and speak S3, but RustFS (rustfs/rustfs, Apache-2.0) and Garage (built by the Deuxfleurs collective, AGPL-3.0) are separate codebases with different designs.

Does Garage use erasure coding like RustFS?

RustFS stores objects across erasure sets through its ecstore crate and repairs them with a heal crate. Garage keeps metadata in replicated tables and stores data blocks through its block manager, replicating across nodes with its own RPC layer.

More architecture comparisons

View all

SeaweedFS vs Garage vs MinIO

SeaweedFS, Garage and MinIO compared on architecture: Go vs Rust, metadata storage, erasure coding, S3 compatibility, licensing and project status.

SeaweedFS vs RustFS

SeaweedFS vs RustFS compared on architecture: Haystack-style volumes and a Filer vs erasure-coded object storage, Go vs Rust, protocols and licensing.

AFFiNE vs AppFlowy

AFFiNE vs AppFlowy compared on architecture: React + Yjs vs Flutter + Rust, local-first storage, sync servers, native code and local AI.

Appsmith vs ToolJet vs Budibase

Appsmith, ToolJet and Budibase compared on architecture: Java vs NestJS vs Koa, MongoDB vs PostgreSQL vs CouchDB, sandboxing, plugins and deployment.