RustFS 1.0 GA: Rust-Based MinIO Alternative for Production Object Storage

MinIO Enters Maintenance Mode, Creating a Gap

On December 3, 2025, MinIO added a notice to its GitHub README: "This project is currently under maintenance and is not accepting new changes." By September 2026 the message escalated to "THIS REPOSITORY IS NO LONGER MAINTAINED," pointing users to the commercial AIStor product. Earlier in 2025 MinIO removed the web console from the community edition, gating bucket management, lifecycle rules, and user management behind the paid enterprise tier. The official Docker Hub image minio/minio was also taken down (404). Combined with the AGPLv3 license — which requires derivative works to be open-sourced — many enterprises faced legal and operational uncertainty. MinIO's installed base spans tens of millions of deployments across CI/CD artifact repos, ML model stores, internal data lakes, and backup archives, so a viable open-source alternative became urgent.

RustFS Overview and Release Timeline

RustFS is a simple, efficient, distributed object storage system, 100% S3-compatible, written in Rust and licensed under Apache 2.0. Key milestones:

2023: Project initiated

February 2024: First line of code

2025: Open-sourced

April 2026: Beta release

August 2026: RC release

September 16, 2026: 1.0.0 GA (Generally Available)

GA does not mean defect-free; the maintainers state that core object storage functionality has reached parity with MinIO's open-source version and is stable enough for production use. At launch the project reported 6,600+ commits, 135+ releases, 180+ contributors, 32.6k GitHub stars, 2.7M+ global installs (70%+ from Europe and North America), 10M+ Docker Hub pulls, and paying customers in AI, energy, finance, and cloud sectors.

Core Features

Rust memory safety: Ownership model eliminates most memory issues at compile time; no GC pauses. Long-running storage processes avoid leaks and GC jitter. Official tests show stable memory usage under sustained high load.

100% S3 compatibility: Existing S3 tooling (aws-cli, mc, language SDKs, backup software, data lake components) works with zero code changes.

Peer-to-peer distributed architecture: All storage nodes are equal, no single point of failure; new nodes join with simple configuration; claimed linear scaling to exabyte capacity.

Cross-platform, cross-CPU: Runs on Linux, macOS, Windows, FreeBSD, Docker, and edge gateways; supports x86 and ARM.

Apache 2.0 license: Permissive, no copyleft concerns — critical for commercial adoption compared to MinIO's AGPLv3.

Built-in web console: Full management UI retained (MinIO community edition removed it).

Cloud-native deployment: Docker, binary, rpm/deb packages provided.

RustFS vs MinIO Comparison

Language: MinIO uses Go; RustFS uses Rust.

License: MinIO uses AGPLv3; RustFS uses Apache 2.0.

Web Console: MinIO removed it from community edition; RustFS fully retains it.

Docker Image: MinIO's official repo delisted (Docker Hub 404); RustFS continuously updated.

Object Performance (4KB): MinIO baseline; RustFS official benchmark claims ~2.3x faster for 4KB object payloads.

Open-Source Status: MinIO in maintenance mode, no new changes; RustFS active iteration, 1.0.0 GA.

Performance caveat: The 2.3x figure comes from the project's own benchmark for 4KB object payloads ("2.3x faster than MinIO for 4KB object payloads"). Small objects stress metadata overhead most; large-file throughput and mixed workloads should be validated with your own workload before drawing conclusions.

Real-World Production Usage

Several organizations ran RustFS in production during Alpha/Beta, managing tens to hundreds of terabytes:

TwinLabs (France, AI startup): Runs a 4-node, 2-disk-per-node (4x2) cluster on NixOS; their CTO fed back numerous issues that drove stability improvements.

HyperApp (Uzbekistan, cloud provider): Uses RustFS + Traefik to serve multi-tenant object storage instances.

Financial firm in Bangladesh and a national bank in Tanzania: Also in production.

Early adopters running real workloads and reporting bugs accelerated the hardening cycle — real-world stress is the ultimate test for storage software.

Migrating from MinIO to RustFS

The project explicitly supports on-disk format compatibility, enabling in-place binary replacement without data migration. However, the GitHub feature matrix marks "MinIO On-Disk Compatibility" as Preview . Recommended migration steps:

Validate fully in a test environment first. Clone real data, run the complete migration flow, verify buckets, objects, versions, and metadata.

Back up configuration and metadata. Keep a rollback path; community tests confirm rolling back to MinIO works.

Encrypted data is a hard boundary. If MinIO uses SSE-C or KMS encryption, current tests show such data cannot be migrated via binary swap; separate evaluation required.

