QuantConnect/Lean

This system is an open-source quantitative trading engine that provides a modular framework for developing, backtesting, and deploying algorithmic strategies across equities, options, futures, forex, and crypto markets. It supports a comprehensive data infrastructure for historical and live market data, alongside a pluggable architecture for alpha generation, portfolio construction, risk management, and execution logic. The platform enables users to write algorithms in C\# or Python, offering extensive brokerage integrations, optimization tools, and cloud deployment capabilities via a dedicated API.

93 changes.

This period focused on a comprehensive refactoring of the LEAN engine's core infrastructure, introducing modular brokerage models, a fluent scheduling system, and enumerator-centric data feeds. The work standardized assembly metadata, integrated Docker support, and expanded technical analysis indicators while removing legacy interfaces and deprecated integrations.

82 changes.

This period focused on establishing a modular Algorithm Framework with pluggable components for alpha generation, universe selection, portfolio construction, risk management, and execution, while introducing comprehensive support for Python-based models. It also significantly expanded the security infrastructure with dedicated implementations for CFDs, cryptocurrencies, and options, alongside new fundamental data APIs and candlestick indicators. The work was heavily supported by extensive unit and regression testing to ensure stability across these new architectural layers and asset classes.

65 changes.

This period focused on introducing the QuantBook research environment for interactive analysis and building a standalone optimizer engine with step-based parameter enumeration. It also expanded the platform's asset coverage by adding support for futures options, perpetual crypto futures, and various index instruments, alongside significant updates to margin data and brokerage integrations.

15 changes.

This period focused on enhancing platform capabilities by introducing a Level One Order Book service for real-time market data and a new token-based authentication infrastructure for brokerages. Significant engineering effort was also directed toward improving backtesting workflows through in-run diagnostics and a comprehensive optimization analysis pipeline. These features were supported by extensive regression testing and the refresh of historical market data for various futures and options contracts.

This change introduces support for Euro Stoxx 50 index futures on EUREX by adding the necessary data files. It includes factor mapping files (fesx.csv) to handle price scaling and mapping modes, contract map files to define the lifecycle of specific futures contracts through 2025, margin requirements for FESX and related DAX futures (FDAX, FDXM, etc.), and universe files containing historical OHLCV data for FESX contracts expiring in 2024 and 2025.

Data/future/eurex · high confidence

Users can now subscribe to Tiingo daily price data. This change introduces the TiingoPrice data type, which provides daily OHLCV, adjusted prices, dividends, and split factors from the Tiingo API. It includes configuration helpers for setting the API token and a symbol mapper to handle ticker format conversion between Lean and Tiingo.

Common/Data/Custom/Tiingo · high confidence

New data files have been added for the CME E-mini S&P 500 (ES) continuous futures contract. The \Data/future/cme/map\_files/es.csv\ file provides the historical mapping of contract symbols to the continuous series, while \Data/future/cme/factor\_files/es.csv\ contains the necessary scaling factors (BackwardsRatioScale, BackwardsPanamaCanalScale, ForwardPanamaCanalScale) and data mapping modes required to adjust price data across contract rollovers. This enables backtesting and live trading strategies to access a seamless, continuous price history for the ES contract.

_Data/future/cme/factor\_files, Data/future/cme/map\files · high confidence

Added historical initial and maintenance margin data for COMEX futures contracts, including the newly listed 1-Ounce Gold (1OZ) and Micro Ultra Treasury (MGT) futures, as well as updated margin schedules for existing contracts such as Gold (GC), Silver (SI), Micro Gold (MGC), Micro Silver (SIL), Platinum (PL), Palladium (PA), and others. This ensures accurate margin requirements are applied for these specific COMEX instruments in backtesting and live trading.

Data/future/comex/margins · high confidence

This change introduces new data files for the Hang Seng Index (HSI) futures on the HKFE exchange. Specifically, it adds \factor\_files/hsi.csv\ containing historical data mapping scales, \map\_files/hsi.csv\ providing contract mapping identifiers, and \margins/HSI.csv\ listing historical initial and maintenance margin requirements. These files support the underlying data infrastructure for HSI futures trading and risk calculations.

Data/future/hkfe · high confidence

Initial and maintenance margin requirements for several NYSE Liffe futures contracts (including M1EU, M1JP, M1MSA, MXEA, MXEF, MXUS, YG, YI, ZG, and ZI) are now available for the date 2022-01-01, enabling accurate margin calculations for these instruments.

Data/future/nyseliffe · high confidence

New margin interest rate CSV files have been added for Binance (ADA/USDT, BTC/USD) and Bybit (BTC/USD, BTC/USDT) perpetual futures. This data allows backtesting engines to account for funding and interest costs when trading these specific instruments.

Data/cryptofuture · high confidence

A new margin data file has been added for the KOSPI 200 Index (KM) Futures contract. This file defines the initial and maintenance margin requirements (7,087,500 and 4,725,000 respectively) starting from January 1, 1990. Note that historical margin data prior to this date is not available.

Data/future/krx · high confidence

This update adds historical portfolio state snapshots for AlphaStreams algorithms (including positions, cash books, and margin usage for dates in April 2018) and introduces a new dataset containing US federal reserve interest rate history from 2003 to 2023. Additionally, placeholder directories are created for Estimize, SEC, and Trading Economics alternative data sources to support future data ingestion.

Data/alternative · high confidence

This change introduces new API response models for CME future options, including classes for option chain quotes, product slates, and expiration lists, alongside a utility class that provides strike price scaling factors for specific underlying symbols like Silver (SI) and Natural Gas (NG).

Common/Securities/FutureOption/Api · high confidence

The engine now includes five new custom data types in the \QuantConnect.Data.Custom.IconicTypes\ namespace to support various data subscription scenarios. \LinkedData\ and \UnlinkedData\ provide base data sources for linked (mappable) and unlinked (non-mappable) tickers respectively, while \UnlinkedDataTradeBar\ offers a trade bar variant for unlinked data. Additionally, \IndexedLinkedData\ and \IndexedLinkedData2\ introduce indexed data types that point to external content files, with the latter explicitly throwing a \NotImplementedException\ for live mode to indicate it is backtesting-only.

Common/Data/Custom/IconicTypes · high confidence

The generated fundamental data classes in Common/Data/Fundamental/Generated have been updated to expose additional multi-period balance sheet properties. New fields such as AccountsPayableBalanceSheet, AccountsReceivableBalanceSheet, and AccumulatedDepreciationBalanceSheet now provide access to values across multiple time horizons (e.g., 1M, 2M, 3M, 6M, 9M, 12M), allowing users to analyze financial statement trends over shorter intervals than previously available.

Common/Data/Fundamental/Generated · high confidence

The Common/Packets module introduces several new packet classes to support updated algorithm lifecycle and resource management features. New packets include AlgorithmNameUpdatePacket and AlgorithmTagsUpdatePacket for metadata updates, AlphaNodePacket and AlphaResultPacket for alpha stream processing, and ResearchNodePacket for research tasks. The Controls class now defines specific limits for RAM, CPU, log usage, insights, orders, and storage, along with leaky bucket parameters for scheduled events. Additionally, result parameter classes (BaseResultParameters, BacktestResultParameters, LiveResultParameters) have been introduced to structure backtest and live result data, and existing packets like AlgorithmNodePacket and AlgorithmStatusPacket have been refactored to use properties, include new fields like OrganizationId and Version, and inherit from PythonEnvironmentPacket.

Common/Packets · high confidence

This change introduces the foundational API client library for the QuantConnect platform, establishing the core data models and communication mechanisms used across the system. It adds response classes for key platform features including Account (with credit card details), Backtests (including optimization parameters and performance statistics), Live Algorithms (deployment status, brokerage, and runtime statistics), and Optimizations. It also implements the Authentication helper for generating secure, time-based authorization headers and query strings, along with supporting models for data pricing, compilation states, and node information.

Common/Api · high confidence

This change introduces the foundational Docker infrastructure for running LEAN, including the \DockerfileLeanFoundation\ (with an ARM64 variant) that installs Python 3.11, Miniconda, and a comprehensive suite of quantitative libraries (e.g., pandas, scikit-learn, TensorFlow, Ray), alongside \Dockerfile\ for the main engine and \DockerfileJupyter\ for the research environment. It also adds essential developer configuration files such as \.editorconfig\ and \.dockerignore\, a \CONTRIBUTING.md\ guide, and CI scripts for performance benchmarking (\run\_benchmarks.py\, \compare\_benchmarks.py\) and automated Python stub generation for IDE support (\ci\_build\_stubs.sh\, \find\_datasource\_repos.py\).

(repo-wide) · high confidence

This change adds the core infrastructure for trading Futures Options, including the \FutureOption\ security class which configures specific margin, fill, and fee models for these instruments. It introduces \FuturesOptionsMarginModel\ to calculate margin requirements based on the underlying future's exposure, and \FuturesOptionsExpiryFunctions\ to determine contract expiration dates for a wide range of CME, CBOT, and COMEX underlying assets (such as ES, NQ, GC, CL, and currency futures). Additionally, it provides \FuturesOptionsUnderlyingMapper\ and \FuturesOptionsSymbolMappings\ to correctly resolve the underlying future contracts and ticker symbols for these options.

Common/Securities/FutureOption · high confidence

Added a new Level One Order Book service that manages real-time tracking of top-of-book market data (best bid/ask quotes and last trades) for subscribed symbols. The service aggregates quote and trade updates, handles deduplication and time-zone conversion, and publishes standardized Tick data to the shared data aggregator, enabling algorithms to access live Level 1 market depth information.

Brokerages/LevelOneOrderBook · high confidence

This change introduces the QuantConnect Research environment, providing a \QuantBook\ class for interactive quantitative analysis in Jupyter notebooks. It includes C\# and Python notebook templates (\BasicCSharpQuantBookTemplate.ipynb\, \BasicQuantBookTemplate.ipynb\, etc.), setup scripts (\Initialize.csx\, \start.py\), and dedicated history classes (\FutureHistory.cs\, \OptionHistory.cs\) to expose futures and options data. The \QuantBook\ implementation initializes the Lean engine in research mode, pre-loads necessary assemblies, and supports historical data requests, indicators, and cloud API interactions.

Research · high confidence

The system now supports a pluggable model for handling option exercise and assignment events. A new \IOptionExerciseModel\ interface and a \DefaultExerciseModel\ implementation define how in-the-money options are settled (physical or cash) and how assignments are processed for short positions. This change allows users to customize exercise logic via a Python wrapper (\OptionExerciseModelPythonWrapper\), enabling tailored behavior for option expiration outcomes rather than relying on hardcoded defaults.

Common/Orders/OptionExercise · high confidence

A new standalone application, QuantConnect.DownloaderDataProvider.exe, is introduced to handle historical data and universe data downloads via command-line arguments. Users can now download TRADE, QUOTE, and OPENINTEREST data for specific symbols and date ranges, as well as execute universe selection downloads (UNIVERSE). The tool parses command-line options for data type, tickers, security type, market, resolution, and date range, merging them with a configuration file (config.example.json) to initialize the data downloader and write results to the local data folder.

DownloaderDataProvider · high confidence

A new standalone launcher component has been added to enable running optimizations locally via the command line. This includes a console-based optimizer implementation that spawns Lean processes for each backtest, a main entry point that parses configuration and command-line arguments, and an example configuration file. Users can now execute optimization strategies (such as GridSearch or EulerSearch) directly on their machine, specifying parameters, constraints, and optimization criteria without requiring a remote server or cloud infrastructure.

