Skip to content

Open Source Trading Resources

Comprehensive guide to the best open-source repositories for building a commodity ETF algorithmic trading platform. Last updated: 2026-04-10

Table of Contents

  1. Full Trading Platforms
  2. Backtesting Frameworks
  3. Commodity-Specific Tools
  4. Systematic Trading & Strategy Libraries
  5. ML / AI for Trading
  6. LLM & Agent-Based Trading
  7. Data Infrastructure & Market Data
  8. Technical Analysis Libraries
  9. Portfolio Analytics & Risk
  10. Derivatives Pricing & Quantitative Finance
  11. Alternative Data & Weather
  12. Curated Lists & Meta-Resources
  13. Priority Build-On Candidates

1. Full Trading Platforms

LEAN (QuantConnect)

  • URL: https://github.com/QuantConnect/Lean
  • Stars: ~18.3k
  • License: Apache 2.0
  • Language: C# core, Python/C# strategies
  • Description: Production-grade algorithmic trading engine supporting equities, futures, options, forex, and crypto. Includes backtesting, optimization, live trading, and a cloud platform with 200k+ live algorithms deployed.
  • Why useful: Multi-asset support including futures makes it directly applicable to commodity ETF trading. Battle-tested in production at scale. The most complete open-source trading engine available.

NautilusTrader

  • URL: https://github.com/nautechsystems/nautilus_trader
  • Stars: ~4k+
  • License: LGPL-3.0
  • Language: Rust core, Python API (via PyO3)
  • Description: Production-grade, Rust-native trading engine with deterministic event-driven architecture. Nanosecond resolution, streams 5M+ rows/sec. Supports FX, equities, futures, options, crypto across multiple venues simultaneously.
  • Why useful: The highest-performance open-source trading engine. Research-to-production parity (same code runs in backtest and live). Futures support and multi-venue architecture are ideal for commodity ETF execution. Rust core means sub-microsecond latency.

VeighNa (vnpy)

  • URL: https://github.com/vnpy/vnpy
  • Stars: ~26k+
  • License: MIT
  • Language: Python
  • Description: Full-featured quantitative trading platform with CTA strategy module, algorithmic execution (TWAP, Iceberg, etc.), GUI-based backtesting, and v4.0 AI/ML quantitative strategy module. Used by hedge funds, investment banks, and proprietary trading firms.
  • Why useful: Mature platform with native CTA (Commodity Trading Advisor) strategy support. The AI module in v4.0 provides an integrated multi-factor ML strategy development pipeline. Massive user base in institutional trading.

Freqtrade

  • URL: https://github.com/freqtrade/freqtrade
  • Stars: ~48k
  • License: GPL-3.0
  • Language: Python
  • Description: The most popular open-source trading bot. Full suite: strategy development, backtesting, hyperparameter optimization via ML, live trading, Telegram/web UI. Supports 20+ exchanges via CCXT.
  • Why useful: Excellent strategy development workflow and optimization pipeline. While crypto-focused, the architecture (strategy classes, data pipeline, risk management) is directly portable to commodity ETF strategies.

Hummingbot

  • URL: https://github.com/hummingbot/hummingbot
  • Stars: ~18k
  • License: Apache 2.0
  • Language: Python
  • Description: Framework for building and deploying high-frequency market-making and arbitrage bots. Users have generated $34B+ in trading volume across 140+ venues. Modular, community-extensible architecture.
  • Why useful: Market-making and execution algorithms are directly applicable to ETF liquidity provision. The connector architecture provides a template for building commodity data feed integrations.

StockSharp

  • URL: https://github.com/StockSharp/StockSharp
  • Stars: ~9.4k
  • License: Apache 2.0
  • Language: C#
  • Description: Full trading platform with visual strategy designer, C#/Python strategy support, historical data management, and 35+ broker/exchange connections including FIX/FAST, InteractiveBrokers, and commodity futures exchanges.
  • Why useful: Direct connections to commodity futures exchanges via FIX protocol. Visual designer allows rapid strategy prototyping. Built-in market data storage.

2. Backtesting Frameworks

Backtrader

  • URL: https://github.com/mementum/backtrader
  • Stars: ~21k
  • License: GPL-3.0
  • Language: Python
  • Description: Event-driven backtesting framework with live trading support. Flexible, well-documented, large community. Supports multiple data feeds, indicators, analyzers, and broker emulation.
  • Why useful: Simplest path from strategy idea to execution. Ideal for prototyping commodity ETF strategies before migrating to a production engine. Excellent for swing/position trading timeframes typical of ETF strategies.

