A complete electronic exchange in modern C++20, built from scratch: deterministic matching engine, sequenced binary market data feed (VITCH), binary order-entry gateway (VOUCH), NASDAQ ITCH 5.0 replay, an ecosystem of algorithmic trading agents, and a live web visualization of the running market.

Live capture of ./scripts/demo.sh flash_crash: all market makers are killed at T+60s — the spread blows out from 4 to ~40 ticks and momentum takers punch holes in the thinned book — then the MMs return at T+120s and the market heals. Nothing staged: this GIF is 71 real frames of the running system.

Everything interesting is hand-rolled — that's the point. The only third-party C++ dependencies are Catch2 (tests) and Google Benchmark. No Boost. The book, the pools, the hash tables, the ring buffers, the wire protocols, the histograms: all here, all tested, all measured.

Every number above was measured on the stated hardware with the stated commands; raw outputs are committed under bench/results/. Unmeasured things are labeled unmeasured.

  itch replayer / agents (python + c++)
        |
        v
  gateway (TCP, VOUCH) ---> [SPSC ring] ---> MATCHING CORE (one thread, deterministic)
        ^                                        |
        |                                        v  events
        +--------------- [SPSC ring] <-----------+
                                                 |
                                                 v
                             feed publisher (VITCH over UDP, unicast fan-out)
                                   |                    |
                                   v                    v
                          bookbuilder (C++)      Node WS bridge --> React viz

Concurrency exists only at the edges: one epoll I/O thread and one feed I/O thread meet the matching thread at single-producer/single-consumer rings. The core never reads a clock, never allocates, never iterates a hash table — same input stream, byte-identical output stream, forever.

Requires Linux (developed on WSL2 Ubuntu 24.04): g++ 13+, CMake 3.25+, Ninja, Python 3.11+ with PyYAML, Node 20+.

# On a fresh Ubuntu/WSL2 box:
sudo apt install build-essential g++-13 cmake ninja-build python3-yaml nodejs npm

git clone https://github.com/vineetsista/vsx.git && cd vsx
cmake --preset release && cmake --build --preset release
ctest --preset release                     # full suite (200k-op fuzz default)
VSX_FUZZ_OPS=10000000 ctest --preset release -R fuzz   # the CI-sized 10M-op gate
./scripts/demo.sh flash_crash              # the show: open http://127.0.0.1:5173

Other presets: debug, asan (ASan+UBSan — the whole suite runs clean under both), bench (adds Google Benchmark targets; run via ./scripts/bench.sh, which refuses to measure on a loaded machine).

Real market data (optional, ~3.3GB): ./scripts/fetch_itch.sh, then

zcat data/12302019.NASDAQ_ITCH50.gz | build/release/itch/vsx_itch_replay replay - AAPL,MSFT,TSLA

• docs/WALKTHROUGH.md — a guided ~2-hour tour through the six files that matter most, in reading order.
• docs/INTERVIEW_DRILL.md — 40 interviewer-style questions with answers referencing file:line.
• DECISIONS.md — the engineering decision log: every non-obvious call, its rationale, and what was rejected.
• BENCHMARKS.md — methodology-first performance numbers, v1 and the post-profiling v2, including the regressions.
• docs/protocols/VITCH.md / VOUCH.md — the wire specs, written before their implementations.

• One box, one instance. No redundancy, no failover. There IS now write-ahead journaling with crash recovery (--journal, added in v1.1: replay the op log through a fresh engine, resnapshot the feed), but durability is batch-flush not per-op fsync — the crash window is the OS page cache. No cross-machine replication.
• WSL2 tails. Every max-latency figure in this repo includes hypervisor descheduling; p50/p99 are meaningful, maxima are the machine's.
• The engine-vs-baseline gap widens with depth, now measured (v1.1): 1.8x at 8 levels, 2.85x at 4096 (BENCHMARKS.md v3). The engine is depth-independent; std::map degrades as its tree deepens. The oft-quoted "only 1.3–1.5x" is the shallow-book number.
• ITCH replay is intent reconstruction: the original taker orders are not in the stream, so E/C become synthetic IOCs. FIFO fidelity is 99.87% per event; end-of-day level agreement 96.7% — the honest ceiling without hidden-liquidity data, with the divergence counted, not hidden.
• Toy auth on VOUCH (any user, password "vsx"), no TLS, no cancel-on-disconnect (a deliberate, documented default). Session replay-on-reconnect is spec'd but not built.
• Scenario "determinism" is seeded macro-phenomena (the crash reproduces from seeds; observed 40- and 38-tick blowouts back to back), not byte-identical tapes — sockets and threads see to that. Engine-level determinism is the strong claim and is enforced byte-for-byte.
• The spoofer is a labeled specimen; a heuristic layering detector now watches for its pattern in the viz (v1.1, viz/bridge/surveillance.mjs) and flags it live, but it is pattern-based (no participant identity in the feed) and surfaces false positives honestly — an alert flags for a human, it does not convict. It never touches anything but this closed synthetic market.