Jump Trading Style Guide⁠‍⁠​‌​‌​​‌‌‍​‌​​‌​‌‌‍​​‌‌​​​‌‍​‌​​‌‌​​‍​​​​​​​‌‍‌​​‌‌​‌​‍‌​​​​​​​‍‌‌​​‌‌‌‌‍‌‌​​​‌​​‍‌‌‌‌‌‌​‌‍‌‌​‌​​​​‍​‌​‌‌‌‌‌‍​‌​​‌​‌‌‍​‌‌​‌​​‌‍‌​‌​‌‌‌​‍​​‌​‌​​​‍‌‌‌​‌​‌‌‍​‌‌​‌‌‌‌‍​​‌​​‌​‌‍‌‌‌‌​‌​‌‍​​‌‌‌‌‌​‍​​​​‌​‌​‍​​‌‌​​​‌⁠‍⁠

Overview

Jump Trading is a proprietary trading firm known for pushing the boundaries of trading technology. They pioneered FPGA-based trading, invested in microwave networks for faster-than-fiber connectivity, and operate at the absolute frontier of latency optimization.

Core Philosophy

"The speed of light is the only limit we accept."

"Software is too slow. Put it in hardware."

"Network latency is just physics. Compute latency is engineering failure."

Jump believes that when software is too slow, you put the logic in hardware. FPGAs can process market data and generate orders in hundreds of nanoseconds—faster than a CPU can even wake up.

Design Principles

Hardware > Software: When latency matters, use FPGAs.

Network is Critical: Microwave beats fiber. Co-location beats remote.

Picoseconds Matter: At the frontier, every nanosecond is fought for.

Deterministic Wins: Jitter is the enemy of consistent performance.

Full Stack Ownership: Own everything from NIC to exchange.

When Building Ultra-Low-Latency Systems

Always

• Measure wire-to-wire latency, not component latency

• Use FPGAs for time-critical decisions

• Optimize network path (co-location, cross-connects, switches)

• Process data in the NIC when possible (smart NICs)

• Eliminate all unnecessary hops

• Use hardware timestamps for accurate measurement

Never

• Trust software timestamps

• Use general-purpose switches in the critical path

• Assume network latency is fixed

• Ignore the physical layer (cables, optics, switches)

• Process sequentially when you can pipeline

• Wait for full message when you can cut-through

Prefer

• FPGAs over CPUs for fixed logic

• Cut-through switching over store-and-forward

• Microwave/millimeter-wave over fiber for long distances

• Dedicated lines over shared infrastructure

• Hardware timestamping over software

• Parallel processing over sequential

Code Patterns

FPGA Market Data Parser (Pseudo-Verilog)

// FPGA-based market data parsing and order generation // Processes UDP multicast market data, generates orders in ~200ns

module market_data_parser ( input wire clk_312_5mhz, // 312.5 MHz clock (3.2ns period) input wire [63:0] eth_data, // 64-bit data from MAC input wire eth_valid, input wire eth_sof, // Start of frame input wire eth_eof, // End of frame

output reg [63:0] order_data,
output reg order_valid,
output reg [15:0] symbol_id,
output reg [31:0] bid_price,
output reg [31:0] ask_price,
output reg [31:0] bid_size,
output reg [31:0] ask_size

);

// Pipeline stages for parallel processing
reg [2:0] state;
localparam IDLE = 0, PARSE_HEADER = 1, PARSE_SYMBOL = 2,
           PARSE_BID = 3, PARSE_ASK = 4, GENERATE_ORDER = 5;

// Pre-computed strategy parameters (loaded at startup)
reg [31:0] fair_value [0:4095];      // Per-symbol fair value
reg [31:0] edge_threshold [0:4095];  // Min edge to trade
reg [31:0] max_position [0:4095];    // Position limits

// Current positions (updated by fill handler)
reg [31:0] positions [0:4095];

always @(posedge clk_312_5mhz) begin
    case (state)
        IDLE: begin
            order_valid <= 0;
            if (eth_valid && eth_sof) begin
                state <= PARSE_HEADER;
            end
        end
        
        PARSE_HEADER: begin
            // Parse UDP header, extract message type
            // Skip IP/UDP headers (known fixed offsets)
            if (is_quote_message(eth_data)) begin
                state <= PARSE_SYMBOL;
            end else begin
                state <= IDLE;
            end
        end
        
        PARSE_SYMBOL: begin
            symbol_id <= eth_data[15:0];
            state <= PARSE_BID;
        end
        
        PARSE_BID: begin
            bid_price <= eth_data[31:0];
            bid_size <= eth_data[63:32];
            state <= PARSE_ASK;
        end
        
        PARSE_ASK: begin
            ask_price <= eth_data[31:0];
            ask_size <= eth_data[63:32];
            state <= GENERATE_ORDER;
        end
        
        GENERATE_ORDER: begin
            // All logic executes in single clock cycle
            wire [31:0] fv = fair_value[symbol_id];
            wire [31:0] edge = edge_threshold[symbol_id];
            wire [31:0] pos = positions[symbol_id];
            wire [31:0] max_pos = max_position[symbol_id];
            
            // Buy if bid is below fair value minus edge
            wire should_buy = (bid_price < fv - edge) && (pos < max_pos);
            
            // Sell if ask is above fair value plus edge  
            wire should_sell = (ask_price > fv + edge) && (pos > -max_pos);
            
            if (should_buy) begin
                order_data <= build_buy_order(symbol_id, bid_price, bid_size);
                order_valid <= 1;
            end else if (should_sell) begin
                order_data <= build_sell_order(symbol_id, ask_price, ask_size);
                order_valid <= 1;
            end
            
            state <= IDLE;
        end
    endcase
