Open-source project
yutiansut/QUANTAXIS avatar
yutiansut/QUANTAXIS

QUANTAXIS 2.1: the Rust fast path, the Python fallback, and the tags that do not match

QUANTAXIS supports task scheduling and distributed deployment for stocks/futures/options: a pure local quantitative solution covering data, backtesting, simulation, trading, visualization and multiple accounts.

11,370 stars3,482 forksPythonMIT

At a glance

What is it?
QUANTAXIS is a local Python quant stack covering market data, backtesting, QIFI accounts and task scheduling for stock, futures and options markets. The Rust core is optional, the options account path is unfinished, and the version in the README does not match the newest release tag.
Who is it for?
Pick QUANTAXIS if you want one local Python stack spanning data fetch, backtest, QIFI accounts and scheduling, and if you can accept pure Python speed until you install the Rust components (the README recommends the [rust] extra). Do not plan around the options account path, QAARP, or QAUltra-rs, which are respectively unfinished, removed, and only partially open source.
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 58 days ago.
What is it written in?
Mainly Python, 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.

From daily snapshots

Star history

  • yutiansut/QUANTAXIS11,370 ★ · +146
Star history
Repository2026-09-222026-11-15
yutiansut/QUANTAXIS11.2k11.4k

146 Stars in the last 54 days, measured from the daily GitHub snapshot. Compare with other projects

Editorial analysis

Two Rust paths decide whether you get the fast account or the Python fallback

Every speed claim sits behind an availability check. The release notes for 2.1.0 give account creation falling from 50ms to 0.5ms, a ten year daily backtest falling from 30 seconds to 3, and 90 percent lower memory on large positions. None of that is reachable from a plain install. QARSAccount arrives through QARSBridge, and when the QARS2 Rust core is absent the library falls back to a pure Python implementation by itself, with the same API surface. The same script therefore runs against either path, at very different speeds. Here is the complete example, stocks and futures on one account object.

python
# 完整示例
from QUANTAXIS.QARSBridge import QARSAccount

account = QARSAccount("test", init_cash=1000000)
account.buy("000001", 10.5, "2025-01-15", 1000)      # 股票买入
account.buy_open("IF2512", 4500.0, "2025-01-15", 2)  # 期货开仓
positions = account.get_positions()                   # 查询持仓

The account exposes buy() and sell() for stocks, buy_open(), sell_open(), buy_close() and sell_close() for futures, and get_qifi(), get_positions() and get_account_info() for queries. Measure your own strategy on the fallback path first, because that is the version you have on day one.

The manual QARS2 install hardcodes /home/quantaxis/qars2

Two routes to the Rust core are written down, and they are not equally portable. The extras route is a single command, while the manual route hardcodes a path.

bash
# 安装QUANTAXIS + QARS2
pip install -e .[rust]

# 或手动安装QARS2
cd /home/quantaxis/qars2
pip install -e .

That /home/quantaxis/qars2 literal is one server layout, not a placeholder you can paste anywhere. Anyone on macOS, in a container, or under a different Linux account has to rewrite it, and the QARS2 crate is not in this tree at all. The Rust work is split across several projects: QARS as the core, QADataSwap for cross language zero copy transfer between Python, Rust and C++, QAEXCHANGE-RS as a Rust exchange with an HTAP hybrid database, a C++ implementation in QAUltra-cpp, and QAUltra-rs, which is described as partially open source. The README labels the [rust] extra as the recommended install that includes the Rust components (100x performance), but the QARS2 source itself is not in this tree.

The README header says 2.1.0-alpha2, the newest version tag says 1.10.2

