Adapting the Actor Model of Concurrency for High-Frequency Trading: Synchronous Message Delivery (fast_send) and a Tick-to-Book Latency Study

Adapting the Actor Model of Concurrency for High-Frequency Trading (arXiv:2609.21173v1) argues that the actor model is suitable for high-frequency trading (HFT) when actors are co-located, challenging the traditional view that its overhead is incompatible with microsecond latency budgets. The paper introduces kaspar-hft, an open-source C++20 framework that reduces per-message overhead to under 1% of the decode-and-book floor through four key adaptations:

• fast_send: A synchronous delivery mechanism where the sending thread runs the receiver’s handler inline, eliminating queue operations and context switches while maintaining receiver transparency.
• Actor Groups: Co-scheduling a set of actors on one thread behind a single shared mailbox to collapse multi-actor pipelines into a single thread execution path.
• Selectable Mailbox Queues: Providing four queue implementations selectable per actor to match specific write patterns, optimizing for latency versus throughput.
• Memory Pool: Removing per-message heap allocation overhead by using stack allocation for synchronous requests and a pooled allocator for messages that must outlive the call.

Live testing on CME market data for ES, NQ, and ZN futures showed that the framework’s contribution to socket-to-book latency was under 1% of the ~7 microsecond decode-and-book floor, with the latency tail attributed to the market’s arrival process rather than the messaging layer.

The paper examines whether the actor model can be made practical for high-frequency trading (HFT) systems, which typically demand microsecond-scale latency and minimal per-message overhead. It challenges the common objection that actors are inherently too heavyweight—because of thread dispatch, per-actor mailboxes, heap-allocated messages, and context switches—by introducing fast_send, a synchronous message-delivery mechanism designed to fit the latency budget of HFT workloads. The study then evaluates this adaptation using a tick-to-book latency measurement, i.e., the end-to-end path from market-data arrival to the update of the local order book.

Its main contribution is a performance-oriented variant of actor concurrency that preserves much of the model’s conceptual appeal—state isolation, data-race freedom, and simpler single-message reasoning—while reducing the runtime costs that usually disqualify it from HFT. By making message delivery synchronous and tightly integrated with the critical path, the work shows that actor-style isolation does not necessarily have to imply the asynchronous, allocation-heavy execution model often assumed in general-purpose actor systems. The tick-to-book study provides empirical evidence for how much of the traditional actor overhead can be removed or bypassed in a latency-sensitive setting.

This matters because HFT systems sit at the intersection of extreme performance requirements and the need for reliable, maintainable concurrency. If actor-style abstractions can be adapted without sacrificing latency, they could offer a more disciplined alternative to hand-tuned lock-free or thread-affine designs. The paper is therefore relevant not only to HFT engineering, but also to systems research on low-latency concurrent programming, where the central tension is between strong reasoning guarantees and minimal runtime overhead.