Motore protocollo FIX · v1.8 · maggio 2026

NexusFIX.
Un motore che non alloca mai.

Un motore di protocollo FIX in C++23 costruito per venue che non perdonano un heartbeat mancato. Zero allocazioni sul percorso caldo, parsing sub-microsecondo, stato sessione deterministico.
Prevedibile. In ogni dettaglio.

nexusfix / session / XCME.PROD.42
C++23 · 0 ALLOC · 247K msg/s

Flusso messaggi · XCME.PROD.42 · NewOrderSingle ⇄ ExecutionReport

tail -f · live stream
12:04:18.11435=D|49=NEXFIX|56=XCME|34=184221|11=ord-9f2e|55=ESM6|54=1|38=2|40=2|44=5418.25parsed 318 ns
12:04:18.11435=8|49=XCME|56=NEXFIX|34=184222|11=ord-9f2e|17=exec-1|150=0|39=0|55=ESM6|54=1acked 1.2 µs
12:04:18.47135=8|49=XCME|56=NEXFIX|34=184223|11=ord-9f2e|17=exec-2|150=F|39=2|32=2|31=5418.25parsed 296 ns
12:04:19.00035=0 heartbeat|34=184224|49=NEXFIX|56=XCME · 30s intervalsent 84 ns
12:04:19.21435=D|49=NEXFIX|56=XCME|34=184225|11=ord-9f2f|55=NQM6|54=2|38=1|40=2|44=19842.75parsed 304 ns
12:04:19.21535=8|49=XCME|56=NEXFIX|34=184226|11=ord-9f2f|17=exec-3|150=0|39=0acked 1.1 µs
12:04:19.60135=8|49=XCME|56=NEXFIX|34=184227|11=ord-9f2f|17=exec-4|150=F|39=2|32=1|31=19842.50parsed 311 ns
12:04:19.88035=F CancelRequest|34=184228|41=ord-9f2e|11=cxl-7a01|55=ESM6parsed 292 ns
12:04:19.88135=8|49=XCME|56=NEXFIX|34=184229|11=cxl-7a01|17=exec-5|150=4|39=4 · cancelledacked 1.0 µs
247K/s
throughput messaggi
0
allocazioni heap su percorso caldo
412ns
latenza parsing p99
3.4×
vs baseline QuickFIX

Il budget di performance.

Ogni numero che cercheresti in un runbook di produzione. Misurato sotto carico, su hardware standard, contro un replay deterministico.

Latenza di parsing
<500ns
p99, NewOrderSingle. Buffer fissi, iterazione campi zero-copy.
Throughput
240K+ /s
Per sessione, core singolo. Scala lineare tra sessioni.
Allocazioni percorso caldo
0
Arena statiche, ring buffer predimensionati, decodifica in-place.
vs QuickFIX
3×
Più veloce end-to-end sullo stesso workload. Suite di benchmark riproducibile.

Perché gli operatori
scelgono NexusFIX.

Tre scelte architetturali che si compongono. Ognuna è ciò che rende possibile la successiva.

1 Livello 1 · Determinismo

Coda stretta. Nessuna sorpresa a p99.

Code SPSC lock-free, decoder di tag senza branching, inlining del percorso caldo. Il messaggio più lento sembra il più veloce. È su questo che le venue ti valutano davvero.

120nsp50 · 240nsp90 · 360nsp99 · 412nsp99.9 · 580ns
2 Livello 2 · Memoria

Zero allocazioni sul percorso caldo.

Arena statiche, freelist intrusive, slot messaggi a dimensione fissa. L'allocatore non gira mai mentre gli ordini scorrono. Così il kernel non ti prelaziona mai per recuperare una pagina.

QuickFIX /order-flow
allocazioni heap / msg~14
NexusFIX /order-flow
allocazioni heap / msg0 · riutilizzo arena
3 Livello 3 · Protocollo

FIX 4.2 / 4.4 / 5.0 / FIXT. Un solo motore.

Dizionari generati per versione, selezionabili a runtime per sessione. Overlay di dialetti personalizzati per campi specifici di venue. Il formato wire che la venue esegue è il formato che invii.

FIX 4.2completo
FIX 4.4completo
FIX 5.0 SP2completo
FIXT 1.1completo
Personalizzatooverlay
Testato sul wire

Configurato per le venue su cui operi davvero.

Profili di sessione precostruiti per le principali venue azionarie, futures, FX e crypto. Heartbeat, semantica di sequence-reset e particolarità di resend-request acquisite da trace di produzione reali.

CMEICENYSENasdaqLSEEurexHKEXSGXEBSRefinitivCoinbase PrimeBinance Inst.

