Skip to content
VYRN
VYRN · Order ticketSerial 00000412

Filled within 1 µs of the first bit.

One order book per instrument. 1B messages a second on that one book. BFT-final within 10 ms. A home that moves TYO → LDN → NYC every 8 hours. x86 and off-the-shelf NICs, no FPGA.

Every figure on this page is a design budget unless it says otherwise. No benchmark has run yet.

Read the designThe answer in one document
One New message · 16 bytesLayout: 01 §6.2
Typeb0
New
0x01
Flagsb1
BUY · IOC
0x02
Reservedb2–3
0
0x0000
Tick u32b4–7
104,250
0x0001973A
Qty u32b8–11
300
0x0000012C
Client tag u32b12–15
0xA41F
0x0000A41F

The answer in six lines.

DESIGN.md §0

  1. One core per book is sequential, and it only sees the BBO.

    Price-time priority is only sequential where orders cross. Joins and cancels (~97% of a quote-driven book) go to 49 lane cores that own accounts. Only messages that change the BBO go to one BBO core.

  2. The cut replaces the sequencer.

    No core waits to be sequenced. The BBO core reads every lane's counter and logs that vector. That log is the total order, and replicas replay it bit for bit.

  3. The fill goes out before consensus and does not revert.

    The ordering frame leaves the NIC on two paths before the fill does. A fill reverts only if the leader dies and both paths drop the same frame inside the same 0.5 ms.

  4. BFT finalizes the order, not the state.

    Simplex runs over 1 ms blocks of ordering metadata inside one metro: ~3 ms typical, < 10 ms p99. Fills are a deterministic function of the order, so they are final at the same moment.

  5. The book moves by certificate, not by vote.

    The same 5 operators run nodes in every home. A handoff costs one WAN one-way latency (35–110 ms), and an auction fills that gap. Light sets that floor, not the design.

  6. Rust.

    One deterministic binary for the leader and every replica.

Words on this ticket.

01 §1
ply 1 · ply 2
This page's name for the two copies of every packet: ply 1 goes to the sequencer, ply 2 to a data node (DESIGN §0, line 3).
home

The region whose facilities run the active book: TYO, LDN or NYC.

epoch

One 8-hour period in which one home is active. Numbered by Epoch (u32).

sequencer

The box (process vyrn-seq) that receives orders, matches them, and sends fills. There is exactly one per book per epoch.

lane

A pinned core in the sequencer that owns a fixed shard of accounts: their sessions, risk, and resting orders. Identified by LaneId.

cut

A vector with one LaneSeq per lane. Lane ops at or below the cut are ordered before a step, and later ops after it.

BBO core

The pinned core that executes every step: crosses, improves, depletions and rescans. It is the only writer of fills and of the BBO.

data tier

The vyrn-data processes that receive the client copy of each packet and fan it out to the replicas.

replica

A box (process vyrn-replica) that replays the order stream with the same engine and votes in consensus. In chain mode a replica is a validator (process vyrn-validator).

block

1 ms of order stream with a header. It is the unit of consensus.

certificate

Signatures from a quorum of replicas over a block header, or over a handoff record.

mode

BASE (off-chain, n = 4) or CHAIN (on-chain, n = 5). The binaries are the same and the mode is configuration.

All terms: 01 §1, Words

Only 3 in 100 messages reach the one sequential core.

DESIGN.md §3

100 messages in the design mix. Outlined squares stay on the lane core that owns the account. Inked squares change the best bid or offer, so they go to the one BBO core.

MessageGoes toShare
Joinits lane~50%
Cancel / reduceits lane~47%
ImproveBBO core~2%
CrossBBO core~1%

Master diagram · spec 00

