The open-source core to
Matching, accounting, and market data: the hardest parts of a trading venue, already built, already tested against failure, and open to read. You bring the product; the engine is done.
Live demo → trade.openexchange.devAn exchange engine you can actually own
An exchange has one core job: match buyers with sellers instantly and fairly, without ever losing an order or letting a balance go wrong. Open Exchange is that core, built in the open.
A trader places an order. It's checked against risk rules, three independent servers agree on it, it's matched in a fraction of a millisecond, and everyone sees the same order book at the same moment. If a server dies mid-trade, another takes over in seconds and nothing is lost, and a test kills our cluster leader on every commit to prove it. That whole path is what you get, as source code you can read.
Built for the teams who need an engine, not a science project.
Exchanges
You’re launching a trading venue, or replacing an engine that has hit its ceiling. Start on a core that already matches, replicates, and recovers, and spend your year on markets and product instead of matching-engine plumbing.
Neobanks and fintechs
You want to add trading to a product people already use. The engine, order management, and market data come as ready infrastructure with a clear API, so your team integrates instead of inventing.
Engineers and quant teams
You want a fast core you can actually read, run, and extend. No black box, no per-trade licensing. Clone it, bring it up locally, and see exactly how it behaves under load, bugs and all.
Market makers and prop desks
You need a realistic matching venue of your own: for internal crossing, strategy testing, or simulation against a book that behaves like the real thing, with exact fills and honest latency numbers.
What we provide vs. what you own
Open Exchange is the infrastructure you build an exchange on. You bring identity, custody, fiat, and compliance; integrate those before you touch real funds.
Open Exchange provides
The infrastructure layer.
- Matching engine & array-backed order book
- Raft-consensus clustering & failover
- OMS pre-trade risk pipeline (7 checks)
- Deterministic money ledger on its own Raft cluster (Assets Engine)
- Real-time market data (WebSocket)
- Admin / ops gateway & runbooks
- Reference trading UI
- Configurable markets (demo ships BTC/ETH/SOL/XRP/DOGE-USD)
You (the integrator) own
Your product & regulatory responsibility.
- KYC / AML & sanctions compliance
- Custody & wallets (hot/cold, key management)
- Fiat on/off ramps & bank/PSP integration
- User identity, login & account opening (IAM)
- Regulatory licensing & compliance
- Real-money settlement (on/off-chain)
- Market surveillance
- Tax & regulatory reporting
Numbers we measured, not numbers we hope for
Zero allocation on the matching path, an array-backed order book, and byte-bounded pipelines. Here is what that adds up to on our test rig.
Sustained at 100.00% acceptance; the test rig ran out before the cluster did
Handles serious volume from day one, with room to grow into.
Median cluster admission latency, flat as load climbs (end-to-end adds egress batching)
Fast enough that the network, not the engine, sets your latency floor.
Egress is byte-bounded; it sheds and reconciles under overload
Doesn’t fall over under load; it stays within a fixed memory budget and recovers on its own.
Fixed-point money math, exact at every step, overflow rejected up front
Money is counted exactly, with no rounding drift and no floating-point cents.
Measured on a single Intel 13700K running a 3-node Aeron Raft cluster with external media drivers, pinned cores, and OS tuning, in local development.
Watch an order become a trade
Risk checks, a money hold on the Assets Engine, three-server Raft matching, and market data served once to the edge. The list narrates each step as it happens; pick a scenario to watch a rolling update or a failover.
The core is free. The people who built it are for hire.
Everything on this page runs without paying us anything. When you want it deployed, tuned, extended, or supported by the team that wrote it, that's what we do.
Architecture consulting
We help you decide how Open Exchange fits your product, your latency budget, and your compliance setup before you commit.
Custom configuration
Markets, tick sizes, risk limits, auth modes, cluster layout: tuned to your case instead of the defaults.
Deployment and setup
From a fresh environment to a running, monitored stack, with backups and runbooks in place.
Performance tuning
OS tuning, driver profiles, and load testing on your hardware, with honest before-and-after numbers.
Security reviews
A hard look at your deployment: auth, network exposure, secrets handling, and the edges where exchanges usually get hurt.
Legacy migration
Planned, rehearsed migrations off an existing engine, with balances reconciled to the unit before you cut over.
Support and SLAs
Ongoing help from the people who wrote the code, under support agreements with response times we'll commit to in writing.
Team training
Your engineers learn the architecture, the operations playbook, and the sharp edges directly from us.
Custom feature work
New order types, connectors, or integrations built into the stack properly, not bolted on.
Where things stand
We push the system past its limits and publish what we find, corrections included. Every release ships with honest notes.
- Money moved to the Assets Engine: a deterministic ledger on its own Raft cluster, the fifth repo in the stack.
- Every money movement is replayable: a settlement journal keyed by OMS order ids, plus a per-node money journal with a Postgres projector.
- Egress is totally ordered: every trade and status message carries its replicated-log position, so downstream state can never reorder.
- Market data is served from the edge: the cluster publishes once, Cloudflare fans out to every viewer.
- Three HIGH CVEs (netty, jackson-core, gRPC-Go) closed before the tag, not after it.
- An external security review before anything touches real funds.
- Standard market-access connectors (FIX and richer gRPC).
- Managed deployments and compliance building blocks as paid layers on top of the free core.
A small team that publishes its mistakes
We build in public: the benchmarks, the trade-offs, the OOM crash, and the 30x measurement error we caught and corrected. If you're going to trust an engine with money, you should be able to read how it was built.