One API, all storage
Object storage, file systems, cloud SaaS, databases, protocols and key-value services reached through a single Operator and one mental model.
Apache OpenDAL™ — Open Data Access LayerOne Layer,
One Layer,
All Storage.
One zero-cost Operator for object storage, file systems, databases and more — in the language you already ship.
50+services
17languages
5k+stars
10M+downloads
$ cargo add opendal
use opendal::services::S3;
use opendal::Operator;
// Configure a backend once, then use one Operator.
let builder = S3::default().bucket("data");
let op = Operator::new(builder)?.finish();
op.write("hello.txt", "Hello, World!").await?;
let bytes = op.read("hello.txt").await?;
Used by
Powering AI, analytics, and real-time data
OpenDAL runs in production across the open-source ecosystem. These are some of the projects that build on it.
Why OpenDAL
A storage layer you can build production on.
OpenDAL turns one vision — One Layer, All Storage — into a practical foundation for applications, libraries and data systems.
Zero-cost core
Built in Rust with composable services and layers. Compile in only the backends and capabilities you use, and pay for nothing else.
Production-ready by composition
Stack retry, timeout, logging, tracing, metrics, throttling and concurrency limits as reusable layers — no rewrites, no glue code.
Open and extensible
Add services, layers and language bindings without forking the model. Developed in the open and governed the Apache Way.
Capabilities
Configure once. Access anything.
One Operator is a full toolkit for real-world data — read and write at scale, recover from failures, and work with files — the same way on every backend.
- Read in parallelFetch a byte range, or a whole object in concurrent chunks.
- Upload in partsStream writes of any size as concurrent, multipart uploads.
- Recover from failureResume on retry, write atomically, and pin a version.
- Work with filesInspect, list, move, and share — without moving bytes.
Read in parallel
let op = Operator::new(S3::default().bucket("data"))?.finish();
// Read just the bytes you need.
let head = op.read_with("logs/today").range(0..64 * 1024).await?;
// Or pull a large object in parallel chunks.
let full = op
.read_with("big.parquet")
.concurrent(8)
.chunk(8 * 1024 * 1024)
.await?;
Services
50+ storage services, one interface.
Enable only the backends your application needs. The Operator contract stays identical across every one.
Object Storage
s3
gcs
azblob
oss
cos
obs
b2
tosFile Storage
fs
hdfs
alluxio
lakefs
ipfs
dbfsCloud SaaS
gdrive
dropbox
onedrive
hf
github
koofrProtocols
http
ftp
webdav
sftpDatabases
sqlite
mysql
postgresql
mongodb
surrealdb
d1Key-Value
redis
etcd
rocksdb
memcached
tikv
foundationdbBindings
Ship it in your language.
Each binding exposes the same OpenDAL service model while following its own ecosystem's conventions.
Rust
Python
Java
Go
Node.js
C
C++
.NET
Ruby
PHP
Swift
Haskell
OCaml
Lua
Dart
D
ZigLayers
Production behavior, composed — not coded.
Stack cross-cutting concerns as reusable layers. The order is explicit and the core stays zero-cost.
RetryLayerRecover from transient failures automatically.TimeoutLayerBound slow or hanging operations.LoggingLayerEmit structured operation logs.TracingLayerTrace requests across systems.MetricsLayerExport operation metrics.PrometheusLayerExpose Prometheus metrics.ConcurrentLimitLayerCap in-flight concurrency.ThrottleLayerThrottle I/O bandwidth.
RetryLayer
use opendal::layers::RetryLayer;
// Exponential backoff with jitter; interrupted
// reads and writes resume where they left off.
let op = op.layer(
RetryLayer::new().with_max_times(5).with_jitter(),
);
Start building
One layer for all your storage.
Join the infrastructure builders, platform teams and application developers accessing data freely, painlessly and efficiently.