VectorBT

  • URL: https://github.com/polakowo/vectorbt
  • Stars: ~4.5k+
  • License: Apache 2.0 (open-source) / Commercial (PRO)
  • Language: Python (NumPy, Pandas, Numba)
  • Description: Lightning-fast vectorized backtesting engine. Uses array-based architecture and Numba JIT compilation for orders-of-magnitude speedup over event-driven alternatives. Portfolio-level strategy testing.
  • Why useful: When you need to test thousands of parameter combinations across commodity ETF universes, VectorBT's speed is unmatched. Perfect for systematic research on momentum, carry, and mean-reversion signals across commodity baskets.

hftbacktest

  • URL: https://github.com/nkaz001/hftbacktest
  • Stars: ~2.5k+
  • License: MIT
  • Language: Python + Rust
  • Description: High-frequency backtesting tool that accounts for limit orders, queue positions, and latencies using full tick data (L2/L3 order book). Multi-asset, multi-exchange support.
  • Why useful: If building execution algorithms for commodity futures/ETFs, this provides the most realistic simulation of order fill mechanics including queue priority and latency modeling.

Jesse

  • URL: https://github.com/jesse-ai/jesse
  • Stars: ~6.6k
  • License: MIT
  • Language: Python
  • Description: Advanced trading framework with Monte Carlo analysis for overfitting detection, built-in ML pipeline (scikit-learn), 300+ indicators, multi-symbol/timeframe support, and spot/futures trading.
  • Why useful: The built-in Monte Carlo stress-testing and ML pipeline are valuable for validating commodity ETF strategies. Clean API design makes it easy to extend for custom asset classes.

PyAlgoTrade

  • URL: https://github.com/gbeced/pyalgotrade
  • Stars: ~4.5k+
  • License: Apache 2.0
  • Language: Python
  • Description: Event-driven algorithmic trading library with backtesting, paper trading, and live trading support. Clean, lightweight design.
  • Why useful: Lightweight alternative when you need a simple, well-tested backtesting core without the overhead of a full platform. Good for embedding in larger systems.

3. Commodity-Specific Tools

pysystemtrade (Rob Carver)

  • URL: https://github.com/robcarver17/pysystemtrade (also https://github.com/pst-group/pysystemtrade)
  • Stars: ~3k+
  • License: GPL-3.0
  • Language: Python
  • Description: The gold standard for systematic futures trading. Implements the framework from Rob Carver's "Systematic Trading" and "Advanced Futures Trading." Full backtesting environment and automated live trading system for futures via Interactive Brokers. Rob Carver himself trades with it 20 hours/day, 5 days/week.
  • Why useful: THIS IS THE SINGLE MOST RELEVANT REPO for a commodity ETF trading platform. It includes: futures roll calendars, carry signal construction, trend-following systems, volatility targeting, portfolio optimization with instrument diversification, and production-grade IB integration. The entire carry/momentum/mean-reversion framework is built in.

risktools

  • URL: https://github.com/bbcho/risktools-dev
  • Stars: ~50+
  • License: MIT
  • Language: Python
  • Description: Risk tools for commodities trading and finance. Includes futures expiry calendars, roll adjustment functions, historical forward curves charting for crude oil and petroleum products. Covers ICE, CME Nymex, CBOT, Comex, LME, SHFE markets.
  • Why useful: Ready-made commodity futures calendars and roll adjustment logic. The forward curve tools are directly applicable to building carry signals for commodity ETFs.

RTL (Risk Tool Library)

  • URL: https://github.com/risktoollib/RTL
  • Stars: ~50+
  • License: MIT
  • Language: R (sister Python package: risktools)
  • Description: R package for commodities and finance analytics. Includes forward curve construction, seasonal analysis, and risk metrics specific to energy and commodity markets.
  • Why useful: Commodity-specific analytics that complement Python-based trading systems. Seasonal analysis is particularly valuable for agricultural and energy commodity ETF timing.

curves

  • URL: https://github.com/bananapy/curves
  • Stars: ~50+
  • License: MIT
  • Language: Python
  • Description: Tools for building commodity forward, swaps, and futures curves. Takes a collection of traded forward prices and transforms them into a forward curve of homogenous granularity. Integrates with pandas time series.
  • Why useful: Core infrastructure for building commodity forward curves, which are the foundation of carry signals. Direct pandas integration means easy pipeline construction.