end

endmodule

Network Topology Optimization

class NetworkOptimizer: """ Jump's network optimization: every nanosecond counts. Model and optimize the full network path. """

def __init__(self):
    self.topology = {}
    self.latency_measurements = {}

def model_path_latency(self, 
                       source: str, 
                       destination: str) -> LatencyBreakdown:
    """
    Break down latency into components.
    """
    path = self.find_path(source, destination)
    
    breakdown = LatencyBreakdown()
    
    for i, (node_a, node_b) in enumerate(zip(path[:-1], path[1:])):
        link = self.topology[(node_a, node_b)]
        
        # Propagation delay (speed of light in medium)
        # Fiber: ~5 ns/meter, Microwave: ~3.3 ns/meter
        prop_delay = link.distance_meters * link.propagation_factor
        breakdown.propagation_ns += prop_delay
        
        # Serialization delay (time to put bits on wire)
        # 10GbE: 67.2ns for 64-byte frame
        serial_delay = (link.frame_size_bytes * 8) / link.bandwidth_gbps
        breakdown.serialization_ns += serial_delay
        
        # Switch/router delay
        if link.device_type == 'cut_through_switch':
            # Cut-through: forward after seeing destination MAC (~300ns)
            breakdown.switching_ns += 300
        elif link.device_type == 'store_forward_switch':
            # Store-and-forward: wait for full frame (~5000ns for 64B)
            breakdown.switching_ns += 5000
        
        # NIC delay (if applicable)
        if i == 0:  # Source NIC
            breakdown.nic_tx_ns += link.nic_tx_latency_ns
        if i == len(path) - 2:  # Destination NIC
            breakdown.nic_rx_ns += link.nic_rx_latency_ns
    
    return breakdown

def compare_microwave_vs_fiber(self, 
                                point_a: Location, 
                                point_b: Location) -> dict:
    """
    Microwave travels at ~c (speed of light in vacuum).
    Fiber travels at ~0.67c (speed of light in glass).
    For long distances, microwave wins despite being line-of-sight.
    """
    distance_km = self.calculate_distance(point_a, point_b)
    
    # Speed of light
    c = 299792.458  # km/s
    
    # Fiber: ~0.67c due to refractive index, plus routing overhead
    fiber_speed = c * 0.67
    fiber_distance = distance_km * 1.3  # Routing adds ~30%
    fiber_latency_ms = (fiber_distance / fiber_speed) * 1000
    
    # Microwave: ~0.99c, nearly straight line
    microwave_speed = c * 0.99
    microwave_distance = distance_km * 1.02  # Slight deviation for terrain
    microwave_latency_ms = (microwave_distance / microwave_speed) * 1000
    
    return {
        'fiber_latency_ms': fiber_latency_ms,
        'microwave_latency_ms': microwave_latency_ms,
        'savings_ms': fiber_latency_ms - microwave_latency_ms,
        'savings_percent': (fiber_latency_ms - microwave_latency_ms) / fiber_latency_ms * 100
    }

Smart NIC Processing

// Smart NIC (Bluefield/Netronome) for in-NIC processing // Process market data before it hits CPU

class SmartNICProcessor { public: // Run on NIC's ARM cores / P4 engine struct PacketContext { uint64_t timestamp_hw; // Hardware timestamp from PHY uint8_t* packet_data; uint16_t length; };

// This runs on the NIC, not the host CPU
__attribute__((section(".nic_code")))
Action process_packet(PacketContext* ctx) {
    // Parse at line rate
    auto* eth = reinterpret_cast<EthernetHeader*>(ctx->packet_data);
    
    if (eth->ethertype != ETHERTYPE_IP) {
        return Action::PASS_TO_HOST;
    }
    
    auto* ip = reinterpret_cast<IPHeader*>(eth + 1);
    auto* udp = reinterpret_cast<UDPHeader*>(ip + 1);
    
    // Filter: only process market data multicast
    if (!is_market_data_multicast(ip->dst_addr, udp->dst_port)) {
        return Action::PASS_TO_HOST;
    }
    
    auto* msg = reinterpret_cast<MarketDataMessage*>(udp + 1);
    
    // Simple filtering: drop if not in our symbol universe
    if (!is_in_universe(msg->symbol_id)) {
        return Action::DROP;
    }
    
    // Add hardware timestamp and pass to host
    ctx->packet_data = prepend_timestamp(ctx->packet_data, ctx->timestamp_hw);
    
    return Action::PASS_TO_HOST;
}

};

