GitHub - StratCraftsAI/NexusFix: A zero-alloc, compile-time hardened FIX engine built for sub-100ns execution.

Ultra-Low Latency FIX Protocol Engine for High-Frequency Trading

Modern C++23 | Zero-Copy | SIMD-Accelerated | 3x Faster than QuickFIX

Performance | Architecture | Features | Quick Start | Docs | Community | Contact

Why NexusFIX?

NexusFIX is a high-performance FIX protocol (Financial Information eXchange) engine built for ultra-low latency quantitative trading, sub-microsecond algorithmic execution, and high-frequency trading (HFT) systems. It solves the performance bottlenecks of traditional FIX engines by utilizing hardware-aware C++ programming.

NexusFIX serves as a modern, faster alternative to QuickFIX with zero heap allocations on the critical path.

"If you're building a low-latency trading system and QuickFIX is your bottleneck, NexusFIX is your solution."

Performance

NexusFIX vs QuickFIX Benchmark

Tested on Linux with GCC 13.3, 100,000 iterations:

Why is NexusFIX Faster?

Zero Allocation Proof

Parsing a NewOrderSingle message on the hot path:

Verified via custom allocator instrumentation. See Optimization Diary.

For kernel bypass (DPDK/AF_XDP) and FPGA acceleration, see Roadmap.

Architecture Influences

NexusFIX stands on the shoulders of giants. We systematically studied 11 industry-leading Modern C++ libraries and applied their techniques to ultra-low latency FIX processing. Below is our learning journey: what we learned, what we built, and what improvement we measured.

Learning → Implementation → Verification

What We Built

Cumulative Impact

Detailed benchmarks: Optimization Summary

Attribution

NexusFIX is MIT licensed. We gratefully acknowledge these open source projects:

Features

Core Capabilities

• Zero-Copy Parsing - std::span<const char> views into original buffer, no memcpy
• Message Encoding - Builder pattern with constexpr serializer for constructing FIX messages
• SIMD Acceleration - AVX2/AVX-512 instructions for delimiter scanning
• Compile-Time Optimization - consteval field offsets, 22 lookup tables for enum/type conversion, ~300 runtime branches eliminated
• O(1) Field Lookup - Pre-indexed lookup table by FIX tag number (post-parse)
• Zero Heap Allocation - PMR pools and stack allocation on hot path
• Session Management - Full session lifecycle: Logon, Logout, Heartbeat, sequence number tracking, reconnect logic
• Type-Safe API - Strong types for Price, Quantity, Side, OrdType

Modern C++23

• std::expected for error handling (no exceptions on hot path)
• std::span for zero-copy data views
• Concepts for compile-time interface validation
• consteval for compile-time computation
• [[likely]] / [[unlikely]] branch hints

Supported FIX Versions

Supported Message Types

Optimization Guide

How we achieved sub-300ns latency with Modern C++23:

• Optimization Diary - Step-by-step journey from 730ns to 246ns
• Modern C++ Quant Techniques - Cache-line alignment, SIMD, PMR strategies, branch hints

Quick Start

Installation

git clone https://github.com/StratCraftsAI/NexusFIX.git
cd NexusFIX
./start.sh build

Requirements

• C++23 compiler: GCC 13+ or Clang 17+
• CMake: 3.20+
• OS: Linux (io_uring optional), macOS, Windows

Basic Usage

#include <nexusfix/nexusfix.hpp>

using namespace nfx;
using namespace nfx::fix44;

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

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

// Send order (zero allocation)
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);

Parse Incoming Messages

// Zero-copy parsing
FixParser parser;
auto result = parser.parse(raw_buffer);

if (result) {
    auto& msg = *result;
    auto order_id = msg.get_string(Tag::OrderID);    // O(1) lookup
    auto exec_type = msg.get_char(Tag::ExecType);    // No allocation
    auto fill_qty = msg.get_qty(Tag::LastQty);       // Type-safe
}

Documentation

• CHANGELOG.md for release history and upgrade notes
• BENCHMARK_REPRODUCTION.md for reproducing published measurements
• CONTRIBUTING.md for contribution boundaries and code standards
• SECURITY.md for coordinated vulnerability disclosure
• SUPPORT.md for bug reports, usage questions, and response expectations
• ROADMAP.md for near-term and mid-term open-source priorities
• docs/COVERAGE_LIMITATIONS.md for coverage-build caveats and usage boundaries
• docs/compare/ for benchmark reports and optimization writeups
• docs/design/ for architecture notes and design tickets that are public

