Wingfoil, the ultra low latency graph based data streaming framework built in Rust, launches a new version (9.0.0.) today with two new big developments:
- A significant rebuild of the streaming engine; and
- A new feature we call Wingfoil Nitro that now allows users to compile sections of a graph or even whole graphs to reduce the latency even further.
Both of these developments deliver significant improvements in latency and performance while maintaining reliability.
A new, faster interpreted streaming engine
Wingfoil uses a Directed Acyclical Graph (DAG) to efficiently coordinate the execution of its nodes, so application developers implement logic to wire up their graph of calculations which Wingfoil’s graph engine then executes. Our new rebuilt interpreter is significantly faster than the engine it replaces reducing the cost per node from ~22ns per node to ~12ns (for more details see benchmarks section below).
Wingfoil Nitro – compiling graphs for even greater performance
No matter how much the interpreter is optimised, ultimately it will always add some overhead. Which is why we are also releasing Wingfoil Nitro – a feature that allows you to compile a graph or parts of a graph and therefore remove the interpreter overhead.
Wingfoil Nitro is much faster again, drop per node latency from roughly ~12ns per node in the rebuilt interpreter to ~0.35ns per node.
This means that Wingfoil 9.0.0. is faster, giving you the option of creating your graph with three ways to run it – fully interpreted, fully compiled, or a mix of the two, with compiled ‘islands’ inside an interpreted graph.
You still need an interpreted graph for the most general cases: waker scheduling (for async and worker-thread I/O patterns), graph dynamism, and so on. But now you can embed islands of nitro graphs within your larger, interpreted graph. In practice we find that the most common pattern is running a mixed graph.
And Nitro works seamlessly with the wider Wingfoil framework: this is one graph definition, not two systems. If you write the same fluent wiring code, you get an identical output however you run it.
All of this means you can stilll backtest on the same graph. Another key benefit of Wingfoil.
Summary
The latest release of Wingfoil is an important step forward, with the interpreted engine getting significantly faster and compiled graphs allowing for even more performant ultra-low latency stream processing. It’s also flexible so you can create modular graphs that combine interpreted sections and compiled sections, which run seamlessly together in the same framework. Backtesting remains simple and there’s none of the drift you’d experience if you use different systems.
About Wingfoil
Wingfoil is an ultra-low-latency stream processing framework built in Rust. It allows the user to describe a directed graph of transformations once and run it against live data or replayed history with identical semantics either way. Wingfoil has a wide range of I/O adapters including Kafka, ZeroMQ, KDB+, Redis, Postgres, FIX and Aeron, a statistics library, dynamic graph mutation, thread offload and Python bindings. For more visit:
