RustFS Crushed MinIO in Benchmarks — Here’s Why It’s the Future of S3-Compatible Storag
I’ve spent eight years designing enterprise object storage architectures. MinIO has long been my go-to recommendation for self-hosted S3 workloads: it’s mature, well-documented, and ubiquitous across data lake teams.
So when I stumbled across a full lakehouse storage benchmark published by Mojtaba Banaie in June 2026, I dug deep into every data point. Mojtaba is a veteran data architect with years of hands-on experience building distributed storage and end-to-end analytical pipelines. He built a complete testing suite to benchmark MinIO, LibreFS, and RustFS against real-world lakehouse traffic patterns.
His dataset leads to one clear conclusion: RustFS is a genuine game-changer for modern data teams.
RustFS claimed wins across 7 out of 10 core performance categories, delivering 2–8× faster Iceberg metadata operations alongside a 20% lift in analytical read throughput. Combined with its permissive Apache 2.0 license that eliminates commercial distribution headaches, it stands out as an ideal foundation for data lakes, OLAP pipelines, and any S3-native analytical platform. Let’s walk through the benchmark framework, hard performance metrics, licensing benefits, and the workloads where RustFS shines brightest.
The Performance Gap Is Rooted in Foundational Architectural Advantages
Mojtaba’s testing stack compares three mainstream S3-compatible systems: MinIO (Go, AGPLv3), LibreFS (community Go fork built from MinIO’s pre-AIStor codebase), and RustFS (a ground-up implementation written entirely in Rust). All three were deployed on identical 3-node Docker clusters running on a Dell Precision 5520 (i7–7820HQ, 32GB RAM, Windows 11 Docker Desktop). Every test case ran three independent rounds to capture stable mean values and standard deviation.
Instead of relying on meaningless raw single-file PUT/GET benchmarks, he built three purpose-built engines replicating daily lakehouse traffic:
- DuckDB for native columnar analytical I/O
- DuckLake for ACID-compliant lakehouse transactions
- Apache Iceberg for file-based metadata workflows
Benchmark Core Results
RustFS dominates the workloads that regularly bottleneck modern lakehouses: high-volume small streaming Parquet files, frequent Iceberg snapshot commits, and high-concurrency analytical queries. This massive performance gap stems from fundamental runtime differences Mojtaba outlined.
Rust‘s GC-Free Runtime Eliminates Go’s Concurrency Limitation
Rust does not include a garbage collector. MinIO and LibreFS rely on Go’s tracing GC, which triggers disruptive stop-the-world pauses under heavy mixed read/write load.
Per his test logs, MinIO’s write P50 latency ballooned to 9.0 seconds under concurrent pressure — a side effect of GC overhead compounded by its mandatory 3-node erasure coding write quorum.
RustFS handles memory safety entirely at compile time via ownership and borrowing rules, yielding consistent, predictable low latency even under sustained traffic. In the identical heavy-load test, its write P50 sat at just 0.77 seconds — a transformative difference for low-latency ingestion and user-facing BI workloads.
Flexible Durability Tuning: RustFS Lets You Optimize for Your Workload
One standout design choice separates RustFS from Go-based alternatives: fully customizable erasure coding quorum rules.
MinIO and LibreFS lock all distributed deployments into a strict 3-node write quorum by default, which unavoidably adds latency under concurrency. RustFS ships with a lightweight cluster configuration tuned for analytical speed out of the box.
Teams with strict durability SLAs can adjust quorum settings to match MinIO’s consistency model, trading a small portion of the latency lead for identical data durability guarantees. This is not a flaw — it’s a configurable balance tailored to your team’s unique priorities.
LibreFS, while mirroring MinIO’s fixed quorum design, suffers from severe run-to-run performance volatility. Its read standard deviation hit ±10.8 MB/s on 32 MB Parquet files, creating unpredictable query timeouts for SLA-bound dashboards. RustFS maintains far tighter variance across all file sizes, delivering stable performance for shared multi-tenant analytical clusters.
Beyond Raw Speed: The Transformative Apache 2.0 Licensing Edge
Mojtaba’s market breakdown outlines a critical shift MinIO made in 2025. Its core server remains AGPLv3, but core enterprise functionality — distributed erasure coding at scale, native WebUI, LDAP/OIDC auth, and built-in monitoring — is now gated behind paid AIStor subscription tiers.
For ISVs, startups, and teams embedding S3 into proprietary commercial software, AGPLv3 carries heavy legal risk: any distributed product bundling MinIO must release its full source code under matching copyleft terms.
RustFS is licensed exclusively under Apache 2.0. Teams can modify, redistribute, and embed it within closed-source software with zero copyleft obligations. This single feature makes it uniquely suited for embedded lakehouse platforms, internal SaaS analytics tools, and white-label data pipeline products.
Get Ethan Carter’s stories in your inbox
Join Medium for free to get updates from this writer.
LibreFS bypasses MinIO’s paywall by retaining the original admin tooling from pre-AIStor releases, yet it stays bound to AGPLv3 with identical commercial redistribution restrictions. For teams prioritizing steady low latency and licensing flexibility over legacy UI functionality, RustFS is the clear upgrade path.
Where RustFS Delivers Unmatched Value (Benchmark-Backed Use Cases)
Apache Iceberg Data Lakes
RustFS delivers 2–8× faster P50 latency for all Iceberg metadata workflows, including snapshot creation, time-travel queries, and partition change detection. Its optimized S3 LIST handling eliminates the primary bottleneck slowing Iceberg manifest resolution. This makes it perfect for Kafka streaming tables with frequent micro-commits and high-frequency metadata refreshes.
Analytical Query Engines (DuckDB, Trino, Spark)
At 32 MB Parquet sizes, RustFS hits 61.0 MB/s read throughput — a 20% uplift over MinIO — with minimal variance of only ±1.2 MB/s for small 1 MB files. Columnar projection, ad-hoc analytics, and interactive BI dashboards all benefit from its steady, low per-request overhead.
Small-File Streaming Ingestion (<5 MB Parquet)
At the 1 MB file size standard for IoT telemetry and event micro-batches, RustFS doubles MinIO’s write throughput (13.2 MB/s vs 6.6 MB/s). Per-object metadata overhead cripples Go-based storage at small file scales — a pain point Rust’s GC-free architecture eliminates entirely.
DuckLake ACID Lakehouse Workloads
RustFS recorded a 36ms P50 latency for multi-table ACID transactions, beating MinIO (54ms) and LibreFS (41ms) while achieving a 100% success rate across 200 concurrent commit cycles. Its time-travel queries run 40% faster than MinIO, a major advantage for auditing and point-in-time data rollbacks.
Commercial Embedding & Closed-Source Platform Development
Apache 2.0 licensing removes all AGPL compliance friction. Independent vendors building proprietary data tools can ship RustFS without mandatory open-source disclosures for their core business logic.
Minor Tradeoff: Large Batch File Write Workloads
For isolated nightly bulk exports over 32 MB, LibreFS posts marginally higher raw write throughput at 28.8 MB/s, 42% faster than MinIO. RustFS lands at 21.8 MB/s for large files, a narrow gap easily offset by its stable low variance on mixed read/write shared workloads.
If your stack runs zero concurrent analytics and only single-threaded batch dumps, LibreFS holds a tiny throughput edge. Still, its volatile performance introduces avoidable SLA risk for most production lakehouse environments.
The Future of Object Storage Is Rust, and RustFS Leads the Wave
RustFS launched its first stable release in 2024, yet it outperforms MinIO — a decade-old industry staple — on all latency-critical lakehouse workloads per Mojtaba’s testing. The project maintains an active development team with transparent roadmaps focused on expanding distributed cluster functionality and durability tuning options.
All raw result files, test scripts, and Docker deployment configs he built are fully open-source and reproducible at https://github.com/sepahram-school/workshops (Workshop 8: MinIO vs LibreFS vs RustFS). I encourage every data architect to clone the repo and validate how its benchmark scenarios map to your unique file sizes and concurrency patterns.
Final Verdict
The benchmark metrics, underlying architecture, and licensing terms all align to one clear conclusion:
For nearly all analytical data lakes, OLAP BI platforms, and proprietary S3-embedded applications, RustFS is the most compelling open-source object storage solution available today.
Core strengths:
- Unrivaled metadata speed: 2–8× faster Iceberg and lakehouse metadata operations
- Predictable low latency: No GC-induced tail latency under heavy concurrency
- Unrestricted commercial use: Apache 2.0 eliminates AGPL legal exposure
- Future-proof Rust design: Native memory safety and concurrency built into core
MinIO remains a reliable legacy pick for teams locked into fixed 3-node quorum deployments. LibreFS fills a narrow niche for users reliant on the original MinIO WebUI without AIStor subscriptions.
But for the vast majority of modern analytical workloads that prioritize low latency, consistent performance, and licensing freedom, RustFS is unambiguously the forward-looking best choice — fully validated by Mojtaba’s reproducible benchmark dataset.
Clone the benchmark repository, run tests matching your pipeline traffic, and pilot RustFS on your analytical workloads. Your ingestion pipelines and query layers will deliver far more consistent, faster results.
Fine-Tuning RustFS for Specialized Workloads
For teams running specialized edge-case workloads, Mojtaba’s full report includes actionable configuration guidance:
- Durability adjustment: RustFS erasure coding quorum rules can be updated to match MinIO’s strict write ordering for stateful streaming stacks, preserving most of its latency advantage.
- Batch-only optimization: Teams running exclusive large-file nightly exports can cross-compare LibreFS’s raw throughput against RustFS’s steady variance for long-term scaling planning.
- Custom consistency tuning: Unlike MinIO’s fixed quorum design, RustFS exposes adjustable consistency parameters to align with strict ordered commit requirements for specialized stateful workloads.
Have you deployed MinIO, LibreFS, or RustFS within your lakehouse stack? Do you have questions around the benchmark methodology or workload-specific RustFS tuning? Drop a comment below to share your production experience and join the discussion.
