apache/opendal

This system is a unified data access layer that provides a consistent API for interacting with over 50 storage services, including cloud object stores, file systems, and key-value databases. Built on a Rust core with bindings for multiple languages, it enables applications to perform standard file operations like read, write, list, and delete across diverse backends without managing protocol-specific details. The architecture supports advanced features such as middleware for retry and caching, streaming I/O, and high-performance async execution.

67 changes.

The project established its Apache OpenDAL governance structure and reorganized the Rust core into a modular facade architecture. This period focused heavily on expanding the ecosystem by introducing and refining bindings for numerous languages, including Python, Java, C++, Node.js, Ruby, and others, while simultaneously building out comprehensive test suites and performance benchmarks for each.

103 changes.

The project extracted built-in storage services into standalone crates to improve modularity and added new backends for cloud, database, and local storage. Simultaneously, it expanded language bindings for Dart, D, Ruby, and Node.js while introducing comprehensive code generation and observability layers.

23 changes.

This period focused on expanding OpenDAL's ecosystem by adding support for multiple new storage backends, including Hugging Face, Volcengine TOS, GooseFS, and Google Cloud Storage via gRPC. Significant work was also done to enhance language bindings, particularly a major rewrite of the .NET bindings for zero-copy performance and the introduction of new layers and examples for Python, Go, Java, and MoonBit.

New C++ examples have been added to the repository, including a basic usage sample and a getting-started quickstart that demonstrates writing, reading, and removing data using the in-memory service. A CMakeLists.txt file has been introduced to build these examples, and accompanying README files provide instructions on how to compile and run the code, noting adherence to the Google C++ Style Guide.

examples · high confidence

Introduces a new service backend for Cloudflare D1, enabling users to store and retrieve data using a key-value model backed by a D1 database. The implementation supports read, write, stat, and delete operations, with configuration options for the API token, account ID, database ID, table name, and custom key/value field names. Users can construct the service via a builder or use the \d1://\ URI scheme for registration.

core/services/d1 · high confidence

Users can now access Cloudflare Workers KV as a storage backend via the \cloudflare-kv\ URI scheme. This new service supports creating directories, reading and writing key-value pairs (with a 25 MB write limit), listing keys, and deleting keys (including bulk deletion). Configuration requires an API token, account ID, and namespace ID, and allows setting a default TTL for write operations (minimum 60 seconds) and a root path prefix. The implementation handles conditional reads (ETag and time-based) and safely strips the configured root prefix from listed keys.

(repo-wide) · high confidence

New example files (basic.dart, getting\_started.dart) are added to the Dart bindings to demonstrate usage. The getting\_started example shows how to initialize a storage service (using the memory scheme for CI compatibility) and perform basic file operations like writing, reading, and deleting files, serving as a runnable reference for documentation.

bindings/dart/examples · high confidence

Introduces a new DBFS service implementation for Apache OpenDAL, enabling users to interact with the Databricks File System via its REST API. This new service supports creating directories, writing files (up to 1MB in a single shot), deleting files, renaming files, listing directory contents, and retrieving file metadata. Configuration is handled through the \DbfsConfig\ struct, requiring an endpoint, a personal access token, and an optional root path. The service registers under the \dbfs\ URI scheme for easy construction.

core/services/dbfs · high confidence

