Github US Stock Quantitative Trading Collection – A Must-Have Tool for Smart People
Since the advent of Github, even ordinary people can dabble in quantitative trading. But don’t jump in and start writing your own backtesting engine from scratch — honestly, most people’s attempts won’t be as robust as a three-year-old repository on Github.
Though there are many repositories, I’ve filtered them for you. Here are the top 4:

1. VeighNa – 41.5K Stars
   VeighNa is a Python-based open-source quantitative trading system development framework. Thanks to continuous contributions from the open-source community, it has evolved into a versatile quantitative trading platform. Since its release, it has accumulated a large number of users from financial institutions and related fields, including private equity funds, securities firms, and futures companies.

2. AI-Trader – 19.6K Stars
   The best thing about this repository is that it stays constantly updated — the latest update was on June 11. Repositories that are continuously maintained are almost always treasure troves.

3. StockSharp – 10.1K Stars
   StockSharp is a free trading platform that can trade in any global market (cryptocurrency exchanges, US stocks, European stocks, Asian stocks, Russian stocks, stocks, futures, options, Bitcoin, forex, etc.). You can choose between manual trading or automated trading (algorithmic trading bots, traditional trading, or high-frequency trading).

4. QuantDinger – 7.8K Stars
   Many people have recommended QuantDinger, but it’s likely that many haven’t used it. The strength of this repository is that you can perform local upgrades and optimizations, modifying variables to create a version that suits your needs. It is an AI infrastructure based on quantitative trading.

Why is quantitative trading a must-have for smart people? Because quantitative tools allow you to free your hands and let models handle the trading. Set up strategies, backtest, simulate trading, and execute in real time — all can be done within a self-hosted tool.

I’m Nika. I regularly share useful and interesting tools and projects related to AI, US stocks, and Web3. If you’re interested, feel free to follow me. See you next time!

vnpy/vnpy

Source: https://github.com/vnpy/vnpy

VeighNa - By Traders, For Traders, AI-Powered.

💬 Want to read this in English? Go here.

VeighNa is a Python-based open-source quantitative trading system development framework. Thanks to continuous contributions from the open-source community, it has evolved into a versatile quantitative trading platform. Since its release, it has accumulated a large number of users from financial institutions and related fields, including private equity funds, securities firms, and futures companies.