Precision Time Protocol (PTP)

// Hardware-based time synchronization

class PTPTimeSync { /* * Jump uses PTP (IEEE 1588) for nanosecond-accurate time sync. * Critical for correlating events across systems and fair latency measurement. */

public: void configure_ptp_hardware(int nic_fd) { // Enable hardware timestamping struct hwtstamp_config config = {}; config.tx_type = HWTSTAMP_TX_ON; config.rx_filter = HWTSTAMP_FILTER_ALL;

    struct ifreq ifr = {};
    ifr.ifr_data = (char*)&config;
    ioctl(nic_fd, SIOCSHWTSTAMP, &ifr);
    
    // Get PHC (PTP Hardware Clock) device
    struct ethtool_ts_info info = {};
    info.cmd = ETHTOOL_GET_TS_INFO;
    ifr.ifr_data = (char*)&info;
    ioctl(nic_fd, SIOCETHTOOL, &ifr);
    
    // Open PHC device
    char phc_device[32];
    snprintf(phc_device, sizeof(phc_device), "/dev/ptp%d", info.phc_index);
    phc_fd_ = open(phc_device, O_RDWR);
}

uint64_t get_hardware_time_ns() {
    struct ptp_clock_time ptc;
    ioctl(phc_fd_, PTP_CLOCK_GETTIME, &ptc);
    return ptc.sec * 1000000000ULL + ptc.nsec;
}

// Extract hardware timestamp from received packet
uint64_t extract_rx_timestamp(struct msghdr* msg) {
    for (struct cmsghdr* cmsg = CMSG_FIRSTHDR(msg); 
         cmsg; 
         cmsg = CMSG_NXTHDR(msg, cmsg)) {
        
        if (cmsg->cmsg_level == SOL_SOCKET &&
            cmsg->cmsg_type == SCM_TIMESTAMPING) {
            
            struct scm_timestamping* ts = 
                (struct scm_timestamping*)CMSG_DATA(cmsg);
            
            // Use hardware timestamp (ts[2]) not software (ts[0])
            return ts->ts[2].tv_sec * 1000000000ULL + 
                   ts->ts[2].tv_nsec;
        }
    }
    return 0;
}

private: int phc_fd_; };

Wire-to-Wire Latency Measurement

class WireToWireLatency { /* * Measure true latency: from photons arriving at RX NIC * to photons leaving TX NIC. * Software timestamps are useless at these scales. */

public: struct Measurement { uint64_t rx_hw_timestamp; // When packet hit our NIC (hardware) uint64_t tx_hw_timestamp; // When response left our NIC (hardware) uint64_t wire_to_wire_ns; // Total latency

    // Component breakdown (if instrumented)
    uint64_t parse_ns;
    uint64_t strategy_ns;
    uint64_t order_build_ns;
    uint64_t tx_queue_ns;
};

void record_tick_to_trade(
    uint64_t market_data_rx_hw_ts,
    uint64_t order_tx_hw_ts) {
    
    uint64_t latency_ns = order_tx_hw_ts - market_data_rx_hw_ts;
    
    histogram_.record(latency_ns);
    
    // Alert if we exceed target
    if (latency_ns > target_latency_ns_) {
        log_slow_path(latency_ns);
    }
}

void print_histogram() {
    // Typical Jump-style output:
    // p50: 180ns, p99: 320ns, p999: 890ns, max: 1.2us
    auto stats = histogram_.get_stats();
    printf("Wire-to-wire latency:\n");
    printf("  p50:  %luns\n", stats.p50);
    printf("  p99:  %luns\n", stats.p99);
    printf("  p999: %luns\n", stats.p999);
    printf("  max:  %luns\n", stats.max);
}

};

Mental Model

Jump approaches ultra-low-latency by asking:

• What's the physics limit? Speed of light × distance

• Where's the compute? Move it to hardware (FPGA/SmartNIC)

• What's the network path? Optimize every hop

• What's the jitter? Worst case matters more than average

• Can we pipeline? Process in parallel, not sequentially

Signature Jump Moves

• FPGA-based trading logic

• Microwave networks for long-haul

• Smart NIC pre-processing

• Hardware PTP time synchronization

• Cut-through switching

• Wire-to-wire latency measurement

• Nanosecond-level optimization

• Co-location at every major exchange

• Full-stack hardware/software ownership