thehardwarestore.ai

Freqtrade is a production-grade cryptocurrency trading bot written in Python. It provides a full-fledged platform for designing, backtesting, and executing automated trading strategies across major exchanges (Binance, Kraken, Bybit, OKX, etc.) via the CCXT library. The bot supports both spot and futures trading, dry-run simulation, and live deployment with docker and systemd integration. At its core, it exposes a plugin architecture for strategy definitions, pairlist filters, and risk protection modules, all configured through a unified YAML/JSON configuration system. It also includes an embedded REST API and WebSocket server for remote monitoring and control, with optional Telegram and Discord notification channels. Beyond live trading, freqtrade offers a comprehensive research subsystem: a deterministic backtesting engine with realistic fee/slippage modeling, hyperparameter optimization (hyperopt) using Optuna with over a dozen loss functions, and a machine learning module (FreqAI) that integrates sklearn, XGBoost, LightGBM, PyTorch, and reinforcement learning (SB3). The codebase includes tools for lookahead and recursive analysis to detect strategy biases, plus data download/convert/clean utilities supporting multiple storage formats (feather, parquet, JSON). Architecturally, the project follows a modular design with clear separation of concerns: exchange abstraction layer, strategy resolver, data provider, persistence (SQLAlchemy), and RPC multiplexing. It uses dependency injection through resolvers, a logging mixin for debounced messages, and a custom scheduler for periodic tasks. The test suite is extensive with over 800 test files covering all major components. While the codebase is large and some modules (e.g., exchange-specific subclasses) are tightly coupled to CCXT, many internal patterns such as the plugin system, resolver, and data handler interfaces are well-abstracted and could be extracted for reuse in other Python trading or data pipeline projects.

This is a feature-rich companion application for the online action RPG Path of Exile (both PoE1 and PoE2). It provides real-time item price checking, trade search, wealth tracking, currency exchange rates, dangerous map modifier detection, wiki integration, and various tools (chromatic calculator, regex hotkeys, chat macros). The application runs as a cross-platform desktop app (Avalonia, legacy WPF) or as a web app, with a Blazor Server UI embedded in a WebView for desktop, or directly hosted for web. It integrates with multiple external APIs (poe.ninja, poeprices.info, poe2scout.com, poewiki.net, official Path of Exile trade API) and uses OAuth2 PKCE for account authentication. The codebase is modular, with clear separation between core common libraries, game data parsing, API clients, UI modules, and platform abstractions. It supports 10+ game languages and maintains accurate item text parsing via regex-based parsers. The architecture is a modular monolith with dependency injection, a centralized settings system (SQLite via EF Core), and an auto-update mechanism using Velopack.

CCXT is a cryptocurrency exchange trading library that provides a unified API for over 100 exchanges across 7 programming languages (TypeScript/JavaScript, Python, PHP, C#, Go, Java). The core is written in TypeScript from which all other language bindings are transpiled. It implements both REST and WebSocket APIs for market data, trading, and account management. The library normalizes exchange-specific data formats into a common schema, enabling cross-exchange arbitrage and analytics. Key architectural patterns include a base Exchange class with exchange-specific subclasses, a pro/ subdirectory for WebSocket-enabled exchanges, static_dependencies/ for vendored third-party code (ethers, starknet, bip39, etc.), and an extensive test suite with both static and live tests. The repository includes a playground (Next.js web IDE), CLI tool, documentation site (Fumadocs), CI/CD for all languages, and Docker development environment.

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.

This repository contains the backend API for a trading platform, specifically QuantDinger. It handles strategies, indicators, and market data, and has various tests and scripts for ensuring the quality and functionality of the code.

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.

This repository is a Chinese futures algorithmic trading system centered on the CTP (Commodity Trading Platform) native protocol. It comprises a C++ pybind11 bridge for low-latency market data and order execution, Python trading strategies (e.g., channel breakout, experimental transformer-based models), and a Django web dashboard for monitoring positions, orders, signals, performance, and correlations. The architecture is hybrid: the native module handles real-time CTP communication, while Python strategies run on an in-process event bus with Redis-like pub/sub. The dashboard visualizes trading metrics with ECharts and provides admin CRUD via Django admin. The system is production-oriented but exhibits several maintenance concerns: hardcoded secrets, outdated frontend libraries (Bootstrap 3, jQuery 3.1), duplicate config loading, and an incomplete ML integration. Despite these, the core CTP bridge and strategy framework are well-constructed and demonstrate solid engineering for the niche domain of Chinese futures trading.