Recently, Voyager has demonstrated its capability to handle more than 21 million account-to-account transfers each second during benchmarks. This figure represents actual on-chain throughput where payments are sent randomly across a network of 100 million accounts.
This impressive claim has led many to inquire about how such extraordinary throughput is feasible. This article delves into the design philosophy and architecture of Voyager, which facilitates its remarkable scalability.
Design Philosophy and Core Components
The fundamental design principle of Voyager is to explicitly declare and minimize dependencies among components. Components operate independently without calling each other or sharing mutexes, coordinating solely through a shared ring buffer. Consequently, coordination overhead is nearly eliminated, with the overall throughput determined by the slowest component in the pipeline.
This decoupling allows for optimization tailored to each component's specific tasks.
- I/O-intensive components batch their operations, distributing the cost of each system call or network write across numerous slots.
- CPU-bound components utilize data structures designed for optimal memory layout to maximize efficiency on individual cores and their caches.
The core components of Voyager include:
- a ring buffer inspired by the LMAX Disruptor
- a high-speed state transition function (STF)
- batched disk and network input/output
- backpressure mechanisms to maintain memory limits when a processing stage lags
Among these components, the STF of Voyager stands out. While many blockchain scaling solutions parallelize execution, Voyager employs a single-threaded approach for its STF. By caching pertinent data and utilizing out-of-order execution, this single thread can manage substantial throughput.
Let's explore the architecture of these components in further detail.
From a User’s Wallet to a Voyager Node
The payment process begins in the user's wallet, which signs the transaction and forwards it to an ingress service. The ingress service verifies transaction signatures, batches valid transactions, and sends them to Voyager. Ingress nodes are stateless, allowing for an increase in capacity as traffic demands grow. This enables verification capability to scale independently of transaction execution.

The Challenges of I/O Batching and Backpressure
Within Voyager, transactions enter a mempool for deduplication before being processed in the “disruptor,” a ring buffer that manages execution, storage, and publication.

In the disruptor, each slot starts empty and is processed in stages. Initially, a “producer” task selects the next batch of transactions from the mempool and writes it to the next available slot. Following that, the journal and STF engage; the journal securely records transactions for crash recovery, while the STF executes them.
As execution occurs, the disruptor slot is populated with transaction results and lists of state changes. Post-execution, the database writer saves state changes to a remote database, while a publisher transmits transaction data to Celestia Fibre. Finally, a “pruner” task deletes transactions from the local database once successful publication is confirmed.
Each task processes data sequentially, yet the entire process is pipelined. For instance, the journal may be recording batch 103 while the STF executes batch 102, with the database writer and publisher handling batch 101 simultaneously.
Batching and Backpressure
Voyager manages batching at two levels. Each ring slot contains multiple transactions, and consumers can combine up to 128 slots before flushing their operations. This arrangement distributes the costs of journal synchronization (fsync), database submissions, and data availability publication across numerous transactions. When less work is available, consumers will process smaller groups.
The ring, which holds a default of 4,096 slots, provides the pipeline with the capacity to absorb temporary slowdowns. If storage lags behind execution, pending batches occupy additional slots. Once all reusable slots are filled, upstream processing halts until consumers make progress. This is known as backpressure: slower stages restrict incoming work to prevent unbounded memory growth.
The capacity of the ring and the size of groups can be adjusted. A larger ring can accommodate prolonged slowdowns, albeit at the expense of increased memory usage.
The Work Behind Each Transaction
The disruptor ensures that the stages remain coordinated with minimal copying or synchronization overhead, yet it operates at the speed of the slowest stage. To maintain 21 million TPS, each stage requires meticulous design for optimal performance.
Journal: preserving inputs for recovery
The journal logs batches of transactions, allowing Voyager to reconstruct work not yet committed to the database following a crash.
Writing every transaction demands significant disk bandwidth, and waiting for durable writes introduces additional delays. We streamline the write path by appending records sequentially and then synchronizing a group with fsync. The journal consumer progresses only after successful synchronization, distributing that overhead across numerous transactions.
STF: transforming transactions into state changes
The state transition function verifies balances, processes transfers and fees, and generates state changes. Achieving high performance amid unpredictable transaction workloads presents a core challenge in blockchain performance engineering.
Recently, the prevailing strategy to enhance blockchain speeds has been to increase parallelism. In contrast, Voyager adopts a single-threaded execution model, which significantly contributes to its speed.
The key insight driving Voyager’s distinctive STF is that CPU resources are not necessarily the bottleneck; instead, memory access is the primary limiting factor. When data is loaded from memory, adding more cores can hinder performance rather than enhance it. Concurrent memory access requests from different threads can lead to pipeline stalls.
Through out-of-order execution, a single CPU can manage multiple memory accesses simultaneously while processing data already cached. To optimize CPU efficiency, it is crucial to ensure that necessary data remains in the cache. This requires:
- Keeping access patterns predictable: All data dependencies are anticipated well before execution.
- Minimizing contention: All state data is managed by a single STF thread, completely eliminating locking overhead and cache coherence traffic.
- Reducing the working set: Voyager’s data structures are designed to fit neatly into cache lines, maximizing the amount of useful data retained near the CPU.
- Prefetching data ahead of time: Voyager retrieves data as much as 32 transactions before the CPU needs it.
Under sustained loads, the STF of Voyager operates at 96–100% utilization on a single CPU core. Minimizing unnecessary lookups and memory stalls enables more effective work extraction from that core.
DA publisher: enabling independent verification
The DA publisher makes transaction inputs accessible for other participants to independently verify execution. It uploads data to Celestia Fibre, which distributes erasure-coded blob shards among validators.
Publishing batches of transactions spreads the overhead of network requests across numerous transactions. Publication occurs after journaling and proceeds concurrently with execution and database writes.
Database writer: ensuring state changes are persisted
The database writer communicates the STF’s state changes to Stargazer, our custom state storage engine, for persistence. The stored balances facilitate queries and serve as a durable basis for planned recovery paths.
Similar to the DA publisher, the database writer batches submissions to minimize network overhead, waiting for both journaling and execution to conclude before sending a batch’s changes.
Journal pruner: safely reclaiming space
The journal pruner prevents recovery records from consuming excessive disk space. Premature deletion could discard inputs still required by downstream stages.
Before permitting record removal, it verifies the progress of downstream consumers, DA confirmation, and the storage persistence watermark. These checks determine the extent to which pruning can advance safely.
Stargazer Distributes Storage Work
Stargazer is a custom state storage engine developed to operate on a separate machine and receive state-diff batches over the network. Similar to Voyager, Stargazer is organized around a central disruptor for optimal performance, where the journal stage is succeeded by parallel database shard writers.

