Replay it exactly.
Prove it did not get slower.
BQL Engine 2.0 is latency evidence infrastructure for market systems: deterministic C++20 replay, CI latency regression gates, canonical symbol IDs, breaker-style protection logic, and audit-ready evidence bundles.
One deterministic contract for replay, latency, gates and evidence.
Low-latency teams do not fail because they lack benchmark scripts. They fail because benchmark results, replay state, runtime protection decisions, and evidence artifacts usually live in separate worlds.
BQL Engine 2.0 brings them into one deterministic contract: replay the same workload, preserve the same gate decisions, verify the same digest, and package the evidence every time.
BQL exists because latency claims without deterministic replay are not engineering evidence. They are anecdotes.
Against latency theater
// rejected- one-off benchmark scripts
- manual spreadsheets
- unstable replays
- tail metrics without sample validity
- incident logs that cannot reconstruct exact state
- “it was faster on my machine” engineering
Built for teams where one unexplained regression invalidates a release.
Head of Low-Latency Infrastructure
A release made latency worse and nobody can prove why.
Quant Platform Lead
Backtests and replays differ across environments.
Market Data / Exchange Systems Engineer
Incidents need deterministic reconstruction, not screenshots.
CTO / Engineering Director
Performance gates must fail CI before regressions reach production.
Compliance / Risk Technology Lead
Evidence needs to be reproducible, retained, and reviewable.
For teams where one unexplained latency regression can invalidate a release, BQL turns replay, latency, and evidence into a CI-enforced contract.
The deterministic proof path is explicit.
Binary capture
ITCH feeds and gen_synth workloads enter as controlled event streams.
Replay harness
The C++20 scheduler applies events through the same deterministic path.
Order book
Canonical symbol IDs normalize ordering and shard-count behavior.
DEG / SCM
Gate decisions are journaled so protection actions replay exactly.
Evidence bundle
Hashes, benchmark artifacts, metrics, reports, and manifests package the proof trail.
Normalized latency tiers, not benchmark theater.
| Tier | Scope | Current | Throughput | Status |
|---|---|---|---|---|
| Tier A | Match-only: parse + book update | ~510ms / 1M events | 1.96M events/sec | Baseline established |
| Tier B | In-process end-to-end | ~813ms / 1M events | 1.23M events/sec | Separated |
| Tier C | Full proof pipeline w/ 128MB journal | ~836ms / 1M events | 1.20M events/sec | Evidence pipeline |
Tier C total runtime improved from ~60–120s to ~0.5–0.9s.
Journal overhead reduced from 17.4s to 136ms.
Removed hot-path flushes and buffered journal writes.
Throughput improved from 2.1 MB/s to 153 MB/s.
Down from 2,518ms in Phase 3.
Digest 0x722112ad4c431cb4 verified across measured tiers.
Benchmark context guard. Benchmarks validate deterministic replay and regression-detection behavior under controlled workloads. They are not a claim of production exchange throughput without environment-specific validation.
Methodology you can audit, line by line.
Golden-state validation
deterministic fixtures and digest checks.
Tail latency purity
p99.9 and p99.99 measured with validity flags.
CI performance contract
p50 / p95 / p99 / p999 budgets fail builds on regression.
Evidence retention
benchmark JSON, Prometheus metrics, reports, manifests, and provenance bundles.
CPU pinning
core 3 default on Linux to avoid core 0 interrupt noise.
Reproducible reporting
HTML analytics report, Prometheus textfile metrics, JSONL artifacts.
Smallest breaker trips first.
Selective Coordination Mode brings the “smallest breaker trips first” principle from power systems into trading-engine protection logic. Instead of halting everything when one subsystem slows down, BQL disables or sheds only the affected zone first, preserving cleaner incident boundaries and replayable decisions.
all features enabled
early breach signals detected
optional work reduced
non-critical work aggressively shed
fail-fast and preserve incident artifacts
Evidence you can inspect, diff, and retain.
- bench.jsonl
- metrics.prom
- report/index.html
- sha256 manifests
- benchmark CSV / log / summary
- system information
- compiler information
- canonical ID evidence docs
- signed or packaged release bundles
- Public harness available
- Golden digest verified
- Benchmark bundle generated
- External replication: seeking review by low-latency C++ engineers, quant infrastructure reviewers, and reproducibility reviewers.
Enterprise BQL 2.0 Pilot
The public version is the proof harness. The enterprise version is the production-shaped integration layer for real market-data workflows, deployment controls, dashboards, and support.
- deterministic replay harness
- baseline latency profile
- CI latency gate
- reproducible benchmark report
- Prometheus/Grafana dashboard plan
- legal/compliance evidence bundle
- deployment recommendation
- executive readout
- real ITCH/FIX ingest
- Prometheus/Grafana dashboards
- CI/CD integration templates
- enterprise auth/SSO
- reproducible benchmark reports
- evidence bundles for legal/compliance
- customer pilots/reference users
- clear commercial license and support terms
Open proof harness. Commercial production path.
The public repository is available for research, review, education, and proof-harness evaluation. Production or commercial deployment should follow the commercial license and enterprise support path.
Founder.
Built by Jean Blanc.
Blanc Quant Systems is led by Jean Blanc, an award-winning engineer, quantitative systems builder and infrastructure strategist with 15+ years at the intersection of reliability engineering, asset performance, risk analytics, R&D and data-driven innovation.
Jean’s career has been built around high-consequence infrastructure: systems where reliability, traceability, performance and evidence matter. That background shapes the design philosophy behind Blanc Quant Systems.
The company is not being built as a generic market-technology project. It is being built from an infrastructure mindset: deterministic workflows, reproducible results, auditable performance, transparent benchmarking and proof-oriented system design.
In serious systems, performance claims are not enough. The system must be able to prove itself.
That means every major capability is designed around evidence: deterministic input handling, replayable execution, measurable latency, benchmark artifacts and a clear chain from input to output. Blanc Quant Systems is built for environments where speed matters, but where credibility, repeatability and auditability matter just as much.
reliability engineering, asset performance, risk analytics, R&D, and data-driven innovation
environments where reliability, traceability, performance, and evidence matter
performance claims are not enough; the system must prove itself