Full stop replacement, not rolling. All nodes must be stopped, replaced, then restarted together; mixed old/new nodes break read/write quorum.

Adjust startup configuration. Environment variables shift from MINIO_* to RUSTFS_* (e.g., MINIO_ROOT_USER → RUSTFS_ACCESS_KEY); TLS parameters must be re-verified.

Application side requires zero code changes. S3 SDKs only need new endpoint and credentials; start with a non-critical bucket, canary 1-2 weeks monitoring latency, error rates, and disk usage before full cutover.

Summary: stop old, swap binary/image, update env vars, start new, verify, canary cutover. Steps 1 and 2 are non-negotiable.

Five-Minute Docker Quickstart

Single-node, four-disk local test (adjust Windows mount paths):

docker run -d 
  --name rustfs 
  -p 9000:9000 
  -p 9001:9001 
  -v d:/rustfs/data:/data 
  -e RUSTFS_VOLUMES=/data/rustfs0,/data/rustfs1,/data/rustfs2,/data/rustfs3 
  -e RUSTFS_ACCESS_KEY=rustfsadmin 
  -e RUSTFS_SECRET_KEY=rustfsadmin 
  -e RUSTFS_CONSOLE_ENABLE=true 
  rustfs/rustfs:latest

Ports:

9000 = S3 API

9001 = Web console

Open http://localhost:9001, log in with rustfsadmin / rustfsadmin (default credentials, only for local testing — use strong secrets in production ).

Any S3 client works by pointing the endpoint to RustFS. Example with aws-cli:

aws configure set aws_access_key_id rustfsadmin
aws configure set aws_secret_access_key rustfsadmin
# Create bucket
aws --endpoint-url http://localhost:9000 s3 mb s3://demo
# Upload file
aws --endpoint-url http://localhost:9000 s3 cp hello.txt s3://demo/
# List objects
aws --endpoint-url http://localhost:9000 s3 ls s3://demo/

Core principle: endpoint targets RustFS API; everything else is identical to AWS S3 usage.

webman Framework Integration Example

The author (a webman ecosystem developer) demonstrates PHP integration via a storage plugin:

Install plugin: composer require tinywan/storage (plugin URL: https://www.workerman.net/plugin/21; webman-admin marketplace: https://www.workerman.net/app/view/storage)

Install S3 driver: composer require league/flysystem-aws-s3-v3 Upload code:

use Tinywan\Storage\Storage;

$res = Storage::uploadFile(Storage::MODE_S3);
var_dump(json_encode($res));

Configuration: select S3 mode in plugin settings; both access domain and endpoint must be the RustFS API address (e.g., http://192.168.3.29:9000); provide matching access key, secret key, and bucket name from the Docker startup.

Sample response includes original filename, stored path, access URL, size, MIME type — ready for DB storage or direct frontend return.

Ecosystem parity: Because RustFS is S3-compatible, Java (AWS SDK for Java), Go (aws-sdk-go), Python (boto3), and any other language only need to change the endpoint configuration — no code rewrites. This "swap engine, keep car" capability is high-value for cost reduction and domestic IT substitution (信创) scenarios.

AI-Focused Roadmap

Version 1.0 is not the endpoint. The declared roadmap centers on AI data infrastructure :

S3 Tables (live): Embeds an Apache Iceberg REST Catalog inside the storage kernel, extending object storage from "store files" to "manage structured data" — fully open source.

S3 Vectors (planned): Treat vector data as first-class objects with low-cost, high-reliability, high-scale storage. RAG, semantic search, and AI agents generate massive vector datasets; the goal is to serve them from object storage instead of a separate vector database.

RDMA / DPU (exploration): GPU compute grows faster than CPU/network paths. Plan to bypass traditional kernel stacks via RDMA, offload erasure coding and encryption to DPUs, keeping GPUs fed with data.

RustFS 2.0: Explicitly AI-centric, targeting a unified platform covering objects, tables, and vectors .

The narrative aligns with industry direction: massive unstructured data from model training and inference ultimately lands in object storage. Delivery remains to be proven over time.

Conclusion

MinIO exits to maintenance; RustFS 1.0 steps in. In just over two years — from first commit to production-grade GA — RustFS has moved remarkably fast. Apache 2.0 licensing, a complete console, and an active community make it the most practical open-source MinIO alternative today. Still, 1.0 is new; production adoption should start with non-critical workloads and gradual canary deployments.

GitHub: https://github.com/rustfs/rustfs

Website: https://rustfs.com

Docs: https://docs.rustfs.com.cn