Version 1.0.0 · Open source · AGPL-3.0

The drop-in replacement for MinIO, rewritten in C.

Buckets is S3-compatible object storage built from MinIO's last public release. Point it at your existing MinIO drives and it serves them in place: the same S3 and admin APIs, the same on-disk format, and no data copied.

View on GitHub Migrate from MinIO →

220 / 222MinIO API handlers implemented
0 bytescopied to migrate your drives
Up to 2×PUT throughput in our benchmarks
Byte-identicalS3 error responses

A maintained home for MinIO users

MinIO archived its community project in April 2026 and no longer publishes images or binaries. Buckets picks up where RELEASE.2025-10-15T17-29-55Z left off, as a supported successor you can build, audit and run yourself. It doesn't depend on any MinIO artifacts, and it ships its own KES-compatible key server.

Drop-in compatible

Your clients won't notice the switch

Buckets keeps MinIO's external contract, so tools, SDKs, dashboards and scripts keep working unchanged.

S3 API

Every S3 route MinIO serves, with byte-identical error responses. AWS SDKs, mint and warp work as before.

Admin API

The madmin protocol, so mc admin keeps working: users, policies, heal, trace, replication, tiers and more.

On-disk format

MinIO's format.json and xl.meta v2, with the same erasure layout and HighwayHash bitrot protection. MinIO and Buckets read each other's drives.

IAM & STS

Users, groups, service accounts and policies, plus STS with LDAP, OpenID Connect and client certificates. Your existing identity setup carries over.

Prometheus metrics

The v2 and v3 metric names are identical, so existing Grafana dashboards and alert rules keep firing.

Configuration

BUCKETS_* environment variables, with a fallback to every MINIO_* name. Your existing configuration needs no rewrite.

One caveat: the internode protocol is Buckets' own, so a single cluster can't mix MinIO and Buckets servers. You migrate a cluster as a whole, and the drives come along unchanged.

Migrate existing drives

Adopt MinIO in place, with a way back

There's no export, no copy and no second set of disks. Buckets takes over the drives MinIO wrote, and hands them back if you change your mind.

On servers

1
Stop MinIO. Leave its drives where they are.
2
Start Buckets on the same drives. It reads MinIO's format, and your MINIO_* settings still apply.
3
Carry on. Same buckets, objects, versions, users and policies.

MINIO_ROOT_USER=admin MINIO_ROOT_PASSWORD=change-me-now \
  bucketsd server /mnt/disk{1...8}

On Kubernetes

1
Dry run. adopt-minio.sh checks the tenant and prints the plan.
2
Adopt. It sets every volume to Retain, saves the tenant, stops MinIO, and creates a BucketsCluster on the same PVCs.
3
Keep your keys. A tenant encrypting with KES carries over, and buckets-kes serves its keys from Vault, AWS, Azure or Google.

scripts/adopt-minio.sh -n storage -t my-tenant           # plan only
scripts/adopt-minio.sh -n storage -t my-tenant --apply   # adopt
scripts/rollback-to-minio.sh -n storage -t my-tenant \
  --state ./adopt-state --apply                          # hand it back

Performance

Faster writes, written in C

We measured both servers with MinIO's own load generator, warp, on the same machine and drives. Buckets leads on writes and small reads, and stays within a few percent on large reads at full saturation.

PUT 10 MiB × 16 clients

709 MiB/s

494 MiB/s

+44%

PUT 1 MiB × 32 clients

571 MiB/s

362 MiB/s

+58%

PUT 64 KiB × 32 clients

2,604 op/s

1,312 op/s

+98%

GET 64 KiB × 32 clients

24,277 op/s

19,265 op/s

+26%

GET 1 MiB × 32 clients

10,527 MiB/s

8,574 MiB/s

+23%

GET 10 MiB × 16 clients

14,684 MiB/s

15,155 MiB/s

−3%

Apple M-series machine (12 cores, shared with the load generator), 4 drives (EC 2+2) on one SSD, release builds, warp v1.3.1 with 15 s per phase. PUT results and the 10 MiB GET are means of four alternating runs. Writes share one disk, so they vary by about ±30% between runs. Methodology and full results.

No garbage collector

The work per request is plain C, with no GC pauses or runtime scheduler between a request and the disk.

SIMD where it counts

Reed-Solomon coding and HighwayHash bitrot checks use NEON and SSSE3 vector instructions. MD5 and SHA-256 use OpenSSL's assembly.

Zero-copy reads

The thread that verifies a block sends it straight to the socket, from the same buffer, while it's still in cache.

Built for concurrency

Several event loops, a worker pool tuned to avoid lock contention, and fewer syscalls on every write.

What's different

Same contract, new engine

Buckets matches MinIO where your clients and drives depend on it, and changes what sits around them.

	MinIO community	Buckets
Status	Archived (April 2026)	Maintained, 1.0.0
Language	Go	C17
Binaries and images	No longer published	Build from source; Dockerfiles included
S3, admin API, on-disk format	Reference	Compatible: 220 of 222 handlers
Key management	Separate KES server	`buckets-kes`: KES-compatible, with Vault, AWS, Azure and Google key stores
Kubernetes	MinIO Operator (Tenants)	Buckets operator, which adopts Tenants in place and can roll them back
Web console	Admin features removed from the community console in 2025	Full admin console, deployed apart from storage
Enterprise sign-in	LDAP, OpenID Connect	LDAP, OpenID Connect, including Microsoft Entra ID app roles
Phone-home	SUBNET, call-home, self-update	None: removed
Mixed clusters	Not supported: the internode protocols differ, so a cluster migrates as a whole
License	AGPL-3.0	AGPL-3.0

Everything you ran on MinIO

A complete object store

Erasure coding and healing: survives drive and node loss, with bitrot protection and background healing.
Versioning and object lock: retention, legal hold and lifecycle rules, for compliance workloads.
Encryption: SSE-S3, SSE-KMS and SSE-C, auto-encryption, and in-place encryption of existing objects.
Replication and tiering: bucket and site replication (with MinIO too), and transitions to S3, Azure and GCS tiers.
Pools and clusters: from one drive to multi-pool clusters, with pool expansion, decommission and rebalance.
Identity: IAM, STS, LDAP, OpenID Connect, Entra ID, and access-management plugins.
Data access: S3 Select over CSV, JSON and Parquet, plus SFTP and FTP servers and batch jobs.
Observability: Prometheus v2 and v3 metrics, trace and logs, notifications to 10 target types, and audit logs.

Get started

Up and running in minutes

1. Get the code

Clone the repository, or download the 1.0.0 release.

git clone https://github.com/StorScale/buckets.git
cd buckets

Release 1.0.0 →

2. Build

Needs a C17 compiler, CMake 3.20+ and OpenSSL 3.2+ (built for you if the system's is older). Dependencies are pinned and fetched for you.

cmake -S . -B build -G Ninja
ninja -C build

3. Run

Start a server, then point any S3 client at it. On Kubernetes, install the operator with Helm.

BUCKETS_ROOT_USER=admin \
BUCKETS_ROOT_PASSWORD=change-me-now \
build/src/bucketsd server /srv/buckets

Go to the repository Read the documentation