The Foyer service is now available as a volatile key-value storage backend, leveraging the foyer-rs library for high-performance in-memory and on-disk caching. Users can configure the cache via URI parameters (e.g., \foyer:///cache?memory=64MB&disk\_path=/tmp/foyer\) or programmatically, specifying memory capacity, disk path, disk capacity, file size, recovery mode, and shard count. The service supports read, write, stat, and delete operations, but does not support listing or blocking operations. Data is volatile and may be evicted when the cache reaches its capacity limit.

core/services/foyer · high confidence

Users can now read and write data to GitHub Actions Cache using the \ghac://\ URI scheme. This new service supports both V1 (JSON-based) and V2 (Protobuf-based) cache APIs, automatically detecting the version from the \ACTIONS\_CACHE\_SERVICE\_V2\ environment variable. For V2 writes, the backend transparently proxies uploads to Azure Blob Storage using the signed URLs provided by GitHub. Configuration is handled via the \GhacBuilder\ or environment variables (\ACTIONS\_CACHE\_URL\, \ACTIONS\_RUNTIME\_TOKEN\), and the service exposes \stat\, \read\, and \write\ capabilities.

core/services/ghac · high confidence

A new HotpathLayer has been introduced to the core layer system, enabling integration with the hotpath profiling library. This layer wraps service operations (such as read, write, copy, and stat) to measure their performance metrics, allowing users to profile and optimize their storage operations when hotpath profiling is enabled.

core/layers/hotpath · high confidence

Users can now connect to an IPFS daemon via the IPFS Mutable File System (IPMFS) API to perform file operations. This new service, available under the \ipmfs\ URI scheme, supports reading, writing, listing, deleting, and creating directories. Configuration allows specifying a custom endpoint (defaulting to \http://localhost:5001\) and a root directory for the MFS path.

core/services/ipmfs · high confidence

This change introduces a new service backend for Koofr, enabling users to store and retrieve files using the Koofr API. The implementation includes configuration via email and application password, and supports core operations such as reading, writing, deleting, listing, copying, and renaming files. It also supports creating directories and reading file suffixes, allowing integration with Koofr-based storage workflows.

core/services/koofr, core/services/upyun · high confidence

The Node.js bindings now include runnable example scripts to help users get started. A new S3 example demonstrates configuring the Operator with explicit credentials or environment variables for reading, writing, and statting objects. Additionally, a getting-started snippet using the memory service is provided to illustrate basic write, read, and delete operations.

bindings/nodejs/examples · high confidence

Introduces a new OpenDAL service backend that enables reading, writing, listing, and deleting files using the browser's Origin Private File System (OPFS). This allows applications running in WebAssembly environments to persist and manage data locally within the browser, with support for directory creation and range-based reads, though operations like copy, rename, and presign are not supported.

core/services/opfs · high confidence

The OpenStack Swift object storage service is now available, enabling users to connect to Swift-compatible backends like OpenStack Swift and Ceph Rados Gateway. This release introduces full support for reading, writing, listing, and deleting objects, including conditional request headers for stat and read operations, pagination via start\_after for list queries, and bulk delete capabilities. Large object uploads are handled via Static Large Object (SLO) multipart uploads, and users can generate presigned URLs using TempURLs with configurable hash algorithms (SHA1, SHA256, SHA512).

core/services/swift · high confidence

The \OtelMetricsLayer\ is now available to record OpenDAL operation and HTTP fetch metrics via OpenTelemetry. Users can enable this by registering the layer with an OpenTelemetry meter, allowing them to track metrics such as operation bytes, entries, duration, and time-to-first-byte (TTFB) using configurable histogram boundaries.

core/layers/otelmetrics · high confidence

Introduces a new Persy service that enables storing data in a local Persy key-value database. Users can configure the service by specifying the data file path, segment name, and index name via the \PersyBuilder\ or URI scheme. The service supports read, write, stat, and delete operations, allowing applications to persist and retrieve data using a local embedded database backend.

core/services/persy · high confidence

A new benchmark suite has been added to the Python bindings to measure and compare performance against the AWS SDK (Boto3). The suite includes scripts for async S3 read/write operations, a blocking GIL release benchmark using a local HTTP server to simulate I/O latency, and a file open/read benchmark over HTTP. These tools allow users to evaluate single-thread overhead, concurrency speedup, and per-operation latency for both synchronous and asynchronous OpenDAL operators.

bindings/python/benchmark · high confidence

Users can now use Sled, an embedded key-value store, as a storage backend. This new service supports reading, writing, deleting, and listing files, with configuration options for the data directory, tree name, and root path. It is available via the 'sled' URI scheme and can be registered with the operator registry for scheme-driven construction.

core/services/sled · high confidence

This change introduces a new backend for Volcengine TOS (Tencent Object Storage), enabling users to store and retrieve data using the \tos://\ URI scheme. The implementation provides full support for core operations including reading, writing (with multipart upload), deleting, and listing objects, as well as native server-side copying and presigned URL generation. Configuration is handled via the \TosBuilder\ and \TosConfig\, allowing users to specify the bucket, endpoint, region, and credentials (with support for environment variable loading and \skip\_signature\ for unsigned requests).

core/services/tos · high confidence

A new Rust example has been added to the core examples directory that demonstrates how to initialize an OpenDAL operator and perform basic operations including writing, reading, fetching metadata, and deleting data.

core/examples/basic · high confidence

A new benchmark suite has been added to compare the read performance of OpenDAL's S3 service against the official AWS SDK for S3. This tool allows users to run performance tests (via \cargo run\) to verify that OpenDAL's throughput remains within 5% of the native AWS SDK, providing a concrete way to validate performance claims for S3 operations.

_core/benches/vs\s3 · high confidence

New storage backends are now available for local caching and distributed key-value storage. The cacache service enables local disk-based caching via a configurable data directory, supporting read, write, stat, and delete operations. The FoundationDB service provides a distributed key-value store interface, allowing users to configure the database root and cluster config path, with support for read, write, stat, and delete operations.

core/services/cacache · high confidence

Users can now enable User Statically-Defined Tracing (USDT) on Linux by adding the \layers-dtrace\ feature and applying \DtraceLayer\ to their operator. This layer injects probes into service operations (such as create\_dir, read, write, stat, delete, list, and presign) and reader/writer streams, allowing external tools like SystemTap or DTrace to monitor operation start/end events and data transfer metrics.

core/layers/dtrace · high confidence

Introduces a new \mini-moka\ service that provides an in-memory cache for object storage operations. Users can now configure a local, ephemeral storage backend with settings for maximum capacity, time-to-live (TTL), and time-to-idle (TTI). This service supports standard operations including reading, writing, listing, and deleting files, but does not support directory creation, copying, or pre-signed URLs.

_core/services/mini\moka · high confidence

The Memory service is now available as a BTreeMap-based backend for storing data in RAM. It supports reading, writing, deleting, and listing files, and allows configuring a root path. The service also supports conditional writes via the \if\_not\_exists\ option, which prevents overwriting existing keys, and includes metadata handling for content type, cache control, and content disposition.

core/core/src/services/memory · high confidence

A new benchmark suite has been added to core/benches/ops to measure the performance of read and write operations across different backends. The suite uses the divan framework and includes benchmarks for whole-file reads and writes at various sizes, as well as concurrent read and write operations. Users can run these benchmarks by setting the OPENDAL\_TEST environment variable to specify the backend and using the cargo bench command with the tests feature.

core/benches/ops · high confidence

New, CI-verified 'Getting Started' example programs have been added for the Rust core and all language bindings (D, .NET, Haskell, OCaml, PHP, Python, Ruby, and Zig). These examples demonstrate the standard write, read, stat, and delete operations using the in-memory service, providing users with copy-pasteable, tested code snippets for the website guide.

(repo-wide) · high confidence

This change introduces the \unftp-sbe-opendal\ crate, which implements the \StorageBackend\ trait for \unftp\ using OpenDAL. It allows users to expose any storage service supported by OpenDAL (such as S3) via the FTP protocol. The implementation includes \OpendalStorage\ to wrap the OpenDAL operator, \OpendalMetadata\ to map file attributes, and logic to handle file listing, metadata retrieval, and data transfer via async read/write loops.

integrations/unftp-sbe · high confidence

New example scripts have been added to the Lua bindings directory to demonstrate usage. The \getting-started.lua\ file provides a runnable quickstart guide using the in-memory service, suitable for documentation embedding and CI validation. The \fs.lua\ file demonstrates file system operations using the local filesystem operator.

bindings/lua/example · high confidence

A new benchmark suite has been added to the Node.js bindings that measures read and write performance of OpenDAL against the official AWS SDK for S3. The benchmark tests various payload sizes (4KB, 256KB, 4MB, and 16MB) and can be executed using the \pnpm bench\ command, requiring standard AWS environment variables for configuration.

bindings/nodejs/benchmark · high confidence

This change introduces a new \opfs\_wasm32\ module that implements the Origin Private File System (OPFS) as a backend for OpenDAL in WebAssembly environments. It enables applications to read, write, and manage files and directories within the browser's isolated storage space, including support for creating directories, listing contents (recursive and non-recursive), and handling file writes with append-like behavior. The implementation includes comprehensive tests to verify functionality such as directory creation, file reading/writing, and quota handling.

_core/edge/opfs\wasm32 · high confidence

The core library now exposes a \Composer\ type and associated traits (\Compose\, \IntoComposeInput\) that allow users to sequentially accept multiple complete source objects and commit them into a single destination object. This new API, located in \core/core/src/types/compose\ and \core/core/src/raw/oio/compose\, provides methods like \compose\ and \close\ to handle the composition workflow, including support for source-specific options such as versioning and ETags via \FutureComposeSource\.

core/core/src/raw/oio/compose, core/core/src/types/compose · high confidence

The Spring integration now includes a default serializer implementation that uses Jackson to convert objects to and from JSON byte arrays. This allows users to seamlessly store and retrieve Java objects as JSON data in OpenDAL storage without needing to implement custom serialization logic.

opendal-spring · high confidence

The Aliyun Drive backend is now available, enabling users to store and retrieve files via the Aliyun Drive API. The service supports reading, writing (including multipart uploads), listing, deleting, copying, and renaming files. Configuration allows specifying a root path, authentication via access token or client credentials (client\_id, client\_secret, refresh\_token), and selecting a drive type (default, backup, or resource).

core/services/aliyun-drive · high confidence

The Aliyun Object Storage Service (OSS) implementation has been split into its own crate (core/services/oss), providing a cleaner module layout and independent maintenance. This change introduces support for OIDC-based assume-role credentials and ECS instance RAM role credentials, with OIDC credentials taking precedence over ECS metadata in ACK RRSA deployments. The configuration option \allow\_anonymous\ is deprecated in favor of \skip\_signature\, and the service now supports \content\_encoding\ in write operations. Additionally, batch delete operations are now bounded against malformed server responses to prevent excessive memory allocation.

core/services/oss · high confidence

A new script, bootstrap-rust-crates.sh, has been added to the opendal-release skill to automate the triggering and monitoring of the Rust crate bootstrap workflow. This script validates the repository state, ensures the GitHub environment requires reviewers, dispatches the bootstrap workflow, and waits for its completion, integrating with the project's trusted publishing process for Rust releases.

.agents/skills/opendal-release/scripts · high confidence

New Python scripts in \.github/scripts/release\_rust/\ automate the Rust release process by calculating the correct dependency-based publish order for crates and handling the actual publication to crates.io with retry logic and trusted publishing support. The \plan.py\ script discovers publishable packages and resolves their dependency graph to ensure they are published in the correct sequence, while \bootstrap.py\ and \publish.py\ manage the interaction with the crates.io API, including patching manifests to remove local dev dependencies before publishing and restoring them afterward.

python · high confidence

The Azure Blob Storage service is now available, providing full support for reading, writing, listing, copying, and deleting blobs. Users can configure the backend using the \AzblobConfig\ struct or the \AzblobBuilder\, which supports connection strings, account keys, SAS tokens, and custom credential providers. The implementation includes block-level copy operations, conditional writes and deletes, and server-side encryption headers.

core/services/azblob · high confidence

This change introduces the Azure Data Lake Storage Gen2 service, enabling users to read, write, list, and delete files and directories in Azure Data Lake Storage Gen2. The implementation supports configuration via URI schemes (azdls://), connection strings, and various authentication methods including account keys, SAS tokens, and client credentials. It also supports conditional operations (if-match, if-none-match, if-modified-since, if-unmodified-since) for both reads and writes, and recursive deletion for directories.

core/services/azdls · high confidence

The \core/core/src/blocking\ module now provides a synchronous, blocking facade for OpenDAL's storage operations. This includes a blocking \Operator\ that wraps the async operator, along with dedicated blocking wrappers for \Copier\, \Deleter\, and \Lister\. These components allow users to perform copy, delete, and list operations in a blocking context by delegating to the underlying async runtime, ensuring that long-running or deeply nested operations do not cause stack overflows on the calling thread.

core/core/src/blocking · high confidence

The Go binding now uses a pure-Go FFI implementation (via libffi/purego) instead of CGO, providing a native Go experience. This release adds a \Copier\ type for streaming large file copies with progress reporting, and introduces a layer system allowing users to configure retry policies (with jitter, backoff factors, and delays) and timeouts (separating general and I/O timeouts) on the Operator. Additionally, the binding exposes granular functional options for core operations: \Copy\ now supports conditions like \IfNotExists\ and \IfMatch\; \Delete\ supports recursive deletion and version-specific removal; and \List\ supports pagination limits, start-after cursors, and version/deleted-marker filtering. The binding also includes a comprehensive benchmark suite comparing performance against the AWS SDK.

bindings/go · high confidence

The Google Cloud Storage (GCS) service implementation has been split out from the core library into its own dedicated crate at core/services/gcs. This new module provides the complete backend implementation, including the GcsBuilder for configuration, GcsCore for request signing and HTTP transport, and specialized components for reading, writing, listing, deleting, copying, and composing objects. The change introduces support for GCS-specific features such as object composition (combining multiple objects into one), chunked rewrite-based copying for large files, and configurable credential providers. It also standardizes configuration by renaming the \allow\_anonymous\ option to \skip\_signature\ and ensures object paths are encoded exactly once to prevent double-encoding issues.

core/services/gcs · high confidence

The HDFS backend has been refactored into a separate crate and now exposes several new capabilities: file copy, rename with an \if\_not\_exists\ option, and recursive directory deletion. Users can now copy files (which overwrites existing destinations non-atomically), rename files only if the target does not exist, and delete directories with their contents in a single operation. The service also supports append writes by default, and the previous \enable\_append\ configuration option has been deprecated.

core/services/hdfs · high confidence

The \core/layers/immutable-index\ crate introduces the \ImmutableIndexLayer\, a new middleware that adds an in-memory index to storage services. This allows services that do not natively support listing (such as HTTP) to provide \list\ and \list\_with\_recursive\ capabilities by populating the index with known keys. Users can insert keys via \insert\ or \extend\_iter\ before applying the layer to an operator, enabling directory traversal and file discovery based on the pre-loaded index rather than backend queries.

core/layers/immutable-index · high confidence

The C binding now exposes a public header (opendal.h) defining the core C-compatible types required to interact with OpenDAL, including the opendal\_code error enum, opendal\_bytes for heap-managed buffers, opendal\_error for structured error reporting, and the opendal\_lister and opendal\_entry structures for blocking list operations. This establishes the foundational API surface for C consumers to handle errors, manage memory, and iterate over directory listings.

bindings/c/include · high confidence

Added a new experimental MoonBit binding under \bindings/moonbit\ that connects the MoonBit native target to OpenDAL via a Rust library and a C adapter. This scaffold includes the necessary build configuration, dependency manifests, and a smoke test that verifies the native link by constructing a memory operator at runtime. Note that this is an initial implementation and does not yet expose a public storage API.

bindings/moonbit · high confidence

The Ruby binding now includes the core library classes that define the public API surface for users. This adds the \OpenDal::Operator\ class for managing services and applying middleware, \OpenDal::IO\ for stream operations like reading lines and seeking, \OpenDal::Entry\ and \OpenDal::Metadata\ for representing file system entries and their attributes, and \OpenDal::OperatorInfo\ for inspecting operator configuration.

_bindings/ruby/lib/opendal\ruby · high confidence

The project now includes a pre-configured development container environment to simplify local setup. The configuration uses the Microsoft Rust devcontainer image and automatically installs dependencies for all supported language bindings (Ruby, Python, Node.js, Java, C, Zig, Haskell, PHP, OCaml, C++, and D) via a post-create script. It also installs development tools like \just\ and \uv\ to streamline contributor workflows.

.devcontainer · high confidence

This change introduces the first version of the .NET binding for Apache OpenDAL, providing a native interface to the OpenDAL data access layer. The package includes the core C\# project, a build script to compile the required Rust native library for Windows, macOS, and Linux, and a generated FFI capability mirror that exposes storage service features (such as conditional reads/writes, multipart uploads, and metadata handling) to .NET consumers. The binding is distributed under the Apache 2.0 license and is currently available for building from source rather than via NuGet.

bindings/dotnet · high confidence

This change introduces the first version of the C++ binding for OpenDAL, providing C++ developers with access to 50+ storage services (including S3, GCS, Azure Blob, and HDFS) through a unified API. The binding is built using CMake and integrates with the Rust core via cxx, exposing synchronous operations such as read, write, stat, list, and delete. It includes an optional async mode (requiring C++20 and Clang) for non-blocking operations, configurable retry and timeout layers, and supports user-configurable service features. The package includes a C++17/20 build system, Doxygen documentation generation, and Google C++ Style Guide formatting.

bindings/cpp · high confidence

The OpenDAL OCaml binding is now available as an experimental, work-in-progress library that allows OCaml applications to access S3, GCS, Azure Blob, local filesystem, and 50+ other storage services through a unified API backed by the Rust core. This initial release (v0.1.0) provides the foundational build infrastructure (Dune, opam, build.rs) and exposes core storage operations, including the ability to create operators for different backends and perform file writes and reads. The binding requires OCaml 4.10–4.x (OCaml 5 is not yet supported) and a Rust stable toolchain for native compilation. Users can build from source using Dune, though the package is not yet published to the opam repository.

bindings/c, bindings/ocaml · high confidence

This change introduces the core OCaml bindings for OpenDAL, providing a unified data access layer for storage services such as local filesystem, S3, GCS, and Azure Blob Storage. The library exposes a blocking API via the \opendal\ package, allowing users to create operators, read and write data, manage directories, and stream directory listings. It includes modules for handling readers, writers, listers, metadata, and operator capabilities, enabling straightforward integration of cloud storage operations into OCaml applications.

bindings/ocaml/lib · high confidence

This change adds a new Azure File service backend, enabling users to store and retrieve data in Azure File Shares. The implementation provides full support for creating directories, reading and writing files (including append operations), deleting files and directories, listing directory contents, and renaming files. Configuration is handled via the \AzfileBuilder\ or by parsing URIs, requiring an endpoint, account name, and share name. The service uses the \reqsign\ library for request signing and supports authentication via account keys, SAS tokens, or default credentials.

core/services/azfile · high confidence

This change adds the Rust-side implementation for the new Dart bindings, exposing core OpenDAL functionality to Dart applications via flutter\_rust\_bridge. The \Operator\ struct provides both asynchronous and synchronous wrappers for key operations including \stat\, \check\, \exists\, \delete\, \create\_dir\, \rename\, \read\, and \write\. Additionally, a \Metadata\ struct is exposed to allow Dart code to inspect file attributes such as content type, length, MD5 hash, ETag, and last modified time.

bindings/dart/rust/src/api · high confidence

The Dashmap service has been split into its own crate, providing an in-memory key-value store backed by the Dashmap concurrent map. This new backend supports reading, writing, deleting, and listing files, along with stat operations, allowing users to use an ephemeral, high-performance memory store for testing or lightweight caching scenarios.

core/services/dashmap · high confidence

Added \FastmetricsLayer\ and \PrometheusClientLayer\ to \core/layers/fastmetrics\ and \core/layers/prometheus-client\ respectively, enabling users to record OpenDAL operation and HTTP fetch metrics using the \fastmetrics\ and \prometheus-client\ libraries. These layers allow users to register metrics with a specific registry or use a global instance, and provide builders to customize histogram buckets for bytes, entries, duration, and TTFB, as well as an option to disable the high-cardinality 'root' label.

core/layers/fastmetrics · high confidence

A new FoyerLayer has been added to the core layer stack, integrating the Foyer in-memory cache to store and serve full objects locally. This layer intercepts read operations to check the cache first, falling back to the underlying storage on a miss, and caches data after successful writes. It supports object versioning by treating different versions of the same path as distinct cache entries, enforces configurable size limits to avoid caching excessively large objects, and ensures cache consistency by invalidating entries upon successful deletion.

core/layers/foyer · high confidence

Added a new GooseFS service backend that connects directly to GooseFS Masters and Workers using the native gRPC protocol (port 9200/9203) instead of a REST proxy. This implementation leverages the \goosefs-sdk\ Rust client to handle HA master discovery, consistent-hash worker routing, and block-level bidirectional streaming I/O. Users can configure the service via builder methods or URI schemes (e.g., \goosefs://host:port/path\), with master address resolution prioritizing the \GOOSEFS\_MASTER\_ADDR\ environment variable, then \goosefs-site.properties\, and finally explicit configuration. The service supports full CRUD operations, including conditional creates (if-not-exists) via a temporary file rename protocol, and optional client-side metadata and page caches enabled via Cargo features.

core/services/goosefs · high confidence

This change adds a new HDFS Native service implementation to the OpenDAL core services, enabling users to interact with Hadoop Distributed File System clusters using the native Rust HDFS client. The service supports high availability (HA) configurations by accepting multiple namenodes in the \name\_node\ configuration option, and provides standard capabilities including reading, writing (with append support), creating directories, deleting files, listing contents, and renaming files. Users can configure the service via the \HdfsNativeConfig\ struct or by using the \hdfs-native://\ URI scheme.

(repo-wide) · high confidence

The HTTP service has been extracted into its own crate under core/services/http, enabling users to read files and retrieve metadata from read-only HTTP servers (such as Nginx or Caddy). This service supports authentication via basic credentials or bearer tokens, allows specifying a root path, and implements conditional requests (If-Match, If-None-Match, If-Modified-Since, If-Unmodified-Since) for both stat and read operations. The HTTPS scheme is registered as an alias for HTTP, allowing users to construct operators using standard https:// URIs.

core/services/http · high confidence

This change adds the Hugging Face service (\core/services/hf\), enabling users to read from and write to Hugging Face repositories (models, datasets, spaces) and object store buckets. The service supports two download modes: \xet\ (the default, using the XET protocol for efficient chunk-deduplicated storage) and \http\ (plain HTTP downloads). Users can configure the service via URI schemes (\hf://\ or \huggingface://\) or the builder API, specifying repo type, ID, revision, and token. It also supports an optional resolve cache to share resolved download addresses and XET metadata across readers, and honors the \HF\_HUB\_DISABLE\_XET\ environment variable to force HTTP mode.

core/services/hf · high confidence

This change adds the initial Java bindings for OpenDAL, exposing the library's core functionality to Java applications via JNI. The implementation provides both asynchronous (AsyncOperator) and synchronous (Operator) APIs, allowing Java users to perform file operations such as read, write, stat, and delete. It includes support for streaming data through OperatorInputStream and OperatorOutputStream, configuration of async execution via a custom Executor, and the application of layers like Retry, ConcurrentLimit, and CapabilityOverride. The bindings also expose service capabilities, metadata handling, and a list of enabled storage services.

bindings/java/src, bindings/ruby/lib · high confidence

The Moka service is now available as a standalone crate in core/services/moka, providing an in-memory key-value store backed by the moka library. Users can configure cache properties such as name, max capacity, time-to-live, and time-to-idle via the MokaBuilder or MokaConfig, and interact with the service using standard OpenDAL operations including read, write, delete, and list. The service registers under the 'moka' URI scheme for convenient construction.

core/services/moka · high confidence

This change adds a new GridFS service implementation for OpenDAL, allowing users to read, write, stat, and delete files stored in MongoDB's GridFS. The service is exposed as a new crate under \core/services/gridfs\ and registers the \gridfs://\ URI scheme for construction. Users can configure the connection via a MongoDB connection string, specifying the database, bucket (defaulting to \fs\), and chunk size (defaulting to 255 KiB). The implementation supports basic file operations but does not yet support directory creation, listing, copying, or renaming.

core/services/gridfs · high confidence

The MySQL service is now available as a new storage backend, allowing users to store and retrieve data using a MySQL database. The implementation supports reading, writing, deleting, and listing files, with configuration options for the connection string, table name, key and value fields, and root directory. This enables MySQL to be used as a key-value store within the OpenDAL framework.

core/services/mysql · high confidence

Added a new \ReqwestTransport\ component in the \core/http-transports/reqwest\ crate that implements the \HttpTransport\ interface using the \reqwest\ client. This provides a concrete HTTP transport layer for the OpenDAL core, handling request construction, body wrapping, redirect logic, and response parsing while supporting both standard and WASM targets.

core/http-transports/reqwest · high confidence

OpenDAL now supports RocksDB as a local storage backend, allowing users to store and retrieve data using a local embedded key-value store. This new service implements the standard OpenDAL operations including read, write, stat, delete, and list (with recursive support), while explicitly noting that directory creation, copying, and renaming are not supported. Users can configure the service by specifying a data directory path and an optional root namespace, and the implementation handles building RocksDB from source by default or linking against an existing system library.

core/services/rocksdb · high confidence

This change adds the initial Ruby binding for OpenDAL, exposing the core file-service operations to Ruby applications. Users can now create an \OpenDal::Operator\ to interact with supported storage backends, performing reads, writes, directory creation, deletion, and renaming. The binding provides an \OpenDal::IO\ class for streaming file access, an \OpenDal::Lister\ for iterating over directory entries, and classes for \Metadata\, \Capability\, and \OperatorInfo\ to inspect file properties and operator configuration. Additionally, it includes \OpenDal::Middleware\ classes (Retry, ConcurrentLimit, Throttle, Timeout) to apply layers to the operator.

bindings/lua, bindings/ruby/src · high confidence

A new SQLite service has been added to the core services, allowing users to store and retrieve objects using a local SQLite database. The implementation supports read, write, delete, stat, and create\_dir operations, with configuration options for the connection string, table name, and custom key/value field names. This enables SQLite to be used as a persistent, file-based object store within the OpenDAL framework.

core/services/sqlite · high confidence

This change adds the initial Swift bindings for OpenDAL, providing a native Swift API to interact with storage operators. The package includes an \Operator\ class that supports initialization with specific schemes (e.g., \memory\) and options, along with \blockingWrite\ and \blockingRead\ methods for file operations. It also introduces a \Data\ extension for zero-copy handling of underlying buffers and includes a \GettingStarted\ example demonstrating basic usage, alongside corresponding unit tests.

bindings/swift/OpenDAL · high confidence

A new \TailCutLayer\ is available to automatically cancel slow requests based on adaptive statistics. Users can configure the layer via a builder to set the percentile threshold (default P95), safety factor, sliding window duration, and minimum/maximum deadline bounds. This allows the system to dynamically adjust cancellation behavior to prevent long-tail latency from impacting overall performance.

core/layers/tail-cut · high confidence

A new \TimeoutLayer\ has been added to the core library to prevent operations from hanging indefinitely. This layer allows users to configure two distinct timeout budgets: a general \timeout\ (defaulting to 60 seconds) for control operations like \stat\, \delete\, and \rename\, and an \io\_timeout\ (defaulting to 10 seconds) for IO-heavy operations such as \read\, \write\, and \list\, as well as methods on returned readers and writers. The implementation uses \tokio::time::timeout\ to enforce these deadlines, ensuring that stalled connections or busy states do not cause the application to wait forever.

core/layers/timeout · high confidence

The parquet integration now provides \AsyncReader\ and \AsyncWriter\ components that wrap OpenDAL's async reader and writer interfaces. The \AsyncReader\ implements the \AsyncFileReader\ trait, supporting configurable footer prefetching to optimize metadata retrieval, while the \AsyncWriter\ implements \AsyncFileWriter\ and exposes an \abort\ method to cleanly cancel and clean up incomplete writes. These additions enable non-blocking Parquet read and write operations for users leveraging OpenDAL as their storage backend.

integrations/parquet · high confidence

The Operator API now supports background task execution via a new \Executor\ system, allowing asynchronous operations to run concurrently without blocking the caller; this includes a default Tokio-based executor and a public \Execute\ trait for custom runtimes. Additionally, operators can now be initialized directly from URIs using \Operator::from\_uri\ and \Operator::via\_iter\, which leverage a global \OperatorRegistry\ to resolve storage schemes dynamically at runtime.

core/core/src/types/operator · high confidence

The \observe-metrics-common\ crate now provides a centralized reference for all OpenDAL metrics, including detailed documentation for operation-level metrics (such as duration, bytes, and errors) and HTTP-level metrics (such as request/response sizes and durations). It also defines standard label constants (scheme, namespace, root, operation, path) and default bucket configurations for histograms, ensuring consistent metric exposure across the library.

core/layers/observe-metrics-common · high confidence

The \core/core/src/types\ module now provides the foundational types for the storage API, including \Buffer\ for handling contiguous and non-contiguous byte sequences, \BytesRange\ for specifying read ranges (including suffix reads), and \Capability\ to describe supported operations and constraints. It also introduces the \Copier\ type to drive long-running copy operations and \Lister\ for asynchronous entry listing, alongside core data structures like \Metadata\, \Entry\, and \Error\.

core/core/src/types · high confidence

Users can now access OpenDAL from D applications via a new binding layer built on top of the existing C bindings. This change adds the \bindings/d\ directory containing the D source code (wrapping the C API), a \dub.json\ package configuration for the DUB package manager, and a build script (\build.d\) that automatically compiles the underlying C library and links it. The binding supports standard storage operations (read, write, list, etc.) and includes parallel execution variants for write, read, and list operations. It also provides a getting-started example and unit tests to verify functionality against various backends.

bindings/d · high confidence

Adds a new Swift binding that wraps the existing C binding to provide access to OpenDAL's storage services from Swift applications. The package is currently experimental and not suitable for production use; it is not published to a registry and must be referenced via a local path in a project's Package.swift. The binding exposes an Operator API with blocking methods like \blockingWrite\ and \blockingRead\, throwing \OperatorError\ on failures, and relies on the C binding's libraries and headers which are built locally via the provided Makefile.

bindings/php, bindings/swift · high confidence

Adds a new Zig binding layer that wraps the existing C bindings, providing a native Zig API for blocking access to storage services (S3, GCS, Azure Blob, local filesystem, and 50+ others). The binding includes a \build.zig\ build script, a \build.zig.zon\ manifest requiring Zig 0.14.0 or higher, and core source files (\src/opendal.zig\) exposing \Operator\, \Lister\, \Entry\, and \Metadata\ structs. It also includes documentation (README, CONTRIBUTING, DEPENDENCIES) and a getting-started example, with tests configured to run against the C library.

bindings/zig · high confidence

The OpenDAL Haskell binding is now available, providing a consistent API to access S3, GCS, Azure Blob, the local filesystem, and 50+ other services from Haskell. This release includes the Rust FFI layer (src/lib.rs, src/types.rs, src/result.rs, src/logger.rs) for blocking operations like read/write, a custom Cabal build hook (Setup.hs) to automatically compile the Rust FFI library, and comprehensive documentation (README, CONTRIBUTING, DEPENDENCIES).

bindings/haskell · high confidence

This change adds the initial Haskell bindings for Apache OpenDAL, providing a high-level API for interacting with various storage backends. The new \OpenDAL\ module exposes core types such as \Operator\, \Lister\, and \Writer\, along with blocking operations including \read\, \write\, \isExist\, \createDir\, \copy\, \rename\, \delete\, \stat\, \list\, \scan\, and \removeAll\. It also includes support for custom logging via \LogAction\ and handles error codes like \NotFound\ and \Conflict\ through the \OpenDALError\ type. The underlying FFI layer (\OpenDAL.FFI\) manages the interface with the native OpenDAL library, handling data marshalling for byte slices, metadata, and operator pointers.

bindings/haskell/haskell-src · high confidence

This change adds the initial OCaml binding implementation in the \bindings/ocaml/src\ directory, providing a new \opendal\_core\ library. It exposes the OpenDAL operator API to OCaml, including blocking operations for reading, writing, listing, and managing files, as well as support for metadata, capabilities, and file seeking.

bindings/ocaml/src · high confidence

The monoiofs service is now available as a separate crate, enabling file system operations (read, write, stat, delete, rename, copy, and create\_dir) via the monoio async runtime. It uses a dedicated thread pool with io\_uring-backed workers to handle I/O, supports configurable root directories, and enforces path confinement to prevent directory traversal attacks.

core/services/monoiofs · high confidence

The \core/testkit\ location now contains a new \opendal-testkit\ crate that provides reusable test actions, data checkers, and runtime setup helpers for service and integration tests. It exposes \ReadAction\ and \WriteChecker\ utilities to verify read/write correctness against random reference data, and offers an \init\_test\_service\ function that constructs an \Operator\ from environment variables, applies logging, timeout, and retry layers, and supports capability overrides via the \OPENDAL\_TEST\_CAPABILITY\_OVERRIDES\ environment variable. The crate is intended as a development dependency and is also re-exported by the main \opendal\ facade behind the \tests\ feature.

core/testkit · high confidence

The core library now exposes a new \HttpTransport\ trait and \HttpTransporter\ handle in \core/core/src/types/http\_transport\, allowing services to use a custom HTTP backend instead of the built-in default. This change introduces streaming response bodies via \HttpBody\ and adds automatic redaction of sensitive credentials (such as Authorization headers and specific query parameters like signatures and tokens) in diagnostic outputs to improve security visibility. It also defines \HttpRedirect\ to support reusable redirect destinations across requests.

_core/core/src/types/http\transport · high confidence

The \core/core/src/raw/oio\ area now exposes a new internal \Entry\ struct and a reorganized module structure (\mod.rs\) that aggregates raw traits and types for operations like compose, delete, copy, read, write, and list. This \Entry\ type serves as the raw API representation for list operations, holding metadata and path, and provides methods to access these details or convert into the public \crate::Entry\. The module structure centralizes these raw output types, which are intended for internal use only and are not exposed to end-users.

core/core/src/raw/oio · high confidence

A new \LoggingLayer\ has been added to the core service composition pipeline, enabling structured logging for all operations via the \log\ crate. Users can now enable detailed operational visibility by setting the \RUST\_LOG\ environment variable (e.g., \opendal::services=debug\). The layer emits structured log entries for operation start, success, completion, and failure, with distinct log levels for expected versus unexpected errors. Additionally, the implementation supports custom logging behavior through the \LoggingInterceptor\ trait, allowing users to inject their own logging logic into the service chain.

core/layers/logging · high confidence

The Java binding now provides a dual-mode API for accessing data stores, featuring a new \AsyncOperator\ for non-blocking operations and a synchronous \Operator\ that wraps the async implementation. The synchronous operator exposes standard data operations including read, write, delete, copy, rename, list, and stat, along with streaming support via \OperatorInputStream\ and \OperatorOutputStream\. The \AsyncOperator\ allows users to specify a custom \AsyncExecutor\ or use a default global executor, and supports operator duplication and layering. Additionally, the binding includes a generated \ServiceConfig\ interface with concrete configuration classes for supported backends (such as Aliyun Drive, Alluxio, and Azblob), enabling type-safe service initialization.

opendal · high confidence

The Java binding now exposes a comprehensive set of new capabilities and options for storage operations. Users can configure reads, writes, and stat operations using dedicated options classes (ReadOptions, WriteOptions, StatOptions, ListOptions) that support features like range reads, conditional writes (if-match/if-none-match), content metadata, and recursive listing. The binding also introduces streaming I/O via OperatorInputStream and OperatorOutputStream, allowing standard Java stream interfaces to interact with OpenDAL operators. Additionally, users can inspect operator capabilities via the Capability class, retrieve operator metadata with OperatorInfo, and generate presigned requests using PresignedRequest. The binding also supports explicit async execution via AsyncExecutor and allows applying layers to operators for cross-cutting concerns.

bindings/java/src/main/java/org/apache/opendal · high confidence

A new \AwaitTreeLayer\ is introduced in the \core/layers/await-tree\ crate, allowing users to instrument service operations with the \await-tree\ library. By adding this layer to an operator, developers can dump the execution tree at runtime and annotate futures with \instrument\_await\, providing visibility into the async execution flow of operations like create\_dir, rename, restore, stat, and presign, as well as wrapping readers, writers, listers, and deleters.

core/layers/await-tree · high confidence

A new \CapabilityCheckLayer\ is introduced that validates optional arguments for write, copy, and list operations against the underlying service's capabilities. Unlike the existing \CorrectnessChecker\, this layer focuses on features that do not affect data integrity (such as \write\_with\_content\_type\, \copy\_with\_if\_not\_exists\, and \copy\_with\_source\_version\) and is not enabled by default. Users can opt-in to this layer to receive immediate errors if they attempt to use optional arguments that the storage service does not support, rather than having the operation proceed or fail silently.

core/layers/capability-check · high confidence

The GitHub service has been extracted from the core module into its own dedicated package at core/services/github. This new implementation provides a full-featured backend for interacting with GitHub repositories, supporting operations such as reading, writing, deleting, creating directories, and listing files (including recursive listing). It allows users to configure the service with a repository owner, name, optional access token, and root path, enabling seamless integration with GitHub's contents API.

core/services/github, core/services/webhdfs · high confidence

A new runnable Go example has been added to the bindings documentation, demonstrating the basic OpenDAL workflow including operator initialization with the memory service, and performing write, read, stat, and delete operations. This example serves as the source for the 'Getting Started' guide and is verified by CI to ensure the documentation snippets remain accurate and copy-pasteable.

bindings/go/examples · high confidence

This location introduces the core implementation for a new Google Cloud Storage (GCS) service that communicates via the gRPC protocol (URI scheme \gcs-grpc\). The \backend.rs\ and \config.rs\ files define the service builder and configuration options, including support for various Google OAuth 2.0 credential providers (service account keys, environment variables, GCE metadata) and custom endpoints. The \core.rs\ file handles the gRPC client setup and request signing, while \copier.rs\, \deleter.rs\, \lister.rs\, \reader.rs\, and \writer.rs\ implement the specific storage operations (copy, delete, list, read, and write) using the generated \google.storage.v2\ protobuf definitions. This enables users to interact with GCS using the more efficient gRPC interface instead of the traditional REST API.

core/services/gcs-grpc · high confidence

The Java bindings now expose three new layer implementations in the \org.apache.opendal.layer\ package: \ConcurrentLimitLayer\ to restrict the number of simultaneous connections to storage services, \RetryLayer\ (configurable via builder for jitter, delay, and attempt limits) to automatically retry temporary failures, and \CapabilityOverrideLayer\ to modify the capabilities exposed by an operator. These classes provide the Java-side API for applying these specific behaviors to OpenDAL operations.

bindings/java/src/main/java/org/apache/opendal/layer · high confidence

The \integrations/dav-server\ module now provides a new \OpendalFs\ implementation that bridges the \dav-server\ WebDAV protocol to OpenDAL storage backends. This change introduces dedicated modules for handling directory listings (\OpendalStream\), file I/O with read/write/seek capabilities (\OpendalFile\), metadata mapping (\OpendalMetaData\), and path normalization, allowing users to access any OpenDAL-supported storage service via standard WebDAV operations.

integrations/dav-server · high confidence

The Python bindings now expose several new operator layers in the \opendal.layers\ module, allowing users to control request behavior without changing backend code. You can now use \ConcurrentLimitLayer\ to cap the total number of simultaneous operations across operators, \TimeoutLayer\ to set separate timeouts for control operations (like \stat\) and I/O operations (like \read\/\write\), and \MimeGuessLayer\ to automatically infer \Content-Type\ headers based on file paths. Additionally, \CapabilityOverrideLayer\ is available to modify the capabilities exposed by an operator, and \RetryLayer\ has been updated to validate numeric inputs (such as backoff factors and delay limits) to prevent configuration errors.

bindings/python/src/layers · high confidence

A new \RouteLayer\ is introduced that allows routing operations to different underlying operators based on glob patterns. Users can configure multiple routes where the first matching pattern determines the target operator for a given path. This enables scenarios like separating archival storage from active data without moving data between services, as copy and rename operations select the route based on the source path.

core/layers/route · high confidence

A new edge module for WebAssembly environments has been added, enabling OpenDAL-based S3 operations directly in the browser. This implementation allows users to write data to and read data from an S3-compatible bucket (configured with default Minio credentials) using the \Operator\ API, with a provided test demonstrating the round-trip functionality.

_core/edge/s3\_read\_on\wasm · high confidence

A new \ThrottleLayer\ is introduced in the \core/layers/throttle\ crate, allowing users to limit bandwidth for storage services. It uses the Generic Cell Rate Algorithm (GCRA) via the \governor\ library to control byte-flow rates based on configurable \bandwidth\ (bytes per second) and \burst\ (maximum bytes at once) parameters. The layer wraps read and write operations with a \ThrottleWrapper\ that enforces these limits, while passing through other operations like copy, delete, and rename without throttling.

core/layers/throttle · high confidence

Added Docker Compose configurations and supporting assets for Alluxio, etcd (including TLS certificates and cluster/standalone setups), FTP, GooseFS (with a custom launcher script to optimize resource usage and fix IPv4 binding issues), and HDFS (including configurations for Azure Blob and GCS backends). Also added a setup script for Azurite to start it via npm and included test data files with special characters in their names to verify path handling.

fixtures · high confidence

The core read module has been restructured to introduce a new \Reader\ type that supports multiple consumption patterns: direct range reads, streaming via \into\_bytes\_stream\, and integration with Rust's standard async I/O traits via \into\_futures\_async\_read\. This change adds \BufferStream\, \FuturesAsyncReader\, and \FuturesBytesStream\ components to handle concurrent chunked reading, zero-copy buffering, and seamless interoperability with \AsyncRead\/\AsyncBufRead\ consumers, improving both memory efficiency and flexibility for async workloads.

core/core/src/types/read · high confidence

A new \Deleter\ component is introduced in the core types module, enabling efficient batch removal of files from storage. Users can now delete single files, iterate over collections of paths, or stream deletions using standard Rust iterators and futures streams. The API also supports integration with the \futures\ Sink trait for asynchronous workflows and allows passing specific delete options, such as version identifiers, per entry.

core/core/src/types/delete · high confidence

The blocking read module now exposes \Reader\, \BufferIterator\, \StdBytesIterator\, and \StdReader\. Users can read data via blocking \read\ and \read\_into\ calls, iterate over buffers or raw bytes using the new iterator types, or adapt the reader to standard library traits (\Read\, \Seek\, \BufRead\) via \StdReader\ for compatibility with existing Rust I/O code.

core/core/src/blocking/read · high confidence

A new \compfs\ service has been added, providing a file-system backend powered by the \compio\ library for asynchronous I/O. This allows users to access local files using the \compfs://\ URI scheme, supporting standard operations like reading, writing, listing, and deleting. The implementation includes strict path confinement to prevent directory traversal attacks and leverages \compio\'s dispatcher for non-blocking execution.

core/services/compfs · high confidence

The core write interface has been restructured into a new \oio::write\ module, introducing a unified \Write\ trait and its dynamic \WriteDyn\ wrapper to standardize how services handle data output. This change provides specialized writer implementations—\OneShotWriter\ for single-operation uploads, \MultipartWriter\ for chunked uploads, \BlockWriter\ for block-based storage, \AppendWriter\ for append-only objects, and \PositionWriter\ for offset-based writes—allowing services to adopt the most efficient strategy for their underlying storage. The API also adds native \copy\_from\ support to the \Write\ trait and \MultipartWrite\ interface, enabling efficient server-side copying without downloading data, while the \BlockWriter\ and \PositionWriter\ include built-in concurrency and timeout handling for write operations.

core/core/src/raw/oio/write · high confidence

The \dev\ directory now includes a code-generation tool that reads OpenDAL core definitions (capabilities, metadata, and service configurations) and automatically produces language-specific mirrors and documentation. This tool generates .NET capability and metadata mirrors, typed service-config classes, Java service-config interfaces, Python type stubs, and website configuration reference pages, ensuring that binding surfaces stay in sync with core without manual maintenance.

dev · high confidence

A new \FastraceLayer\ is available to integrate OpenDAL with the fastrace distributed tracing system. This layer automatically creates spans for all service operations (such as read, write, copy, and create\_dir) and wraps deferred IO bodies (readers, writers, listers, deleters, and copiers) to provide end-to-end visibility into both synchronous calls and asynchronous streaming operations.

core/layers/fastrace · high confidence

The scripts directory now includes a suite of Python tools to streamline project maintenance and the release process. \dependencies.py\ automates the checking and generation of Rust dependency licenses using \cargo-deny\. \label.py\ manages repository labels and uses an AI model to classify pull requests and issues by category and component. \release\_impact.py\ validates breaking change declarations and prepares version plans for releases. \sign\_source\_release.py\ handles the secure signing and verification of source release bundles. Additionally, \merge\_local\_staging.py\ assists in merging local staging directories, and \constants.py\ provides shared configuration for package paths and features.

scripts · high confidence

Added \MetricsLayer\ and \PrometheusLayer\ to the core library, enabling users to instrument OpenDAL operations with standard metrics. The \MetricsLayer\ records operation details (such as bytes, duration, errors, and status codes) using the generic \metrics\ crate, while the \PrometheusLayer\ provides a concrete implementation that registers these metrics into a Prometheus registry for scraping. These layers allow users to monitor storage service performance and usage directly through their OpenDAL operators.

core/layers/metrics, core/layers/prometheus · high confidence

A new \object\_store\_opendal\ integration crate has been added to \integrations/object\_store\, allowing users to access OpenDAL's 30+ storage services (including Amazon S3, via the new \AmazonS3Builder\) using the standard \object\_store\ Rust API. The crate provides an \OpendalStore\ implementation that maps \object\_store\ operations (read, write, list, delete) to OpenDAL operators, including support for multipart uploads, range reads, and conditional requests, while re-exporting a future helper (\IntoSendFuture\) for Send-safety.

_integrations/object\store · high confidence

The core library introduces a new \oio::copy\ module that provides a stateful \Copy\ trait and a \Copier\ type-erased wrapper, allowing copy operations to be driven incrementally via \next()\, \close()\, and \abort()\. This replaces the previous one-shot approach with two concrete implementations: \BlockCopier\, which handles large files by splitting them into concurrent block copies, and \MultipartCopier\, which manages multipart upload-style copies with part queuing and completion. Service providers can now implement the \BlockCopy\ or \MultipartCopy\ traits to support efficient, resumable, and abortable copy operations for large objects.

core/core/src/raw/oio/copy · high confidence

Added two new Rust examples in the core examples directory: \concurrent-upload\ and \multipart-upload\. The concurrent-upload example demonstrates how to use the \concurrent\ method on a writer to handle multiple chunks simultaneously, while the multipart-upload example shows standard sequential chunk writing. Both examples illustrate how to initialize an operator via test service configuration and verify uploaded data integrity.

core/examples/concurrent-upload, core/examples/multipart-upload · high confidence

The Node.js binding has been reorganized into a new project layout, introducing a dev container environment and a devbox configuration for consistent local development. The binding now supports Node.js streams, allowing users to create readable and writable streams from readers and writers via \createReadStream\ and \createWriteStream\ methods. Additionally, the binding exposes new layers including \CapabilityOverrideLayer\, \RetryLayer\, and \ConcurrentLimitLayer\, and provides a \Capability\ class to inspect operator support for various operations.

bindings/nodejs · high confidence

The OCaml bindings for the Operator now provide a comprehensive blocking API, allowing users to create operators, perform file operations (read, write, copy, rename, delete, list), and manage directories. This update introduces support for streaming via Reader and Writer types, including pread capabilities, and exposes detailed file metadata (such as content length, MD5, ETag, and last modified time) through the Metadata type. Users can also inspect operator capabilities and information, enabling more robust and feature-complete interactions with storage backends from OCaml.

bindings/ocaml/src/operator · high confidence

The Rust core library is now published as a separate crate (opendal-core) with its own README, contributing guide, and dependency manifest (DEPENDENCIES.rust.tsv). This separation allows users to depend on the core API and blocking primitives (including the new StdWriter adapter for std::io::Write) without pulling in service-specific features, and provides clearer upgrade and usage guidance via a dedicated upgrade guide and users list.

core · high confidence

The \oteltrace\ layer has been introduced as a standalone crate to provide OpenTelemetry tracing for OpenDAL service operations. By applying this layer, users can automatically generate spans for metadata, create, read, write, copy, rename, stat, list, and presign calls, with read, write, and list contexts carried into their stateful I/O bodies. The layer integrates with the global OpenTelemetry tracer provider, allowing applications to install and configure their own provider to capture detailed observability data for storage operations.

core/layers/oteltrace · high confidence

The Python binding location now includes a comprehensive set of documentation and development configuration files. A new \CONTRIBUTING.md\ guide details the setup process using \uv\ for dependency management and \just\ as the command runner for building, testing, and linting. The \justfile\ defines recipes for generating type stubs, building wheels, running tests, and serving documentation. Documentation is now built using Zensical (via \mkdocs.yml\), replacing previous setups. The \README.md\ has been updated to reflect the independent versioning of the Python binding relative to the Rust core, providing clear installation instructions for PyPI, Anaconda, and conda-forge, along with a quickstart example. Additionally, license files (\LICENSE\, \LICENSE-MPL-2.0.txt\, \LICENSE-libgcc.txt\), a \NOTICE\ file, and a \DEPENDENCIES.md\/\DEPENDENCIES.rust.tsv\ for tracking Rust dependencies have been added to ensure proper attribution and compliance.

bindings/python · high confidence

The Python binding now includes generated \.pyi\ stubs and a \py.typed\ marker, enabling static type checking for the public API. This introduces \TypedDict\-based service configurations (e.g., \S3Config\) that validate scheme, required keys, and value types, and adds typed keyword argument dictionaries (e.g., \ReadKwargs\, \WriteKwargs\) for operator methods. The \Scheme\ enum is now available for type-safe service selection, and the \Capability\ class exposes detailed boolean and integer properties for all supported operations and constraints.

bindings/python/python · high confidence

The repository has been initialized with the foundational structure for Apache OpenDAL, including the addition of the \.asf.yaml\ file to configure GitHub integration, branch protection, and notification channels for the Apache project. A comprehensive \AGENTS.md\ file has been added to provide guidance for AI coding agents, establishing policies for human involvement, AI-assisted contributions, and documentation standards. The project layout has been reorganized to split the Rust core into a facade crate and smaller service/layer crates, with a new \core/\ directory structure. Configuration files for code formatting (\.editorconfig\, \.taplo.toml\, \.yamlfmt\), typo checking (\.typos.toml\), and environment variables (\.env.example\) have been added to standardize development workflows. The Apache License 2.0 has been applied, and various metadata files like \CITATION.cff\ and \DEPENDENCIES.md\ have been introduced.

(repo-wide) · high confidence

The Ruby binding is now available as an independent gem, allowing users to access 50+ storage services (S3, GCS, Azure Blob, local filesystem, etc.) via a unified API. This release includes the native extension build infrastructure (Rakefile, build.rs) to compile the Rust core, along with documentation, license files, and dependency manifests. The binding is versioned independently from the Rust core, so users should rely on the Ruby gem version for compatibility updates.

bindings/ruby · high confidence

The S3 service implementation has been moved into its own crate (\core/services/s3\), introducing a dedicated \S3Builder\ and \S3Config\ for configuration. This update adds support for explicit AWS profiles, configurable assume role duration and session tags, and S3 Express session authentication. It also introduces conditional operations, allowing users to specify \if-match\ for deletes and \if-none-match\ for writes, alongside a new multipart copier for large file copies. The service now supports object restoration and includes comprehensive documentation for compatible services such as OCI, Tigris, and SeaweedFS.

core/services/s3 · high confidence

The individual service crates in core/services (such as Aliyun Drive, Alluxio, Azure Blob, GCS, and others) now ship with README.md files and LICENSE/NOTICE symlinks. This provides users with immediate documentation on how to enable each service via the opendal facade or opendal-core, along with proper licensing attribution in published packages.

core/services · high confidence

The Spring Boot starters for both synchronous (Spring MVC) and reactive (WebFlux) applications now include auto-configuration classes that automatically register OpenDAL beans. Users can inject \OpenDALTemplate\ or \ReactiveOpenDALTemplate\ directly into their services without manual setup, as the configuration reads \spring.opendal.schema\ and \spring.opendal.conf\ properties to initialize the underlying \AsyncOperator\ and serializer factory.

integrations/spring/opendal-spring-boot-starter, integrations/spring/opendal-spring-boot-starter-reactive · high confidence

The Spring integration module now includes core classes that enable Spring applications to interact with Apache OpenDAL. This change introduces \OpenDALTemplate\ and \ReactiveOpenDALTemplate\ for synchronous and reactive operations respectively, along with \OpenDALOperations\ and \ReactiveOpenDALOperations\ interfaces that support write, read, and delete actions. It also adds a serialization framework (\OpenDALSerializer\, \OpenDALSerializerFactory\, and \DefaultOpenDALSerializerFactory\) to handle entity conversion, and \OpenDALProperties\ for configuration binding under the \spring.opendal\ prefix. A test for the default serializer factory is also included.

integrations/spring/opendal-spring · high confidence

OpenDAL now supports Tencent Cloud COS as a standalone service in core/services/cos. Users can connect to COS buckets using the \cos://\ or \cosn://\ URI schemes, configure endpoints and buckets, and authenticate via static secret keys or temporary STS security tokens. The implementation provides full support for reading, writing, deleting, listing, copying, and presigning objects, including multipart uploads and versioned listing.

core/services/cos · high confidence

The \Writer\ type in the core write module now provides \into\_bytes\_sink()\ and \into\_futures\_async\_write()\ methods, allowing users to stream data using the standard \futures::Sink\ and \std::io::AsyncWrite\ traits respectively. This change introduces new adapter types (\BufferSink\, \FuturesBytesSink\, and \FuturesAsyncWriter\) that bridge the internal write generator to these async interfaces, enabling seamless integration with existing async Rust ecosystems and libraries that expect these standard traits.

core/core/src/types/write · high confidence

The async backtrace functionality has been moved into its own crate, \opendal\_core::layer\_async\_backtrace\, making it a standalone, reusable component. This change allows developers to easily enable logical stack trace recording for asynchronous service operations by simply applying the \AsyncBacktraceLayer\ to their OpenDAL operator, facilitating better debugging and observability of async workflows without requiring internal core modifications.

core/layers/async-backtrace · high confidence

The Backblaze B2 storage service has been refactored out of the core module into its own dedicated crate at core/services/b2. This change introduces the full service implementation—including the builder, configuration, core HTTP logic, and operations for reading, writing, listing, deleting, and copying files—allowing the B2 backend to be developed, tested, and maintained independently while remaining registered with the operator registry.

core/services/b2 · high confidence

The \core/core/src/raw\ module has been reorganized to provide foundational traits and utilities for storage services and layers. This includes the new \Service\ trait in \accessor.rs\ for defining storage operations, the \Layer\ trait in \layer.rs\ for intercepting service stacks, and various I/O abstractions like \FlexBuf\, \PooledBuf\, and \QueueBuf\ for efficient buffer management. Additionally, operation-specific argument structs (e.g., \OpDelete\, \OpRead\) and reply types (e.g., \RpRead\, \RpStat\) are now defined in \ops.rs\ and \rps.rs\, establishing a clearer separation between raw internal APIs and public-facing functionality.

core/core/src/raw · high confidence

The Google Drive backend has been split out from the core services into its own dedicated crate (\core/services/gdrive\). This change introduces a new module structure with separate files for configuration, core logic, path indexing, and I/O operations (reader, writer, lister, deleter), along with updated documentation and registration mechanisms. Users can now configure and use the Google Drive service via the new \GdriveBuilder\ and \GdriveConfig\ types, with support for both temporary access tokens and long-term refresh token flows.

core/services/gdrive · high confidence

The Yandex Disk storage service has been split out from the core module into its own standalone crate (core/services/yandex-disk). This change introduces the full service implementation—including the builder, configuration, core HTTP logic, and I/O components (reader, writer, lister, deleter)—as a distinct, registerable service module, improving modularity and allowing the Yandex Disk backend to be built and maintained independently.

core/services/yandex-disk · high confidence

The C++ binding now provides an asynchronous API (opendal::async) for non-blocking read, write, list, and stat operations, alongside a synchronous Operator class that supports configurable retry and timeout layers via OperatorOption. The Metadata class has been expanded to include versioning fields (version, is\_current, is\_deleted) and HTTP-style headers, and the is\_exist method has been renamed to exists to align with the core API.

bindings/cpp/include · high confidence

The core library now provides a centralized mechanism to register all enabled storage services and install the default HTTP transport through the \install\_default\ and \init\_default\_registry\ functions. This change consolidates the initialization logic, ensuring that services (such as memory, Aliyun Drive, Alluxio, Azure Blob, B2, Cloudflare KV, and many others) are automatically registered with the global \OperatorRegistry\ when their respective feature flags are enabled. This simplifies setup for applications using URI-based construction or static linking, while still allowing explicit control over the process-wide HTTP transport and registry initialization for advanced use cases.

core/src · high confidence

The concurrent-limit functionality has been split into its own crate (\core/layers/concurrent-limit\), making it easier to manage and reuse. This change introduces a \ConcurrentLimitSemaphore\ trait, allowing users to provide custom semaphore implementations instead of being limited to the default \Arc\<Semaphore\>\. The layer now supports separate concurrency limits for general operations and HTTP requests via \with\_http\_semaphore\, and it correctly limits copy and rename operations to prevent deadlocks.

core/layers/concurrent-limit · high confidence

The Node.js binding documentation now displays a custom footer containing the Apache Software Foundation copyright notice (2022–current year) and trademark information. This is achieved by introducing a new theme file that overrides the default TypeDoc render context to inject specific footer content, ensuring legal compliance in the generated API documentation.

bindings/nodejs/theme · high confidence

The Dart binding now automatically detects the host operating system and architecture to locate the correct Rust native library (e.g., \libopendal\_dart.so\ for Linux, \.dylib\ for macOS, \.dll\ for Windows), falling back to a default release directory if the platform-specific path is missing. This change, implemented in \lib/opendal.dart\, ensures the native library loads correctly across different environments. Additionally, the binding has upgraded the underlying \flutter\_rust\_bridge\ library to version 2.12.0, which is reflected in the regenerated FFI code in \lib/src/rust/\ and requires matching codegen versions to avoid startup failures.

bindings/dart · high confidence

The Rust source files for the Dart bindings have been regenerated to use flutter\_rust\_bridge version 2.12.0. This update includes fixes for native library loading, ensuring that the Dart application can correctly interface with the underlying Rust code on supported platforms.

bindings/dart/rust/src · high confidence

The FTP backend has been refactored to replace the previous synchronous implementation with an asynchronous one based on the \suppaftp\ 10 library and \tokio\. This change introduces a connection pool managed by \asyncband\ to handle concurrent FTP/FTPS sessions, enabling non-blocking read, write, list, and delete operations. Users benefit from improved concurrency and responsiveness when interacting with FTP servers, as the service no longer blocks threads during network I/O.

core/services/ftp · high confidence

The POSIX file system backend has been extracted into its own module (core/services/fs) and now supports the standard 'file://' URI scheme as an alias for 'fs'. This update introduces user-defined metadata support on Unix systems (stored via extended attributes) and enforces strict path confinement by rejecting absolute paths and parent-directory traversal attempts to prevent root escape. Additionally, the listing behavior now correctly preserves backslashes in filenames on Unix, and the reader implementation has been optimized with a pooled buffer and lazy opening of positioned read handles.

core/services/fs · high confidence

The Huawei Cloud Object Storage Service (OBS) implementation has been refactored into a standalone crate (\core/services/obs\) and migrated to \reqsign-core\ v2 for request signing, which updates the underlying credential and HTTP transport mechanics. The \enable\_versioning\ configuration option is now deprecated and ignored, as versioning is no longer controlled by service config. Users interacting with this location will see the service isolated as its own module, utilizing the new signing infrastructure while retaining support for standard operations like read, write, list, and delete.

core/services/obs · high confidence

The new build.py tool for the Java bindings now supports building for musl-based Linux distributions and targets glibc 2.17 compatibility via zigbuild. Users can now build the Java bindings for a wider range of Linux environments, including Alpine (musl) and older glibc systems, by specifying the appropriate classifier or target.

bindings/java/tools · high confidence

The Java bindings directory has been restructured with new documentation and build tooling. The README now clarifies that the Java binding version is independent of the Rust core version and provides updated Maven and Gradle installation instructions, including support for musl-based Linux distributions like Alpine. A new CONTRIBUTING guide details the Maven-based build process, testing, and code style enforcement. Additionally, an upgrade guide documents breaking changes across versions v0.41 through v0.50, such as the renaming of \Operator\ to \AsyncOperator\ and \BlockingOperator\ to \Operator\, the deprecation of the \append\ method, and the removal of batch operations. The directory also includes new dependency tracking files (DEPENDENCIES.md, DEPENDENCIES.rust.tsv) and a users list.

bindings/java · high confidence

The Java bindings directory now includes a Maven Wrapper configuration that pins the build environment to Maven 3.9.4. This ensures that developers and CI systems building the Java bindings use a consistent, reproducible version of Maven rather than relying on whatever version is installed locally, eliminating potential build inconsistencies caused by version drift.

bindings/java/.mvn · high confidence

The \MimeGuessLayer\ functionality, which automatically sets the \Content-Type\ header based on a file's extension when it is not already provided by the service or caller, has been moved into its own standalone crate (\core/layers/mime-guess\). This change isolates the layer's logic and its dependency on the \mime\_guess\ library, making it easier to include or exclude this specific behavior in your OpenDAL configuration without pulling in unrelated code.

core/layers/mime-guess · high confidence

The core HTTP utilities have been reorganized into a dedicated \http\_util\ module, introducing a \BytesContentRange\ struct to correctly parse and format HTTP \Content-Range\ headers for range-based reads. This module also provides standardized helpers for parsing common HTTP headers (such as \ETag\, \Content-Type\, and \Cache-Control\) into service metadata, utilities for building and parsing multipart/form-data requests, and functions for safe URL path encoding and decoding.

_core/core/src/raw/http\util · high confidence

The core library introduces dedicated context structures—ReadContext, WriteContext, and OperationContext—to manage the runtime state and resources for object storage operations. ReadContext now tracks the file path, operation arguments, and the underlying reader, while also caching object metadata and providing methods to parse byte ranges and determine content length. WriteContext similarly encapsulates the service, path, and write arguments, and includes logic to calculate optimal chunk sizes based on service capabilities. OperationContext serves as the base container for composed runtime resources like HTTP transport and executors, ensuring these are correctly passed through the operator stack to services.

core/core/src/types/context · high confidence

The core layer module now includes several new layers that change how operations are validated and simulated. The CorrectnessCheckLayer enforces capability checks before operations, returning an Unsupported error if arguments (such as append, if\_match, or version) are not supported by the underlying service, preventing incorrect data writes. The CapabilityOverrideLayer allows users to manually tune or disable specific capabilities (e.g., write\_with\_if\_match) for testing or specific endpoints without changing the service's native capability. The SimulateLayer provides configurable simulation of missing capabilities, such as emulating suffix reads, recursive listing, directory creation, and recursive deletion for backends that lack native support. Additionally, the ErrorContextLayer now automatically adds service, operation, and path context to all errors, and the CompleteLayer ensures content length consistency for copy operations.

core/core/src/layers · high confidence

The core list operation implementation has been refactored into a modular set of internal components: a type-erased \List\ trait and \Lister\ wrapper, a \PageLister\ for services that support pagination, a \PrefixLister\ to filter entries by prefix, a \HierarchyLister\ to present flat results as a directory tree, and a \FlatLister\ for recursive bottom-up directory traversal. The \FlatLister\ specifically improves reliability during recursive listing by silently skipping \PermissionDenied\ and \NotFound\ errors (e.g., when directories are deleted or inaccessible during traversal), ensuring the listing operation continues rather than failing.

core/core/src/raw/oio/list · high confidence

The OneDrive backend has been split into its own crate (\core/services/onedrive\) and refactored to use a new modular structure (separate files for core, reader, writer, lister, and deleter). This change includes fixes for file listing and upload behavior, specifically correcting the construction of children URLs when listing the root directory and addressing upload issues on smaller machines by disabling \write\_total\_max\_size\ on 32-bit architectures. The \enable\_versioning\ configuration option is now deprecated as version listing is supported by default.

core/services/onedrive · high confidence

The Python bindings have been restructured into a mixed Python/Rust layout, exposing a new \File\ and \AsyncFile\ class that replaces the previous \Reader\/\Writer\ abstractions to provide a standard file-like interface. This change introduces typed configuration via \TypedDict\ (e.g., \S3Config\) and dedicated option classes (\ReadOptions\, \WriteOptions\) for granular control over operations. Additionally, the bindings now expose a detailed \Capability\ structure to inspect supported operations and constraints, and implement a comprehensive set of specific Python exceptions (such as \NotFound\, \ConditionNotMatch\, and \Conflict\) to improve error handling.

bindings/python/src · high confidence

The internal I/O interface for reading data has been restructured to introduce two new adapter patterns: \PositionReader\ and \StreamReader\. \PositionReader\ allows services to implement reading via a \PositionRead\ trait, which opens a read handle lazily (using \OnceCell\) and supports random access via \read\_at\, improving efficiency for services that support positioned I/O. \StreamReader\ wraps services that natively support range streams, providing a complete \oio::Read\ implementation by opening a stream for the requested range. These changes replace the previous monolithic read handling, enabling more flexible and efficient data retrieval strategies depending on the underlying storage capabilities.

core/core/src/raw/oio/read · high confidence

The core library has been reorganized into a new module structure, exposing public APIs under \opendal::layers\, \opendal::raw\, \opendal::services\, and a conditional \opendal::blocking\ module. This change introduces explicit Send + Sync trait implementations for key public types (Entry, Capability, Error, Reader, Writer, Lister, Operator) and includes a test to verify these thread-safety guarantees, ensuring the API is safe for concurrent use.

core/core/src · high confidence

The retry layer has been updated to capture more detailed information during retry attempts. Users can now access additional context via the retry interceptor, allowing for better debugging and monitoring of retry behavior when operations fail temporarily.

core/layers/retry · medium confidence

The OpenDAL .NET bindings have been rebuilt to use a new FFI boundary that enables zero-copy read and write paths, allowing users to parse data directly from native memory without intermediate copying. The \Operator\ now binds to a configurable \Executor\ at construction to manage the underlying runtime. Additionally, a generated \Capability\ struct is now exposed, providing detailed, per-operation feature flags (such as conditional reads, versioning, and metadata support) so applications can accurately detect backend capabilities at runtime.

bindings/dotnet/OpenDAL · high confidence

The SFTP service has been refactored into its own separate crate (core/services/sftp), making it a distinct, independently maintained component. This change introduces support for writing files only if they do not already exist (write\_with\_if\_not\_exists) and enables the copy capability by default, removing the need for the previously optional enable\_copy configuration. Users can now configure the service via the new SftpBuilder and SftpConfig, including endpoint, root, user, key, and known\_hosts\_strategy settings, and register the service using the sftp URI scheme.

core/services/sftp · high confidence

The built-in storage services have been extracted from the core library into individual \opendal-service-\\ crates. The \core/core/src/services\ module now only contains the \Memory\ service, while other services are re-exported by the main \opendal\ facade behind specific \services-\\ Cargo features. Users must enable the appropriate feature flags to access specific storage backends.

core/core/src/services · high confidence

The tracing layer has been refactored to wrap the HTTP transporter and executor, ensuring that HTTP fetch requests and their response bodies are captured within dedicated spans, and that tasks spawned by the executor inherit the current tracing context. This change improves observability by keeping trace spans consistent across asynchronous operations and network calls.

core/layers/tracing · high confidence

The generated documentation for the Python bindings now includes specific Apache Software Foundation branding. A new Jinja2 template adds an Apache trademark notice and a dynamic copyright footer (2022–current year) to the module pages, replacing the previous default layout.

bindings/python/template · high confidence

The WebDAV service has been refactored into its own separate crate (\core/services/webdav\), introducing a dedicated \WebdavBuilder\ and \WebdavConfig\. This change adds support for user-defined metadata via configurable XML namespace prefixes and URIs, and allows disabling automatic parent directory creation (MKCOL) for servers that do not support PROPFIND. Several previously available capability toggles (\enable\_user\_metadata\, \enable\_conditional\_read\, \disable\_copy\) are now deprecated as these capabilities are enabled by default.

core/services/webdav · high confidence

The website has been rebuilt with a new engineering-grade design system (documented in DESIGN\_SYSTEM.md) featuring a precise-blue accent, system fonts, and CSS variables for theming. Under the hood, the project has migrated from Yarn to pnpm, upgraded to React 19 and Docusaurus 3.10.1, and added a local dependency manifest (DEPENDENCIES.node.csv) for license tracking.

website · high confidence

The Java binding JAR now includes standard META-INF files (LICENSE, NOTICE, DEPENDENCIES, and LICENSE-MPL-2.0.txt) that document the Apache 2.0 license, copyright years, and third-party dependencies (colored, option-ext, persy) under MPL-2.0, ensuring proper attribution and compliance for users distributing the library.

bindings/java/src/main/resources · high confidence

A new build script (header.mjs) has been added to automatically prepend the Apache License 2.0 header to the generated JavaScript (generated.js) and TypeScript declaration (generated.d.ts) files. This ensures that all distributed Node.js bindings include the required legal notices without manual intervention.

bindings/nodejs/scripts · high confidence

The chaos testing layer in \core/layers/chaos\ has been fixed to correctly handle an error ratio of 1.0. Previously, setting the error ratio to 1.0 (100% failure rate) would fail; it now reliably injects errors for every read operation as intended, allowing users to test service robustness under maximum failure conditions.

core/layers/chaos · high confidence

Add C binding test framework and suites; Add OCaml binding test suite; Added BDD test for OpenDAL blocking operator in Zig bindings; Added D language bindings tests for the memory backend; Added Java Quickstart example to documentation sources; Added Node.js test infrastructure and utilities; Added PHP binding tests for basic IO and extension validation; Added Ruby binding test suite; Added behavior tests for OpenDAL services; Added behavior tests for the .NET Operator API; Added benchmark comparing OpenDAL performance against standard library filesystem; Added benchmarks for Buffer and ConcurrentTasks using Divan; Added edge test for AWS Assume Role with Web Identity; Added edge test for file write failure on full disk; Added metadata and operation argument benchmarks; Added test fixtures for normal and special-character file paths; Added tests for Dart bindings file and directory operations; Added tests for OpenDAL Lua binding operators and metadata; Added tests for RetryLayer input validation; Added unit tests for the .NET OpenDAL binding; Comprehensive C++ binding test suite with async support; Comprehensive behavior tests for Python bindings; Expanded Java binding test coverage for operator lifecycle, layers, and I/O streams; Go binding behavior tests added; Initial test suite for the Haskell binding; Java binding behavior tests split into dedicated async operation suites; New fuzz testing targets for Operator, Reader, Writer, and Path operations; New integration tests and documentation for dav-server, object\_store, and parquet integrations; Node.js binding test suite expansion.

This change introduces dependency manifests and build configurations for new language bindings, specifically adding the Moonbit binding and initializing the Go binding with its module files and examples. It also updates the .NET binding example to target .NET 8.0 and .NET 10.0, and adds a new Python script for weekly updates with dependencies on OpenAI, python-dateutil, pytz, and requests. Additionally, it updates the Lua binding rockspec and refreshes the Go module dependencies to include purego v0.10.1, jupiterrider/ffi v0.7.0, and golang.org/x/sys v0.46.0.

(dependencies) · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 60 → 62 (+2.0)
• Rubric changed (rubric-2026.09.11 → rubric-2026.09.18) — scores are not directly comparable.

• Code Health 70 → 70 (-0.2)
• Architecture 99 → 99 (+0.1)
• Maturity 86 → 86 (-0.1)
• Readiness 56 → 56 (+0.0)
• Security 53 → 64 (+11.9)
• Domain Modelling 91 → 88 (-2.8)
• Performance 73 → 62 (-10.5)

• Change coupling: backend.rs ↔ backend.rs (core/services/cloudflare-kv/src/backend.rs)
• Change coupling: backend.rs ↔ backend.rs (core/services/cloudflare-kv/src/backend.rs)
• Change coupling: backend.rs ↔ backend.rs (core/services/mysql/src/backend.rs)
• Change coupling: backend.rs ↔ backend.rs (core/services/mysql/src/backend.rs)
• Change coupling: lib.rs ↔ lib.rs (core/layers/concurrent-limit/src/lib.rs)
• Change coupling: lib.rs ↔ lib.rs (core/layers/concurrent-limit/src/lib.rs)
• Change coupling: lister.rs ↔ lister.rs (core/services/azblob/src/lister.rs)
• Change coupling: lister.rs ↔ lister.rs (core/services/azblob/src/lister.rs)
• Change-coupling hub: backend.rs → backend.rs, backend.rs, backend.rs, backend.rs (core/services/azblob/src/backend.rs)
• Change-coupling hub: backend.rs → uri.rs, backend.rs, backend.rs, backend.rs, backend.rs, backend.rs (core/services/s3/src/backend.rs)
• Documentation: no usage examples (website/README.md)
• High: security finding (details withheld)
• High: security finding (details withheld)
• Hotspot: core/core/src/layers/correctness_check.rs (core/core/src/layers/correctness_check.rs)
• Hotspot: core/core/src/layers/simulate.rs (core/core/src/layers/simulate.rs)
• Hotspot: core/core/src/raw/oio/list/flat_list.rs (core/core/src/raw/oio/list/flat_list.rs)
• Hotspot: core/layers/fastmetrics/src/lib.rs (core/layers/fastmetrics/src/lib.rs)
• Hotspot: core/layers/metrics/src/lib.rs (core/layers/metrics/src/lib.rs)
• Hotspot: core/layers/observe-metrics-common/src/lib.rs (core/layers/observe-metrics-common/src/lib.rs)
• Hotspot: core/layers/otelmetrics/src/lib.rs (core/layers/otelmetrics/src/lib.rs)
• …and 19 more

• Change coupling: backend.rs ↔ backend.rs (core/services/cloudflare-kv/src/backend.rs)
• Change coupling: backend.rs ↔ backend.rs (core/services/cloudflare-kv/src/backend.rs)
• Change coupling: backend.rs ↔ backend.rs (core/services/mysql/src/backend.rs)
• Change coupling: backend.rs ↔ backend.rs (core/services/mysql/src/backend.rs)
• Change coupling: lib.rs ↔ lib.rs (core/layers/concurrent-limit/src/lib.rs)
• Change coupling: lib.rs ↔ lib.rs (core/layers/concurrent-limit/src/lib.rs)
• Change coupling: lister.rs ↔ lister.rs (core/services/azblob/src/lister.rs)
• Change coupling: lister.rs ↔ lister.rs (core/services/azblob/src/lister.rs)
• Change-coupling hub: backend.rs → backend.rs, backend.rs, backend.rs (core/services/azblob/src/backend.rs)
• Change-coupling hub: backend.rs → uri.rs, backend.rs, backend.rs, backend.rs, backend.rs (core/services/s3/src/backend.rs)
• Critical CVE: [GHSA redacted] (.github/scripts/weekly_update/uv.lock)
• Documentation: no contributor guidance (bindings/go/README.md)
• Duplicated block (10 lines × 2) (bindings/go/copier.go)
• Duplicated block (10 lines × 2) (bindings/go/reader.go)
• Duplicated block (10 lines × 3) (bindings/go/metadata.go)
• Duplicated block (10 lines × 4) (bindings/go/reader.go)
• Duplicated block (10 lines × 6) (bindings/go/copier.go)
• Duplicated block (11 lines × 2) (bindings/go/stat.go)
• Duplicated block (12 lines × 2) (bindings/go/presign.go)
• Duplicated block (12 lines × 2) (bindings/swift/OpenDAL/Sources/OpenDAL/Operator.swift)
• …and 61 more

• 28 commits — 17 feature/other, 11 fixes

• core/services — 5 commits
• .agents/skills — 4 commits
• .github/workflows — 4 commits
• bindings/python — 4 commits
• .github/services — 3 commits
• bindings/dotnet — 3 commits
• core/core — 2 commits
• scripts/release_impact.py — 1 commit
• scripts/release_lifecycle.py — 1 commit
• scripts/verify.py — 1 commit

• fix: fix(ci): mount repository root for Dart cross builds (#8305)
• fix: fix(ci): publish dotnet packages only from final release tags (#8311)
• fix: fix(core): disable prefetch for concurrent writes and copies (#8327)
• fix: fix(release): enable automatic resolution and deduplicate failure notices (#8303)
• fix: fix(release): include unlabeled PRs and preserve version titles (#8308)
• fix: fix(release): publish approved source before optional distributions (#8304)
• fix: fix(release): sync lifecycle through discussion comments (#8297)
• fix: fix(release): validate declarations and published state correctly (#8322)
• fix: fix(scripts): show release verification build output (#8317)
• fix: fix(services/goosefs): reject unknown write_type instead of defaulting to MUST_CACHE (#8294)
• fix: fix(services/oss): prefer OIDC credentials over ECS metadata (#8339)
• change: Add BufferCursor, an implementation of Read + Seek for Buffer (#8320)
• change: chore: sync released versions for 0.59.2 (#8307)
• change: chore: sync released versions for 0.59.3 (#8334)
• change: ci(s3): set MinIO anonymous policy via aws instead of mc (#8295)
• change: ci: classify current issues and pull requests with Qwen (#8312)
• change: ci: prepare weekly releases on Thursday UTC (#8335)
• change: ci: use an allowed 1Password action version (#8299)
• change: docs: add Anaconda main installation for Python (#8328)
• change: feat(bindings/dotnet): add Exists and Check (#8337)
• …and 8 more

• Containers 0 added · 0 removed · contexts 3 added · 0 removed · edges 1 added · 0 removed

• opendal
• opendal-spring
• python

• opendal-spring → opendal

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

apache/opendal was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.