The master diagram. Clients send each packet twice: once to vyrn-seq in facility F1 (NICs, 49 lanes, cut core, BBO core, TX), and once to the vyrn-data tier. Fills and acks loop back to the clients within 1 µs. Order frames go on 2 paths and payloads go from the data tier to the vyrn-replica nodes, which replay the log and run Simplex. Their certificate gives finality within 10 ms. The finalized log goes over the WAN to the follower homes, and the book moves TYO to LDN to NYC every 8 hours, with each handoff a certificate plus an opening auction.
Drawn from the ASCII original below. Open full size · Download the Excalidraw file
ASCII original
                              ┌── one home region (the sun's) ──────────────────────────────────────┐
  clients (colo / cloud)      │  facility F1                                                        │
  each packet is sent twice   │  ┌── vyrn-seq ─────────────────────────────────┐                    │
                              │  │                                             │                    │
    1. to the sequencer ──────┼─►│ NICs ─► 49 lanes ─► BBO core ─► TX ─────────┼─► fills/acks ──────┼──► clients
    2. to a data node         │  │            │            ▲ │                 │                    │
      │                       │  │            └─► cut core─┘ └─► order frames ─┼───┐                │
      │                       │  └─────────────────────────────────────────────┘   │ 2 paths        │
      │                       │                                                    │                │
      │                       │  facilities F2 … Fn                                ▼                │
      │                       │  ┌── vyrn-data ──┐              ┌── vyrn-replica ×(n−1) ──────────┐ │
      └───────────────────────┼─►│ data tier     ├── payloads ─►│ replay engine (same code)       │ │
                              │  └───────────────┘              │ Simplex: 1 ms blocks, q votes   ├─┼─┐
                              │                                 │ state roots · market data       │ │ │
                              │                                 └───────────────┬─────────────────┘ │ │
                              │                                                 │                   │ │
                              │         finality ≤ 10 ms ◄── certificate ───────┘                   │ │
                              └─────────────────────────────────────────────────────────────────────┘ │
                                                                                                      │
   other homes (followers) ◄── finalized log over WAN ────────────────────────────────────────────────┘
   TYO ──8h──► LDN ──8h──► NYC ──8h──► TYO      handoff = certificate (e, S) + opening auction

Budgeted past the state of the art on every axis at once.

Every figureBudgetDESIGN.md §1
AxisBest in production · public figuresThis spec · budget
Wire-to-wire responsetens of µs (Eurex T7, Nasdaq)1 µs
Throughput of one bookone matching thread: LMAX's famous 6M orders/s1B msgs/s
Hardwareevery sub-µs tick-to-trade record is on an FPGAx86 + COTS NIC
On-chainHyperliquid: 0.2 s median, ~200k orders/s1 µs fill, 10 ms final

Public figures as DESIGN.md §1 states them; the design document does not attach sources to them yet.

The book follows the sun.

Spec 08 · Epochs

The same operators run nodes in every home. The book moves by certificate, not by vote. A handoff costs one WAN one-way latency, and an opening auction serves that gap.

  1. TYO00:00–08:00 UTC
  2. LDN08:00–16:00 UTC
  3. NYC16:00–24:00 UTC

Reading the UTC clock.

HandoffWAN one-wayNo-fill window
TYO → LDN~110 ms~120 ms
LDN → NYC~35 ms~45 ms
NYC → TYO~80 ms~90 ms

Light sets this floor, not the design. Orders in the window get a 1 µs ack that they joined the auction.

The schedule · 08 §2.1

A UTC timeline cut at 00:00, 08:00 and 16:00 into three 8-hour epochs (e ≡ 0, 1, 2, then e+3 …, by e mod 3), homed in TYO, LDN and NYC. Under each boundary sit the local opening hours (09:00 JST, 08:00 GMT or 09:00 BST, 11:00 EST or 12:00 EDT). It argues that the boundaries are UTC constants needing no time-zone table: daylight saving moves the local hour, never the boundary.
Drawn from the ASCII original below. Open full size · Download the Excalidraw file
ASCII original
UTC     00:00         08:00         16:00         00:00
         │── e ≡ 0 ───│── e ≡ 1 ───│── e ≡ 2 ───│── e+3 ...      (e mod 3)
home     TYO           LDN           NYC           TYO
local    09:00 JST     08:00 GMT     11:00 EST     09:00 JST
                       (09:00 BST)   (12:00 EDT)

Five tests settle it in week one.

DESIGN.md §9
  1. 1

    Empty ef_vi echo on an isolated core, wire-to-wire, measured through a passive fiber splitter into a capture NIC with hardware timestamps

    Passes if

    ≤ 560 ns at p99.99, or the card is out

    Not yet run
  2. 2

    One lane on a real message mix

    Passes if

    ≤ 30 ns per message

    Not yet run
  3. 3

    49 lanes (42 dedicated + 7 pooled) at 1B msgs/s with 1% crosses

    Passes if

    MAX ≤ 1 µs wire-to-wire for every message at every index; BUSY per class within spec 01 §14.17; BBO core ≤ ~0.33 busy

    Not yet run
  4. 4

    Replay the leader's log on a replica built separately

    Passes if

    identical fills and state hash, bit for bit

    Not yet run
  5. 5

    Kill the sequencer mid-run

    Passes if

    every fill the sequencer sent is in the final log

    Not yet run

The grilling, answered.

DESIGN.md §10
"1 µs without an FPGA is impossible."

The NIC must echo in ≤ 560 ns and the engine adds ≤ 405 ns even at message index 9. Deadline admission turns overload into a BUSY within 1 µs, never a late answer. Benchmark 1 settles the NIC in a day.

"A hard 1 µs maximum is impossible with queues."

Without admission control it is. Every queued system, FPGA exchanges included, has two packets arriving together sometimes. With deadline admission, a packet gets either its result or BUSY within 1 µs, and that decision is logged.

"1B/s on one book is one message per nanosecond."

Only if one core touches every message. Here the BBO core touches ~3% of them.

"Two lanes' quotes cross each other."

See the lemma: against one snapshot they cannot, and against different snapshots the BBO core knows the exact range and scans it.

"Cancel races fill."

Each field has one writer and the cut orders the events. The outcome is logged and deterministic.

"Why not hash orders to cores by order id?"

Risk would then cross cores on every message. Accounts → lanes keeps risk local.

"Why not shard the book across servers?"

A cross-box hop is ≥ 1 µs, which is the whole budget. The book stays in one socket, and its replicas run on other boxes.

"The leader crashes right after a fill."

The ordering frame was already on two paths. A revert requires leader death plus a double drop inside 0.5 ms.

"The book pauses when it moves."

For one WAN one-way latency, by physics, and the auction makes that window fair.

"Why not a GPU?"

A PCIe round trip to a GPU costs microseconds. GPUs are fine off the critical path, for example for hashing and archive work.

"Fairness between lanes?"

Hardware RX timestamps on every packet, and lane-id tie-breaks whose order rotates each epoch.

"What breaks first?"

The BBO core, at ~10M crosses/s on one book. Then the NIC packet rate.

Source-available. Read it freely.

Research and education are free. Commercial or production use, and any use by a financial institution or a government body, needs written permission first, even for testing. Read the license for its complete terms.

License requests are public GitHub issues: leave out anything confidential. Opening one does not grant permission.