JetDev builds margin engines and AI inference for trading venues, brokers and fintech teams, in Rust and modern C++. On day one you get a written latency budget. After that, every commit has to hold it.
Fast on an average day is easy. The work is staying fast on the worst one: at p99, in a burst, in the second the market moves.
<1µs
Margin check at p99, run inside the order path.
150µs
AI inference at p99. A quantized model on the GPU, no network hop.
2.4M/s
Throughput on a single node of commodity hardware.
99.995%
Uptime over 18 months, across three live trading deployments.
Each figure measured against the system it replaced, at the same venue, on the same class of hardware.
Day one: the budget
Follow one order through the hot path.
Five steps, one written budget of a microsecond. Scroll to fly through.
Illustrative budget
800 nanoseconds of a 1,000 nanosecond budget. A commit that crosses the line fails the build.
0ns
Step 1 of 5 · Decode order
0 nsBudget 1,000 ns
Drawn to scale
The Python tax.
Two requests leave at the same moment. One crosses a Python service to a Triton inference server. The other never leaves the Rust binary. Scroll to let time pass.
Two requests, one moment. Scroll to let time pass.
Elapsed0µs
Python service and Triton serverPython + Tritonwaiting
Rust, in-processwaiting
Native runtimeCandle and Burn instead of a PyTorch server. No interpreter on the hot path.
Quantizationint8 and f16 weights, backtested against float32 on real production traces.
Custom kernelsCUDA and Metal kernels written for the exact matrix shapes the risk model produces.
Zero-copy data pathrkyv archives and shared memory between ingest, risk and inference.
40 ms against 150 µs. One answer on the left, 266 on the right.
A 40 ms Triton call against a 150 µs in-process call, run back to back. Both lanes share one scale.
MARGIN
Where it pays off
Six moments that cost money.
Two of them are JetDev systems in production. The other four are the same method, pointed at a different hot path.
Proven in productionDerivatives and crypto venues
Volatility spikes, and the margin check becomes the slowest step in the order path.
What JetDev builds
A margin engine in Rust that runs inside the order path itself.
What you measure
p99 per check, against the written budget.
Proven in productionBrokers and fintech platforms
Your risk model sits behind a Python server, one network hop away from every decision.
What JetDev builds
The model, quantized and running inside your own binary.
What you measure
p99 per prediction, and the GPUs you no longer need.
Same methodMarket makers and trading firms
The market moves, the feed bursts, and your book falls behind exactly when it matters.
What JetDev builds
Lock-free ingest with kernel-bypass networking.
What you measure
Tail latency in the busiest second of the day.
Same methodPayments
Fraud scoring adds a service call and a queue to every single payment.
What JetDev builds
The fraud model inside the payment path, with no extra service.
What you measure
Decision time per payment at p99.
Same methodRisk desks
VaR arrives after the trade, when it should arrive before it.
What JetDev builds
VaR predicted in-process, before the order leaves.
What you measure
Time from order to risk figure.
Same methodVenues on an old engine
Nobody dares to touch the C++ engine from 2014, and every release feels like a risk.
What JetDev builds
A Rust rewrite that runs next to the old engine behind shadow traffic.
What you measure
Incidents, and p99 before and after cutover.
0106
Two systems in production.
Each one measured against the system it replaced, at the same venue, on the same class of hardware. Client names stay under NDA until we talk.
Crypto derivatives exchange2024–25
A margin engine inside the order path
Legacy C++ risk system
JetDev margin engine
Latency to scale, from the published 94 % reduction.
Problem
A legacy C++ risk system sat on the venue's hot path.
Decision
Rebuild it in Rust and run every margin check inside the order path, without adding measurable latency.
Did it hold?
Six months in production without an incident.
0.8µsp99 margin check
2.4M/sthroughput
−94%latency vs. legacy C++
Rust
Crossbeam
Tonic
Dioxus
DPDK
Fintech platform2023–24
Inference on the trading servers themselves
24of 24 GPUs retired
Problem
Predictions came from a separate Python and Torch tier: one more layer to deploy, one network hop per call.
Decision
A Rust runtime that runs quantized models right next to the trading code.
Did it hold?
The Python tier and a whole deployment layer are gone.
150µsp99 inference
−62%latency vs. Python and Torch
−78%model size
Rust
Burn
Candle
CUDA
ONNX
Our own stack. In the open since 2020.
Most trading systems are assembled from other people's frameworks. JetDev wrote its own, from TLS sockets to market-data storage, and published it: 186 repositories you can read before you ever call us.