QuanTime is an open-source distributed benchmarking platform that stress-tests trading matching engines. Upload an order-matching engine; QuanTime containerizes it under strict isolation, bombards it with a distributed bot fleet, and scores it live on latency, throughput, and correctness. It is a crash-test lab for exchange software, not a trading bot.
QuanTime runs every engine through the same five-stage pipeline: Upload, Isolate, Load, Measure, Rank. The same harness, the same bot fleet, the same scenario for every submission, so results are comparable and reproducible.
QuanTime is a set of decoupled Go microservices that talk over NATS and persist to TimescaleDB and Redis. Each subsystem does one job and does it under load.
QuanTime accepts a tar/zip upload of your engine with a path-traversal guard and Dockerfile validation, then builds and runs it as a hardened sibling container. Every submission gets an identical, fair hardware budget.
A NATS-driven goroutine pool generates realistic market traffic against your engine: sustained, burst, and adversarial profiles of limit, market, and cancel orders, all reproducible from a deterministic seed.
Every interaction between the bot fleet and your engine is ingested into a TimescaleDB hypertable using pgx CopyFrom batching, then aggregated into exact percentiles, no sampling, no approximation.
Scores land in Postgres as the source of truth, are cached hot in a Redis sorted set, and stream to the browser over a live WebSocket so rankings update the instant a run finishes.
Plenty of tools fire orders at an endpoint. QuanTime checks whether your engine is actually correct, reviews your code privately, and accepts any language behind a Dockerfile.
A separate reference order book replays a deterministic 10-order scenario (crossing, partial fills, market order, cancel, sweep) through both your engine and the oracle, then diffs fills order-by-order. A broken engine scores 50, not 100, and the unit tests prove it.
A multi-agent static reviewer (security, performance, correctness) reads a submission and returns a structured report. The LLM backend is pluggable — Google Gemini by default, with OpenAI and Anthropic Claude selectable. You bring your own API key; it is stored only in your browser and never persisted server-side.
Because submissions are containerized, the engine language is up to you. QuanTime ships example engines in Go, C++, and Python, plus a real-world order book, proving it accepts any language behind a Dockerfile + POST /submit.
QuanTime runs end-to-end on your laptop with Docker. Bring it up, open the console, and benchmark the bundled sample engine or your own.
Every number below comes from a real run on a laptop with a single bot-fleet replica via docker compose. No marketing math, just what the telemetry recorded.
orders per second, single bot-fleet replica.
median acknowledgment time under load.
tail latency across the run.
zero transport errors over the run.
captured per ~20-second run.
percentile_cont p50 / p90 / p99, no sampling.
speed, throughput, correctness composite.
independent reference book, fill-by-fill diff.
Go microservices over NATS JetStream, exact analytics in TimescaleDB, hot rankings in Redis, fronted by Caddy. Reproducible infra and CI that takes correctness seriously.
Decoupled Go microservices communicate over NATS JetStream and persist to TimescaleDB and Redis, all behind a Caddy reverse proxy.
A verified docker-compose stack runs the whole platform, with Kubernetes manifests and Terraform for scaling beyond a single machine.
CI runs build, vet, and tests with the Go race detector on every change, and the correctness oracle is unit-tested to catch a broken engine.
A preview of the live leaderboard using seeded sample entries. Run the platform locally to see your own engine scored and ranked here in real time over WebSocket.
| # | Engine | p50 | p99 | TPS | err | Score |
|---|
Everything you need to know about what QuanTime is, who it is for, how scoring and correctness work, how submitted code is isolated, and how it scales.
QuanTime is an open-source distributed benchmarking and hosting platform that stress-tests trading matching engines. You upload an order-matching engine; QuanTime containerizes it under strict isolation, bombards it with a distributed bot fleet, and scores it live on latency, throughput, and correctness.
No. QuanTime does not trade and does not make money. It is a test and benchmark arena, a crash-test lab for exchange software. It generates synthetic order flow purely to measure how a matching engine behaves under load, never to take positions in a real market.
QuanTime is built for the people who build matching engines: quant and HFT developers, exchange and trading-infrastructure engineers, and anyone writing an order book who wants objective, reproducible numbers on how their engine performs under realistic stress.
Package your matching engine with a Dockerfile and send it to the platform with POST /submit, or upload the .tar.gz directly in the console. QuanTime builds it, isolates it, runs the bot fleet against it, and shows you the live score. You can also start from the bundled sample engine.
The composite score is a weighted sum: 0.40 × speed + 0.40 × throughput + 0.20 × correctness. Speed and throughput come from the exact percentile and TPS telemetry, and correctness comes from the independent oracle, so an engine has to be fast, sustained, and correct to rank well.
An independent reference order book replays a deterministic 10-order scenario (crossing, partial fills, a market order, a cancel, and a sweep) through both your engine and the oracle, then diffs the fills order-by-order. The result feeds the correctness term of the composite score. The oracle is unit-tested to catch a broken engine, which scores 50 instead of 100.
Each submission runs as a hardened sibling container with --memory 256m, --cpus 1, a pid limit, --cap-drop ALL, --read-only, and no-new-privileges, on an isolated bridge network with no host access. Uploads are validated with a path-traversal guard and Dockerfile checks before anything is built.
Yes to both. The bot fleet scales horizontally with docker compose up --scale botfleet=N or a Kubernetes HPA, and the project ships docker-compose, Kubernetes manifests, and Terraform. QuanTime is open source, with the full public repository on GitHub.
Bring QuanTime up with one command, upload your matching engine, and watch live latency, throughput, correctness, and score, all on your own machine.