If you have any questions during the development of add-ons (strategies, modules, etc.) using VeighNa, please check the VeighNa Project Documentation (https://www.vnpy.com/docs/cn/index.html). If the issue persists, visit the Official Community Forum (https://www.vnpy.com/forum/) and post in the “Q&A” section. You are also welcome to share your experience in the “Experience Sharing” section.

Want more information about VeighNa?
Scan the QR code below to add the assistant and join the VeighNa Community WeChat Group:

AI-Powered

On the occasion of VeighNa’s 10th anniversary, version 4.0 has been officially released, featuring a new vnpy.alpha module for AI quantitative strategies, providing professional quantitative traders with an all-in-one multi-factor machine learning (ML) strategy development, research, and live trading solution:

• :bar_chart: dataset: Factor feature engineering

  • Optimized for ML algorithm training, supporting efficient batch feature computation and processing
  • Built-in rich factor expression computation engine for fast one-click generation of training data
  • Custom expression function registration supported, providing common data processing functions like missing value imputation, infinity replacement, time-series normalization, and feature deletion
  • Alpha 158: Stock market feature set from Microsoft Qlib project, covering multi-dimensional quantitative factors like candlestick patterns, price trends, and time-series volatility

• :bulb: model: Predictive model training

  • Provides a standardized ML model development template that greatly simplifies model building and training
  • Unified API design enables seamless switching between different algorithms for performance comparison
  • Integrates multiple mainstream machine learning algorithms:
    • Lasso: Classic Lasso regression model with L1 regularization for feature selection
    • LightGBM: Efficient gradient boosting decision tree with an engine optimized for large-scale datasets
    • MLP: Multi-layer perceptron neural network suitable for complex nonlinear relationship modeling

• :robot: strategy: Strategy research and development

  • Quickly build quantitative trading strategies based on ML signal prediction models
  • Supports both cross-sectional multi-instruments and time-series single-instrument strategy types

• :microscope: lab: Research workflow management

  • Integrates the complete workflow: data management, model training, signal generation, and strategy backtesting
  • Simple API design with built-in visualization tools for intuitive evaluation of strategy performance and model effects

• :book: notebook: Quantitative research demos

  • download_data_rq: Download A-share index constituent stock data using RQData, including index constituent change tracking and historical market data retrieval
  • download_data_xt: Use Xuntouyan data service to download historical changes of A-share index constituents and stock K-line data
  • research_workflow_lasso: Quantitative research workflow based on Lasso regression model, demonstrating linear model feature selection and prediction capability
  • research_workflow_lgb: Quantitative research workflow based on LightGBM gradient boosting tree, using efficient ensemble learning for prediction
  • research_workflow_mlp: Quantitative research workflow based on multi-layer perceptron neural network, showing the application of deep learning in quantitative trading

The design philosophy of the vnpy.alpha module is inspired by the Qlib project. While maintaining ease of use, it provides powerful AI quantitative capabilities. Special thanks to the Qlib development team!

Features

Modules marked with :arrow_up: have completed the version 4.0 upgrade and adaptation tests. The 4.0 core framework adopts a compatibility-first upgrade approach, so most modules can be used directly (interfaces involving C++ API wrappers must be upgraded before use).

1. :arrow_up: Multi-functional quantitative trading platform (trader), integrating multiple trading interfaces and providing a simple and easy-to-use API for specific strategy algorithms and feature development, allowing traders to quickly build quantitative trading applications.

2. Covers the following trading product interfaces (gateway) both domestic and international:

   • Domestic Markets
     • :arrow_up: CTP (ctp): Domestic futures, options
     • :arrow_up: CTP Mini (mini): Domestic futures, options
     • :arrow_up: CTP Securities (sopt): ETF options
     • :arrow_up: Femas (femas): Domestic futures
     • :arrow_up: Esunny (esunny): Domestic futures, Gold TD
     • :arrow_up: HTS (hts): ETF options
     • :arrow_up: SEC (sec): ETF options
     • :arrow_up: Zhongtai XTP (xtp): Domestic securities (A-shares), ETF options
     • :arrow_up: Huaxin Qidian (tora): Domestic securities (A-shares), ETF options
     • OST (ost): Domestic securities (A-shares)
     • EMT (emt): Domestic securities (A-shares)
     • SGIT (sgit): Gold TD, domestic futures
     • :arrow_up: Ksgold (ksgold): Gold TD
     • :arrow_up: Lstar (lstar): Futures asset management
     • :arrow_up: Rohon (rohon): Futures asset management
     • :arrow_up: Jees (jees): Futures asset management
     • Comstar (comstar): Interbank market
     • :arrow_up: TTS (tts): Domestic futures (simulation)
   • Overseas Markets
     • :arrow_up: Interactive Brokers (ib): Overseas securities, futures, options, precious metals, etc.
     • :arrow_up: Tap (tap): Overseas futures
     • :arrow_up: DA (da): Overseas futures
   • Special Applications
     • :arrow_up: RQData Market Data (rqdata): Cross-market (stocks, indices, ETFs, futures) real-time quotes
     • :arrow_up: Xuntouyan Market Data (xt): Cross-market (stocks, indices, convertible bonds, ETFs, futures, options) real-time quotes
     • :arrow_up: RPC Service (rpc): Cross-process communication interface for distributed architecture

3. Covers the following quantitative strategy trading applications (app):

   • :arrow_up: cta_strategy (cta_strategy): CTA strategy engine module. While maintaining ease of use, it allows fine-grained control over order placement and cancellation behavior during CTA strategy operation (reducing trading slippage, enabling high-frequency strategies).
   • :arrow_up: cta_backtester (cta_backtester): CTA strategy backtesting module. No need for Jupyter Notebook; directly use the graphical interface for strategy backtesting analysis, parameter optimization, etc.
   • :arrow_up: spread_trading (spread_trading): Spread trading module. Supports custom spreads, real-time calculation of spread quotes and positions, two modes: spread algorithm trading and automatic spread strategy.
   • :arrow_up: option_master (option_master): Options trading module. Designed for the domestic options market, supporting multiple option pricing models, implied volatility surface calculation, Greek risk tracking, etc.
   • :arrow_up: portfolio_strategy (portfolio_strategy): Portfolio strategy module. For quantitative strategies that trade multiple contracts simultaneously (Alpha, options arbitrage, etc.), providing historical data backtesting and live automated trading capabilities.
   • :arrow_up: algo_trading (algo_trading): Algorithmic trading module. Provides several commonly used intelligent trading algorithms: TWAP, Sniper, Iceberg, BestLimit, etc.
   • :arrow_up: script_trader (script_trader): Script strategy module. Designed for multi-instrument quantitative strategies and computational tasks. Also supports REPL command trading from the command line. Does not support backtesting.
   • :arrow_up: paper_account (paper_account): Local simulation module. Pure local simulation trading function, matching orders based on real-time quotes obtained from trading interfaces, providing order fill push and position recording.
   • :arrow_up: chart_wizard (chart_wizard): K-line chart module. Based on RQData data service (futures) or trading interfaces to obtain historical data, combined with tick push to display real-time quote changes.
   • :arrow_up: portfolio_manager (portfolio_manager): Trading portfolio management module. Based on independent strategy trading portfolios (sub-accounts), providing order fill record management, automatic position tracking, and daily P&L real-time statistics.
   • :arrow_up: rpc_service (rpc_service): RPC service module. Allows one process to act as a server, acting as a unified market and order routing channel, allowing multiple clients to connect simultaneously, enabling multi-process distributed systems.
   • :arrow_up: data_manager (data_manager): Historical data management module. View data overview in the database through a tree directory, select any time period to view field details, support CSV file import and export.
   • :arrow_up: data_recorder (data_recorder): Market data recorder module. Configured via graphical interface, records tick or K-line data in real time to the database as needed, for strategy backtesting or live initialization.
   • :arrow_up: excel_rtd (excel_rtd): Excel RTD (Real Time Data) real-time data service. Based on pyxll module, enables real-time push updates of various data (quotes, contracts, positions, etc.) in Excel.
   • :arrow_up: risk_manager (risk_manager): Risk management module. Provides statistics and limits on rules including trading flow control, order quantity, active orders, total cancellations, achieving front-end risk control.
   • :arrow_up: web_trader (web_trader): Web service module. Designed for B-S architecture, implements a web server with active function calls (REST) and passive data push (Websocket).

4. Python trading API interface wrappers (api), providing low-level implementation for the above trading interfaces.

   • :arrow_up: REST Client (rest): High-performance REST API client based on coroutine asynchronous I/O, using event message loop programming model, supporting high-concurrency real-time trading order sending.
   • :arrow_up: Websocket Client (websocket): High-performance Websocket API client based on coroutine asynchronous I/O, supports concurrent operation with REST Client on the same event loop.

5. :arrow_up: Simple and easy-to-use event-driven engine (event), the core of event-driven trading programs.

6. Adapter interfaces for various databases (database):

   • SQL types
     • :arrow_up: SQLite (sqlite): Lightweight single-file database, no need to install and configure a database server. Default option for VeighNa, suitable for beginners.
     • :arrow_up: MySQL (mysql): Mainstream open-source relational database with rich documentation, replaceable with other NewSQL-compatible implementations (e.g., TiDB).
     • :arrow_up: PostgreSQL (postgresql): More feature-rich open-source relational database, supports adding functionality via extensions. Recommended for experienced users only.
   • NoSQL types
     • :arrow_up: QuestDB (questdb): Open-source high-performance columnar time-series database, compatible with PostgreSQL protocol and SQL queries, good for high-throughput writes and low-latency analytics.
     • DolphinDB (dolphindb): High-performance distributed time-series database, suitable for extremely low-latency or real-time tasks requiring high speed.
     • :arrow_up: TDengine (taos): Distributed, high-performance, SQL-supported time-series database with built-in caching, stream computing, data subscription, etc., greatly reducing R&D and operations complexity.
     • :arrow_up: MongoDB (mongodb): Document database based on distributed file storage (bson format). Built-in hot data memory cache provides faster read/write speeds.

7. Adapter interfaces for various data services (datafeed):

   • :arrow_up: Xuntouyan (xt): Stocks, futures, options, funds, bonds
   • :arrow_up: Miqian RQData (rqdata): Stocks, futures, options, funds, bonds, Gold TD
   • :arrow_up: MultiCharts (mcdata): Futures, futures options
   • :arrow_up: TuShare (tushare): Stocks, futures, options, funds
   • :arrow_up: Wind (wind): Stocks, futures, funds, bonds
   • :arrow_up: iFinD (ifind): Stocks, futures, funds, bonds
   • :arrow_up: TQSDK (tqsdk): Futures
   • :arrow_up: Golden Miner (gm): Stocks
   • :arrow_up: polygon (polygon): Stocks, futures, options

8. :arrow_up: Cross-process communication standard components (rpc), for implementing complex distributed trading systems.

9. :arrow_up: Python high-performance K-line charts (chart), supporting large data volume display and real-time data updates.

10. Community Forum (http://www.vnpy.com/forum) and Zhihu Column (http://zhuanlan.zhihu.com/vn-py), including VeighNa development tutorials and Python quantitative trading application research.

11. Official QQ group 262656087 (strict management, regular removal of long-term inactive members). The entry fee will be donated to the VeighNa community fund.

Note: The above feature descriptions are based on the documentation at the time of release. Subsequent updates or adjustments may occur. If there are discrepancies between feature descriptions and reality, please contact via Issue for corrections.

Environment Preparation

• It is recommended to use VeighNa Studio-4.4.0, a Python distribution specifically built for quantitative trading by the VeighNa team (https://download.vnpy.com/veighna_studio-4.4.0.exe). It comes with the VeighNa framework and VeighNa Station quantitative management platform integrated, no manual installation required.
• Supported systems: Windows 11+ / Windows Server 2022+ / Ubuntu 22.04 LTS+
• Supported Python versions: Python 3.10+ (64-bit), Python 3.13 recommended

Installation Steps

Download the release version here, unzip, and run the following commands to install:

Windows
install.bat

Ubuntu
bash install.sh

MacOS
bash install_osx.sh

Usage Guide

1. Register a CTP simulation account on SimNow (http://www.simnow.com.cn/) and obtain the broker code and trading market server address on this page (http://www.simnow.com.cn/product.action).
2. Register on the VeighNa Community Forum (https://www.vnpy.com/forum/) to get a VeighNa Station account and password (forum account and password are the same).
3. Launch VeighNa Station (VeighNa Studio installation will automatically create a shortcut on the desktop). Log in with the account and password from the previous step.
4. Click the VeighNa Trader button at the bottom to start trading!!!

Note:

• Do not close VeighNa Station while VeighNa Trader is running (it will automatically exit)

Script Execution

Besides the graphical launch via VeighNa Station, you can also create a run.py file in any directory and write the following example code:

from vnpy.event import EventEngine  
from vnpy.trader.engine import MainEngine  
from vnpy.trader.ui import MainWindow, create_qapp  
from vnpy_ctp import CtpGateway  
from vnpy_ctastrategy import CtaStrategyApp  
from vnpy_ctabacktester import CtaBacktesterApp  

def main():  
    """Start VeighNa Trader"""  
    qapp = create_qapp()  
    event_engine = EventEngine()  
    main_engine = MainEngine(event_engine)  
    main_engine.add_gateway(CtpGateway)  
    main_engine.add_app(CtaStrategyApp)  
    main_engine.add_app(CtaBacktesterApp)  
    main_window = MainWindow(main_engine, event_engine)  
    main_window.showMaximized()  
    qapp.exec()  

if __name__ == "__main__":  
    main()  

Open CMD in that directory (Shift + right-click -> Open command window/PowerShell here) and run the following command to start VeighNa Trader:

python run.py  

Contributing Code

VeighNa uses Github for source code hosting. If you wish to contribute code, please use Github’s PR (Pull Request) workflow:

1. Create an Issue - For larger changes (new features, large refactors, etc.), it is recommended to first open an issue for discussion. Smaller improvements (documentation fixes, bugfixes, etc.) can be submitted directly as PRs.
2. Fork VeighNa - Click the Fork button in the top right corner.
3. Clone your fork: git clone https://github.com/$userid/vnpy.git
   • If your fork is outdated, manually sync: sync method
4. Create your feature branch from dev: git checkout -b $my_feature_branch dev
5. Make changes on $my_feature_branch and push them to your fork.
6. Create a Pull Request from your fork’s $my_feature_branch branch to the main project’s dev branch. Click compare across forks, select the required fork and branch, and create the PR.
7. Wait for review. It may require further improvements, or it could be merged!

When submitting code, please follow these rules to improve code quality:

• Use ruff to check your code style, ensuring no errors or warnings. Run ruff check . in the project root directory.
• Use mypy for static type checking, ensuring type annotations are correct. Run mypy vnpy in the project root directory.

Other Content

• Getting Help
• Code of Conduct
• Issue Template
• PR Template

License

MIT

Jealousy Nika (@eastweb3eth):
Github’s most starred open-source [US Stock Intelligent Analysis System]

I just realized I haven’t shared this repository yet — truly my fault. As the repository with the most stars on Github (41.5K), its value speaks for itself.

Main features:

AI decision report: Core conclusions, scoring, trends, buy/sell points, risk alerts, catalysts, operation checklist.