thehardwarestore.ai

This repository is a curated list (awesome-list) of open-source quantitative finance libraries, packages, and resources. It provides a structured README.md organized by category, with inline language tags, and a pipeline that parses the list, enriches it with GitHub metadata (stars, last commit dates), and generates a static website deployed to GitHub Pages. The repo also includes automated tooling for pull-request review: a validation script that checks entry format, section placement, URL security, duplicate detection, and a full CI-driven PR review workflow. The core logic resides in parse.py (multi-threaded GitHub API enrichment), site/generate.py (static site generator), scripts/validate_readme.py (entry validation), and scripts/review_pr.py (automated PR review with offline URL reachability checks and cross-PR duplicate detection). The project is primarily a reference list, not an application or data pipeline, but it includes high-quality supporting tooling for maintainers and contributors.

Binance Grid Trader is a cryptocurrency trading bot that implements grid trading strategies for Binance Spot and Futures markets. The application features a modular architecture with separate layers for exchange gateways, event processing, strategy management, and user interface. It provides both a graphical interface built with PyQt5 and script-based execution modes for running trading strategies without UI. The system connects to Binance via REST and WebSocket APIs to receive market data and execute trades based on configurable grid strategies.

This repository implements a complete quantitative trading framework for A-shares, known as 'zettaranc-skill'. It is a dual-track project: (1) a Python/Rust software application providing CLI tools, a FastAPI REST API, and a React frontend for stock analysis, backtesting, simulation, screening, and strategy optimization; (2) an AI character-play skill pack that encodes a specific trading methodology (Zettaranc/Shaofu strategies) into a SKILL.md for LLM role-play. The application side dominates: it has 15+ CLI subcommands, a modular architecture with 30+ technical indicators, 20+ strategy detectors, a multi-source data layer (Tushare, Indevs, A-Stock-Data, Hithink, SQLite), a Rust-accelerated backtesting engine (via PyO3), a walk-forward simulation framework, and a self-optimization pipeline. The codebase is well-structured with clean abstractions (DataSource protocol, unified error codes, parameter registration), extensive test coverage, and CI/CD. However, it suffers from some technical drift: dual Python/Rust implementations must stay synchronized, Chinese vernacular naming reduces readability, hardcoded constants persist, and the self-optimizer's LLM judge is a stub. Overall, it is a production-grade personal quant framework with high craftsmanship in its core components.

Jesse is a mature, full-stack algorithmic trading framework designed for cryptocurrency backtesting, live/paper trading, hyperparameter optimization, Monte Carlo simulation, and rule significance testing. It combines a Python library with a FastAPI web server and a Nuxt.js dashboard, offering a comprehensive environment for developing and validating trading strategies. The repository also includes an MCP (Model Context Protocol) server for AI-assistant integration, over 180 technical indicators (many with Rust-accelerated backends), and a research API for programmatic strategy analysis. Architecture is modular with distinct layers: CLI entrypoint → web controllers / MCP tools → service layer → simulation engine (backtest/optimize/live) → exchange adapters. State management uses global singletons for in-memory simulation state, while persistent data is stored via Peewee ORM (PostgreSQL, optional TimescaleDB). The indicator library showcases a clean pattern with sequential/non-sequential modes and Rust fallback. However, the codebase shows signs of organic growth with some tightly coupled modules (global config, store singletons) and a large static frontend bundle that is opaque to analysis. Key strengths include the breadth of supported exchanges (10+), robust backtesting with realistic fee/margin/leverage modeling, and a well-designed MCP tool layer for AI-assisted development. Weaknesses include exchange driver duplication, a complex Rust subprocess for coordination, and dependency on many external APIs that require ongoing maintenance.

Pinkfish is a Python library for backtesting equity trading strategies, primarily used via Jupyter notebooks. It provides a modular framework with components for data fetching (Yahoo Finance via yfinance), trade logging, portfolio management, performance statistics, and signal generation. The core architecture revolves around a Strategy class pattern, a Portfolio class for multi-symbol backtesting, and a TradeLog class for simulating trade entries/exits with realistic open/close fills. The library includes a wide range of technical indicators (both custom and TA-Lib wrappers), comprehensive performance metrics (Sharpe, Sortino, drawdown, etc.), and support for signal notifications via Pushover/email. The codebase is well-structured with clear separation of concerns, but uses some global state in TradeLog and relies on a static stock market calendar, introducing minor maintenance risks. The examples cover diverse strategies such as momentum, moving average crossovers, and sector rotation, serving as both documentation and reusable templates.

OsEngine is a comprehensive, multi-exchange algorithmic trading platform for desktop (WPF/WinForms hybrid). It provides data downloading (OsData), backtesting (OsTester), walk-forward optimization (OsOptimizer), and live trading (OsTrader) with support for 30+ exchange connectors (MOEX, Binance, Bybit, OKX, Interactive Brokers, etc.). The platform includes a built-in technical indicator library (100+ indicators), a trading robot framework with attribute-based registration, and an MCP (Model Context Protocol) API for external AI/automation control. The architecture is modular: separate executables for different modes, a common server abstraction layer, and a consistent parameter system for bots and indicators. While the codebase is large and well-organized, it suffers from significant duplication across exchange connector entity classes and some copy-paste logic in trading robots. The UI mixes WPF and Windows Forms, and some patterns are legacy. Overall, it is a production-grade algorithmic trading platform with strong engineering practices and a rich feature set.

This repository is a high-frequency trading (HFT) research and development framework, primarily written in Java with a significant Python layer for reinforcement learning and data analysis. The actual system provides a modular architecture for backtesting and live execution of algorithmic trading strategies across multiple exchanges (Binance, Interactive Brokers, Kraken, MetaTrader). It supports market making algorithms (Avellaneda-Stoikov, ConstantSpread), factor investing, and a wide range of execution algorithms (TWAP, VWAP, Implementation Shortfall). Reinforcement learning integration is a key feature, with Gymnasium environments communicating via ZeroMQ to Java-based RL agents. The data pipeline ingests tick-level depth and trade data from Parquet/CSV files or live streams, generates OHLCV candles, and feeds into both traditional backtesting and RL training loops. While the framework is functionally rich and demonstrates advanced patterns (Disruptor ring buffers, object pools, time-series utilities), the codebase suffers from maintenance drift: many third-party libraries are vendored or outdated, hardcoded paths are scattered, and several modules contain commented-out or incomplete code. The project is a hybrid of a production-like trading engine and research code, with the dominant character being an application framework for algorithmic trading research.