Il hot path,
in due modi.

Un NewOrderSingle decodificato e instradato, fianco a fianco. Stesso messaggio, stessa macchina, costo molto diverso.

QuickFIX (C++) application.cpp
void Application::onMessage(const FIX44::NewOrderSingle& msg, const SessionID& sid)
{
  FIX::ClOrdID    clOrdId;   msg.get(clOrdId);       // allocates
  FIX::Symbol     symbol;    msg.get(symbol);        // allocates
  FIX::Side       side;      msg.get(side);
  FIX::OrderQty   qty;       msg.get(qty);           // allocates Decimal
  FIX::Price      price;     msg.get(price);         // allocates Decimal

  std::string key = symbol.getString();          // allocates std::string
  router_->route(key, clOrdId.getString(), qty, price);
}                                                // ~14 heap allocs / msg
p99 parse + route1.42 µs · 14 allocs
NexusFIX (C++23) order_handler.cpp
void OrderHandler::on_message(MessageView m, SessionRef sid) noexcept
{
  auto [cl_ord_id, symbol, side, qty, price] =
      m.decode<D::ClOrdID, D::Symbol, D::Side,
                D::OrderQty, D::Price>();     // in-place, span<const char>

  // fixed-arena order slot, no heap, no copies
  auto& slot = arena_.acquire(cl_ord_id);
  slot.init(symbol, side, qty, price, sid);

  router_.route(slot);                              // 0 heap allocs / msg
}
p99 parse + route412 ns · 0 allocs

Perché i team sostituiscono QuickFIX.

QuickFIX ha portato il grosso del lavoro per il settore per due decenni. NexusFIX è ciò a cui si ricorre quando quelle scelte sono diventate il collo di bottiglia.

QuickFIXNexusFIX
Allocazioni sull'hot path~14 allocazioni heap per messaggio (std::string, Decimal)0 · arene statiche, decode in-place
Latenza p99 di parsing1,2–1,8 µs a seconda del dialetto< 500 ns · decode di tag senza branch
Throughput / core60–90K msg/s sostenuti240K+ msg/s sostenuti
Comportamento della coda sotto caricoSenza GC, ma il churn dell'allocatore = picchi imprevedibiliNessun allocatore sull'hot path. coda piatta
Versioni di protocollo4.2 / 4.4 / 5.0. Dizionario dati XML per build4.2 / 4.4 / 5.0 / FIXT + overlay di dialetto a runtime
LinguaggioIdiomi C++03 / C++11, dispatch virtualeC++23, concepts + ranges, nessun virtual sull'hot path
QuickFIX è stato costruito quando 5.000 msg/sec era una sessione affollata. NexusFIX è costruito per le venue dove quello è un minuto tranquillo. e la coda deve comunque restare piatta.

Il hot path,
end-to-end.

Byte dal filo in ingresso. Ordine instradato in uscita. Tre stadi, tutti nello stesso thread, tutti senza allocare.

1 Stadio 1 · Decodifica

Byte in entrata, campi in uscita. senza copia.

Lo stream delimitato da SOH viene iterato in-place. Ogni tag si risolve in una vista tipizzata sul buffer originale; i campi numerici sono parsati senza branch, con l'overlay di dialetto applicato al bind di sessione.

span<const char>senza branchchecksum SIMD
2 Stadio 2 · Validazione

Stato di sessione, in modo deterministico.

Numeri di sequenza, finestre di heartbeat, semantica gap-fill, stranezze del resend-request. Gestito da una state machine generata per profilo di venue. Ogni transizione è registrata in un journal memory-mapped.

seq-numheartbeatresendmmap journal
3 Stadio 3 · Routing

Nel tuo handler, zero allocazioni.

Uno slot di ordine in un'arena fissa viene acquisito, popolato per riferimento, e consegnato alla tua applicazione via una coda SPSC lock-free. Lo slot vive fino allo stato terminale dell'ordine, poi torna all'arena.

coda SPSCslot di arenanessun virtual

Vai più a fondo.

Due fili da tirare ora. L'articolo di architettura, o l'esplicatore conversazionale dal vivo.

Collegalo in un pomeriggio.

NexusFIX viene rilasciato come una singola libreria statica e un simulatore di sessione CLI. Porta una config di venue e un handler, e hai una sessione FIX deterministica che gira in locale. Riproducibile da un journal, tracciabile fino al byte.

Esplora altri progetti.

NexusFIX è uno dei tre motori che costruiamo. Stessa filosofia: open-source dove possibile, performance prima, no lock-in.