We propose developing a high-performance Rust client library for Ogmios, enabling fast, safe, and efficient communication with the Cardano node. While a TypeScript client currently exists, there's a growing demand for Rust-based infrastructure, especially for backend applications requiring low latency, high throughput, and robust memory safety.

The library will support all four Ogmios mini-protocols (chain sync, ledger queries, transaction submission, and mempool monitoring). It will be optimized using advanced techniques such as arena allocation, Struct-of-Arrays optimizations, and SIMD parsing, where appropriate. A complete example application and comprehensive test suite (unit, end-to-end, and live network) will ensure usability and reliability.

This project lowers the barrier for Rust developers building on Cardano, improves performance for critical applications (e.g., trading bots, DEXes, mempool tools), and better integrates with Cardano's existing Rust-based serialization ecosystem.

Rust is a performance and safety-oriented programming language with a mature and rich ecosystem, widely adopted in blockchain development for its efficiency, reliability, and control over system resources.

Ogmios is the most popular method for interacting with the Cardano node. Currently, the best-supported client is written in TypeScript, which is appropriate given Ogmios’s WebSocket-based design and alignment with web tooling. However, this leaves a gap for high-performance backend and system-level development, where Rust is increasingly the language of choice.

Providing a native Rust client for Ogmios would directly address this gap. Rust offers:

• Tight control over memory usage while guaranteeing the absence of memory-related bugs;
• Support for rich parallelism and concurrency,
• Low-latency opportunities are crucial for high-performance applications (e.g., trading bots) and generally favorable for any application interacting with the transaction memory pool (real-time transaction processing)
• Reduced infrastructure costs and latency, and increased throughput and robustness of applications.

Additionally, the Cardano serialization library is the state-of-the-art (de-)serialization library written in Rust, and many wallets and libraries (like MeshJs) wrap in through webassembly to expose its functionality to the JavaScript ecosystem. Using a Rust Ogmios client would allow developers to use this library natively, avoiding unnecessary layers and boosting performance.

Choosing Rust for a blockchain application is a common choice and would lower the barrier for developers transitioning from other blockchains.

Team: WingRiders team is composed of experienced professionals in blockchain technology and software development. Our team members stand behind projects like Adalite, Yoroi wallet, Emurgo’s first blockchain explorer/indexer, firmware for hardware wallets Trezor and Ledger (bringing them to Cardano) and WingRiders DEX. Team's mission is to improve the performance of Cardano ecosystem, and thus increase its competitive potential.

We propose building a high-performance Rust client library for Ogmios, supporting all four mini-protocols: Chain synchronization, Ledger state queries, Transaction submission, Mempool monitoring

The implementation will be optimized for performance (arena allocation, structure-of-arrays, SIMD parsing, etc. where appropriate). It will include an example application using all library features, and will be thoroughly tested on preprod and mainnet data.

A. Usecases: This library's intended usage is for New projects written in Rust, Rewrites of performance-critical parts of existing applications, like DEX batchers.

By offering an off-the-shelf, well-tested, and optimized client, we aim to reduce the development burden for teams building low-latency or high-throughput systems. Example applications that will benefit from a Rust Ogmios client:

Mempool visualizers and explorers

• Batched DEXes during congestion
• Non-batched DEXes integrating with mempool
• Trading and monitoring bots
• Big data analysis applications

B. Testing strategy: The client will be tested from day one of development using live Ogmios data to ensure correctness. An example application will be developed alongside the library to showcase all supported features and to make sure the library API makes sense for general-purpose development. The library will have unit-testing and end-to-end testing suites.

Effort estimates include:

• Initial in-depth dependencies and Ogmios research - 10 days
• Figuring out the best data-types representation - 15 days
• Figuring out the allocation strategy - 10 days
• Setting up profiling and benchmarking - 5 days
• Ogmios websocket connection and state management - 5 days
• Exposing the chain synchronization mini-protocol - 3 days
• Exposing the ledger state queries mini-protocol - 3 days
• Exposing the transaction submission mini-protocol - 2 days
• Exposing the mempool monitoring mini-protocol - 3 days
• Optimizing the performance and memory usage - 20 days
• Setting up end-to-end testing - 15 days
• Unit testing - 10 days
• Automated testing bug fixing - 10 days
• Preprod testing - 10 days
• Mainnet testing - 10 days
• Bug fixing - 10 days
• Library API polishing - 10 days
• Example application - 15 days
• Tutorial - 5 days
• Documentation - 15 days
• Marketing - 10 days