RustFS 1.0 Is GA After 2.5 Years: What's Actually Production-Ready, and What Isn't

RustFS 1.0.0 GA: What Actually Shipped, and What Isn't

RustFS 1.0.0 reached general availability on September 16, 2026. The core S3-compatible object storage engine is stable and supported for production. RustFS is a distributed, Apache 2.0-licensed object store written in Rust, now with 32,000+ GitHub stars and 2.7 million+ deployed instances worldwide.

RustFS 1.0.0 GA: What Actually Shipped

RustFS 1.0.0 is the first generally available release of the project. "GA" here means one specific thing: the core object storage engine (PUT, GET, multipart upload, versioning, replication, and the S3 API surface) is stable and supported for production traffic.

The team spent two years and seven months getting there, from the first commit in February 2024 to open sourcing in July 2025, then Beta in April 2026 and RC in August 2026.

What shipped is not a rewrite of someone else's storage engine. RustFS is built from scratch in Rust, which the team chose for memory safety and concurrency under heavy write loads. GA matters because it lets you stop evaluating RustFS and start running it where downtime costs money. The release also closes a promise the project made at open source: a self-hosted, S3-compatible store with no commercial license gate on the core engine.

What Is RustFS, and Why Rust?

RustFS is a distributed object storage system that speaks the S3 API. You point an existing S3 client (the AWS CLI, MinIO's mc, rclone, or your application's SDK) at a RustFS endpoint and it behaves like S3. Under the hood it is written in Rust, which is the part that actually matters to operators.

Rust brings two things to a storage engine:

• Memory safety without a garbage collector - no stop-the-world pause while you serve a hot bucket.
• Fearless concurrency - the borrow checker lets the team write parallel I/O paths that do not corrupt data under load.

The practical result the project cites is steady throughput on PUT-heavy workloads. If you have run a Go-based store and fought GC tail latency, that is the class of problem RustFS targets. The trade-off is a smaller ecosystem and fewer prebuilt integrations than the incumbents.

Is RustFS Production-Ready Today?

For the core object storage path, yes. RustFS 1.0.0 lists single-node and distributed deployment as available, along with versioning, object lock (WORM), bucket and site replication, durability through bitrot protection, and server-side encryption. Those are the features most teams actually turn on in production.

What I would not do on day one is assume RustFS matches MinIO or Ceph feature for feature. The RustFS feature matrix marks S3 Tables (Apache Iceberg) as preview, not GA, and the surrounding tooling (backup operators, third-party connectors, managed offerings) is thinner than the incumbents.

My recommendation: run RustFS for a real workload you can measure, not just a hello-world bucket. Stand up a single node, point rclone at it, and watch p99 latency under your own traffic before you trust it with the primary copy of anything.

What Can RustFS Do That Matters for Storage Teams?

RustFS covers the S3 surface most applications need:

• Multipart upload for large objects
• Versioning
• Object lock for compliance hold
• S3 Select for server-side filtering

On access it is not S3-only. The GA release ships the Swift API, WebDAV, FTPS, and SFTP alongside the S3 endpoint, which matters if you are retiring an old Swift cluster or want file-style access without a separate gateway.

On the control plane, RustFS gives you:

• IAM policies
• OIDC single sign-on
• A RustFS KMS
• STS tokens
• Audit logging

For operations there are event notifications, health inspection, multi-tenancy, and Helm charts for Kubernetes. Data movement is handled by bucket replication and site replication, plus ILM tiering to a remote S3 target. If your stack already speaks S3, the migration is mostly a DNS and credential change.

How Do You Run RustFS 1.0.0?

The fastest path is a single container. The official image is rustfs/rustfs:latest, and the README's verified command maps the API port 9000 and console port 9001, with volumes for data and logs:

docker run -d -p 9000:9000 -p 9001:9001 \
  -v $(pwd)/data:/data -v $(pwd)/logs:/logs \
  rustfs/rustfs:latest

