RustFS 1.0 Release Candidate: A Rust-Based S3 Alternative with a 2.3x Claim on Small Objects

The Problem RustFS Targets

RustFS addresses two common pain points in object storage: licensing and small-object performance. Many S3-compatible systems, notably MinIO, are licensed under AGPL, which can be a barrier for commercial products that want to embed or modify the storage layer without exposing their own source code. RustFS uses Apache 2.0, a permissive license that allows unrestricted use and modification. The project also claims a 2.3x performance advantage over MinIO for 4KB object payloads, which is a typical size for metadata-heavy or IoT workloads. The intended audience is clear from the README: data lakes, AI, and big data workloads, plus edge devices where a lightweight, memory-safe store is attractive. RustFS is built in Rust, which the project highlights for memory safety and raw speed compared to Go or C-based alternatives.

Architecture and Data Flow

The README does not provide a detailed architectural diagram, but it does list the key components. RustFS supports both S3 and OpenStack Swift APIs, with native Keystone authentication for Swift. The data flow is typical for an object store: clients issue S3 or Swift requests, which are authenticated (via Keystone or S3 credentials), then routed to the storage engine. The project mentions a distributed architecture that is scalable and fault-tolerant, but the actual data placement, replication, and consistency mechanisms are not described in the README. What is visible is a feature table that separates available features from those under testing. Single node mode is available, while distributed mode is under testing. That distinction matters for deployment decisions: if you need multi-node redundancy, you are relying on a feature that has not been marked stable.

Getting Started: Installation and Configuration

The README points to a Getting Started guide and documentation at docs.rustfs.com/en/installation, but the repository material itself does not include the exact installation commands. Based on the repository layout, you can expect a standard Rust project with a Docker image (the CI workflow includes docker.yml). The typical path would be to pull a Docker image or build from source using cargo build --release. Configuration keys are not listed in the README; you would need to consult the docs. The project provides Kubernetes Helm charts, which are marked as available. For a quick start, the single node mode is the recommended entry point, as distributed mode is under testing. Users should check the S3 compatibility matrix in docs/architecture/s3-compatibility-matrix.md to see which S3 operations are supported before integrating with existing tools.

Performance Claims and What They Mean

The headline claim is a 2.3x speedup over MinIO for 4KB object payloads. The README includes a stress test environment: 2-core Intel Xeon Sapphire Rapids, 4GB RAM, 15Gbps network, and four 40GB drives with 3800 IOPS each. That is a constrained environment, and the result is specific to 4KB objects. The README does not provide throughput or latency numbers for larger objects, nor does it describe the benchmark methodology (e.g., whether it was PUT, GET, or mixed). As a point of view, a 2.3x gain on small objects is plausible given Rust's memory management, but it is not a general performance guarantee. For workloads with multi-megabyte objects, the difference may shrink or reverse. The project also compares itself to 'other object storage' on features like console experience and licensing, but those are qualitative claims, not benchmarks. Treat the 2.3x figure as a single data point, not a universal promise.

Licensing and Legal Implications

RustFS is released under Apache 2.0, which is a permissive license. This is a genuine differentiator from MinIO, which uses AGPL v3. The README explicitly calls out the 'poison pill' clauses of AGPL, arguing that Apache 2.0 is more business-friendly. For a company that wants to use object storage as a library or embed it in a proprietary product, Apache 2.0 removes the obligation to share source code. However, this is not legal advice, and you should verify that all dependencies are also permissively licensed. The README also claims 'No Telemetry / Full Compliance' with GDPR, CCPA, and APPI, which is a strong statement. No telemetry is a design choice, not a license feature. If you have strict data sovereignty requirements, you should verify that the build you run has no outbound network calls, but the README asserts this as a benefit.

Current Limitations and Failure Modes

The most obvious limitation is that RustFS is at 1.0.0-rc.4, a release candidate. The feature table marks Lifecycle Management, Distributed Mode, and RustFS KMS as 'Under Testing'. That means production use of these features is risky. Lifecycle management is critical for tiering and deletion policies; if it is not stable, you cannot rely on it. Distributed mode is the core of a scalable object store; without it, you are limited to single node, which is a single point of failure. The Swift Metadata Ops are only partially available, so Swift users may hit gaps. Another failure mode is S3 compatibility: the README says coverage is tracked in a matrix, but it does not list which operations are missing. If your application uses a niche S3 feature like object lock or multipart upload edge cases, you need to check that matrix before committing. The project is also young, with the first release candidate in August 2026, so the ecosystem of tools and community support is thin compared to MinIO.

Alternatives and How They Differ

The most direct alternative is MinIO, which RustFS explicitly compares against. MinIO is written in Go, uses AGPL licensing, and has a mature ecosystem with extensive documentation and a large community. MinIO's distributed mode is battle-tested, and it offers a wide range of enterprise features like erasure coding, bucket replication, and a fully featured console. The key difference in approach is that MinIO is a mature, proven system with a restrictive license, while RustFS is a newer, Rust-based system with a permissive license but less maturity. Ceph is another alternative, but it is a heavyweight system with a different architecture (RADOS) and is often used for block and file storage in addition to object. Ceph's S3 gateway is part of a larger cluster, which is more complex to operate. RustFS aims to be simpler, like MinIO, but with Rust's performance and memory safety. If licensing is your primary concern, RustFS offers a clear advantage; if stability and feature completeness are non-negotiable, MinIO or Ceph are safer.

Editorial conclusion

RustFS is for teams that need S3-compatible object storage with a permissive license (Apache 2.0) and are willing to run a release candidate in production. It is not for organizations that require battle-tested distributed mode or full lifecycle management, as those features are still under testing. Before adopting, verify the S3 compatibility matrix for the exact APIs your clients depend on, and test the 2.3x performance claim against your own workload, especially if your object sizes are not 4KB. If you need proven multi-node reliability today, MinIO or Ceph remain safer choices.

Official sources

1. Official documentation
2. Official README
3. Project repository
4. Release notes