RustFS 1.0 GA: Rust-Rewritten Object Storage Hits 2.7M Deployments, Beats MinIO on Small Files

What GA Means for RustFS

On 16 September 2026 RustFS 1.0.0 reached General Availability. For an open-source storage project GA signifies: API freeze, stable S3 compatibility layer, immutable on-disk metadata format, documented upgrade paths, and verifiable production deployments. RustFS progressed from first commit (Feb 2024) to open-source (Jul 2025), Beta (Apr 2026), RC (Aug 2026), and GA in 2 years 7 months, amassing >32k GitHub stars, >10M Docker pulls, and >2.7M deployed instances.

Architecture Overview

RustFS uses a single-server multi-disk architecture: multiple block devices form one logical storage pool. Each object is split into k data shards and m parity shards (n = k + m) distributed across disks for durability and parallel throughput.

Core Technical Pillars

3.1 Erasure Coding: SIMD-Accelerated Reed-Solomon

The ecstore module leverages AVX2 SIMD instructions to encode multiple blocks in parallel. In a 4+2 configuration with 4 KB blocks, encoding throughput reaches 1,450 MB/s — 2.45× faster than a standard implementation . Recommended tuning profiles:

High Performance : data_shards=4, parity_shards=1, block_size=4096 → 1,450 MB/s encode, CPU <50%

Balanced Reliability : data_shards=4, parity_shards=2, block_size=4096 → Decode latency 0.78 ms (P99)

High Reliability : data_shards=6, parity_shards=2, block_size=4096 → Tolerates 2 disk failures, 15% perf drop

Official benchmarks on 2-core/4 GB show 4 KB random-read IOPS of 1.58M vs. MinIO's 1.1M (+43%) .

3.2 Zero-Copy I/O: io_uring

MinIO relies on Go's standard syscalls (epoll/kqueue), incurring user/kernel transitions on every I/O. RustFS uses Linux 5.1+ io_uring with shared-memory ring buffers, eliminating syscalls for the hot path — ~70% syscall overhead reduction . At startup, io_uring_register() pins a pool of 4 KB buffers (default 32K slots) into the kernel; subsequent reads/writes reuse these registered slots, avoiding copy_to_user() entirely.

3.3 No-GC Runtime: Latency Stability

Go's GC triggers periodic Stop-The-World pauses under heavy small-object concurrency. Rust's ownership/borrowing/lifetime model performs all memory-safety checks at compile time; no GC thread exists at runtime , removing unpredictable latency spikes. Measured 4 KB random-read P99 latency: RustFS 7.3 ms vs. significantly higher for MinIO (same 2C/4G hardware).

3.4 Three-Layer Self-Healing