We implement sharding to allocate state across multiple RocksDB databases, each located on separate disk volumes. Each shard writer processes the shared batches but applies only the changes assigned to its specific shard.
Stargazer reports a committed height only after all shards have reached it. Its pruner awaits all shard writers before progressing. If storage falls behind, the bounded ring and ingress queue propagate backpressure back to Voyager.
Benchmarks
We evaluated Voyager with a dataset of approximately 100 million accounts, executing 400 billion transfers across multiple runs. The following charts are derived from our Grafana dashboards for one of these runs.
These benchmarks assess the Voyager node itself, including execution, journaling, data publication, and storage. The load generator directs transactions straight to the node, bypassing ingress, thus excluding signature verification from these figures. As ingress is horizontally scalable, verification capacity can be independently increased. Transactions still carry full-size signatures, ensuring the journal and DA publisher handle realistic data volumes.



What Comes Next
Voyager remains a work in progress. While we are pleased with the throughput of the hot path, several critical components are still in development.
Firstly, the current benchmarks do not include Merkleizing the state. Similar to Solana, we intend to compute state roots slightly less frequently than for each block. This design will ensure that state root computation does not obstruct transaction processing, although this may introduce some additional latency for light clients.
Secondly, while we currently maintain the data required for replay and replication, the logic for recovery after a restart and replication to other nodes is yet to be implemented. Developing and testing these pathways is a priority.
Lastly, our benchmarking has been conducted on a working set small enough to fit within the RAM of a single machine. We have designed the necessary logic to scale well beyond RAM limits and are confident this will not pose a significant bottleneck, although the implementation remains incomplete.
As all state resides on one executor, the foundational engine of Voyager is not restricted to payments. Our next step is making execution pluggable, allowing the same pipeline to handle exchanges and various other applications at scale. While Voyager is primarily designed for payments, future iterations will support a wide range of market functionalities.

Beyond 21 Million TPS
Storage throughput can be enhanced by sharding journal and database writes across additional disks. The benchmark of approximately 3 Tb/s for Fibre indicates considerable potential for data publication growth.