cot_reports

  • URL: https://github.com/NDelventhal/cot_reports
  • Stars: ~100+
  • License: MIT
  • Language: Python
  • Description: Fetches Commitments of Traders reports from the CFTC. Supports Legacy, Supplemental, Disaggregated, and Traders in Financial Futures reports in both futures-only and futures-and-options variants.
  • Why useful: CFTC positioning data is a critical alternative data source for commodity trading. Sentiment and positioning signals from COT reports are proven alpha sources for commodity ETFs.

Commodity Derivatives Pricing Engine

  • URL: https://github.com/NavnoorBawa/Commodity-Derivatives-Pricing-Engine-Forward-Curves-Multi-Currency-Valuation-Supply-Demand-Analytics
  • Stars: Small
  • License: MIT
  • Language: Python
  • Description: Production-ready system for pricing commodity forwards/futures across 8 commodities and 5 currencies. Implements cost-of-carry models, convenience yield analysis, and supply shock scenarios.
  • Why useful: Ready-made convenience yield and cost-of-carry models. These are the theoretical foundations of commodity carry strategies.

4. Systematic Trading & Strategy Libraries

Systematic Trading Notebooks (rolling-panda-san)

  • URL: https://github.com/rolling-panda-san/notebooks
  • Stars: ~100+
  • License: MIT
  • Language: Python (Jupyter)
  • Description: Analysis on systematic trading strategies including trend-following, carry, and mean-reversion. Universe includes 24 commodity futures, 12 cross-currency pairs, and 9 equity indices. Regularly updated results.
  • Why useful: Pre-built implementations of exactly the strategies we need: trend-following, carry, and mean-reversion across commodity futures. The 24-commodity universe is a direct starting point.

quant-trading

  • URL: https://github.com/je-suis-tm/quant-trading
  • Stars: ~4k+
  • License: MIT
  • Language: Python
  • Description: Python quantitative trading strategies including Commodity Trading Advisor patterns, VIX Calculator, Pattern Recognition, Monte Carlo, Pair Trading, RSI, Bollinger Bands, MACD, and more.
  • Why useful: CTA strategy implementations are directly relevant. The pattern recognition and pair trading modules can be adapted for commodity ETF relative value strategies.

Algorithmic Trading with Python

  • URL: https://github.com/Nikhil-Adithyan/Algorithmic-Trading-with-Python
  • Stars: ~1k+
  • License: MIT
  • Language: Python
  • Description: Library of quantitative algorithms for algorithmic trading implemented in Python. Covers momentum, mean-reversion, and factor-based strategies.
  • Why useful: Reference implementations of core systematic strategies. Useful as building blocks for a commodity ETF signal library.

5. ML / AI for Trading

Qlib (Microsoft)

  • URL: https://github.com/microsoft/qlib
  • Stars: ~17k+
  • License: MIT
  • Language: Python
  • Description: AI-oriented quantitative investment platform covering the full ML pipeline: data processing, model training, backtesting, alpha seeking, risk modeling, portfolio optimization, and order execution. Supports supervised learning, market dynamics modeling, and RL. New RD-Agent automates the research process.
  • Why useful: The most mature ML-for-trading framework. The full pipeline from alpha research to execution is exactly what's needed for building ML-enhanced commodity ETF signals. The automated RD-Agent for alpha discovery is cutting-edge.

FinRL

  • URL: https://github.com/AI4Finance-Foundation/FinRL
  • Stars: ~12k+
  • License: MIT
  • Language: Python
  • Description: First open-source framework for financial reinforcement learning. Includes DQN, DDPG, PPO, SAC, A2C, TD3 agents. Simulates trading across NASDAQ-100, DJIA, S&P 500, and more. Train-test-trade pipeline.
  • Why useful: Reinforcement learning for portfolio allocation across commodity ETFs. The multi-agent environment can model commodity basket rebalancing as an RL problem.

FinRL-Meta

  • URL: https://github.com/AI4Finance-Foundation/FinRL-Meta
  • Stars: ~1.5k+
  • License: MIT
  • Language: Python
  • Description: Market environment and benchmark layer for FinRL. Builds a universe of market environments for data-driven financial RL. Provides standardized data processing and environment construction.
  • Why useful: Standardized market environment construction. Can be extended to build commodity futures market simulators for RL agent training.