Online healing — on every GET/HEAD, missing or corrupt shards are reconstructed from parity and the repaired object is returned transparently (behavior matches MinIO's read-time healing).

Background scanner — continuously verifies 1/1024 of objects; lightweight checks compare metadata/shard sizes, deep checks read full shard data and validate checksums.

Manual full heal — rc admin heal start --all triggers cluster-wide repair.

3.5 Data Flow

Two architecture diagrams (omitted here) illustrate the write path (client → API → erasure coding → parallel disk writes) and read path (parallel shard fetch → decode → assemble → client).

S3 Tables: Iceberg REST Catalog Inside Object Storage

The headline GA feature is S3 Tables — an Apache Iceberg REST Catalog running in-process on the same port (9000) . Spark, DuckDB, PyIceberg, etc. can create/read/write tables without plugins, extra services, or license fees . Crucially, RustFS ships this under the same Apache 2.0 core, whereas MinIO's equivalent Tables feature lives in the commercial AIStor product. One process serves both object and table APIs, eliminating dual-system ops, glue pipelines, and permission sync.

Java Integration: Three Steps

RustFS provides no first-party Java SDK; the docs instruct users to configure the official AWS SDK for Java v2 against the RustFS endpoint.

5.1 Dependency

<dependency>
  <groupId>software.amazon.awssdk</groupId>
  <artifactId>s3</artifactId>
  <version>2.25.0</version>
</dependency>

5.2 Client Configuration

import software.amazon.awssdk.auth.credentials.AwsBasicCredentials;
import software.amazon.awssdk.auth.credentials.StaticCredentialsProvider;
import software.amazon.awssdk.regions.Region;
import software.amazon.awssdk.services.s3.S3Client;
import java.net.URI;

public class RustFSClient {
  public static S3Client createClient() {
    AwsBasicCredentials credentials = AwsBasicCredentials.create(
      "rustfsadmin", "rustfsadmin");
    return S3Client.builder()
      .region(Region.US_EAST_1)
      .endpointOverride(URI.create("http://localhost:9000"))
      .credentialsProvider(StaticCredentialsProvider.create(credentials))
      .forcePathStyle(true)
      .build();
  }
}

Key points: forcePathStyle(true) is mandatory (otherwise 301 redirect errors); region us-east-1 is the conventional default for S3-compatible stores; use http:// in endpointOverride if TLS is not enabled.

5.3 Bucket Create & Upload

S3Client s3 = RustFSClient.createClient();
s3.createBucket(CreateBucketRequest.builder().bucket("my-bucket").build());
s3.putObject(PutObjectRequest.builder()
  .bucket("my-bucket").key("demo/hello.txt").build(),
  RequestBody.fromFile(new File("hello.txt")));

Migration from MinIO requires zero Java code changes — only the endpoint host/port.

Performance Showdown

6.1 Small Files: 2.3× MinIO

4 KB workloads benefit from the trio of zero-copy I/O, SIMD erasure coding, and smart shard placement. MinIO's GC-induced STW pauses hurt exactly this workload; RustFS has no GC thread.

6.2 AI Training: GPU Utilization 40% → 90%+

A large video-generation platform migrated 800 TB of training data to RustFS; model training time dropped from 18 to 12 days ( +33% efficiency ). Parallel data access, intelligent prefetch, and caching raised GPU utilization from 40% to over 90%.

6.3 Summary Comparison

4 KB small files : RustFS 2.3× baseline, MinIO baseline

4 KB random-read IOPS : RustFS 1.58M, MinIO 1.1M

P99 latency (4 KB) : RustFS 7.3 ms, MinIO higher

Pure GET (large objects) : RustFS behind, MinIO better

License : RustFS Apache 2.0, MinIO AGPLv3

During node failure recovery, RustFS maintains >85% throughput thanks to simpler architecture; MinIO drops to ~400 MB/s with visible jitter.

Pros & Cons

Pros

License certainty — Apache 2.0 eases commercial embedding; MinIO community repo archived Apr 2026, marked unmaintained.

Small-file dominance — 2.3× throughput, 43% higher IOPS.

Zero-copy + no GC — 70% syscall reduction, zero STW pauses.

Three-tier self-healing — online, background, manual; 85%+ perf during rebuild.

S3 Tables in open core — Iceberg catalog built-in, no extra cost/service.

Full S3 compatibility — drop-in MinIO replacement for Java workloads.

AI-optimized — demonstrated GPU utilization gains.

Cons

Pure GET / large-read slower than MinIO .

Ecosystem maturity lagging — MinIO has 10+ years of production hardening and tooling.

No official Java SDK — must wire AWS SDK v2 manually.

2.3× claim from vendor benchmarks — independent verification needed.

2.7M deployments metric opaque — methodology undisclosed; not equal to active production customers.

Recommended Use Cases

AI training data store — ✅✅✅ Strong: GPU util 90%+, training time -33%

Small-file intensive — ✅✅✅ Strong: 4 KB 2.3× MinIO

China info-sec / private cloud — ✅✅✅ Strong: Apache 2.0, commercial-friendly

Data lake / Iceberg — ✅✅✅ Strong: S3 Tables open core

MinIO community migration — ✅✅✅ Strong: S3 compat, zero Java changes

High HA during rebuild — ✅✅✅ Strong: 85%+ perf during recovery

Pure GET / large reads — ⚠️ Evaluate: MinIO faster

Max ecosystem maturity — ⚠️ Evaluate: MinIO leads

Closing Thoughts

RustFS 1.0 GA marks the transition from "works" to "production-safe": frozen APIs, stable metadata, documented upgrades, real deployments. Its strategic wedge — small-file performance, GC-free latency, Apache 2.0 licensing — directly addresses the pain points of MinIO community-edition users (now on an archived, unmaintained repo). While RustFS still trails on pure-read throughput and ecosystem breadth, it is already a serious contender for AI training storage, small-object workloads, sovereign/private clouds, and Iceberg-centric data lakes.

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

Docs : https://docs.rustfs.com