Celestia has announced that its Voyager blockchain architecture has 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, highlighting the potential of application-specific blockchain architectures to support high-volume financial operations.
The performance milestone reflects an architectural approach focused on reducing coordination overhead, improving processor efficiency, and optimizing transaction processing across multiple system components. Rather than relying on conventional parallel execution methods, Voyager uses a coordinated processing pipeline designed to minimize dependencies between individual components.
The Voyager architecture achieved sustained throughput exceeding 21 million transfers per second across 100 million accounts, demonstrating a potential approach to scaling blockchain infrastructure for high-frequency payment applications.
Ring Buffer Architecture Reduces System Coordination
Voyager’s performance is based 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 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 notable design decisions is its use of a single-threaded state transition function (STF), which differs from blockchain architectures that depend heavily on parallel transaction execution.
The STF performs 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 uses a single processing thread to maintain predictable memory access patterns. This approach is intended to avoid performance degradation caused by multiple threads competing for shared memory resources.
The system also uses 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 accessing 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. This allows different transaction batches to move through separate stages simultaneously rather than requiring the entire system to complete one operation before beginning another.
The architecture also 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.
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
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.
Celestia‘s 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. 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 benchmark 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 to improve blockchain scalability, particularly for payment applications requiring extremely high transaction capacity.
