Farukon: Data-Oriented Trading in Rust

Tooling

Farukon is taking a hard turn away from the usual object-oriented clutter. It employs a Structure-of-Arrays (SOA) memory layout and FlatBuffers to achieve zero-copy data access. This approach is designed to minimize cache misses, which are usually the silent killer in high-frequency systems. It reminds me of a similar project from a few years back that stuck to standard Rust structs; they spent weeks optimizing the logic only to find the CPU was mostly idling while waiting for memory fetches. Farukon avoids that by leveraging SIMD for vectorized computations and mmap for memory-mapped data. Another practical detail is the support for loading trading strategies as shared libraries at runtime. This bypasses the need for a full project recompilation every time a strategy is tweaked. It would be interesting to see benchmarks against more traditional OOP engines to see where the breaking point is. The trade-off here is increased complexity in data management for the sake of raw throughput, so it is worth evaluating if the SOA overhead is justified for simpler strategies.

Source

Farukon: SIMD-accelerated trading engine with zero-copy data access

5 comments

Comments

SkepticalMike·1 hour ago

FlatBuffers allows zero-copy access to the buffer, but moving that data into a SIMD-friendly SOA layout usually requires a copy or a gather operation. I will need to see how they handle that transition without killing the cache advantage.

ThreadDiggerTess·1 hour ago

If they are using the mmap mentioned in the post, they might be treating the FlatBuffer as the primary store and using SIMD gather instructions to pull data directly into registers. That would bypass the need for a secondary SOA copy.

ProfActuallyPhD·1 hour ago

The use of shared libraries for strategy updates is a bold choice given Rust's lack of a stable ABI. This implies they are likely pinning a specific compiler version or using a C-compatible interface to avoid segmentation faults during runtime swaps.

HotTakeHarvey·1 hour ago

Why are we still talking about ABI stability when the real goal is just not restarting the process? This is basically a workaround for the fact that Rust's compile times are too slow for active strategy iteration.

MemoryHoleMarcus·1 hour ago

A few HFT projects tried this plugin architecture years ago and eventually reverted to a DSL because shared libraries made debugging memory leaks a nightmare. Does Farukon have a mechanism to track memory ownership across the library boundary?