[sourced from RustFS GitHub README, NOT EXECUTED IN CI]

Default credentials are rustfsadmin / rustfsadmin (change them before this touches a network). The web console is at http://localhost:9001.

For a bare-metal box there is also a one-click script:

curl -O https://rustfs.com/install_rustfs.sh && bash install_rustfs.sh

Kubernetes users get Helm charts. For a quick distributed test, docker compose with the project's docker-compose-simple.yml brings up multiple nodes. Pick the method that matches where your workload already runs.

Where Does RustFS Still Trail MinIO and Ceph?

Honesty first: RustFS is younger. Ceph has a decade of production deployments and MinIO has a far larger install base and connector ecosystem. On mixed and read-heavy workloads RustFS is still closing the gap. The beta.10 benchmarks showed RustFS ahead on PUT-heavy patterns, but read-mixed tuning is where the incumbents remain ahead today.

S3 Tables (Iceberg) is in preview, so if your roadmap depends on in-storage analytics tables, that is not GA yet. The third gap is operational muscle memory: fewer community runbooks, fewer third-party backup tools with first-class RustFS support, and a smaller talent pool who have run it at scale.

None of that is a reason to skip RustFS, but it is a reason to validate on your own workload and keep a rollback path. RustFS is betting that Rust's safety and write-path concurrency outweigh ecosystem lag over time.

What's Next After 1.0.0 GA?

GA is a start line, not a finish. The RustFS team's stated next steps are two: harden what shipped and push further into AI infrastructure.

On hardening, the plan is to keep absorbing feedback from production users and close rough edges in replication, tiering, and the console. On the AI side, RustFS is adding S3 Vectors support and framing a RustFS 2.0 built around AI data centers - object storage that feeds training and inference pipelines directly. That direction fits the project's positioning as AI-native storage rather than a generic S3 bucket.

For now, treat S3 Vectors and 2.0 as roadmap, not something you can deploy today. If vector storage or AI data lakes are on your 2027 plan, RustFS is worth watching, but build this year's system on what is GA.

Should You Migrate from MinIO to RustFS Now?

If you are greenfield or adding a new storage tier, RustFS 1.0.0 is reasonable to adopt for production workloads that are S3-centric and write-heavy. The S3 compatibility means your existing clients work unchanged, and the Apache 2.0 license means no commercial surprise.

If you already run MinIO or Ceph in production with mature tooling, do not rip it out. Migrate one workload, measure it, and expand only if RustFS earns it on your numbers. The lowest-risk first project is a secondary tier (backups, artifacts, or a staging bucket), where a write-path latency win shows up without betting the primary data path.

RustFS is not asking you to trust a promise; it is asking you to run a benchmark on your own traffic. That is the right bar for a 1.0.

FAQ

Is RustFS compatible with the S3 API?
Yes. RustFS implements the S3 API, so existing S3 clients such as the AWS CLI, MinIO's mc, and rclone work against a RustFS endpoint without code changes. Multipart upload, versioning, and object lock are supported.

Can RustFS replace MinIO?
For S3-centric, write-heavy workloads, RustFS 1.0.0 is production-ready and a viable alternative. It does not have feature parity yet. MinIO's ecosystem and read-mixed performance lead. Migrate one workload first and measure.

Is RustFS free and open source?
Yes. RustFS is licensed under Apache 2.0, with the source on GitHub. There is no commercial license gate on the core object storage engine.

How do I install RustFS?
The fastest method is a single Docker container using the official rustfs/rustfs:latest image (API on 9000, console on 9001). A one-click script (install_rustfs.sh) covers bare metal, and Helm charts cover Kubernetes.

Does RustFS run distributed, and is it production-ready?
Distributed deployment is listed as available in RustFS 1.0.0. Single-node mode is the simplest production start. Durability comes from bitrot protection, versioning, and bucket or site replication. S3 Tables (Iceberg) remains in preview.

Originally published at the RustFS blog.