Celestia, the project behind the modular data availability network of the same name, has announced that its Voyager blockchain architecture demonstrated the ability to sustain more than 21 million account-to-account transfers per second (TPS) during performance testing involving 100 million accounts. The benchmark was achieved using randomly generated payment transactions, a result the project says highlights the potential of application-specific blockchain architectures to support high-volume financial operations.

The milestone reflects an architectural approach centered on reducing coordination overhead, improving processor efficiency, and optimizing transaction processing across multiple system components. Rather than relying on conventional parallel execution methods, Voyager employs a coordinated processing pipeline designed to minimize dependencies between individual components, presenting a potential path to scaling blockchain infrastructure for high-frequency payment applications.

Ring Buffer Architecture Reduces System Coordination

Voyager's performance rests on a design philosophy that separates system components and minimizes direct dependencies between them. Instead of allowing components to communicate through shared synchronization mechanisms or mutex locks, the architecture uses a common ring buffer adapted from the LMAX Disruptor model. The LMAX Disruptor is an open-source inter-thread messaging library originally developed for LMAX Exchange, a financial trading platform, to sustain high transaction throughput with low latency.

The ring buffer acts as a coordination mechanism through which different processing components exchange transaction data. This arrangement reduces the need for frequent synchronization between threads and helps limit coordination-related performance bottlenecks.

The architecture also follows a performance model in which overall system throughput depends on the slowest processing component. By minimizing unnecessary interactions between components, Voyager aims to improve operational efficiency and make performance bottlenecks easier to identify.

Its main architectural elements include the shared ring buffer, a single-threaded state transition function, batched disk and network operations, and backpressure mechanisms designed to control memory consumption.

Single-Threaded Processing Improves CPU Efficiency

One of Voyager's most notable design decisions is its use of a single-threaded state transition function (STF), which departs from blockchain architectures that depend heavily on parallel transaction execution. The STF performs the essential operations involved in updating blockchain state, including checking account balances, applying transfers, and generating the resulting state changes.

Rather than distributing these operations across multiple execution threads, Voyager runs them on a single processing thread to maintain predictable memory access patterns. The approach is intended to avoid the performance degradation that occurs when multiple threads compete for shared memory resources.

The system also leverages processor-level out-of-order execution and data caching to improve computational efficiency. These techniques allow the processor to execute instructions more effectively while reducing delays associated with retrieving frequently required information.

By limiting competition between processing threads, Voyager seeks to maintain consistent execution performance even when handling extremely large transaction volumes.

Pipelined Processing and Batch Operations

Voyager organizes transaction processing into multiple stages, including journaling, execution, database writing, and data availability publication. Each stage operates independently while communicating with other components through the shared ring buffer, allowing different transaction batches to move through separate stages simultaneously rather than requiring the entire system to complete one operation before beginning another.

The architecture incorporates batching at two levels: individual ring buffer slots can contain multiple transactions, while downstream processing components can combine as many as 128 slots before submitting their operations.

Celestia addressed the design rationale in a post on X on November 12, 2026:

Most chains have attempted to scale by parallelizing execution. Voyager takes the opposite approach with the core state transition function running on a single core. This works because the execution isn't the bottleneck, memory access is.

— Celestia (@celestia), November 12, 2026 (https://x.com/celestia/status/2120928085277331607?ref_src=twsrc%5Etfw)

This approach reduces the frequency of resource-intensive activities, including journal synchronization and database submissions. Processing larger batches can lower operational overhead and improve overall throughput.

Voyager also incorporates backpressure mechanisms to prevent excessive memory consumption. When downstream components experience delays, upstream processing is slowed to maintain a manageable workload and prevent system resources from becoming overwhelmed.

Implications for Blockchain Scalability

The reported benchmark highlights the potential of specialized blockchain architectures designed around particular workloads rather than general-purpose execution requirements. High-frequency payment systems require infrastructure capable of processing large transaction volumes while maintaining predictable performance and reliable state updates.

The pipeline's culminating data availability publication stage also ties into Celestia's broader role as a modular data availability network, where keeping transaction data retrievable for verification is a central design concern.

Conventional blockchain architectures can encounter limitations when transaction execution, storage operations, and network communication compete for system resources. Voyager attempts to address these challenges through component separation, coordinated batching, and optimized state processing.

By combining a shared ring buffer, single-threaded state execution, and independent processing pipelines, Celestia's Voyager architecture seeks to reduce computational bottlenecks while supporting exceptionally high transaction throughput.

The reported 21-million-TPS result represents a significant performance milestone for the project. However, practical adoption will also depend on factors such as network conditions, hardware requirements, security, decentralization, and performance under real-world transaction workloads.

The development adds to ongoing efforts across the industry to improve blockchain scalability, particularly for payment applications requiring extremely high transaction capacity.