Community

• Support: SUPPORT.md
• Contributing: CONTRIBUTING.md
• Security: SECURITY.md
• Code of Conduct: CODE_OF_CONDUCT.md

Build Options

# Build with all optimizations
cmake -B build -DCMAKE_BUILD_TYPE=Release -DNFX_ENABLE_SIMD=ON
cmake --build build -j

# Run benchmarks
./start.sh bench 100000

# Compare with QuickFIX
./start.sh compare 100000

Benchmarking

Verify performance claims by running benchmarks yourself.

Quick Start

# Run parser and session benchmarks
./start.sh bench 100000

# Example output:
# [BENCHMARK] ExecutionReport Parse
#   Iterations: 100000
#   Mean: 246 ns
#   P50:  245 ns
#   P99:  258 ns

QuickFIX Comparison

Compare NexusFIX against QuickFIX (requires QuickFIX installed):

# Install QuickFIX first
# Ubuntu: sudo apt install libquickfix-dev
# Or build from source: https://github.com/quickfix/quickfix

# Run comparison
./start.sh compare 100000

Full Reproduction Guide

For detailed instructions on reproducing benchmark results, including:

• Environment setup (CPU governor, pinning, priority)
• Build configuration options
• Interpreting results
• Troubleshooting

See BENCHMARK_REPRODUCTION.md

Technical References

• API Reference - Complete API documentation
• Implementation Guide - Architecture overview
• Benchmark Report - Detailed performance analysis
• Modern C++ Techniques - Optimization techniques used

Project Structure

nexusfix/
├── include/nexusfix/
│   ├── parser/           # Zero-copy FIX parser (SIMD)
│   ├── session/          # Session state machine
│   ├── transport/        # TCP / io_uring / Winsock transport
│   ├── platform/         # Cross-platform abstraction
│   ├── types/            # Strong types (Price, Qty, Side)
│   ├── memory/           # PMR buffer pools
│   ├── store/            # Message store (PMR-optimized)
│   ├── serializer/       # Message serialization
│   ├── util/             # Utilities (diagnostics, formatting)
│   ├── messages/fix44/   # FIX 4.4 message builders
│   └── interfaces/       # Concepts and interfaces
├── benchmarks/           # Performance benchmarks
├── tests/                # Unit tests
├── examples/             # Example programs
└── docs/                 # Documentation

FAQ

How does NexusFIX achieve zero-copy parsing?

NexusFIX uses std::span<const char> to create views into the original network buffer. Field values are never copied - the parser returns spans pointing to the exact byte range in the source buffer. This eliminates all memcpy and heap allocation overhead.

Is NexusFIX compatible with QuickFIX?

NexusFIX implements the same FIX 4.4/5.0 protocol standards but with a different API optimized for performance. It is wire-compatible with any FIX counterparty, including systems using QuickFIX.

What latency can I expect in production?

In our benchmarks: ~250 nanoseconds for ExecutionReport parsing. Actual production latency depends on network, kernel configuration, and hardware. NexusFIX is designed to minimize the application-layer overhead.

Does NexusFIX support FIX Repeating Groups?

Yes. Repeating groups are parsed with the same zero-copy approach. Group iteration is O(1) per entry.

Use Cases

NexusFIX is designed for:

• High-Frequency Trading (HFT) - Sub-microsecond message processing
• Algorithmic Trading Systems - Low-latency order routing
• Market Making - High-throughput quote updates
• Smart Order Routing (SOR) - Multi-venue connectivity
• Trading Infrastructure - FIX gateways and bridges

Contact

For questions or collaboration: nonagonal.portal@gmail.com

Development

Built with Modern C++23. Optimized via hardware-aware high-performance patterns including cache-line alignment, SIMD vectorization, and zero-copy memory design. Verified through rigorous benchmarking and AI-assisted static analysis.

For technical deep-dives on our optimization journey, see Optimization Diary.

Contributing

This project is maintained by StratCraftsAI.

• Issues & Discussions: Welcome for bug reports, performance questions, and feature discussions
• Pull Requests: Bug fixes and performance optimizations welcome (see CONTRIBUTING.md)
• Feature PRs require prior discussion in Issues
• Performance PRs must include benchmark data (before/after)

All contributions must follow:

• C++23 standards
• Zero allocation on hot paths
• Include benchmarks for performance changes

License

MIT License - See LICENSE file.

_{Built with Modern C++23 for ultra-low latency quantitative trading}