FinGPT

  • URL: https://github.com/AI4Finance-Foundation/FinGPT
  • Stars: ~14k+
  • License: MIT
  • Language: Python
  • Description: Open-source financial large language models. Data-centric approach for fine-tuning LLMs on financial data. FinGPT v3 series fine-tuned on news/tweets sentiment. Fine-tuning cost under $300.
  • Why useful: LLM-based sentiment analysis for commodity markets. Can process news about weather events, geopolitical disruptions, supply chain issues that affect commodity prices. Low fine-tuning cost makes it practical.

TradingAgents

  • URL: https://github.com/TauricResearch/TradingAgents
  • Stars: ~2k+
  • License: MIT
  • Language: Python
  • Description: Multi-agent LLM framework with specialized agents: Fundamentals Analyst, Sentiment Analyst, News Analyst, Technical Analyst, Researcher, Trader, and Risk Manager. Built on LangGraph. Supports OpenAI, Anthropic, Google, xAI.
  • Why useful: The multi-agent architecture maps perfectly to commodity analysis workflows: one agent tracks weather/supply data, another monitors CFTC positioning, another runs technical signals. Modular and extensible.

6. LLM & Agent-Based Trading

awesome-ai-in-finance

  • URL: https://github.com/georgezouq/awesome-ai-in-finance
  • Stars: ~3.5k+
  • License: MIT
  • Language: Various
  • Description: Curated list of LLMs, deep learning strategies, and tools in financial markets. Covers papers, models, datasets, and implementations.
  • Why useful: Central index for finding the latest AI/ML approaches applicable to trading. Saves research time when evaluating new techniques for commodity signal generation.

7. Data Infrastructure & Market Data

OpenBB

  • URL: https://github.com/OpenBB-finance/OpenBB
  • Stars: ~35k+
  • License: AGPL-3.0
  • Language: Python
  • Description: Financial data platform for analysts, quants, and AI agents. "Connect once, consume everywhere" architecture. CLI, Python SDK, REST API, Excel, and MCP server interfaces. Commodity data, futures, economic indicators, and alternative data sources.
  • Why useful: The data layer for a commodity ETF platform. Provides unified access to commodity prices, futures data, economic indicators, and alternative data. The MCP server integration means AI agents can directly query financial data.

ArcticDB (Man Group)

  • URL: https://github.com/man-group/ArcticDB
  • Stars: ~1.5k+
  • License: Business Source License
  • Language: C++ core, Python API
  • Description: High-performance, serverless DataFrame database built for the Python data science ecosystem. Successor to Arctic (from Man AHL). Optimized for time series and tick data storage.
  • Why useful: Built by Man AHL, one of the world's largest systematic futures traders. Purpose-built for the exact use case: storing and querying commodity futures time series data at scale.

Arctic (Legacy)

  • URL: https://github.com/man-group/arctic
  • Stars: ~3.1k
  • License: LGPL-2.1
  • Language: Python (MongoDB backend)
  • Description: High-performance time series and tick data store built on MongoDB. LZ4 compression, pandas DataFrame serialization. Now in maintenance mode (successor: ArcticDB).
  • Why useful: Still valuable as a reference architecture for building a trading data store. The TickStore module specifically handles exchange price feeds.

CCXT

  • URL: https://github.com/ccxt/ccxt
  • Stars: ~41.7k
  • License: MIT
  • Language: JavaScript/TypeScript, Python, C#, PHP, Go
  • Description: Unified API for 100+ cryptocurrency exchanges. Full REST and WebSocket support. Market data, order execution, portfolio management.
  • Why useful: While crypto-focused, the unified exchange connector architecture is the gold standard for multi-venue data integration. The design pattern is directly applicable to building connectors for commodity data providers and brokers.

Trading Economics Python

  • URL: https://github.com/tradingeconomics/tradingeconomics-python
  • Stars: ~500+
  • License: MIT
  • Language: Python
  • Description: Python client for Trading Economics API. Access to commodity prices, economic indicators, forecasts, and historical data for 196 countries.
  • Why useful: Direct API access to commodity prices and macroeconomic data that drives commodity markets (GDP, inflation, industrial production, etc.).

8. Technical Analysis Libraries

TA-Lib (Python)

  • URL: https://github.com/TA-Lib/ta-lib-python
  • Stars: ~10k+
  • License: BSD
  • Language: Python (C core)
  • Description: Python wrapper for TA-Lib. 150+ technical indicators: ADX, MACD, RSI, Stochastic, Bollinger Bands, etc. C core for performance. Supports numpy, pandas, and polars.
  • Why useful: Industry-standard technical indicators. The C core provides the performance needed for computing indicators across large commodity futures datasets.