Optimizer.Launcher · high confidence

The Common/Scheduling module has been refactored to support a new fluent event-building syntax via \FluentScheduledEventBuilder\, allowing users to chain date and time rules (e.g., \Every(DayOfWeek.Monday).At(TimeSpan.FromHours(9))\) before registering callbacks. The system now supports composite time rules through \CompositeTimeRule\, enabling multiple time conditions to be combined into a single scheduled event. Additionally, \FuncDateRule\ and \FuncTimeRule\ have been added to allow date and time logic to be defined by custom functions, including direct support for Python \PyObject\ callbacks and rule definitions, facilitating seamless integration with Python-based algorithms.

Common/Scheduling · high confidence

Adds new fee calculation implementations for Alpaca, AlphaStreams, Axos, Binance (spot, futures, and Coin Futures), Bitfinex, Bybit (spot and futures), Charles Schwab, Coinbase, Exante, Eze, FTX (and FTX US), FXCM, and a generic ConstantFeeModel. These models define the specific commission structures, maker/taker rates, and currency handling for orders executed through these respective brokers, ensuring accurate backtesting and live trading cost estimation.

Common/Orders/Fees · high confidence

The Algorithm/Alphas location now provides a new base \AlphaModel\ class and \IAlphaModel\ interface for generating insights, replacing the previous implicit structure. This update adds a \CompositeAlphaModel\ to combine multiple alpha models into a single stream while automatically tagging insights with their source model name, and introduces \AlphaModelPythonWrapper\ to allow Python-based alpha models to be used directly within the C\# framework. A \NullAlphaModel\ is also provided for scenarios where no alpha generation is required.

Algorithm/Alphas · high confidence

This change adds several foundational classes to the Brokerages module to support more robust live trading and data subscription. It introduces DefaultConnectionHandler for automatic reconnection and idle-time monitoring, DefaultOrderBook with BestBidAskUpdated events for tracking market depth, and BrokerageConcurrentMessageHandler to safely manage streaming messages during order submission. Additionally, it adds BaseWebsocketsBrokerage as a shared base for WebSocket-based brokerages, BrokerageMultiWebSocketSubscriptionManager for managing multiple WebSocket connections with symbol weighting, and a CrossZero order handling subsystem (CrossZeroFirstOrderRequest, CrossZeroSecondOrderRequest, CrossZeroOrderResponse) to support complex order execution flows.

Brokerages · high confidence

The engine now includes foundational data structures for market data, including the \Bar\ class for OHLC aggregation, \BaseContract\ for standardized option and future contract properties, and \BaseChain\ to manage collections of contracts. Additionally, \BaseChain\ and its derivatives (\FuturesChain\, \OptionChain\) now support a fluent filtering API, allowing users to select contracts by expiration, moneyness, or other criteria directly on the chain object.

Common/Data/Market · high confidence

The engine now includes new settlement and buying power models, specifically the AccountCurrencyImmediateSettlementModel and the BuyingPowerModel base class. The AccountCurrencyImmediateSettlementModel ensures that cash from trades is immediately converted to the account currency and applied to the portfolio, while the new BuyingPowerModel provides a structured way to calculate margin requirements and available buying power based on leverage and initial/maintenance margin settings.

Common/Securities · high confidence

This change adds the core infrastructure for grouping positions, enabling portfolio margin calculations and option strategy support. It introduces the \IPositionGroup\ and \IPositionGroupBuyingPowerModel\ interfaces, along with resolvers like \CompositePositionGroupResolver\ and \OptionStrategyPositionGroupResolver\ to handle grouping logic. New parameter and result classes (\GetMaximumLotsForDeltaBuyingPowerParameters\, \HasSufficientPositionGroupBuyingPowerForOrderParameters\, etc.) define the inputs and outputs for margin and buying power checks against these groups. Additionally, \PortfolioMarginChart\ is added to visualize the margin usage of position groups in the portfolio state.

Common/Securities/Positions · high confidence

The optimizer now uses a new set of classes in the \QuantConnect.Optimizer.Parameters\ namespace to define and serialize optimization configurations. Users can now specify step-based parameters with minimum, maximum, step, and minimum-step bounds via \OptimizationStepParameter\, or fixed values via \StaticOptimizationParameter\. These are handled by a custom \OptimizationParameterJsonConverter\ that supports deserialization from JSON objects containing 'min', 'max', 'step', and 'value' fields, and are grouped into \ParameterSet\ objects for individual optimization runs.

Common/Optimizer/Parameters · high confidence

This change introduces a new \Common/Brokerages\ location containing the foundational infrastructure for brokerage-specific behavior modeling. It adds \BrokerageExtensions\ with utility methods for validating order constraints (such as cross-zero holdings and Market-on-Open windows) and introduces the \BrokerageFactoryAttribute\ for registering brokerage factories. Additionally, it provides concrete \BrokerageModel\ implementations for Alpaca, AlphaStreams, Axos Clearing, Binance (spot, futures, and coin futures), Binance.US, Bitfinex, and Bloomberg FIX, defining their specific fee structures, leverage limits, supported order types, and security constraints.

Common/Brokerages · high confidence

The engine now exposes a new \ILeanManager\ interface in the \Engine/Server\ namespace, which standardizes the lifecycle management of a Lean instance through methods like \Initialize\, \SetAlgorithm\, \Update\, \OnAlgorithmStart\, and \OnAlgorithmEnd\. A corresponding \LocalLeanManager\ class implements this interface, providing the core logic for initializing the algorithm, setting up API handlers, and processing commands via a \FileCommandHandler\ during live trading sessions.

Engine/Server · high confidence

