Posted on Jul 17 • Originally published at aerospike.com

Aerospike Rust client preview: Introducing a native integration for high-performance systems

Brian Porter - Principal Product Manager, Database

Explore Aerospike's new official Rust client, built for memory-safe, low-latency systems. See features, roadmap, and how to start integrating today.
_

Developers building high-throughput, low-latency applications in Rust now have access to a high-performance client developed and maintained by Aerospike with the preview release of its official Rust client. This milestone represents more than just a new client library; it marks a shift from a community-supported project to one that business leaders can feel safe adopting.

Driven by increasing demand from our developer community and the rapid adoption of Rust for performance-critical, memory-safe systems, this release enables Rust developers to integrate Aerospike into their applications, all while preserving the consistency, speed, and reliability that define our platform.

Why Rust: Strategic alignment with developer needs

Rust is increasingly used across industries such as finance, telecommunications, cloud infrastructure, and embedded systems. It has become the preferred choice for performance-critical systems development. Organizations such as Amazon, Cloudflare, and Discord have adopted Rust to build reliable infrastructure and eliminate classes of memory-related bugs that commonly affect C/C++-based software.

Its popularity is driven by a combination of performance and reliability characteristics that are a natural fit for Aerospike applications:

No garbage collection: Rust’s lack of a garbage collector helps eliminate latency outliers, a key requirement for real-time systems.
Compile-time memory safety: Rust’s memory safety model reduces crash potential by catching common security vulnerabilities at compile time.
Safe concurrency support: Rust prevents data races by enforcing thread safety at compile time, helping high-concurrency applications scale better.
Modern tooling and developer experience: Over 100,000 Rust crates exist today, providing straightforward integration with Kafka, gRPC, observability tools, and more, forming a mature ecosystem.

Rust client capabilities

Rust Preview highlights include:

Execution models:

Async-first: Built for non-blocking IO, powered by Tokio by default, with optional support for async-std
Sync support: Blocking APIs available using a sync sub-crate for flexibility in legacy or mixed environments

Advanced data operations:

Batch protocol: Full support for read, write, delete, and UDF operations through the new BatchOperation API
New query/scan support: Implements updated query protocols for improved consistency and performance, allowing pagination and limiting the number of returned records

Policy and expression enhancements:

Replica policies: Includes support for Replica, including PreferRack policy
Policy additions: New fields such as allow_inline_ssd, respond_all_keys in BatchPolicy, read_touch_ttl, and QueryDuration in QueryPolicy
Rate limiting: Supports records_per_second for scan/query throttling

Data model improvements:

Type support: Adds support for boolean particle type
New data constructs: Returns types such as Exists, OrderedMap, and UnorderedMap, now supported for CDT reads
Value conversions: Implements TryFromAerospike::Value for type interoperability
Infinity and wildcard: Supports Infinity, Wildcard, and corresponding expression builders expressions::infinity() and expressions::wildcard()
Size expressions: Adds expressions::record_size() and expressions::memory_size() for granular control

Take a look at the changelog for more details.

The client has been built from the ground up to integrate easily with today’s Rust frameworks and async runtimes. Support for the Tokio async runtime, standard Rust crates, and idiomatic usage patterns are all part of the design.

Release timeline

The client is currently available as a preview release, with support for foundational operations. The general availability (GA) release is planned for later in 2025 and will include:

Full feature parity with other official Aerospike clients (e.g., Go, C#, Java)
Community feedback-driven improvements

The preview release is available on GitHub, and we encourage developers to experiment, provide feedback, and report issues.

Designed for the community
Aerospike developed this client because we listened to our developer community. Requests for async support, tighter performance tuning, and alignment with Rust’s ecosystem have been recurring themes in our forums and GitHub discussions. The new client is a direct response to that input.

By releasing this client under an open license and hosting it on GitHub, we aim to foster ongoing community engagement. Contributions, feature requests, and feedback will help shape the GA version and future enhancements.