There is a version mismatch worth settling before you pin anything. The README header reads QUANTAXIS 2.1.0-alpha2 with an update date of 2025-10-25, and the last push to the master branch was 2026-09-18, so the tree itself is being worked on. The release list tells a different story. The most recent named version tags are 1.10.2 from 2020-12-21 and 1.9.23 from 2020-05-18, plus a release tagged latest, titled QUANTAXIS BooK, dated 2022-05-18. No 2.0.0 or 2.1.0 tag appears on that list, even though both versions have detailed change notes in the project. What this means in practice is that installing from a tag and installing from master give you different products with different dependency floors, since the Python range moved as part of the 2.x line. The alpha2 suffix also says plainly that the 2.1 track is not a stable cut, so treat a master install as a moving target and read UPGRADE_PLAN.md at the repository root before you depend on it.

v2.0.0 removed QAARP and left the options account path unfinished

Version 2.0.0 is flagged as an incompatible upgrade with major architectural change, and it names its first casualty: QAARP is removed and the older versions are no longer maintained. Anything written against it will fail to import until you rewrite it. Two further parts of the account stack are explicitly unfinished. Options support inside the QIFI module is marked as under development, and the QAFactor optimizer is listed as in development next to working single factor research, factor management, testing and factor merging. The rest of the QIFI layer is more settled: a standard qifiaccount held consistent with the Rust and C++ implementations, a qifimanager for running many accounts, a qaposition for precise single instrument positions used by arbitrage, CTA and stock work, and a marketpreset base class holding tick size, margin and fee presets. The QIFI protocol itself is designed for cross language compatibility across Python, Rust and C++, carries full account state for accounts, positions, orders and trades, supports incremental updates through a Diff mechanism, and is described as MongoDB friendly. If your book is options, the release does not support it, and the project description advertises options anyway, so check the QIFI module rather than the summary.

Four pip extras and four different costs

A minimal install is one clone and one pip command.

bash
# 克隆仓库
git clone https://github.com/QUANTAXIS/QUANTAXIS.git
cd QUANTAXIS

# 安装依赖
pip install -e .

Beyond that there are three extras, and they differ in what they drag in.

bash
# 基础安装
pip install -e .

# 包含Rust组件 (推荐)
pip install -e .[rust]

# 包含性能优化包
pip install -e .[performance]

# 完整安装
pip install -e .[full]

The base install is pure Python. The rust extra is the one marked recommended and covers the Rust components. The performance extra covers the performance optimization packages, and full is the complete install. The stated environment is Python 3.9 to 3.12 with 3.11 plus recommended, Linux, macOS or Windows, 4GB of memory minimum with 8GB plus recommended, and MongoDB 4.0 plus or ClickHouse 20.0 plus listed as optional. Those optional databases matter, because QASU and QAFetch are the modules that support MongoDB and ClickHouse storage alongside automatic maintenance, data updates, tick, L2 order and transaction formats. A base install gives you the engine without deciding where your data lives.

Cargo.toml builds only qapro-rs, not the core behind the speed claim

This repository is not a Rust project in the usual sense. The workspace file declares exactly one member.

toml
[workspace]
members = [
  "qapro-rs"]

A plain cargo build in this tree compiles qapro-rs and nothing else. The QARS2 core that the account speed figures depend on is published from the separate qa-rs repository, and the C++ implementation lives in QAUltra-cpp, so neither is reachable from a checkout of this tree. At the root you will also find Cargo.lock, a config directory, a dev directory, a doc directory, a docker directory, a scripts directory, an examples directory, install_afterrequirements.txt, setup.py, book.toml and _config.yml, which are the documentation site files. There are example scripts covering factor analysis, the data bridge, the Rust account bridge, QIFI accounts, a resource manager and a schedule server. The consequence for anyone auditing what actually executes is that the checkout looks Rust capable while containing none of the Rust that produces the quoted numbers, so reviewing the dependency graph means following references into other repositories.

setup.py refuses any interpreter outside 3.9 to 3.12

