RustFS is an open-source, S3-compatible, high-performance distributed object storage system written in Rust, aimed at teams running data lakes, AI, and big data workloads who want MinIO-style operational simplicity without the restrictions of an AGPL licence.

What it is

RustFS is a distributed object storage system built in Rust and released under the Apache 2.0 licence. It combines the simplicity of MinIO with the memory safety and raw performance of Rust, and offers broad S3 API compatibility for the features it supports. It lives in the cloud-native object storage ecosystem alongside tools such as MinIO and Ceph, and it supports migration from and coexistence with other S3-compatible platforms. Coverage of the S3 API is tracked explicitly in a compatibility matrix at docs/architecture/s3-compatibility-matrix.md, which signals that partial coverage is documented rather than assumed.

The concrete problem it solves is licence and performance friction in self-hosted object storage. Teams that already run S3-compatible infrastructure, most commonly MinIO, often want to consolidate or migrate without rewriting application code, and they want a permissive licence that avoids the copyleft restrictions of AGPL for commercial usage. RustFS addresses this by speaking the S3 protocol those tools and applications already use, by adding an OpenStack Swift API and Keystone authentication for OpenStack environments, and by building on Rust for resource efficiency at scale. It also targets throughput-sensitive workloads such as data lakes and AI pipelines, where storage is the bottleneck rather than the compute layer.

Key capabilities

• S3 core features including upload and download, versioning, object lock (WORM), bucket quota, bucket replication, site replication, and event notifications.
• Server-side encryption with RustFS KMS, supporting Vault (KV2 and Transit) and AWS KMS backends for production; the Local and Static backends are development and testing only.
• Lifecycle management (ILM) with remote S3 tiering, plus bitrot protection, healing, and a scanner for data integrity.
• OpenStack Swift API with native Keystone authentication using X-Auth-Token headers, enabled through the opt-in --features swift cargo feature.
• Multiple access protocols: SFTP (opt-in via --features sftp), FTPS, and WebDAV, with the latter two enabled in the default build.
• Identity and access: IAM policies, OIDC and SSO, multi-tenancy, audit logging, and logging and observability, managed through a web console.
• Kubernetes Helm charts for deployment, plus preview features for S3 Tables as an Iceberg REST Catalog and MinIO on-disk compatibility behind the rio-v2 feature.

Who uses it and how

• Teams migrating from or running alongside MinIO and Ceph, using the S3 compatibility layer to move workloads without changing client applications.
• Data lake and AI platform operators who need high-throughput object storage for big data and AI pipelines rather than general-purpose file serving.
• OpenStack operators who require Swift protocol support and Keystone authentication alongside S3 in the same storage tier.
• Platform teams deploying on Kubernetes through the provided Helm charts, using multi-tenancy and IAM policies to isolate workloads.
• Organisations with multi-cloud or hybrid-cloud footprints that need tiering to remote S3 targets and site replication across locations.

Getting started

The README points to the project download page at https://rustfs.com/download/ as the entry point, alongside links to the documentation and discussions. Deployment can run in single node mode or distributed mode, with Kubernetes Helm charts available for cluster installs.

How it compares

RustFS is positioned explicitly against MinIO and Ceph as S3-compatible platforms it can migrate from and coexist with. Its central differentiator is licensing: RustFS ships under Apache 2.0, which avoids the AGPL restrictions that apply to some comparable storage systems, and that permissiveness extends to commercial usage and unrestricted community contribution. The project also claims the operational simplicity associated with MinIO while adding Rust-based performance characteristics for large-scale deployments.

When to use it — and when not to

A self-hoster takes on a distributed storage system: KMS backend configuration for production encryption, lifecycle and replication policy design, and the operational work of running a fault-tolerant cluster. Several advertised capabilities are not in the default build and require opt-in cargo features, including Swift and SFTP, while S3 Tables and MinIO on-disk compatibility remain preview, with the latter gated behind rio-v2 and unable to read objects that MinIO encrypted. Anyone who needs every listed feature in a default binary, or who needs guaranteed bidirectional MinIO disk-format interoperability today, should wait or test carefully before committing.