Pandas-TA

  • URL: https://github.com/twopirllc/pandas-ta
  • Stars: ~5.5k+
  • License: MIT
  • Language: Python
  • Description: 150+ indicators and 60+ candlestick patterns as a pandas DataFrame extension. Uses numba for performance. Three processing styles: Standard, DataFrame Extension, and Strategy.
  • Why useful: The DataFrame extension style means indicators integrate seamlessly into pandas-based commodity data pipelines. The Strategy abstraction allows batch computation of indicator sets.

ta (Technical Analysis Library)

  • URL: https://github.com/bukosabino/ta
  • Stars: ~4.5k+
  • License: MIT
  • Language: Python
  • Description: Technical analysis library for feature engineering from OHLCV financial time series. Built on pandas and numpy. Clean API for momentum, volatility, trend, and volume indicators.
  • Why useful: Designed specifically for ML feature engineering. The output format is ideal for feeding into ML models for commodity ETF signal generation.

9. Portfolio Analytics & Risk

QuantStats

  • URL: https://github.com/ranaroussi/quantstats
  • Stars: ~5k+
  • License: Apache 2.0
  • Language: Python
  • Description: Portfolio profiling with in-depth analytics and risk metrics. Three modules: stats (Sharpe, Win rate, Volatility, etc.), plots (drawdowns, rolling stats, monthly returns), reports (HTML tear sheets). Built-in Monte Carlo simulation.
  • Why useful: Generate professional tear sheets for commodity ETF strategy evaluation. The Monte Carlo module estimates bust probability and goal probability for risk assessment.

Pyfolio

  • URL: https://github.com/quantopian/pyfolio
  • Stars: ~5.5k+
  • License: Apache 2.0
  • Language: Python
  • Description: Portfolio and risk analytics originally developed by Quantopian. Performance attribution, sector analysis, risk factor decomposition. Maintained forks: pyfolio-reloaded.
  • Why useful: Factor-based performance attribution can decompose commodity ETF returns into systematic risk factors (commodity momentum, carry, value, etc.).

Empyrical

  • URL: https://github.com/quantopian/empyrical
  • Stars: ~1.2k+
  • License: Apache 2.0
  • Language: Python
  • Description: Common financial risk and performance metrics: Sharpe, Sortino, alpha, beta, VaR, max drawdown, etc. Used by Zipline and Pyfolio. Maintained fork: empyrical-reloaded.
  • Why useful: Core risk metrics computation library. The building block for strategy evaluation in any commodity ETF backtesting pipeline.

10. Derivatives Pricing & Quantitative Finance

QuantLib

  • URL: https://github.com/lballabio/QuantLib
  • Stars: ~5.5k+
  • License: Modified BSD
  • Language: C++ (Python bindings via QuantLib-Python/PyQL)
  • Description: The definitive open-source library for quantitative finance. Models for derivatives pricing (Black-Scholes, Hull-White, LIBOR market models), Monte Carlo, finite-difference methods, yield curves, and risk management. Used by investment banks globally.
  • Why useful: Commodity futures and options pricing. Yield curve construction for carry signal computation. Risk management models for portfolio-level VaR calculations on commodity ETF positions.

FinancePy

  • URL: https://github.com/domokane/FinancePy
  • Stars: ~2k+
  • License: GPL-3.0
  • Language: Python
  • Description: Python finance library focused on pricing and risk management of financial derivatives including fixed-income, equity, FX, and credit derivatives.
  • Why useful: Pure Python alternative to QuantLib for derivatives pricing. Easier to integrate into a Python-based commodity ETF trading system.

11. Alternative Data & Weather

Open-Meteo

  • URL: https://github.com/open-meteo/open-meteo
  • Stars: ~2.5k+
  • License: AGPL-3.0
  • Language: Swift (server), Python (client libraries)
  • Description: Free, open-source weather API. Historical data from 1940+, forecasts, and climate data. No API key required for non-commercial use. Python client libraries available.
  • Why useful: Weather data is a primary driver of agricultural commodity prices. Historical weather data from 1940 enables backtesting weather-based commodity trading signals. Free tier makes it accessible for research.

awesome-satellite-imagery-datasets

  • URL: https://github.com/chrieke/awesome-satellite-imagery-datasets
  • Stars: ~4k+
  • License: MIT
  • Language: Various
  • Description: Curated list of satellite image training datasets with annotations for computer vision and deep learning. Includes maritime object detection (xView3 Dark Vessel Detection for shipping).
  • Why useful: Satellite imagery datasets for training models that detect shipping activity, crop health, and storage facility utilization. These are proven alternative data signals for commodity trading.