Version checking happens before anything else in the install script. setup.py compares sys.version_info against the bounds (3, 9) and (4, 0) and prints a framed error naming the exact interpreter currently running when the version is below 3.9 or 4.0 and above (its message says 3.9-3.12), then points at Python 3.9 plus as compatible with the QARS2 Rust core and 3.11 plus as the best performance choice. That window moved in this release from 3.5 through 3.10 up to 3.9 through 3.12, so an environment sitting on 3.8 that installed cleanly before now stops at install time rather than at first use. The same file imports setuptools and falls back to distutils.core, with an inline comment noting that distutils is deprecated in 3.12 and the fallback exists for older interpreters. So at the top of the range the install depends on setuptools being present, using a shim the comment itself marks as deprecated. Pin an interpreter deliberately, and remember that the dependency floor moved too: pymongo goes to 4.10.0 or newer, pandas to 2.0.0, pyarrow to 15.0.0 and redis to 5.2.0, while delegator.py, six and pyconvert were dropped.

Thirteen modules, and the services each one pulls into your deployment

The module list is wide, and each entry adds an operational dependency rather than a function call. QAPubSub is a RabbitMQ message system handling one to one, one to many and many to many distribution of compute jobs and real time order flow, so a broker becomes part of your deployment. QAWebServer is built on Tornado and exposes RESTful APIs for middle platform microservices, and QASchedule adds background, automatic and remote task scheduling. QAEngine supplies custom thread and process base classes plus a LAN distributed computing agent. QASU and QAFetch handle multi market data with MongoDB and ClickHouse storage, automatic operations and updates, and tick, L2 order and transaction formats alongside a factorized data structure. QAFactor handles factor research, QAData is an in memory database for many instruments and markets feeding real time computation and the backtest engine, QAIndicator applies custom indicators across a whole market and builds factor expressions, QAStrategy is the backtest suite for CTA and arbitrage strategies with full QIFI mode, and QAUtil covers trading calendars and time arithmetic. For live or simulated trading the notes list CTP interfaces for futures and options, QMT for stocks, a parent and child account OMS, and OrderGateway risk control. You are adopting pieces of an infrastructure, not a library, and the service count is the real adoption cost.

Editorial conclusion

Pick QUANTAXIS if you want one local Python stack spanning data fetch, backtest, QIFI accounts and scheduling, and if you can accept pure Python speed until you install the Rust components (the README recommends the [rust] extra). Do not plan around the options account path, QAARP, or QAUltra-rs, which are respectively unfinished, removed, and only partially open source. Before installing, check your interpreter, because setup.py rejects anything below Python 3.9 or at 4.0 and above.

Frequently asked questions

Does QUANTAXIS need Rust installed to work?

No. QARS2 is optional, and when it is absent the library falls back to the pure Python implementation with the same API. The Rust components are published from separate repositories, QARS at qa-rs and QADataSwap in the QUANTAXIS organization.

Which Python versions does QUANTAXIS 2.1 support?

Python 3.9 to 3.12, with 3.11 plus recommended for best performance. The range moved up from 3.5 through 3.10, and setup.py refuses interpreters below 3.9 or at 4.0 and above at install time, and its message names 3.9-3.12.

What databases does QUANTAXIS need?

MongoDB 4.0 plus or ClickHouse 20.0 plus, both marked optional. QASU and QAFetch support MongoDB and ClickHouse storage, and the QIFI protocol is described as MongoDB friendly.

Can QUANTAXIS trade options?

Not fully, according to the README. Options support inside the QIFI module is marked as under development, and QAFactor's optimizer is also listed as in development. CTP interfaces are listed for futures and options, with QMT covering stocks.

Official sources

  1. License: MIT
  2. Project website
  3. README
  4. Releases
  5. yutiansut/QUANTAXIS on GitHub
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.

Add this badge to your README

markdown
[![Hysen Labs](https://hysenlabs.com/badge/yutiansut-quantaxis.svg)](https://hysenlabs.com/projects/yutiansut-quantaxis)

Star history chart for your README

markdown
[![Star history](https://hysenlabs.com/chart/yutiansut-quantaxis.svg)](https://hysenlabs.com/projects/yutiansut-quantaxis)

Was this useful?