← Alle Insights
11 Min. Lesezeit · Engineering · Oktober 2026

FPGA im Trading: Einstieg, Kosten, realistische Erwartungen.

FPGAs sind das Ende des Latenz-Wettrüstens. Wer Marktdaten in 100 Nanosekunden parsen und Orders im selben Atemzug senden will, kommt um programmierbare Logik nicht herum. Was Sie wissen sollten, bevor Sie das erste Board bestellen — und warum die Entscheidung für die meisten Häuser nüchtern „nein" lauten sollte.

Was ein FPGA eigentlich ist.

Ein Field Programmable Gate Array ist im Kern ein Meer aus konfigurierbaren Logik-Blöcken (LUTs, Flip-Flops), DSP-Slices, Block-RAM und Hochgeschwindigkeits- Transceivern. Statt eine CPU mit Software zu instruieren, beschreiben Sie in einer Hardware-Beschreibungssprache wie VHDL oder SystemVerilog direkt die Schaltung — und der Synthesizer übersetzt diese in eine konkrete Belegung der Logikressourcen.

Im Trading-Kontext bedeutet das: Sie können Marktdaten direkt am SFP+/QSFP-Anschluss der Karte parsen, ohne dass je ein Paket den PCIe-Bus gesehen hat. Die typische Tick- to-Trade-Latenz reiner Hardware-Strategien liegt im Bereich 30–80 Nanosekunden. Zum Vergleich: ein hochgetunter Software-Pfad mit Kernel-Bypass schafft 1–3 Mikrosekunden, also rund das 30-fache.

Wofür FPGAs in Trading-Systemen typisch eingesetzt werden.

Der Entwicklungsstack.

Drei Schichten sind im Spiel:

Ein Mini-Beispiel: ein UDP-Header-Parser.

Wie sieht so etwas aus? Stark vereinfacht — SystemVerilog ist hier die Wahl, weil sie das Aussehen klassischer Programmiersprachen mit der Hardware-Semantik verbindet: 

// SystemVerilog: Minimaler UDP-Payload-Extractor
module udp_extract (
    input  logic         clk,
    input  logic         rst_n,
    input  logic [63:0]  axis_tdata,
    input  logic         axis_tvalid,
    input  logic         axis_tlast,
    output logic [15:0]  dst_port,
    output logic [63:0]  payload,
    output logic         payload_valid
);
    typedef enum logic [2:0] { IDLE, ETH, IP, UDP, PAYLOAD } state_t;
    state_t state, next;
    logic [3:0] beat;

    always_ff @(posedge clk or negedge rst_n) begin
        if (!rst_n) begin
            state <= IDLE;
            beat  <= 0;
            payload_valid <= 0;
        end else begin
            state <= next;
            if (axis_tvalid) beat <= beat + 1;
            case (state)
                UDP: dst_port <= axis_tdata[31:16];
                PAYLOAD: begin
                    payload <= axis_tdata;
                    payload_valid <= 1;
                end
                default: payload_valid <= 0;
            endcase
        end
    end

    always_comb begin
        next = state;
        case (state)
            IDLE:    if (axis_tvalid)       next = ETH;
            ETH:     if (beat == 4'd1)      next = IP;
            IP:      if (beat == 4'd4)      next = UDP;
            UDP:                            next = PAYLOAD;
            PAYLOAD: if (axis_tlast)        next = IDLE;
        endcase
    end
endmodule

Dieses Modul nimmt einen 64-Bit-AXI-Stream entgegen (Standard-Schnittstelle in der Xilinx-Welt) und extrahiert UDP-Zielport sowie Payload. In Hardware läuft das mit einer Taktfrequenz von typisch 250–400 MHz — also alle 2,5 bis 4 Nanosekunden eine Operation. Mehrere solche Module hintereinandergeschaltet bilden einen Feed-Parser, der Pakete weiter durchreicht als der PCIe-Bus sie überhaupt liefern könnte.

Das Software-Pendant — und warum es nicht reicht.

Zur Einordnung: Derselbe Parser in C++ läuft selbst auf einem 5-GHz-x86-Core mit etwa 100–200 ns. Faktor 30–50 schneller in Hardware. Das ist der Grund, warum Firmen wie Hudson River, Jump Trading oder DRW seit Jahren signifikant in FPGA-Kompetenz investieren. 

// C++-Pendant (vereinfacht)
struct UdpInfo {
    std::uint16_t dst_port;
    const uint8_t* payload;
    std::size_t len;
};

UdpInfo parse_udp(const uint8_t* p, std::size_t n) {
    // 14 Byte Ethernet + 20 Byte IPv4 ohne Options + 8 Byte UDP
    UdpInfo info;
    info.dst_port = (p[36] << 8) | p[37];
    info.payload  = p + 42;
    info.len      = n - 42;
    return info;
}

Was es wirklich kostet.

Ein realistisches Budget für den Einstieg eines kleinen Hauses:

Realistische Gesamtkosten im ersten Jahr: 300.000–500.000 €. Im Folgejahr deutlich weniger, aber laufende Lizenz-, Personal- und Co-Location-Kosten bleiben.

Wann es sich wirklich lohnt.

Drei Bedingungen sollten gleichzeitig erfüllt sein:

  1. Ihre Strategie hat eine nachgewiesene Sensitivität gegenüber Latenz im Sub-Mikrosekunden-Bereich — gemessen, nicht vermutet.
  2. Sie haben Co-Location an mindestens einer relevanten Venue oder konkrete Pläne dafür.
  3. Sie können einen Zeithorizont von 12+ Monaten finanzieren, ohne dass der ROI währenddessen unter Druck steht.

Wer diese drei Punkte nicht klar bejahen kann, ist mit einer hervorragend optimierten Software-Pipeline besser bedient. Das ist nicht resigniert — das ist ökonomisch rational. Die meisten Strategien, die in der öffentlichen Wahrnehmung „HFT" heißen, sind in Wahrheit auf Software-Stacks lauffähig und werden auch so betrieben.

Einstieg ohne sofortige Großinvestition.

Wenn Sie das Feld lernen wollen, ohne sechsstellig zu investieren: günstige Entwicklungsboards (Digilent Nexys, Xilinx KV260) gibt es ab 300 €. Damit lassen sich grundsätzliche Konzepte — Pipelining, Timing-Closure, AXI-Streams — sauber lernen. Der Sprung zu produktiver Trading-Hardware ist danach immer noch groß, aber konzeptionell kein Sprung mehr ins Unbekannte.

Open-Source-Projekte, AWS F1 Instances (Xilinx UltraScale+ in der Cloud) oder kommerzielle Trading-Cores erlauben einen Einstieg mit überschaubarem Aufwand. Wer ernsthaft in die Richtung will, baut über zwei bis drei Jahre Kompetenz auf und beobachtet, ob sich die strategische Notwendigkeit konkretisiert.

Mein Rat.

Für 95 % der Häuser, mit denen ich arbeite, ist FPGA das falsche Werkzeug. Nicht weil es nicht funktioniert — es funktioniert hervorragend —, sondern weil die strategische Edge nicht in den letzten 500 Nanosekunden liegt. Wer die Software-Seite des Stacks sauber aufgesetzt hat, hat in der Regel größere Hebel woanders: bessere Signale, besseres Risiko, niedrigere Gebühren. Erst wenn diese ausgeschöpft sind, lohnt der Blick auf programmierbare Logik.

Sie überlegen, ob FPGA für Ihre Strategie sinnvoll ist — oder ob ein gut getuneter Software-Stack reicht? Erstgespräch buchen — wir prüfen Ihre Latenzkritikalität und treffen die Entscheidung gemeinsam.