Nexusfix

NexusFIX Development Expert

• GitHub: https://github.com/StratCraftsAI/NexusFIX

When to Use

When the user needs to build, optimize, or debug FIX protocol connectivity in C++. Covers session management, order entry, market data, and low-latency message parsing.

Architecture

NexusFIX is a header-only C++23 FIX protocol engine. Parse latency is under 250ns for ExecutionReport messages. Throughput exceeds 4M msg/sec single-threaded.

Key design decisions:

• Zero-copy parsing: std::span<const char> views over raw buffer. No intermediate string copies.
• Two-stage SIMD parsing: AVX2/AVX-512 scans for SOH delimiters first (structural index), then extracts fields by tag. Similar to how simdjson handles JSON.
• Builder pattern for outbound messages: NewOrderSingle::Builder chains field setters, calls .build(assembler) to serialize.
• std::expected error handling: All parse functions return std::expected<T, ParseError>. No exceptions on hot path.
• Fixed-point arithmetic: FixedPrice (8 decimal places) and Qty (4 decimal places). No floating-point for prices.
• PMR memory pools: Pre-allocated buffers, zero heap allocations during message processing.

Constraints (Strict)

When generating code that uses NexusFIX, the following rules are mandatory:

• C++23 only. Use designated initializers, std::expected, concepts, constexpr/consteval.
• Zero allocations on hot path. No new, delete, std::map, std::unordered_map, or std::string construction in message processing loops.
• No std::endl. Use \n.
• No virtual functions in performance-critical code.
• No std::shared_ptr on hot path.
• No floating-point for prices. Use FixedPrice::from_double() or FixedPrice::from_string().
• All functions that can fail return std::expected. Check .has_value() before accessing.
• Mark hot-path functions noexcept.
• Use [[nodiscard]] on all API return values.

Common Patterns

Connecting and Sending an Order

#include <nexusfix/nexusfix.hpp>
using namespace nfx;
using namespace nfx::fix44;

TcpTransport transport;
transport.connect("fix.broker.com", 9876);

SessionConfig config{
    .sender_comp_id = "MY_CLIENT",
    .target_comp_id = "BROKER",
    .heartbeat_interval = 30
};
SessionManager session{transport, config};
session.initiate_logon();

while (!session.is_active()) {
    session.poll();
}

MessageAssembler asm_;
NewOrderSingle::Builder order;
auto msg = order
    .cl_ord_id("ORD001")
    .symbol("AAPL")
    .side(Side::Buy)
    .order_qty(Qty::from_int(100))
    .ord_type(OrdType::Limit)
    .price(FixedPrice::from_double(150.00))
    .build(asm_);
transport.send(msg);

Parsing an ExecutionReport

void on_message(std::span<const char> data) {
    auto result = ExecutionReport::from_buffer(data);
    if (!result) return;

    auto& exec = *result;
    if (exec.is_fill()) {
        // handle fill
    }
}

Message Routing

auto parser = IndexedParser::parse(data);
if (!parser) return;

switch (parser->msg_type()) {
    case '8': on_execution_report(data); break;
    case 'W': on_snapshot(data); break;
    case 'X': on_incremental(data); break;
}

Anti-patterns

Do NOT generate code like this when working with NexusFIX:

// BAD: heap allocation on hot path
std::string field_value(data.begin() + offset, data.begin() + end);

// BAD: std::map for field lookup
std::map<int, std::string> fields;

// BAD: floating-point price
double price = 150.50;

// BAD: exceptions for control flow
try { parse(data); } catch (...) { }

// BAD: std::endl
std::cout << "done" << std::endl;

Supported FIX Messages

References

For full API details, use skill_view("nexusfix", "references/api-reference.md").

For getting started quickly, use skill_view("nexusfix", "references/quick-start.md").

Verification

After generating NexusFIX code, verify:

1. No new/delete/std::string construction in message processing
2. All parse results checked via std::expected (no raw pointer returns)
3. Prices use FixedPrice, quantities use Qty
4. Session lifecycle follows: connect -> logon -> wait active -> trade -> logout

Source: StratCraftsAI/NexusFix — distributed by TomeVault.