Two implementation models
Same Java language, different owners.
Both flavors expose typed support for the same 17 message families and all 27 tracked session behaviors. They differ in who implements those behaviors, and that decides which network paths each one can use.
| Question | Java Pure | Java/JNI |
|---|---|---|
| Who implements the session? | Java: session and codec engine without the C++ runtime | The C++ core, behind provider-neutral Java APIs |
| Session lifecycle, recovery, connectivity, durable state | Owned | C++ core |
| Tracked API capability | 88/90 (2 absent) | 88/89 (1 absent, 1 n/a) |
| Tracked session behaviors | 27/27 | 27/27, 13 inherited from the engine |
| Solarflare Onload preload | Yes | Yes |
| Mellanox VMA preload | Loads; verify acceleration | Yes |
| TCPDirect and SocketXtreme | Not available: ordinary sockets only | Initiator and acceptor |
| ef_vi / ibverbs raw receive | Not available | Vendor-neutral facade |
| FAST 1.1 | Generated whole-message codecs | Native stop-bit and presence-map primitives; whole-message codecs stay managed |
Sources: the generated binding coverage matrix reviewed on 30 September 2026, the kernel-bypass coverage matrix and protocol coverage. Both flavors load the bundled FIX 4.0–5.0 SP2 and FIXT 1.1 dictionaries at runtime and record high availability on all four tracked capabilities.
Java Pure
An independent JVM engine.
Java Pure implements session and codec behavior in Java. It owns session lifecycle, sequence recovery, connectivity and durable state, and it runs on ordinary sockets: Onload or VMA can sit beneath it by preload, while the vendor user-space stacks are out of reach.
HP reference campaign, collected 19 September 2026 and recorded 20 September 2026 on the HP reference host (Intel Xeon Gold 6254): one session, a sustained 50,000 requests per second, response time from the intended send slot.
| Transport | p50 | p99 | p99.9 | Maximum |
|---|---|---|---|---|
| Kernel TCP | 17.063 µs | 18.559 µs | 20.856 µs | 58.363 µs |
| Solarflare Onload | 7.195 µs | 7.613 µs | 7.737 µs | 61.928 µs |
| Mellanox VMA | 7.469 µs | 7.773 µs | 7.912 µs | 36.972 µs |
In the 25 August 2026 full bypass matrix on the HP Z6 G4 rig (Xeon Gold 6154), VMA initialized beneath one pure-Java NIO test but delivered only 1.03× its own kernel baseline, while Onload accelerated the same path. A mapped library proves initialization, not offload.
The diagnostic SCAN sweep of 29 September 2026 (kernel TCP, one session) held 50,000 requests per second at 32.633 µs p50 and first saturated at 75,000 per second. Java Pure FIX engine benchmarks →
Java/JNI
A Java API over the C++ core.
Java/JNI exposes provider-neutral Java-facing APIs backed by the native engine. Session lifecycle, recovery, connectivity and durable state deliberately delegate to the C++ FIX engine, which is why 13 of its 27 tracked session behaviors are recorded as inherited. In exchange, a Java application reaches TCPDirect and SocketXtreme with initiator and acceptor routes, and raw receive through the vendor-neutral facade.
Same HP reference campaign, 19–20 September 2026, 50,000 requests per second:
| Transport | p50 | p99 | p99.9 | Maximum |
|---|---|---|---|---|
| Kernel TCP | 15.665 µs | 18.656 µs | 24.764 µs | 117.330 µs |
| Solarflare Onload | 6.047 µs | 6.461 µs | 6.572 µs | 34.939 µs |
| Mellanox VMA | 6.555 µs | 7.001 µs | 7.118 µs | 36.278 µs |
| Solarflare TCPDirect | 5.639 µs | 6.549 µs | 6.668 µs | 40.571 µs |
| Mellanox SocketXtreme | 6.574 µs | 7.514 µs | 8.695 µs | 47.039 µs |
The diagnostic SCAN sweep of 29 September 2026 held 75,000 requests per second at 26.819 µs p50 and first saturated at 100,000 per second. Java/JNI FIX engine benchmarks →
Each HP percentile is the mean of three 30-second runs after a 5-second warm-up. Read rows within one flavor; the two tables are not a ranking of Java engines. How the campaign was measured · capacity brackets · Java codec microbenchmarks · Java engine comparison
QuickFIX/J counterpart
Coming from QuickFIX/J.
Both Java flavors are LibHFT’s counterparts of QuickFIX/J ↗. Its XML dictionaries are reused after validation. Its settings are assessed in QuickFIX/J’s own terms, because runtime ownership, store behavior, callback APIs and scheduling details differ between QuickFIX implementations even where names look alike. Replay and recovery conformance come before any benchmark.
Selection
Choosing between the two.
- Choose Java Pure when a standalone JVM engine, without the C++ runtime, is the architectural requirement.
- Choose Java/JNI when the Java application should reuse the C++ engine and its native transport integrations, including TCPDirect and SocketXtreme.
- Other runtimes follow the same split: the .NET FIX engine for C# comes as an independent or a native-backed flavor, and the Rust FIX engine is independent.
- Benchmark the exact flavor, transport, message path and deployment hardware you will operate.