openmeteopy

  • URL: https://github.com/m0rp43us/openmeteopy
  • Stars: ~100+
  • License: MIT
  • Language: Python
  • Description: Python wrapper for Open-Meteo API. Simple object model for consuming weather data including temperature, precipitation, wind, and soil moisture.
  • Why useful: Easiest way to integrate weather data into a Python-based commodity signal pipeline. Soil moisture and precipitation data are directly relevant to agricultural commodity forecasting.

12. Curated Lists & Meta-Resources

awesome-quant

  • URL: https://github.com/wilsonfreitas/awesome-quant
  • Stars: ~18k+
  • License: MIT
  • Description: The definitive curated list of libraries, packages, and resources for quantitative finance. Organized by category: frameworks, data sources, indicators, risk, etc.
  • Why useful: Master index for discovering new tools. Check this regularly for emerging projects.

awesome-systematic-trading

  • URL: https://github.com/wangzhe3224/awesome-systematic-trading
  • Stars: ~3k+
  • License: MIT
  • Description: Curated list specifically for systematic trading across crypto, stocks, futures, options, CFDs, and FX. Includes libraries, strategies, books, and tutorials.
  • Why useful: More focused than awesome-quant on systematic/algorithmic approaches. Better for finding strategy implementations and futures-specific tools.

best-of-algorithmic-trading

  • URL: https://github.com/merovinh/best-of-algorithmic-trading
  • Stars: ~1.5k+
  • License: CC-BY-SA-4.0
  • Description: Ranked list of 100 algorithmic trading open-source projects (310k+ total stars) across 7 categories. Updated weekly with quality scores.
  • Why useful: Automatically ranked and scored. The weekly updates surface emerging projects before they become well-known. Quality scoring helps prioritize evaluation.

paperswithbacktest/awesome-systematic-trading

  • URL: https://github.com/paperswithbacktest/awesome-systematic-trading
  • Stars: ~1k+
  • License: MIT
  • Description: Curated list with strategy implementations tied to academic papers. Includes time-series momentum, carry, and cross-sectional factor strategies with code.
  • Why useful: Academic paper implementations provide rigorous, peer-reviewed strategy logic. The carry and momentum implementations are directly applicable to commodity ETFs.

13. Priority Build-On Candidates

Based on the analysis above, here are the top candidates for building a commodity ETF trading platform, ranked by strategic value:

Tier 1 -- Core Foundation (Build On These)

Repository Why
pysystemtrade Purpose-built for systematic futures trading. Has roll calendars, carry signals, trend-following, volatility targeting. The closest thing to what we need out of the box.
NautilusTrader Production-grade execution engine. Rust performance with Python strategy API. Multi-asset futures support. Research-to-production parity.
Qlib Best ML pipeline for alpha research. Full workflow from data to model to backtest to execution. The RD-Agent for automated alpha discovery is a competitive advantage.
OpenBB Data layer solved. Unified access to commodity data, economic indicators, and alternative data through a single platform.

Tier 2 -- Key Components (Integrate These)

Repository Why
VectorBT Fastest backtesting for parameter sweeps across commodity universes. Essential for research phase.
FinGPT LLM sentiment analysis for commodity news (weather events, geopolitics, supply disruptions). Fine-tuning cost under $300.
ArcticDB Time series storage built by Man AHL. Purpose-designed for futures data at scale.
QuantStats Professional tear sheet generation for strategy evaluation and investor reporting.
cot_reports CFTC positioning data for sentiment/positioning signals.
Open-Meteo Free weather data from 1940+ for agricultural commodity signals.

Tier 3 -- Reference & Inspiration

Repository Why
LEAN Reference architecture for a complete trading platform.
Freqtrade Best-in-class strategy optimization and ML integration workflow.
FinRL RL-based portfolio allocation for commodity baskets.
TradingAgents Multi-agent architecture for commodity market analysis.
risktools / curves Commodity-specific forward curve and roll calendar utilities. 
Data Layer:      OpenBB + ArcticDB + Open-Meteo + cot_reports
Research:        Qlib (ML) + VectorBT (backtest) + pysystemtrade (systematic)
Signals:         FinGPT (sentiment) + TA-Lib (technical) + Custom (carry/momentum)
Execution:       NautilusTrader (production) + Backtrader (prototype)
Analytics:       QuantStats + Pyfolio + QuantLib

This document is a living reference. Repositories should be re-evaluated quarterly as the open-source trading ecosystem evolves rapidly.