WonderTrader splits signals from execution, and names its latencies
WonderTrader - an all-in-one framework for quant research, development and trading.
At a glance
- What is it?
- A C++ quantitative trading framework whose selling point is separation of concerns: four engines with stated latency bands, target position merging across accounts, and a Python layer called wtpy that most engines can drive but the fastest one cannot.
- Who is it for?
- WonderTrader fits a team that already trades Chinese futures, options or stock channels and needs one signal to fan out across many accounts with different risk budgets, or a research group whose Python prototypes need to survive into production. It fits badly if your latency budget is below a microsecond and your strategy is written in Python, because the fastest engine exposes nothing to an application layer, and the framework has no tagged releases to pin against.
- Can I use it commercially?
- Yes. MIT is a permissive licence: you can use, modify and sell software built on it, as long as you keep its copyright and licence notices.
- Is it still maintained?
- Yes. The repository last received commits 75 days ago.
- What is it written in?
- Mainly C++, according to GitHub's language statistics.
Answers come from the project's GitHub data, last synced on November 15, 2026, and from our analysis. They are not legal advice.
Star history
- wondertrader/wondertrader6,446 ★ · +89
| Repository | 2026-09-23 | 2026-11-15 |
|---|---|---|
| wondertrader/wondertrader | 6.4k | 6.4k |
89 Stars in the last 53 days, measured from the daily GitHub snapshot. Compare with other projects
Editorial analysis
Four engines are documented with their latency bands, not just their names
The engine list is unusually specific about what each one costs. The CTA engine, called the synchronous strategy engine, suits strategies with few instruments and fast computation, driven by events plus time, with single-instrument timing and sub-medium-frequency arbitrage as the named cases. Its demo DualThrust strategy is given a figure: about 70 microseconds per recompute in the Python implementation, about 4.5 microseconds in C++. The SEL engine, the asynchronous strategy engine, is time driven and aimed at many instruments with slow computation, such as factor stock selection and cross-sectional long short strategies. The HFT engine targets high frequency strategies and is documented at 1 to 2 microseconds of system latency. The UFT engine, added at version 0.9, targets very high frequency and is documented at under 200 nanoseconds.
The two latency figures for the same engine do not quite match, and the documentation does not reconcile them: the opening section says system latency within 175 nanoseconds, while the engine list says under 200 nanoseconds. Read both as the same order of magnitude rather than as two measurements. UFT is also the one engine with no application layer at all, since it is detached from the WtCore project and developed entirely in C++, which is why it cannot be driven from wtpy.
Signals and execution live on separate threads and can be cut apart
The clutch mechanism is the most interesting idea in the risk control chapter, and it exists only because signal generation and execution are already separated. Strategies and execution are decoupled so that signal execution and strategy computation run as independent threads. That separation is what makes a clutch possible: if a strategy or a portfolio goes wrong, the clutch disconnects signal execution directly, leaving the strategy's own logic untouched. The stated benefit is that you can keep observing how the strategy behaved during that particular stretch of market and compare it against theory, rather than killing the process and losing the evidence.
The other emergency control is blunter. A manual intervention entry point is provided by uploading a configuration file, which is described as suitable for the case where a single instrument turns risky; for market wide risk the recommendation is simply to stop the system. Alongside those sit two conventional limits: channel flow risk control aimed at compliance, counting total cancellations, order placements in a short window and cancellation counts, and account capital risk control, which limits account drawdown. Portfolio level capital control is separate again, working against the portfolio's virtual capital.
Target positions are merged, so several accounts share one set of signals
The execution model is called M+1+N and it is the piece most teams would care about. One portfolio sits in the middle, with N trading channels fanning out from it. The portfolio is the unit of product management: one combination pairs a number of strategies over a number of instruments, with a base unit of capital attached, and each strategy keeps its own theoretical position inside it. Strategies trading the same instrument therefore do not interfere with each other, theoretical positions are stored independently, and portfolio level performance is accounted separately. That independence is what makes internal performance review possible.
Execution merges target positions before sending orders, which the documentation credits with avoiding self trading and reducing margin usage and commission cost. Then multiple accounts execute the merged target concurrently, so account level performance stays consistent. The example given is concrete: a portfolio with 5 million base capital, 30 percent expected return and 10 percent maximum drawdown. An account with 10 million and the same 10 percent drawdown tolerance gets a 2x multiplier, while an account with the same 10 million but 20 percent tolerance gets 4x, and each account can carry its own independent risk logic.
wtpy is the Python layer, and it is the only part on PyPI
The application layer sits in a separate project, wtpy, written in Python 3 and built on the core. The reasoning given is that Python has strong third party libraries for time series work, needs no compilation step for editing and debugging, and is cross platform. wtpy also bundles a monitoring component, WtMonSvr, which offers a remote web interface for watching portfolio runs and a 24x7 scheduling service. That component backs the console features: real time logs, theoretical strategy data and channel data with manual start and stop, automatic scheduling of timed jobs with weekly repetition and process supervision, event forwarding from portfolios to the monitor, and a backtest viewer through the WtBtSnooper module.
Installation is documented only for this layer. It needs Python 3.8 or newer and installs from PyPI:
pip install wtpy --upgradeFor the core itself, the documentation gives repository addresses on GitHub and on Gitee for both WonderTrader and wtpy rather than a package command, and the repository root carries copy_bins_linux.sh and copy_bins_win.bat for the native binaries. So a Python only install gets you the framework's Python surface, not a built C++ core.
One data server, many portfolios, with history held in memory
The data layer is built around a one-to-many shape. The built in storage engine works locally, and real time quotes are broadcast over UDP so a 1+N structure can feed several portfolios identical data. The claim is that this reaches the architecture level of a professional data vendor and can be layered into a multi level distribution system. Historical data is cached in memory during trading, and slices of memory are referenced directly rather than copied, which the documentation credits with avoiding copies altogether. Real time data uses mmap files for fast reads and writes without data loss, and MySQL is supported for historical storage so a proprietary research database can be built on top.
The reason this exists is a scale argument made against Python platforms. A platform whose core is written in an interpreted language handles a small number of instruments fine, but past fifty or a hundred instruments the resource cost becomes the problem: multiprocessing means one process per instrument, and memory and CPU overhead climb with it, while contention makes the strategies themselves slower. The C++ core plus a shared data server is the answer to that case. Note what is not described: no crypto venue appears in the interface list at all.
The broker list is named per market, and one adapter is market data only
Supported trading interfaces are enumerated rather than abstracted, which makes this list the fastest way to judge fit. Futures: CTP, CTPMini, Femas, Yida, and Ekronke, which is listed as multicast market data only. Options: CTPOpt, the Jinzheng options maOpt interface, and a secondary development of QWIN. Stocks: Zhongtai XTP and its XTPXAlgo variant, Huaxin Qidian, Huarui ATP, and Kuanrui OES.
Two limits are visible in that list. Ekronke gives quotes and nothing else, so anyone needing futures execution through it is not covered. And the whole set is domestic Chinese venues, with no international or crypto counterparty named anywhere in the documentation. Backtesting is broader than live trading in one respect and narrower in another: a single unified engine backtests C++ strategies, wtpy Python strategies and strategies written in other language sub frameworks, and it covers not only CTA and SEL but also HFT strategies, UFT strategies and execution units. So a strategy can be tested before any broker is chosen, but only in markets somebody has written an adapter for.
No tagged releases, and the deployment piece is still marked unfinished
Two items in the documentation deserve a plain reading. The repository has no tagged releases at all, so there is no version to pin, no changelog tied to a release, and no upgrade note to read before moving between versions. The last push to the master branch is dated 2026-09-01, which tells you the branch is being worked on, but it is not a release cadence you can plan against.
The console feature list ends with full automatic remote deployment, and it is annotated as under construction. Everything beside it is presented as working: portfolio run monitoring, automatic scheduling of start, stop and restart tasks, real time event notification, and the backtest viewer. Separately, there is an extension project, Wt4ElegantRL, which uses wtpy as its backtest engine underneath a reinforcement learning framework, and the documentation closes with an official documentation site, a semi official one, and a third party set of study notes. Those are the reading materials to reach for, since the repository README itself is a feature pitch rather than an operator guide.
Editorial conclusion
WonderTrader fits a team that already trades Chinese futures, options or stock channels and needs one signal to fan out across many accounts with different risk budgets, or a research group whose Python prototypes need to survive into production. It fits badly if your latency budget is below a microsecond and your strategy is written in Python, because the fastest engine exposes nothing to an application layer, and the framework has no tagged releases to pin against. Before committing, check the broker list against your own channel, confirm whether you need the multicast-only market data adapter, and read the risk control chapter, since the clutch and the uploaded configuration file for manual intervention are the two mechanisms standing between a bad strategy and the market.
Frequently asked questions
What is WonderTrader used for?
It is a C++ quantitative trading framework covering the whole path from data storage and cleaning through backtesting to live trading and scheduling, aimed at institutional teams. Four engines are named with different latency bands, from the CTA and SEL engines for ordinary strategies to HFT and UFT for the fastest ones, and signals can be merged across many accounts through an M+1+N execution architecture.
How do I install WonderTrader and wtpy?
Only the Python layer has a documented install. wtpy needs Python 3.8 or newer and installs from PyPI with pip install wtpy --upgrade. For the C++ core the documentation gives GitHub and Gitee repository addresses for both WonderTrader and wtpy, with copy_bins_linux.sh and copy_bins_win.bat at the repository root for the native binaries, and no package manager command.
Which markets and brokers does WonderTrader support?
Futures adapters named are CTP, CTPMini, Femas, Yida and Ekronke, with Ekronke listed as multicast market data only. Options list CTPOpt, Jinzheng maOpt and a QWIN secondary development, and stocks list Zhongtai XTP, XTPXAlgo, Huaxin Qidian, Huarui ATP and Kuanrui OES. No crypto venue appears in the list.
Official sources
Add this badge to your README
If you maintain this project, the badge below links readers to this analysis and shows its maintenance status from the daily GitHub snapshot. Paste the markdown into your README; add ?metric=license or ?metric=stars to the image URL for a different field.
[](https://hysenlabs.com/projects/wondertrader-wondertrader)Star history chart for your README
[](https://hysenlabs.com/projects/wondertrader-wondertrader)Was this useful?