Now in Beta

Core pub/sub and API gateway are stable.

A digital twin for your financial stack

Mirror every trade, stream, and exchange in a live event-driven simulation. Test strategies against production data — without production risk.

Explore the Docs Contact Us
Who This Is For

For teams that build their own strategies

Quantitative developers and small trading firms who write their own algorithms — and are tired of rebuilding exchange integrations, stitching together vendor tools, and maintaining parallel production and backtest stacks.

The Problem

Trading infrastructure hasn't kept up

Most teams are running a fragile patchwork of vendor services held together by bespoke code and institutional knowledge.

Vendor lock-in

Every exchange, broker, and data feed speaks its own protocol. With Virtufin, only the edge is venue-specific: a WebSocket connection plus a market-data worker that maps the venue's messages onto shared contracts. Strategies, indicators and executors don't change when you switch venues.

Brittle glue code

The contract between services lives in Slack threads and Postman collections. Virtufin bakes the contract into a published specification — every service knows the rules.

Year-long integrations

Adding a new exchange, strategy language, or transport is a six-month project. Virtufin makes it a configuration change. The platform handles the rest.

The Solution

One event stream. Two realities.

The same live market data that drives your production stack also feeds a parallel simulation environment — your digital twin.

Production Live trades
Events
Simulation Backtests

Zero-risk experimentation

Every market event flows through a single pub/sub fabric. Each event belongs to a world — act for the live market, hyp.<name> for a named hypothetical one — and each strategy run to a scenario (sc.<id>), so production and simulation never collide.

  • Paper-trade a new strategy on the live feed against a simulated executor
  • Run shadow-mode: compare a strategy's orders with live execution
  • Swap exchanges or brokers without touching strategy code
  • Every scenario's events carry its id and worlds in the envelope
Capabilities

Built for scale from day one

Virtufin is not a framework. It's a platform — pluggable, language-agnostic, and governed by a published specification.

01

Polyglot strategies

Write workers in .NET or Python, or in C, C++ or Rust as a shared library against the native C ABI. .NET and native workers run inside the worker runtime process; Python and C# source workers run in a child process.

02

Exchange-agnostic

Binance and Alpaca today, any WebSocket-based feed tomorrow. Adding a venue means three small pieces: a WebSocketManager connection, a naming fragment for its topics, and a market-data worker that decodes its messages into the shared candle, trade and order-book contracts. Everything downstream consumes those contracts unchanged.

03

Backtesting & paper trading

All inter-service traffic flows as CloudEvents on a Dapr pub/sub bus. A scenario puts the market, portfolio and strategy each in the live world or a named hypothetical one, so a strategy can trade against a simulated executor without touching production.

04

Real-time observability

Every order, fill, and signal emits a structured event. OpenTelemetry traces every call through the gateway. No black boxes. No mystery latency.

Ready to mirror your markets?

Start with the docs, deploy a sample worker, and see your first digital twin. Needs Dapr and the .NET SDK.

Get Started Contact Us