A new InsightManager class has been added to the Analysis framework to encapsulate the storage of insights. This component allows users to assign an insight scoring function (supporting both C\# models and Python wrappers) that is executed during each algorithm time step via the Step method. It also provides explicit methods to expire or cancel insights for specific symbols or collections, integrating directly with the algorithm's UTC time for expiration logic.

Common/Algorithm/Framework/Alphas/Analysis · high confidence

The framework now includes a new portfolio target system, introducing the IPortfolioTarget interface and the PortfolioTarget class to represent desired security holdings by quantity or percentage. The PortfolioTarget.Percent method has been updated to respect the FreePortfolioValuePercentage setting, adjusting target calculations based on free portfolio value rather than total portfolio value. Additionally, a new PortfolioTargetCollection class provides a thread-safe collection for managing these targets, supporting operations like adding, removing, and clearing targets for specific symbols.

Common/Algorithm/Framework/Portfolio · high confidence

This change introduces a new, dedicated \Crypto\ security class and its supporting components (\CryptoExchange\, \CryptoHolding\) within the \Common/Securities/Crypto\ namespace. For users, this provides a specialized implementation for cryptocurrency assets that explicitly handles base and quote currency decomposition, utilizes the \GDAXFeeModel\ for fee calculations, applies \NullSlippageModel\ by default, and leverages \ICurrencyConverter\ for accurate position valuation. The \Crypto\ class also defines its price source to prioritize the last trade price over the quote midprice, ensuring more accurate pricing representation for crypto markets.

Common/Securities/Crypto · high confidence

The Queues location now includes a new JobQueue.cs file that implements the IJobQueueHandler interface for local/desktop job requests. This change introduces automatic algorithm language detection based on file extension (.dll for C\#, .py for Python) when the 'algorithm-language' config is not explicitly set. It also adds configurable resource controls for backtesting and live modes, including limits for symbol minutes/seconds/ticks, maximum data points per chart series, maximum chart series, storage limits, and storage access permissions. The implementation supports Python virtual environment configuration via 'python-venv' and integrates with the global object store for user ID, token, and data folder settings.

Queues · high confidence

The Common/Interfaces area now defines the foundational contracts for the engine, including IAlgorithm, IApi, IBrokerage, and IAlgorithmSettings. This introduces explicit support for project IDs on algorithms, standardized brokerage models and message handling, and a comprehensive settings interface that exposes configuration options like stale price detection, warmup resolution, and portfolio rebalancing triggers. Additionally, new interfaces for data management (IDataCacheProvider, IDataProvider) and subscription management (IAlgorithmSubscriptionManager) are added to control data fetching, caching, and subscription lifecycles.

Common/Interfaces · high confidence

The algorithm framework now uses a dedicated \Insight\ model to represent alpha predictions, replacing the previous \Alpha\ terminology. This change introduces a structured \Insight\ class with properties for direction, magnitude, confidence, and scoring, along with \InsightCollection\ and \GeneratedInsightsCollection\ to manage these predictions. Users can now leverage insight scoring via the \IInsightScoreFunction\ interface and benefit from improved lifecycle management, including explicit active/expired states and grouping capabilities.

Common/Algorithm/Framework/Alphas · high confidence

The LEAN engine is now launched via a dedicated \Lean.Launcher\ executable (\Launcher/Program.cs\) instead of the previous entry point. This launcher initializes the engine system and algorithm handlers, manages the job queue lifecycle, and handles safe shutdown procedures including Python environment cleanup. A new \Launcher/config.json\ provides the default configuration structure, defining environments (backtesting, live), data providers, and brokerages (such as Interactive Brokers, Tradier, and Coinbase).

Launcher · high confidence

A new ObjectStore helper class has been added to the Common/Storage module, implementing the IObjectStore interface. This class provides a convenient wrapper around the underlying store implementation, exposing properties for maximum storage size and file limits, and offering methods to read, write, and delete data in various formats including raw bytes, strings, JSON, and XML.

Common/Storage · high confidence

The Option Strategy Matcher has been added to the Common/Securities/Option/StrategyMatcher directory, providing a new system to automatically identify and group option positions into defined strategies. This change introduces the core data structures for representing positions (\OptionPosition\, \OptionPositionCollection\) and strategy blueprints (\OptionStrategyDefinition\), along with an extensible enumeration system (\IOptionPositionCollectionEnumerator\, \IOptionStrategyDefinitionEnumerator\) to prioritize how positions and strategy definitions are evaluated. It also includes a factory for pre-defined strategy definitions (\OptionStrategyDefinitions\) and supporting utilities for predicate matching, enabling the engine to match existing holdings against known strategies to optimize margin requirements.

Common/Securities/Option/StrategyMatcher · high confidence

ToolBox now includes a new AlgoSeek Futures Converter that processes raw AlgoSeek futures data (including trade, quote, and open interest ticks) into LEAN format, utilizing a new price multipliers CSV and a Bz2StreamProvider for archive handling. Additionally, a Coarse Universe Generator has been added to produce coarse fundamental data from daily equity files, incorporating support for blacklisted tickers and map/factor file providers.

ToolBox · high confidence

The Algorithm Framework now includes a dedicated risk management layer, allowing users to define, combine, and manage risk models independently of the portfolio logic. This change introduces the \IRiskManagementModel\ interface and a \RiskManagementModel\ base class in C\#, along with corresponding Python implementations. Users can now create custom risk models by inheriting from \RiskManagementModel\ and implementing the \ManageRisk\ method to adjust portfolio targets, or use the \CompositeRiskManagementModel\ to chain multiple risk models together. A \NullRiskManagementModel\ is also provided for algorithms that do not require risk adjustments. This API is designed to be used within the Algorithm Framework, enabling more modular and flexible risk control strategies.

Algorithm/Risk · high confidence

The Algorithm/Execution directory now contains the core infrastructure for the new algorithm framework, introducing the IExecutionModel interface and the ExecutionModel base class which supports both C\# and Python implementations. This includes ImmediateExecutionModel for submitting market orders immediately based on portfolio targets, NullExecutionModel as a no-op placeholder, and ExecutionModelPythonWrapper to bridge Python algorithm logic with the C\# execution engine. These components enable users to define custom execution behaviors within the framework structure.

Algorithm/Execution · high confidence

The Indicators/CandlestickPatterns directory now includes a comprehensive suite of new candlestick pattern indicators (such as AbandonedBaby, AdvanceBlock, BeltHold, and Breakaway) built on a new CandlestickPattern base class. This addition introduces a configurable settings system (CandleSettings) that allows users to customize how candle attributes like body length and shadow size are defined, enabling more flexible pattern recognition in trading strategies.

Indicators/CandlestickPatterns · high confidence

This change introduces the new fundamental data infrastructure in the Common/Data/Fundamental directory. It adds the core data classes (FineFundamental, Fundamental, FundamentalUniverse) and a FundamentalInstanceProvider to manage and reuse data instances per symbol, improving memory footprint and performance. It also includes helper classes for Morningstar Asset Classification (StockType, StyleBox, EconomySphere, Sector codes) and the MultiPeriodField base class with period constants, enabling access to detailed financial statements, valuation ratios, and company profiles.

Common/Data/Fundamental · high confidence

The engine now includes several new classes in the HistoricalData namespace that implement the IHistoryProvider interface. BrokerageHistoryProvider retrieves historical data directly from a connected brokerage, while SubscriptionDataReaderHistoryProvider handles file-based and cached data sources with support for parallel requests and complex enumerators (fill-forward, corporate events, strict end times). MappedSynchronizingHistoryProvider provides a base for resolving symbol mappings across time. Additionally, FakeHistoryProvider and SineHistoryProvider are added to support testing and simulation by generating synthetic trade and quote data.

Engine/HistoricalData · high confidence

The platform now includes a dedicated Index security class that is non-tradable by default but allows users to explicitly enable trading via the IsTradable property. This change introduces specific infrastructure for index assets, including a market map in IndexSymbol that resolves tickers like SPX, DAX, and HSI to their correct exchanges, and specialized components for exchange hours, data filtering, and caching tailored to index behavior.

Common/Securities/Index · high confidence

Users can now access Federal Reserve Economic Data (FRED) via the Intrinio API using the new IntrinioEconomicData class, which supports various data transformations such as rate of change and logarithmic levels. The integration includes a centralized IntrinioConfig class for setting API credentials and managing request throttling via a RateGate, allowing users to adjust the time interval between API calls to comply with free (1 per minute) or paid (1 per second) subscription limits. Additionally, a new IntrinioEconomicDataSources class provides predefined constants for specific economic indicators from sources like BofA Merrill Lynch and the CBOE.

Common/Data/Custom/Intrinio · high confidence

The Optimizer area now includes the core \LeanOptimizer\ class and supporting data structures (\OptimizationNodePacket\, \OptimizationResult\) that handle optimization job packets, track backtest metrics, and manage the optimization lifecycle. A key behavioral addition is the \OptimizationStepParameterEnumerator\, which enables step-based iteration over optimization parameters, allowing users to define ranges with specific increments for their optimization strategies.

Optimizer · high confidence

The Algorithm.Framework now includes a new static utility class, NotifiedSecurityChanges, which provides convenience methods for updating collections and dictionaries in response to security change events. This class simplifies the process of adding and removing securities by offering generic methods like UpdateCollection and UpdateDictionary that handle the iteration over added and removed securities, allowing users to easily sync their internal state with the engine's universe selection changes.

Algorithm.Framework · high confidence

A new ParameterAttribute class has been introduced in the Common/Parameters namespace, allowing developers to mark fields and properties as configurable parameters. This attribute enables automatic binding of values from an AlgorithmNodePacket dictionary to algorithm instances via reflection, supporting both explicit naming and fallback to member names. It also provides utilities to inspect assemblies and types to discover all available parameters and their expected types, streamlining the process of externalizing algorithm configuration.

Common/Parameters · high confidence

This change introduces the core interfaces and base implementations for the new Portfolio Construction Model framework, including IPortfolioConstructionModel, IPortfolioOptimizer, and the PortfolioConstructionModel base class. It adds a PortfolioBias enum to define portfolio direction (Short, Long/Short, Long) and implements a NullPortfolioConstructionModel for scenarios where no targets are needed. Crucially, it adds PortfolioConstructionModelPythonWrapper to enable Python algorithms to override C\# portfolio construction logic, ensuring proper PythonNet integration and GIL management. The base model now supports rebalancing on security changes and insight updates, with logic to expire insights for removed securities.

Algorithm/Portfolio · high confidence

The Report/PortfolioLooper directory now contains the core implementation for a new report generation engine that reconstructs portfolio states from historical order events. This includes the PortfolioLooper class, which orchestrates the reprocessing of filled orders to calculate point-in-time holdings and metrics, supported by a specialized PortfolioLooperAlgorithm that initializes securities and cash settings based on the provided order history. A MockDataFeed is also introduced to provide a no-op data feed implementation required by the internal LEAN engine components during this offline backtesting-style report generation.

Report/PortfolioLooper · high confidence

The SignalExports module now includes built-in support for exporting portfolio signals to four third-party platforms. Users can configure Collective2 (including white-label API support), CrunchDAO, Numerai, and vBase directly within the framework. The SignalExportManager handles the orchestration, allowing providers to be added via C\# or Python, and automatically filters out non-tradeable securities and unsupported security types before sending the payload.

Common/Algorithm/Framework/Portfolio/SignalExports · high confidence

The system now supports three distinct order expiration behaviors via new \TimeInForce\ implementations. The \*\Day\\* time-in-force expires orders at the end of the trading day, with specific cutoff logic for Forex (5 PM New York time), Crypto (midnight UTC), and other securities (market close). The \*\Good-Til-Canceled (GTC)\\* time-in-force ensures orders remain active indefinitely until manually canceled. The \*\Good-Til-Date (GTD)\\* time-in-force allows users to specify a fixed expiration date/time, applying similar asset-class-specific expiry rules (Forex cutoff, Crypto midnight, others market close) to determine when the order is automatically cancelled.

Common/Orders/TimeInForces · high confidence

The Compression library now includes a new ZipStreamWriter class that provides a TextWriter-based interface for appending text content to zip entries, simplifying the creation of text-based zip archives. Additionally, the existing ZipData methods have been refactored to support new overloads, including one that accepts lines of text directly, and the internal implementation has been optimized to use more direct byte writing and improved error handling.

Compression · high confidence

The Common module introduces the AlgorithmConfiguration class to bundle algorithm metadata (name, tags, account currency, brokerage, account type, parameters, and deployment details) for inclusion in result packets, and the AlgorithmSettings class to expose user-configurable runtime options such as automatic indicator warm-up, portfolio rebalancing triggers, stale price detection, and trading days per year. A new AlgorithmUtils class provides helper methods to seed security prices and currency conversion rates, while the Analysis class defines a structure for backtest diagnostic results. On the Python side, AlgorithmImports.py is added to streamline assembly loading and restore Python's built-in Exception handling.

Common · high confidence

The engine now introduces a new algorithm framework for universe selection, providing a set of new models to define which securities to trade. This includes \CompositeUniverseSelectionModel\ to combine multiple selection strategies, \CustomUniverseSelectionModel\ for dynamic symbol selection via delegates, \ManualUniverseSelectionModel\ for static symbol lists, and \OptionChainedUniverseSelectionModel\ to automatically create option chains based on underlying universe changes. A new \IUniverseSelectionModel\ interface and \UniverseSelectionModel\ base class standardize this behavior, with full Python support via \UniverseSelectionModelPythonWrapper\ allowing users to implement custom selection logic in Python.

Algorithm/Selection · high confidence

The framework now includes several new universe selection models to broaden algorithmic strategies, alongside full Python support for existing models. New additions include CoarseFundamentalUniverseSelectionModel for US equity coarse data selection, FineFundamentalUniverseSelectionModel for combined coarse/fine fundamental filtering, ETFConstituentsUniverseSelectionModel to select constituents of specific ETFs, and FutureUniverseSelectionModel for subscribing to future chains. Additionally, the EmaCrossUniverseSelectionModel has been implemented to select symbols based on exponential moving average crossovers, and the EnergyETFUniverse provides a pre-configured basket of energy sector ETFs. All these models are available in both C\# and Python, allowing users to define selection logic in their preferred language.

Algorithm.Framework/Selection · high confidence

The system now includes a new set of classes in the Common/Data/Auxiliary directory to manage auxiliary data such as map files and corporate action factors. This introduces interfaces like IFactorProvider and IMapFileProvider, along with concrete implementations for reading from local disk (LocalDiskFactorFileProvider, LocalDiskMapFileProvider) and local zip archives (LocalZipFactorFileProvider, LocalZipMapFileProvider). These providers handle caching, expiration, and resolution of symbol mappings and price/split factors, enabling more robust and performant access to historical corporate action data for backtesting and live trading.

Common/Data/Auxiliary · high confidence

Added a suite of new benchmark algorithms in the Algorithm.CSharp/Benchmarks directory to establish performance baselines for various engine capabilities. These include BasicTemplateBenchmark for a standard minute-resolution equity strategy, CoarseFineUniverseSelectionBenchmark and Stateful/StatelessCoarseUniverseSelectionBenchmark for universe selection overhead, EmptyMinute400EquityBenchmark and EmptyEquityAndOptions400Benchmark for large-scale data loading and synchronization, HistoryRequestBenchmark for history retrieval performance, IndicatorRibbonBenchmark for indicator calculation load, ScheduledEventsBenchmark for event scheduling overhead, and EmptySPXOptionChainBenchmark and EmptySingleSecuritySecondEquityBenchmark for specific data handling scenarios.

Algorithm.CSharp/Benchmarks · high confidence

This update introduces several new example algorithms in the \Algorithm.CSharp/Alphas\ directory, expanding the available benchmark strategies. These include \GasAndCrudeOilEnergyCorrelationAlpha\ (using natural gas as a leading indicator for crude oil), \GlobalEquityMeanReversionIBSAlpha\ (ranking global ETFs by Internal Bar Strength), \GreenblattMagicFormulaAlpha\ (selecting stocks via EV/EBITDA and Return on Capital), \IntradayReversalCurrencyMarketsAlpha\ (USD reversal during NY lunch hours), \MeanReversionLunchBreakAlpha\ (ETF mean-reversion during lunch breaks), \RebalancingLeveragedETFAlpha\ (capitalizing on leveraged ETF rebalancing momentum), \ShareClassMeanReversionAlpha\ (dollar-neutral pairs trading on dual share classes), and \SykesShortMicroCapAlpha\ (shorting micro-cap stocks).

Algorithm.CSharp/Alphas, Algorithm.Python/Alphas · high confidence

The DownloaderDataProvider/Models area introduces a new set of classes to support downloading data directly from brokerages. This includes \BaseDataDownloadConfig\ as an abstract base for download parameters, concrete configurations for standard data (\DataDownloadConfig\) and universe data (\DataUniverseDownloadConfig\), and the \BrokerageDataDownloader\ implementation which retrieves historical data via a configured brokerage instance. Additionally, \DownloaderCommandArguments\ defines the command-line constants used to configure these downloads.

DownloaderDataProvider/Models · high confidence

This update introduces a comprehensive set of new order property classes for various brokerages, including Alpaca, Binance, Bitfinex, Bloomberg FIX, Bybit, Charles Schwab, ClearStreet, Coinbase, Eze, FTX, and GDAX (deprecated in favor of Coinbase). These classes allow users to configure brokerage-specific settings such as post-only execution, extended hours trading, and locate requirements. Additionally, the diff adds the foundational classes for combo orders (ComboOrder, ComboMarketOrder, ComboLimitOrder, ComboLegLimitOrder) and their management (GroupOrderManager, GroupOrderCacheManager, GroupOrderExtensions), enabling the creation and handling of multi-leg order groups.

Common/Orders · high confidence

The Common/Commands module introduces a structured command framework that allows external systems to interact with running algorithms via a queue. This includes a base command infrastructure (ICommand, BaseCommand, CommandResultPacket) and specific handlers for managing algorithm state and trading actions, such as adding securities, submitting/updating/canceling orders, liquidating positions, and changing algorithm status. A FileCommandHandler is provided to source these commands from local JSON files, enabling file-based orchestration of algorithm behavior.

Common/Commands · high confidence

This change introduces a new base class, BaseDataConsolidator, for consolidating generic base data into TradeBars, and a timeless base class, BaseTimelessConsolidator, for value-driven bars like Renko and Range. It adds specific consolidators including ClassicRenkoConsolidator, ClassicRangeConsolidator, and DollarVolumeRenkoConsolidator, alongside utility classes like Calendar (replacing the obsolete CalendarType) and FilteredIdentityDataConsolidator. The update also includes DynamicDataConsolidator for flexible data types and MarketHourAwareConsolidator to restrict consolidation to market hours.

Common/Data/Consolidators · high confidence

The data feed engine has been refactored to introduce a new \AggregationManager\ for consolidating ticks and bars, alongside new \BacktestingChainProvider\ implementations for sourcing futures and options contract lists from local zip files. Additionally, an \ApiDataProvider\ has been added to download and update data files via the QuantConnect API, including logic to handle purchase limits and data agreements.

Engine/DataFeeds · high confidence

The Common/Data module introduces several new foundational classes to support the data engine: BaseDataRequest for abstracting data request parameters, Channel for managing subscription channels, ConsolidatorWrapper for handling consolidator scan timing, DataHistory for lazy-evaluated historical data, DataMonitor for tracking data request success/failure rates, and DataQueueHandlerSubscriptionManager for managing live data subscriptions. It also adds ConstantDividendYieldModel and ConstantRiskFreeRateInterestRateModel for static financial models, DiskDataCacheProvider for file-based caching, and DownloaderExtensions for symbol mapping during data downloads.

Common/Data · high confidence

Added three new execution models in the Algorithm.Framework.Execution namespace: SpreadExecutionModel, StandardDeviationExecutionModel, and VolumeWeightedAveragePriceExecutionModel, each with C\# and Python implementations. SpreadExecutionModel submits orders only when the bid-ask spread is within a configurable percentage of the current price. StandardDeviationExecutionModel executes when the price is at least a configured number of standard deviations away from the mean in the favorable direction, with a maximum order value cap. VolumeWeightedAveragePriceExecutionModel executes when the price is more favorable than the current volume-weighted average price, with a maximum order size based on a percentage of current bar volume. All models support asynchronous order submission, order sizing by margin impact, and Python override hooks for customization.

Algorithm.Framework/Execution · high confidence

The platform now supports a new file-based options universe structure located in \Data/indexoption/usa/universes\. This change introduces CSV files for the S&P 500 (SPX), weekly S&P 500 (SPXW), and Nasdaq-100 (NQX) indices, containing detailed option chain data including expiry, strike, right (Call/Put), pricing, volume, open interest, and Greeks. This new format replaces or supplements previous data ingestion methods, allowing users to access historical and current options universes via this standardized file structure.

Data/indexoption/usa/universes · high confidence

This change introduces five new alpha model implementations in the Algorithm.Framework.Alphas namespace, available in both C\# and Python, allowing users to generate trading insights using different statistical and technical strategies. The BasePairsTradingAlphaModel identifies correlated security pairs and emits long/short ratio insights when the spread deviates from the mean. The ConstantAlphaModel provides a simple way to emit a fixed insight (type, direction, magnitude) for every security in the universe. The EmaCrossAlphaModel generates insights based on crossovers between fast and slow Exponential Moving Averages. The HistoricalReturnsAlphaModel creates insights derived from the Rate of Change (historical returns) of securities. Finally, the MacdAlphaModel produces insights based on MACD crossovers, including support for a bounce threshold to handle flat signals. All models follow the standard AlphaModel interface, integrating with the framework's security change and data update lifecycle.

Algorithm.Framework/Alphas · high confidence

The \Algorithm.Framework/Risk\ directory now includes five new risk management models implemented in both C\# and Python: \MaximumDrawdownPercentPerSecurity\ limits drawdown on individual holdings, \MaximumDrawdownPercentPortfolio\ caps total portfolio drawdown (with optional trailing mode), \MaximumSectorExposureRiskManagementModel\ restricts exposure per sector using fundamental data, \MaximumUnrealizedProfitPercentPerSecurity\ caps unrealized gains per holding, and \TrailingStopRiskManagementModel\ liquidates positions when losses exceed a threshold from their peak value. All models implement \IRiskManagementModel\ and automatically cancel insights and liquidate positions when their respective risk thresholds are breached.

Algorithm.Framework/Risk · high confidence

The algorithm API now includes dedicated helper classes to simplify common analysis tasks. The new \CandlestickPatterns\ class provides factory methods for registering various candlestick pattern indicators (such as BeltHold, TwoCrows, and AbandonedBaby) directly on symbols, automatically handling indicator registration and resolution. Additionally, the \ConstituentUniverseDefinitions\ class offers pre-built universe definitions based on Morningstar asset classifications, allowing users to easily select groups of stocks like AggressiveGrowth or ClassicGrowth without writing custom selection logic.

Algorithm · high confidence

The engine now runs a reduced set of result analyses periodically while a backtest is in progress, allowing users to detect issues like slow execution, degrading throughput, or flat equity curves before the run finishes. This is powered by a new \AlgorithmSpeedTracker\ that samples cumulative speed counters (data points processed, history data points, calendar days) to compute throughput and projected remaining time, alongside a new \BaseResultsAnalysis\ framework that supports in-run execution and state-based findings. Several new diagnostic analyses have been added to detect specific problems: \CrisisEventsAnalysis\ compares strategy vs. benchmark Sharpe ratios during historical stress periods, \FlatEquityCurveAnalysis\ identifies prolonged zero-change segments in the equity curve, and various \MessageAnalysis\ subclasses detect brokerage-specific rejections (e.g., Alpaca extended hours, Binance unsupported order types, Coinbase stop-market deprecation, invalid order sizes) as well as margin calls and insights emitted for delisted securities.

Engine/Results/Analysis · high confidence

The notification system now supports sending alerts via Telegram and FTP/SFTP in addition to the existing Email, SMS, and Web hooks. The \NotificationManager\ exposes new methods for these channels, and the JSON deserialization logic has been updated to handle the new notification types case-insensitively. Additionally, Python users can now pass headers to Web and Email notifications using \PyObject\ overloads, which are automatically converted to string dictionaries.

Common/Notifications · high confidence

Added a set of data models in the Common/Optimizer namespace to support post-optimization analysis. These include OptimizationAnalysis as the aggregate diagnostic container, BacktestSummary and OptimizationBacktestMetrics for per-backtest identity and performance data, Cluster for k-means grouping, Mode for local Sharpe maxima, ParameterReport for sensitivity analysis, and supporting types like SharpeSummary, SliceFit, and LinearSegment. This provides the structural foundation for analyzing optimization results, including clustering, sensitivity, and failure breakdowns.

Common/Optimizer · high confidence

The optimizer now includes a dedicated analysis module that processes completed optimization runs to provide deeper insights into parameter performance. This new capability aggregates per-backtest metrics to calculate overall Sharpe statistics (mean, standard deviation, min, max, median) and identifies the single best-performing backtest. It also performs sensitivity analysis by slicing the parameter space to show how Sharpe ratios change with individual parameters, detects local maxima (modes) on the parameter grid, groups similar backtests into clusters using K-means, and flags zero-order backtests that failed to generate trades.

Common/Optimizer/Analysis, Optimizer/Analysis · high confidence

The optimizer now supports defining statistical constraints and optimization targets via new model classes. Users can specify constraints (e.g., maximum drawdown limits) using comparison operators, and define optimization targets with explicit maximization or minimization directions. The system parses JSON backtest results to evaluate these objectives, allowing the optimization process to filter or terminate based on whether statistical thresholds are met or improved.

Common/Optimizer/Objectives · high confidence

The Optimizer/Strategies area now includes a new \IOptimizationStrategy\ interface and supporting settings classes (\OptimizationStrategySettings\, \StepBaseOptimizationStrategySettings\) to define optimization behavior. Two new concrete strategies have been added: \GridSearchOptimizationStrategy\, which performs a brute-force search of the initial parameter generation, and \EulerSearchOptimizationStrategy\, which implements an advanced brute-force approach that refines the search scope in subsequent steps based on previous results.

Optimizer/Strategies · high confidence

The option engine now includes new components for pricing and assignment simulation: flat and Fed-rate risk-free rate estimators, a constant dividend yield estimator, and an underlying volatility estimator that pulls from the underlying's volatility model. A new \DefaultOptionAssignmentModel\ simulates early assignment of deep ITM short options based on time value and arbitrage P/L, replacing the previous implicit behavior. Additionally, a \CurrentPriceOptionPriceModel\ stub and an \EmptyOptionChainProvider\ are added to support placeholder pricing and empty chain scenarios.

Common/Securities/Option · high confidence

Added several new portfolio construction models to the framework: AccumulativeInsightPortfolioConstructionModel allocates a fixed percentage per insight with cumulative position sizing; ConfidenceWeightedPortfolioConstructionModel weights positions by insight confidence; AlphaStreamsPortfolioConstructionModel provides a base class for Alpha Streams integration; BlackLittermanOptimizationPortfolioConstructionModel implements Black-Litterman optimization to combine market equilibrium with investor views; and EqualWeightingPortfolioConstructionModel distributes weights equally across active insights. Each model is implemented in both C\# and Python, supporting configurable rebalancing frequencies, portfolio bias (Long, Short, Long/Short), and specific parameters like insight percentage or optimization settings.

Algorithm.Framework/Portfolio · high confidence

Added new regression test algorithms including AccumulativeInsightPortfolioRegressionAlgorithm to validate the new portfolio construction model, and AccordVectorMachinesAlgorithm as a C\# example for machine learning using Accord.NET Vector Machines.

Algorithm.CSharp · high confidence

The report generator now includes dedicated report elements for Annual Returns, Asset Allocation, and Estimated Capacity. The Annual Returns element renders a plot of yearly strategy performance for both backtest and live results. The Asset Allocation element displays a pie chart of the portfolio's asset distribution over time. The Estimated Capacity element displays the strategy's estimated capacity in financial figures, parsed from the backtest statistics.

Report/ReportElements · high confidence

The system now includes new shortable data providers that source availability from local disk files, specifically adding support for Interactive Brokers via a dedicated provider. These providers expose borrowing costs by returning fee rates and rebate rates alongside shortable quantities, allowing algorithms to account for the cost of borrowing shares. A null provider is also introduced to treat assets as infinitely shortable when no local data is available, and a Python wrapper enables custom shortable logic to be implemented in Python.

Common/Data/Shortable · high confidence

The slippage simulation engine now supports multiple configurable models via the new ISlippageModel interface. Users can apply a fixed percentage slip with ConstantSlippageModel, simulate realistic market impact using the MarketImpactSlippageModel (which accounts for order size relative to average volume and includes latency/impact time parameters), or use VolumeShareSlippageModel to calculate slippage based on the ratio of order quantity to bar volume. Additionally, AlphaStreamsSlippageModel provides a default 0.01% constant slip for equities, and NullSlippageModel allows disabling slippage entirely. These models handle Market-on-Open orders by referencing the bar open price and include specific logic for different asset types, such as FX/CFD warnings in the volume-share model.

Common/Orders/Slippage · high confidence

The Common/Statistics area introduces a new statistics implementation that exposes algorithm performance results at runtime via the IStatisticsService interface, allowing users to query current statistics during execution. This new engine calculates a broader set of performance metrics, including Probabilistic Sharpe Ratio, Sortino Ratio, Value at Risk (95% and 99%), and Drawdown Recovery time, while also providing rolling performance data for 1, 3, 6, and 12-month periods. The TradeBuilder component has been updated to support derivatives with multipliers and correctly applies stock splits to open positions, ensuring accurate trade construction and fee reporting.

Common/Statistics · high confidence

The Indicators namespace now includes a broad set of new technical analysis tools, such as the Absolute Price Oscillator, Acceleration Bands, Accumulation/Distribution (and its oscillator), Advance/Decline metrics (Ratio, Difference, Volume Ratio), Alpha, Arms Index (TRIN), Arnaud Legoux Moving Average, Augen Price Spike, and AutoRegressiveIntegratedMovingAverage. These additions expand the available quantitative analysis capabilities for users building trading algorithms.

Indicators · high confidence

The engine now includes dedicated stream readers for four distinct data sources: LocalFileSubscriptionStreamReader reads from local disk (including zip archives), ObjectStoreSubscriptionStreamReader retrieves data from the object store (with transparent zip extraction), RemoteFileSubscriptionStreamReader downloads remote files with retry logic and caching, and RestSubscriptionStreamReader polls REST endpoints with live-mode awareness. These components standardize how the engine fetches and streams subscription data across different storage and transport mediums.

Engine/DataFeeds/Transport · high confidence

The Common/Util area introduces several new components to support data processing and serialization. A new \BaseExtendedDictionary\ class provides a generic base for dictionary implementations, while \BusyBlockingCollection\ and \BusyCollection\ offer thread-safe collections that track busy states for better synchronization. JSON serialization is enhanced with new converters for \Candlestick\, \ChartPoint\, and \Color\ types, enabling proper handling of chart data and color values. Additionally, utility classes like \CashAmountUtil\ and \CircularQueue\ are added to support cash balance logic and queue-based iteration patterns.

Common/Util · high confidence

The volatility model system has been refactored to support explicit history requirements and improved initialization. A new \StandardDeviationOfReturnsVolatilityModel\ is now available, calculating annualized standard deviation of daily returns with configurable update frequency and resolution. The \BaseVolatilityModel\ and \IVolatilityModel\ interfaces now include \GetHistoryRequirements\ methods, allowing models to define the historical data needed for warm-up. A new \VolatilityModelExtensions.WarmUp\ method uses these requirements to pre-populate the model with historical data, ensuring accurate volatility calculations from the start and handling price discontinuities in live or raw data modes. Existing models like \RelativeStandardDeviationVolatilityModel\ and \IndicatorVolatilityModel\ have been updated to implement this interface.

Common/Securities/Volatility · high confidence

The engine now supports Index Options (such as SPX, NDX, VIX, and RUT) as a distinct asset type, enabling backtesting and live trading for these instruments. This change introduces specific handling for index options, including variable minimum price variations (tick sizes) that depend on the contract's market price, and correct settlement logic for PM-settled contracts like RUTW and SPXW. The implementation includes dedicated security classes, symbol properties, and price variation models to ensure accurate pricing and execution for these specialized derivatives.

Common/Securities/IndexOption · high confidence

This change introduces the core infrastructure for trading perpetual crypto futures, including the new \CryptoFuture\ security type and \CryptoFutureMarginModel\. It adds exchange-specific implementations for Binance and Bybit, featuring a \BinanceCryptoFutureMarginModel\ that correctly handles supplementary collateral (such as BNFCR for EU/EEA accounts) and a \BinanceFutureMarginInterestRateModel\ that applies periodic funding rate cash flows to open positions. Bybit and dYdX inherit the funding rate logic, while the \CryptoFutureHolding\ class ensures accurate position valuation for both USDT-margined and coin-margined contracts.

Common/Securities/CryptoFuture · high confidence

Users can now implement and inject custom models written in Python for various engine components, including brokerage behavior (BrokerageModelPythonWrapper), buying power calculations (BuyingPowerModelPythonWrapper), fee structures (FeeModelPythonWrapper), order fill logic (FillModelPythonWrapper), margin calls (MarginCallModelPythonWrapper), dividend yields (DividendYieldModelPythonWrapper), benchmarks (BenchmarkPythonWrapper), data consolidation (DataConsolidatorPythonWrapper), and command handling (CommandPythonWrapper). This is enabled by the new BasePythonWrapper\<TInterface\> class, which provides a standardized mechanism to wrap Python objects, validate interface implementations, and manage method/property invocation with proper Python GIL handling.

Common/Python · high confidence

The Tradier brokerage integration has been removed from the codebase. All source files defining the TradierBrokerage controller, account balance models, order handling, position tracking, and API data structures within the Brokerages/Tradier directory have been deleted.

Brokerages/Tradier · high confidence

The legacy IAlgorithm interface and its associated app.config file have been removed from the Interfaces project. This deletion signifies the completion of the migration away from the v1.0 event-driven model, as the interface is no longer part of the current codebase structure.

Interfaces · high confidence

The \Tasks.cs\ file, which implemented the \ITaskHandler\ interface for local/desktop job requests, has been removed. This deletion eliminates the legacy logic that automatically generated \LiveNodePacket\ or \BacktestNodePacket\ jobs by hardcoding Tradier endpoints for live trading and Console/FileSystem endpoints for backtesting, effectively removing the built-in support for this specific local execution mode.

Tasks · high confidence

The local \Controls\ class, which previously provided stub implementations for cloud algorithm activity controls (such as log allowance checks, algorithm status retrieval, and market data), has been removed from the codebase. This eliminates the local fallback logic that returned default values (e.g., \AlgorithmStatus.Running\ or maximum log limits), indicating a shift where these controls are no longer handled by this specific local component.

Controls · high confidence

The example algorithms for loading custom Bitcoin and Nifty/USDINR data, as well as the custom tick filtering example, have been removed from the codebase. These files previously demonstrated how to define custom data types and apply exchange-based tick filters, but are no longer included in the examples directory.

Algorithm/Examples · high confidence

The DotNetZip library has been upgraded to version 1.13.3 to address a known security vulnerability. This update ensures that the application remains secure against potential exploits associated with earlier versions of the library.

(dependencies) · high confidence

The logging infrastructure has been restructured to replace the previous monolithic implementation with a modular \ILogHandler\ interface and dedicated handler classes. This change introduces \ConsoleLogHandler\ for console output, \FileLogHandler\ for disk-based logging, \CompositeLogHandler\ to pipe messages to multiple destinations simultaneously, and \QueueLogHandler\ for asynchronous or queued logging. The global \Log\ class now delegates to the configured \ILogHandler\ instance, allowing users to customize logging behavior, redirect output streams, or integrate with external result handlers without modifying core logging logic.

Logging · high confidence

The API client implementation has been updated to replace the legacy RestSharp dependency with the standard System.Net.Http.HttpClient. This change introduces a pooled HttpClient architecture (via BlockingCollection) to improve connection reuse and performance, while maintaining backward compatibility through deprecated RestSharp wrappers. The refactoring also standardizes JSON serialization settings and improves error handling and logging within the API connection layer.

Api · high confidence

The Python algorithm library now includes explicit assembly metadata (title, product name, culture, COM visibility, and GUID) via a new AssemblyInfo.cs file, ensuring consistent identification and proper COM interop settings for the Python language interop support.

Algorithm.Framework/Properties, Algorithm.Python/Properties · high confidence

The Launcher project now includes an AssemblyInfo.cs file that defines standard .NET assembly metadata, including the title and product name 'QuantConnect.Lean.Launcher', sets the culture to neutral, disables COM visibility, and assigns a specific GUID. This ensures the resulting executable carries consistent identity and versioning information required by the .NET runtime and Windows systems.

Launcher/Properties · high confidence

The Report project now includes an AssemblyInfo.cs file that defines standard assembly metadata, including the title and product name 'QuantConnect.Report', sets the culture to neutral, disables COM visibility, and assigns a specific GUID for type library identification.

Report/Properties · high confidence

AssemblyInfo.cs files were added to the Optimizer and Optimizer.Launcher projects to define standard assembly metadata, including titles, product names, and COM visibility settings.

Optimizer.Launcher/Properties, Optimizer/Properties · high confidence

New factor and map files have been added for COMEX Gold (GC) futures, covering the period from 2013 through early 2020. The \factor\_files/gc.csv\ file provides auxiliary data including backward and forward scales and data mapping modes, while \map\_files/gc.csv\ defines the specific contract symbols and their active dates. These additions support more accurate price modeling and contract rollover handling for GC futures in backtests.

_Data/future/comex/map\files · high confidence

The system now includes initial and maintenance margin specifications for VIX Mini Futures (VXM), allowing users to trade this instrument with correct margin calculations. Additionally, the margin data files for the standard VIX contract (VX) have been moved to a new location, ensuring the data structure remains consistent with the updated organization of CME Group exchange futures margin files.

Data/future/cfe · high confidence

The Common assembly metadata has been updated to reflect the 'QuantConnect.Common' product identity, replacing the previous 'qc.common' naming. The assembly version has been bumped to 2.5, and the copyright year is now set to 2018. Additionally, the assembly now explicitly grants internal visibility to the Algorithm Framework, Brokerages, Lean Engine, and Tests projects via InternalsVisibleTo attributes, facilitating tighter integration between these components.

Common/Properties · high confidence

The assembly information for the Api project has been updated to reflect the new project name (QuantConnect.Api instead of QuantConnect.API) and the removal of explicit version attributes (AssemblyVersion and AssemblyFileVersion). This change means the assembly will no longer carry hardcoded version numbers in its metadata, relying instead on build-time generation or default values, while retaining the company/product title and GUID.

Api/Properties · high confidence

This change introduces a new \Common/Messages\ folder containing strongly-typed, centralized message definitions for the \Algorithm\, \Brokerages\, \Framework\ (including Alphas, Portfolio, and Analysis), \Commands\, \Exceptions\, \Indicators\, \Notifications\, and \Optimizer\ namespaces. By moving user-facing strings—such as validation errors for \Insight\ properties, brokerage order type restrictions, Python exception interpreters, and configuration warnings—into dedicated static classes, the system ensures consistent, maintainable, and easily localizable error reporting across the engine.

Common/Messages · high confidence

The Configuration module has been rewritten to replace the static dictionary-based config with a JSON-object model (JObject) that supports merging command-line arguments with configuration file settings. This change introduces the ability to select a configuration file at runtime via the --config CLI argument and enables dynamic environment switching through nested 'environments' definitions in the config file. Additionally, new argument parsers (LeanArgumentParser, ToolboxArgumentParser, etc.) have been added to handle CLI options using the McMaster.Extensions.CommandLineUtils library, allowing users to override specific settings like data folders, algorithm types, and brokerage credentials directly from the command line without editing the config file.

Configuration · high confidence

The symbol properties data has been consolidated into a single \symbol-properties-database.csv\ file, replacing the previous fragmented structure. This new database includes a comprehensive \security-database.csv\ for standard security identifiers (such as ISINs and CUSIPs) and expands the symbol properties to cover a wider range of asset types, including detailed entries for Eurex futures, FXCM and OANDA CFDs, and Interactive Brokers CFDs and forex pairs. Users benefit from a unified source for symbol metadata, ensuring consistent contract multipliers, minimum price variations, and lot sizes across these exchanges.

Data/symbol-properties · high confidence

The engine's startup sequence has been restructured into a dedicated Initializer class that configures logging and retrieves system-level handlers (API, messaging, job queue) via MEF configuration. Concurrently, the legacy static DataStream and StreamStore classes have been removed, and a new AlgorithmTimeLimitManager has been introduced to enforce maximum execution times for algorithm time loops, providing warnings and the ability to request additional time for scheduled events.

Engine · high confidence

Equity short positions now incur daily margin interest fees calculated via the new ShortMarginInterestRateModel, which applies fee or rebate rates from the ShortableProvider. Equity settlement has shifted to a default of 1 day (T+1) with a 6:00 AM settlement time, replacing the previous logic. Additionally, the Equity class now exposes Shortable and TotalShortableQuantity properties to query short availability, and the underlying transaction and exchange logic has been refactored to support these changes.

Common/Securities/Equity · high confidence

The Forex security implementation has been rewritten to replace the legacy ForexTransactionModel with a composition of new, pluggable models: ImmediateFillModel, InteractiveBrokersFeeModel, NullSlippageModel, and ImmediateSettlementModel. The Forex constructor now requires explicit Cash objects for base and quote currencies and an ICurrencyConverter, removing the previous reliance on string-based symbol properties and the old transaction model. Additionally, ForexHolding now exposes a TotalCloseProfitPips method to calculate profit in pips, and ForexExchange now derives its open/close times from the MarketHoursDatabase instead of using hardcoded FXCM hours.

Common/Securities/Forex · high confidence

The Algorithm.CSharp project now includes an AssemblyInfo.cs file that defines standard assembly metadata, including the title and product name 'QuantConnect.Algorithm.CSharp', sets the culture to neutral, disables COM visibility, and assigns a specific GUID for type library identification.

Algorithm.CSharp/Properties · high confidence

The benchmarking system now uses a dedicated IBenchmark interface instead of raw Func delegates, allowing benchmarks to be defined either by a simple time-value function (FuncBenchmark) or by the closing price of a specific security (SecurityBenchmark). This change enables users to easily benchmark algorithms against specific market instruments in their account currency or use custom functional logic, providing a more structured and flexible way to measure performance.

Common/Benchmarks · high confidence

The engine now includes a dedicated \Cfd\ security class (along with supporting \CfdHolding\, \CfdCache\, \CfdDataFilter\, and \CfdExchange\ components) that replaces previous implicit or generic handling. This implementation requires explicit construction via constructors that accept \SymbolProperties\ and an \ICurrencyConverter\, enabling precise control over contract multipliers, minimum price variations, and quote currency conversion. The CFD security is configured with default behaviors such as zero fees, immediate fills, and a 50% margin model, while exposing properties like \ContractMultiplier\ and \MinimumPriceVariation\ for user interaction.

Common/Securities/Cfd · high confidence

The engine now includes new \LiveDataQueue\ and \FakeDataQueue\ classes in the \Engine/DataFeeds/Queues\ directory to manage live data subscriptions. \LiveDataQueue\ serves as a placeholder that throws \NotImplementedException\ for local/desktop environments, while \FakeDataQueue\ provides a test implementation that generates random tick data using an internal subscription manager and timer. Both classes implement the \IDataQueueHandler\ interface, introducing \SetJob\, \IsConnected\, and \Dispose\ methods to manage lifecycle and connection state.

Engine/DataFeeds/Queues · high confidence

The backtesting engine now utilizes a dedicated \BacktestingBrokerage\ class, replacing previous ad-hoc logic with a structured implementation that conforms to the \IBrokerage\ interface. This change introduces explicit handling for order lifecycle events (submission, updates, and cancellation) via \OnOrderEvent\ calls, manages pending orders in a thread-safe manner, and exposes account state (open orders, holdings, and cash balances) directly from the algorithm's portfolio. A corresponding \BacktestingBrokerageFactory\ is provided to instantiate this brokerage, ensuring consistent integration with the broader brokerage abstraction layer.

Brokerages/Backtesting · high confidence

The Local Object Store now enforces configurable storage limits (maximum size in bytes and maximum file count) and respects granular storage permissions (read, write, delete). When limits are exceeded, the store throws a StorageLimitExceededException, and operations are blocked if the user lacks the necessary permissions, providing clear error messages. A new FileHandler abstraction and StorageLimitExceededException class support this behavior.

Engine/Storage · high confidence

The local messaging implementation has been restructured to support both event-based and streaming communication. A new EventMessagingHandler has been introduced to dispatch messages via .NET events (such as DebugEvent, LogEvent, and BacktestResultEvent) to the UI, while a new StreamingMessageHandler sends packets over TCP using NetMQ for external consumption. The legacy Messaging class has been updated to implement the new IMessagingHandler interface, replacing the old SetChannel method with SetAuthentication and adding logic to log backtest statistics and order hashes. These changes enable more robust, decoupled message handling for the desktop application and external integrations.

Messaging · high confidence

The system now uses a dedicated \OrderEventJsonConverter\ and \SerializedOrderEvent\ class to handle the JSON serialization of order events. This change introduces specific JSON properties for order event details (such as ID, symbol, status, and fill information) and ensures that null order fees are not serialized, resulting in cleaner and more efficient data payloads.

Common/Orders/Serialization · high confidence

The system now uses a dedicated \SerializedInsight\ data transfer object and a custom \InsightJsonConverter\ to handle the persistence and transmission of Insight data. This change introduces new fields to the serialized output, including \GroupId\, \SourceModel\, \ReferenceValueFinal\, \Weight\, and \Tag\, while replacing the deprecated \GeneratedTime\ with \CreatedTime\. It also ensures that null values for \GroupId\ and \SourceModel\ are ignored during serialization and provides backward compatibility for deserializing older JSON formats that used the \group-id\ key.

Common/Algorithm/Framework/Alphas/Serialization · high confidence

The data feed engine now uses dedicated factory classes to create subscription enumerators for specific data types. Backtesting coarse fundamental data is handled by BaseDataCollectionSubscriptionEnumeratorFactory, which emits data on the following trading day to prevent look-ahead bias. Live custom data is managed by LiveCustomDataSubscriptionEnumeratorFactory, which supports rate limiting, backup universe file fallbacks, and unfolding collections. Standard backtesting subscriptions use SubscriptionDataReaderSubscriptionEnumeratorFactory to integrate with the existing reader and corporate event providers. Additionally, TimeTriggeredUniverseSubscriptionEnumeratorFactory enables user-defined universes to fire selection logic at specific scheduled times.

Engine/DataFeeds/Enumerators/Factories · high confidence

The Brokerages/Authentication area now introduces a new token-based authentication system. This includes a new \LeanOAuthTokenHandler\ class that manages OAuth token retrieval, caching, and retry logic, along with supporting classes like \LeanTokenCredentials\, \LeanTokenHandler\, \OAuthTokenRequest\, and \TokenType\. This change provides a more robust and standardized way for brokerages to handle authentication with the Lean platform, replacing older, deprecated OAuth authentication base classes.

Brokerages/Authentication · high confidence

The engine now uses a new work scheduling subsystem in the data feed layer to manage background tasks. This system introduces a singleton scheduler that maintains a pool of background worker threads, with the count defaulting to two in live trading mode to conserve CPU and RAM, or the full processor count in backtesting. Work items are prioritized by a dynamic weight, allowing the engine to process lower-weight tasks first and cap resource usage via a configurable maximum work weight. This change replaces the previous ad-hoc scheduling approach with a structured, weighted queue system.

Engine/DataFeeds/WorkScheduling · high confidence

The PaperBrokerage implementation now processes dividend distributions during live paper trading by scanning the current slice and crediting the security's quote currency, while skipping these applications during the algorithm's warmup period. Additionally, concurrent processing of messages to and from the brokerage is now enabled by default, and the factory provides the default brokerage model for configuration.

Brokerages/Paper · high confidence

The \AlgorithmPythonWrapper\ now explicitly initializes and caches references to key Python-side lifecycle methods (such as \OnData\, \OnMarginCall\, and \OnEndOfDay\) during construction. This ensures that the engine correctly detects and invokes user-defined Python handlers, resolving previous issues where these events might not fire or caused exceptions in Python-based algorithms.

AlgorithmFactory/Python · high confidence

The AlgorithmFactory now supports modern Python debugging via DebugPy, replacing the deprecated PTVSD method, and enables debugging of code executed by data stack workers. A new DebuggerHelper manages the initialization of debugging sessions for Python and C\#, while the Loader has been refactored to handle Python algorithm instantiation separately and pass worker initialization callbacks to ensure debug contexts are correctly established across threads.

AlgorithmFactory · high confidence

The real-time engine in Engine/RealTime has been restructured to replace the previous RealTimeEvent-based polling model with a new ScheduledEvent system. This change introduces BaseRealTimeHandler as a shared base for BacktestingRealTimeHandler and LiveTradingRealTimeHandler, unifying how end-of-day and custom scheduled events are managed. The new system ensures scheduled events fire in deterministic order, handles time-zone conversions correctly for both backtesting and live trading, and improves resource diagnostics and error handling for long-running scheduled tasks.

Engine/RealTime · high confidence

The monolithic ISecurityTransactionModel interface has been removed and split into specialized interfaces (IFeeModel, IOrderFillModel, ISlippageModel) to separate concerns for fees, fills, and slippage. Additionally, a new IContinuousContractModel interface has been added to support modeling continuous futures series, including handling adjustment types (forward/backward) and roll dates, while minor cleanup was applied to the ISecurityDataFilter interface.

Common/Securities/Interfaces · high confidence

The data feed system in the engine has been rewritten to be enumerator-centric, replacing the previous implementation with a new stack of specialized enumerators in the Engine/DataFeeds/Enumerators directory. This change introduces new components such as AuxiliaryDataEnumerator for handling corporate actions, DelistingEventProvider for emitting delisting warnings and events, and FrontierAwareEnumerator to prevent emitting future data in live trading. It also includes performance and stability improvements like EnqueueableEnumerator for thread-safe data injection, FastForwardEnumerator to skip stale data, and ConcatEnumerator to sequence warmup and live data streams, fundamentally changing how data is pulled, filtered, and emitted to the algorithm.

Engine/DataFeeds/Enumerators · high confidence

The fill simulation logic in Common/Orders/Fills has been restructured to use a new base FillModel class and a FillModelParameters container, replacing the previous direct method signatures. This change introduces a unified Fill return type and adds explicit support for combo orders (ComboMarket, ComboLimit, ComboLegLimit) within the base model. Additionally, market and stop-order fills now include logic to detect and handle stale data, waiting for fresh prices or issuing warnings when the latest data is significantly behind the order time, and a new LatestPriceFillModel is provided to ignore trade/quote distinctions for crypto-like securities.

Common/Orders/Fills · high confidence

The futures module has been restructured to support daily cash settlement, introducing a new \FutureSettlementModel\ that marks positions as settled each day and updates the cash book accordingly. The \Future\ security class now explicitly distinguishes between chain and contract symbols via \IsFutureChain\ and \IsFutureContract\ flags, and enforces that canonical futures are not tradable. Margin calculations now support intraday requirements via the \EnableIntradayMargins\ flag in \FutureMarginModel\, and universe selection is standardized through new \FutureFilterUniverse\ and \FuturesChainFilterUniverse\ classes that share a common \BaseFutureFilterUniverse\ for filtering by expiration cycles and contract months.

Common/Securities/Future · high confidence

The indicator infrastructure has been reorganized by moving core interfaces (IIndicator, IIndicatorWarmUpPeriodProvider), base classes (WindowBase), and data types (IndicatorDataPoint, InternalIndicatorValues) into the Common/Indicators namespace. This change introduces a new non-generic RollingWindow wrapper for Python interoperability and significantly improves the thread safety of the generic RollingWindow by replacing the coarse object lock with a ReaderWriterLockSlim, allowing concurrent reads. Additionally, the RollingWindow now supports negative indexing, uses int for sample counts instead of decimal, and enforces stricter readiness checks for the MostRecentlyRemoved property.

Common/Indicators · high confidence

The custom data module in Common/Data/Custom has been restructured: the legacy Quandl data type (which relied on the V1 API and DynamicData) has been removed, and two new custom data types have been added. FxcmVolume now provides FXCM Real FOREX Volume and Transaction data for major currency pairs, supporting both live mode (via REST API) and backtesting (via local zip files). Additionally, a NullData placeholder class has been introduced to serve as a generic custom data type stub.

Common/Data/Custom · high confidence

The Report project has been restructured, introducing new core data models including Crisis and CrisisEvent for predefined market event tracking, PointInTimePortfolio for capturing portfolio state snapshots, and DrawdownCollection/DrawdownPeriod for detailed drawdown analysis. To support these changes and improve robustness, the report generator now utilizes custom JSON converters (NullResultValueTypeJsonConverter and OrderTypeNormalizingJsonConverter) to handle null chart points and normalize OrderType values during deserialization, preventing crashes on malformed or legacy JSON data. Additionally, utility classes like DeedleUtil and Metrics provide new calculation methods for cumulative returns, leverage utilization, and asset allocation, while the main Program entry point now supports custom HTML templates, CSS overrides, and optional PDF output generation.

Report · high confidence

The backtesting and live trading result handlers now inherit from a new BaseResultsHandler, which centralizes common logic for charting, equity sampling, and message handling. The ConsoleResultHandler has been removed, and result initialization is now managed via a dedicated ResultHandlerInitializeParameters DTO. A new BacktestProgressMonitor provides thread-safe progress tracking for backtests, and a DeploymentDetailsHelper allows components to share deployment information with the algorithm and user through the result handler.

Engine/Results · high confidence

AssemblyInfo files across multiple projects (Algorithm, AlgorithmFactory, Brokerages, Compression, Configuration, Indicators, Logging, Messaging) have been updated to use consistent 'QuantConnect.'-prefixed titles and product names, while removing hardcoded version numbers (AssemblyVersion/AssemblyFileVersion) and copyright attributes. This change shifts version management away from static assembly attributes, likely relying on external build systems or shared assembly info files for version control.

(repo-wide) · high confidence

The Research component now includes a dedicated AssemblyInfo.cs file that explicitly defines standard .NET assembly metadata, including the title and product name 'QuantConnect.Research', sets the culture to neutral, disables COM visibility, and assigns a specific GUID. This change ensures consistent and explicit assembly identification for the Research library.

Research/Properties · high confidence

The engine now includes a set of specialized exception interpreters in Common/Exceptions that detect specific Python errors—such as AttributeError, KeyError, ModuleNotFoundError, NoMethodMatch, and datetime/date comparison issues—and replace the raw Python tracebacks with concise, actionable messages. This change improves the debugging experience by highlighting the root cause (e.g., missing keys, wrong bar-type attributes, or invalid method overloads) and providing targeted hints, while preserving the original stack trace for deeper investigation.

Common/Exceptions · high confidence

The engine's algorithm initialization process has been consolidated into a new \BaseSetupHandler\ and specialized \BrokerageSetupHandler\ and \BacktestingSetupHandler\ classes, replacing the previous scattered handlers like \PaperTradingSetupHandler\ and \TradierSetupHandler\. This change introduces configurable timeouts for algorithm creation and initialization (controlled by \initialization-timeout\ and \algorithm-creation-timeout\ in config.json), allowing complex algorithms to start without timing out. Error reporting is improved by using a strongly-typed \AlgorithmSetupException\ and collecting \List\<Exception\>\ errors instead of generic strings, providing users with more detailed and actionable feedback during setup failures.

Engine/Setup · high confidence

The engine now uses a single, unified BrokerageTransactionHandler for all brokerages, replacing the previous per-brokerage handlers (such as TradierTransactionHandler, which has been removed). This handler introduces a dynamic OrderRequestProcessingPool that processes order requests on background worker threads, allowing the pool to grow on demand when saturated. This change enables concurrent order processing for live trading, significantly improving performance for algorithms with high trade volumes, while backtesting continues to use synchronous processing to maintain deterministic timing.

Engine/TransactionHandlers · high confidence

The universe selection subsystem in Common/Data/UniverseSelection has been restructured to improve reliability and performance, particularly in live trading. A new BackupUniverseFileDataProvider wraps the primary data provider to automatically fall back to backup universe files (e.g., '\*.backup') when the expected data is unavailable, with rate-limited logging to prevent log flooding. This fallback mechanism is explicitly utilized by the CoarseFundamentalDataProvider in live mode. Additionally, new data types such as BaseChainUniverseData and BaseDataCollection provide optimized, memory-efficient handling of chain and collection data, while CoarseFundamentalUniverse and ConstituentsUniverse offer streamlined, pre-filtered universe selection paths that reduce runtime computation overhead.

Common/Data/UniverseSelection · high confidence

The assembly metadata for the engine has been updated to reflect the correct product name (QuantConnect.Lean.Engine) and removed obsolete version attributes, while also adding an InternalsVisibleTo directive to allow the test project to access internal members.

Engine/Properties · high confidence

The assembly information file has been moved to the Queues project and updated to reflect the new assembly name 'QuantConnect.Queues'. The previous generic metadata, including the old 'Tasks' title and product name, has been replaced with the specific project identifier. Additionally, explicit version numbers (1.0.0.0) and several unused assembly attributes (such as description, company, and copyright) have been removed to streamline the assembly metadata.

Queues/Properties · high confidence

The AAPL option universe files for June 2, 3, 4, and 5, 2014 have been updated with new CSV data. These files contain daily option chain records including expiry dates, strikes, rights, pricing, volume, open interest, and Greeks (implied volatility, delta, gamma, vega, theta, rho) for the specified dates.

Data/option/usa/universes · high confidence

The CME ES future universe data files in Data/future/cme/universes/es have been updated with new CSV files covering dates from 2013 to 2020. These files provide daily snapshot data for various future expiry months (e.g., 201312, 201403, 202003, 202103), including open, high, low, close, volume, and open interest. The data reflects the standard format for future universes, with some files showing placeholder zeros for distant or non-active contracts.

Data/future/cme/universes · high confidence

The historical initial and maintenance margin data for CME futures contracts (including 6A, 6B, 6C, 6E, 6J, 6L, 6M, 6N, 6R, 6S, 6Z, ACD, AJY, ANE, BIO, BTC, CJY, CNH, E7, EAD, ECD, EI, EMD, ES, ESK, GD, GE, GF, HE, IBV, J7, LBS, LE, M2K, M6A, M6B, M6C, M6E, MBT, MCD, MES, MET, MIR, and MJY) has been refreshed. These CSV files now contain the specific margin values applied on various dates, ensuring that backtesting and risk calculations reflect the actual exchange requirements for these instruments.

Data/future/cbot/margins, Data/future/cme/margins, Data/future/nymex · high confidence

The COMEX Gold (GC) futures universe data files in Data/future/comex/universes/gc have been refreshed with new daily snapshots spanning from October 2013 through January 2020. These CSV files provide the specific expiry contracts, pricing (open, high, low, close), volume, and open interest required for backtesting and historical analysis of Gold futures.

Data/future/comex/universes · high confidence

The historical market data for S&P 500 (ES) and Gold (GC) futures options has been refreshed for January 2020. This update adds daily CSV files for ES March and June 2020 expirations covering January 2–8, 2020, and for GC April 2020 expirations covering January 2–3, 2020. The new data includes strike prices, option rights (calls/puts), and OHLCV metrics, ensuring backtesting and research models have accurate pricing for these specific periods.

Data/futureoption · high confidence

The equity data repository has been refreshed with new factor files for US equities (including AAPL, AIG, BAC, IBM, SPY, QQQ, and others) and India (CCCL), as well as a map file for 3mindia. Additionally, coarse fundamental data files for March 24–26, 2014, have been added to support historical backtesting and regression algorithms.

Data/equity · high confidence

Added API integration tests for account, authentication, data, live trading, and object store endpoints; Added comprehensive unit tests for candlestick pattern indicators; Added comprehensive unit tests for equity, future, and future option fill models; Added engine test coverage for algorithm lifecycle, brokerage messaging, and performance; Added regression tests for Collective2 signal export and Correlation indicator stability; Added regression tests for Python algorithm wrapper and exception handling; Added regression tests for QuantBook history, indicators, and custom data; Added regression tests for research notebook templates; Added regression tests for strategy capacity estimation across multiple asset classes; Added test data for American options Greeks validation; Added test data for new indicators and financial models; Added test data for shortable equity rebate and fee rates; Added test data for symbol properties; Added test for Python path initialization order; Added tests for Bybit margin calculations and Binance EU collateral handling in crypto futures; Added tests for CanonicalDataDownloaderDecorator and DataDownloaderSelector; Added tests for DataDownloadConfig and DownloadHelper in DownloaderDataProvider; Added tests for FileLogHandler logging functionality; Added tests for Kraken brokerage model and fee calculations; Added tests for LevelOneMarketData event handling and exchange mapping; Added tests for LocalObjectStore behavior and permissions; Added tests for Pandas DataFrame indexing and mapping behavior; Added tests for Python custom data resolution and sparsity behavior; Added tests for Python exception interpreters; Added tests for StreamingMessageHandler; Added tests for auxiliary data providers and corporate action serialization; Added tests for engine data providers; Added tests for engine results analysis and handling components; Added tests for futures option expiry and underlying mapping logic; Added tests for optimizer analysis and end-to-end wiring; Added tests for paper brokerage dividend handling and cash balance control; Added tests for position group collection and group logic; Added tests for remote file subscription stream reader behavior; Added tests for subscription enumerator factories; Added tests for the historical data provider infrastructure; Added unit tests for CFD security constructor and properties; Added unit tests for DataCacheProviders; Added unit tests for Exante brokerage fee model; Added unit tests for Forex security and holding logic; Added unit tests for Index security quote currency extraction; Added unit tests for IndicatorExtensions; Added unit tests for Insight JSON serialization and deserialization; Added unit tests for LeanOptimizer and OptimizationNodePacket; Added unit tests for MapFileResolver symbol mapping logic; Added unit tests for MarketImpact, VolumeShare, and AlphaStreams slippage models; Added unit tests for OAuth token response parsing and token handler behavior; Added unit tests for ParameterAttribute; Added unit tests for Portfolio Construction Models and Optimizers; Added unit tests for Python algorithm imports and wrapper behavior; Added unit tests for QuantBook research capabilities; Added unit tests for RandomDataGenerator components; Added unit tests for Report calculation logic and PortfolioLooper stability; Added unit tests for Tastytrade fee model calculations; Added unit tests for TimeInForce order expiration logic; Added unit tests for Toolbox data generation and reading components; Added unit tests for TradeStation brokerage model order validation; Added unit tests for algorithm data and security management; Added unit tests for alpha models and insight management; Added unit tests for brokerage fee models; Added unit tests for brokerage models and security benchmarks; Added unit tests for common engine components; Added unit tests for common utility classes; Added unit tests for compression utilities and ZipStreamWriter; Added unit tests for configuration parsing and environment handling; Added unit tests for crypto security base currency parsing; Added unit tests for data consolidators and data monitoring; Added unit tests for data feed enumerators; Added unit tests for engine setup handlers; Added unit tests for framework execution models; Added unit tests for framework risk management models; Added unit tests for fundamental data providers and MultiPeriodField; Added unit tests for futures daily settlement and expiry logic; Added unit tests for market data structures and filters; Added unit tests for multiple new and existing indicators; Added unit tests for notification targets and manager behavior; Added unit tests for optimization parameter enumeration and serialization; Added unit tests for optimizer search strategies; Added unit tests for packet serialization and backtest job handling; Added unit tests for portfolio and trade statistics calculations; Added unit tests for rate-limiting utilities; Added unit tests for real-time event handling and thread safety; Added unit tests for securities settlement, volatility, brokerage initialization, and buying power models; Added unit tests for the Algorithm Factory Loader; Added unit tests for the Brokerage Transaction Handler and Order Request Processing Pool; Added unit tests for the Lean command system; Added unit tests for the LocalDiskShortableProvider; Added unit tests for the Option Strategy Matcher; Added unit tests for the data feed engine components; Added unit tests for the scheduling system; Added unit tests for universe selection data providers and components; Added unit tests for universe selection models; Expanded test coverage for option chain providers, strategies, and risk models; Expanded test coverage for order properties, serialization, and sizing logic; New Python regression algorithms for framework models and security management; New brokerage test infrastructure and order parameter classes; New test infrastructure for regression and research testing; Regression tests for ETF constituent universe selection; Regression tests for custom data iconic types and resolution handling; Removed assembly metadata attributes from test project; Updated test data for American option pricing greeks; Updated test data for SPY symbol properties.

A new NuGet configuration file has been added to enable automatic package restore and define a local package source pointing to the ../LocalPackages directory, ensuring that local dependencies are resolved without manual intervention.

.nuget · high confidence

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

• CAI 48 → 47 (-1.1)
• Rubric changed (rubric-2026.08.19 → rubric-2026.09.15) — scores are not directly comparable.

• Code Health 43 → 41 (-2.0)
• Architecture 91 → 91 (+0.0)
• Maturity 61 → 61 (-0.4)
• Readiness 60 → 57 (-2.8)
• Security 41 → 40 (-0.3)
• Performance 65 → 65 (+0.0)

• BarePragmaDisable repeated 19 times in 5 files (Tests/Common/Storage/LocalObjectStoreTests.cs)
• Bounded contexts not declared
• Duplicated block (10 lines × 2) (Algorithm.CSharp/AddAlphaModelAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/AutomaticIndicatorWarmupDataTypeRegressionAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/BasicTemplateOptionsAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/CoarseFineFundamentalComboAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/CoveredCallComboLimitOrderAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/FutureOptionCallITMExpiryRegressionAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/IndexOptionCallITMExpiryRegressionAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/NakedShortOptionStrategyOverMarginAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/OptionEquityBearCallLadderRegressionAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/OptionEquityBearPutLadderRegressionAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/OptionEquityBearPutSpreadRegressionAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/OptionEquityCallCalendarSpreadRegressionAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/RiskParityPortfolioAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/SectorExposureRiskFrameworkAlgorithm.cs)
• Duplicated block (10 lines × 2) (Algorithm.CSharp/StandardDeviationExecutionModelRegressionAlgorithm.cs)
• Duplicated block (10 lines × 2) (Common/Data/Auxiliary/CorporateFactorProvider.cs)
• Duplicated block (10 lines × 2) (Common/Util/LeanData.cs)
• Duplicated block (10 lines × 2) (Indicators/CandlestickPatterns/Hikkake.cs)
• …and 288 more

• AccumulativeInsightPortfolioConstructionModel.determine_target_percent (cognitive 19) (Algorithm.Framework/Portfolio/AccumulativeInsightPortfolioConstructionModel.py)
• AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.on_data (cognitive 23) (Algorithm.Python/AddFutureOptionSingleOptionChainSelectedInUniverseFilterRegressionAlgorithm.py)
• BarePragmaDisable repeated 17 times in 3 files (Tests/Common/Storage/LocalObjectStoreTests.cs)
• BaseOptionFilterUniverse.IronCondor (cognitive 16) (Common/Securities/Option/OptionFilterUniverse.cs)
• BaseOptionFilterUniverse.IronCondor (cyclomatic 19) (Common/Securities/Option/OptionFilterUniverse.cs)
• BaseOptionFilterUniverse.Strikes (cognitive 16) (Common/Securities/Option/OptionFilterUniverse.cs)
• BaseResultsHandler.IsEncodedRuntimeStatistic (cyclomatic 17) (Engine/Results/BaseResultsHandler.cs)
• BasicTemplateCryptoAlgorithm.on_data (cognitive 16) (Algorithm.Python/BasicTemplateCryptoAlgorithm.py)
• BasicTemplateCryptoAlgorithm.on_data (cyclomatic 20) (Algorithm.Python/BasicTemplateCryptoAlgorithm.py)
• BasicTemplateCryptoFutureAlgorithm.on_data (cognitive 43) (Algorithm.Python/BasicTemplateCryptoFutureAlgorithm.py)
• BasicTemplateCryptoFutureAlgorithm.on_data (cyclomatic 21) (Algorithm.Python/BasicTemplateCryptoFutureAlgorithm.py)
• BasicTemplateCryptoFutureHourlyAlgorithm.on_data (cognitive 41) (Algorithm.Python/BasicTemplateCryptoFutureHourlyAlgorithm.py)
• BasicTemplateCryptoFutureHourlyAlgorithm.on_data (cyclomatic 19) (Algorithm.Python/BasicTemplateCryptoFutureHourlyAlgorithm.py)
• BasicTemplateEurexFuturesAlgorithm.on_data (cognitive 16) (Algorithm.Python/BasicTemplateEurexFuturesAlgorithm.py)
• BasicTemplateEurexFuturesAlgorithm.on_order_event (cognitive 17) (Algorithm.Python/BasicTemplateEurexFuturesAlgorithm.py)
• BlackLittermanOptimizationPortfolioConstructionModel.determine_target_percent (cognitive 21) (Algorithm.Framework/Portfolio/BlackLittermanOptimizationPortfolioConstructionModel.py)
• BlackLittermanOptimizationPortfolioConstructionModel.get_views (cognitive 22) (Algorithm.Framework/Portfolio/BlackLittermanOptimizationPortfolioConstructionModel.py)
• BubbleAlgorithm.on_data (cognitive 37) (Algorithm.Python/BubbleAlgorithm.py)
• BubbleAlgorithm.on_data (cyclomatic 23) (Algorithm.Python/BubbleAlgorithm.py)
• BybitCryptoFuturesRegressionAlgorithm.on_data (cognitive 43) (Algorithm.Python/BybitCryptoFuturesRegressionAlgorithm.py)
• …and 662 more

• 78 commits — 65 feature/other, 13 fixes

• Engine/Results — 9 commits
• Common/Securities — 6 commits
• Tests/Indicators — 5 commits
• Common/Orders — 4 commits
• Engine/DataFeeds — 4 commits
• Common/Api — 3 commits
• Common/Brokerages — 3 commits
• Common/Data — 3 commits
• Tests/Common — 3 commits
• Tests/Engine — 3 commits
• Data/market-hours — 2 commits
• Data/symbol-properties — 2 commits
• Indicators/AutoRegressiveIntegratedMovingAverage.cs — 2 commits
• Tests/Brokerages — 2 commits
• Algorithm.CSharp/IndexOptionScaledStrikeRegressionAlgorithm.cs — 1 commit
• Algorithm.CSharp/OptionUniverseOpenInterestRegressionAlgorithm.cs — 1 commit
• Algorithm.CSharp/QuantConnect.Algorithm.CSharp.csproj — 1 commit
• Algorithm/QCAlgorithm.Indicators.cs — 1 commit
• Algorithm/QCAlgorithm.cs — 1 commit
• Brokerages/Authentication — 1 commit

• fix: Fix LeanDataReader failing on zips with duplicated entry names (#9744)
• fix: Fix MOO slippage reference price (#9763)
• fix: Fix OverflowException in SecurityIdentifier hash code (#9765)
• fix: Fix chained fundamental universe selection look-ahead (#9804)
• fix: Fix daily history bar counts for markets with a lunch break (#9806)
• fix: Fix double digit year future ticker parsing 10+ years out (#9816)
• fix: Fix index option market hours entries: NDXP, NQX, VIXW and RUT (#9671)
• fix: Fix pandas conversion of dynamic data with heterogeneous properties (#9769)
• fix: Fix the USD/KRW minimum price variation (#9656)
• fix: Fix the warm-up order analysis for Python algorithms and register the MarketOnClose too-late analysis (#9657)
• fix: feature: move locate broker to shared fix order properties (#9661)
• fix: fix: show the failed order in place order assertion (#9767)
• fix: fix: take only market and limit orders on clear street options (#9768)
• change: Add 1-Ounce Gold and Micro Ultra Treasury futures (#9692)
• change: Add Interactive Brokers KRX future fees (#9655)
• change: Add a Least Squares Moving Average with a benchmark reference (#9761)
• change: Add big-request guardrails and honest resource diagnostics (#9669)
• change: Add contract filters to futures chains and universes (#9791)
• change: Add server statistics to the API backtest result (#9719)
• change: Add strike, expiration and moneyness filters to option chains and universes (#9783)
• …and 58 more

Written by watchdog.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

QuantConnect/Lean was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.