thehardwarestore.ai

This repository implements an agentic crypto trading platform called AI Market Maker (AIMM). Despite the name, the code is not a low-latency market-making engine; it is a multi-agent hedge-fund-style trading stack that combines LLM-driven research agents with deterministic quant logic for backtesting, paper trading, and live trading. The core execution path is a LangGraph workflow: nine Tier-0 specialist agents (monetary, news, TA, on-chain, order flow, etc.) produce structured signals, a weighted arbitrator fuses them into trade intents, a Risk Guard vetoes dangerous proposals, and portfolio management routes execution through an OMS with an in-memory or SQLite ledger. The platform includes a FastAPI backend with REST and streaming endpoints, a Next.js/React dashboard, Docker deployment, Alembic migrations, CI, and a large test suite.

EasyXT is a comprehensive quantitative trading toolkit for Chinese A-share markets, built on top of the Xuntou QMT broker platform. It provides a modular ecosystem that includes data management (multi-source with automatic fallback via DuckDB, Tushare, BaoStock, QMT DAT files, etc.), factor research (Alpha101/Alpha191 engines, IC/IR analysis, layered backtesting, Fama-French factors), backtesting engines (vectorized and event-driven with T+1 enforcement), live trading capabilities (auto-login, signal bridges, real-time quote providers, WebSocket push, monitoring), and multiple strategy implementations (grid trading, small-cap, convertible bonds, Xueqiu portfolio following). The system also features a PyQt5 desktop GUI and a Streamlit web app for factor analysis and strategy configuration. While primarily an application framework for executing trading strategies, it contains significant data research components for alpha factor development and performance analysis, making it a hybrid tool with a focus on production deployment. The codebase is large and actively maintained, with well-designed abstractions like data source adapters, cache backends, and a config manager, but also exhibits some duplication, hardcoded paths, and mixed Chinese/English naming that may hinder portability.

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.

pyalgotrading is a Python library that provides an interface to the AlgoBulls algorithmic trading platform. It enables users to create, upload, and execute trading strategies for backtesting, paper trading, and live trading. The library includes abstractions for strategies, orders, and technical indicators, along with an API client for communicating with the AlgoBulls platform. Users define strategy classes that inherit from StrategyBase, implement required methods, and then use the AlgoBullsConnection class to deploy and manage their strategies on the platform. The library supports multiple order types, technical indicators via TA-Lib, and various candlestick chart formats.

GeneTrader is a Python application that optimizes trading strategy hyperparameters for Freqtrade using genetic algorithms (default) and Optuna. It runs as a CLI tool (`main.py`) or a systemd daemon, generating candidate strategies, executing Freqtrade backtests via subprocess, and scoring candidates with a multi-component fitness function designed to prevent overfitting (minimum trades, drawdown cap, profit factor requirement, complexity penalty). The architecture is modular: `genetic_algorithm/` provides generic GA operators (crossover, mutation, tournament selection, diversity maintenance), `optimization/` contains optimizer base classes and implementations, `strategy/` handles backtest execution, walk-forward validation, and a selection bar (false-discovery diagnostic), and `scripts/` includes deployment workflows and utility scripts. The repo is hybrid—it is a software application that performs data research for trading strategy optimization, with strong emphasis on statistical rigor (walk-forward, Monte Carlo robustness, selection bar). External dependencies include Freqtrade (Docker image), Binance (for pair listing and delisting data), and SSH/SCP for deployment. The codebase is well-structured with tests, but shows signs of personal project maintenance (script sprawl, hardcoded paths, potential overfitting in sample results).

FinRL-Meta is a comprehensive Python library and framework for applying deep reinforcement learning (DRL) to financial trading. It provides a modular, plug-and-play ecosystem consisting of market environments (stock, crypto, futures, forex, portfolio allocation, order execution optimization, market impact), data processors (Yahoo Finance, Alpaca, Binance, Tushare, etc.), and DRL agent wrappers (Stable-Baselines3, ElegantRL, RLlib). The library implements the full training-testing-trading pipeline, with CLI entry points (train.py, test.py, trade.py), backtesting engines (WonderTrader integration for futures), and paper trading capabilities (Alpaca). It is the market environment layer of the larger FinRL ecosystem and includes research-grade features such as market impact models, turbulence index, and ensemble strategies. The codebase is hybrid: while primarily an application/library, it contains numerous Jupyter notebooks, experimental sub-projects (order execution with qlib, high-frequency futures), and academic paper references. This reflects its dual role as both a reusable software framework and a research reproducibility platform. The architecture is well-structured with abstract base classes (data processors, impact models, environments), factory patterns, and consistent Gym/Gymnasium interfaces. However, the repository also carries technical debt from its research origins: hardcoded paths, mixed gym versions, deprecated library usage, and some incomplete or commented-out code. The most reusable components are the data processor base class (providing a common data pipeline) and the pluggable impact model hierarchy, both of which can be extracted with minimal modification for other financial RL or simulation projects.

OptionSuite is an options trading strategy backtesting framework implemented in Python. The system uses an event-driven architecture to simulate trading strategies by processing historical options data from CSV files. It provides modular components for option types, data handling, strategy definition, portfolio management, and risk management. The main entry point is backTester.py which orchestrates the backtesting session by initializing data handlers, portfolio managers, and strategy managers. The framework supports various options strategies including naked puts, put verticals, and strangles, with configurable risk management rules for position exits.