Darts vs. Sktime vs. MLForecast: A no-nonsense faceoff for financial time series

A no-BS comparison of three popular tools for forecasting stocks, crypto, and other financial chaos.

Introduction

Time series forecasting in finance isn’t about chasing shiny neural networks—it’s about precision, speed, and interpretability. While deep learning has its place, most quants and traders still rely on battle-tested tools: Linear Regression, exponential smoothing, and gradient-boosted trees. Enter Darts, Sktime, and MLForecast—three libraries that claim to handle these classics with flair. Let’s strip away the marketing and see which one actually delivers for price prediction, volatility modeling, and portfolio optimization.

---

Package showdown: what each tool brings to the table

1. Darts: the jack-of-all-trades

Best for: Unified workflows, hybrid models (statistical + ML), and probabilistic risk modeling.
Darts isn’t just for PyTorch fanatics. Its real power lies in blending statistical models (ARIMA, ETS) with ML techniques like LightGBM, all under a single fit()/predict() API.

Key advantages for finance:

• Statistical + ML Fusion: Train an ARIMA model, then ensemble it with a gradient-boosted tree—no duct-tape code required.

• Probabilistic Forecasting: Generate confidence intervals for risk management (critical for options pricing or Value-at-Risk calculations).

• Covariates Done Right: Seamlessly integrate macroeconomic data (e.g., Fed rates) as past covariates or earnings estimates as future covariates, even with mixed frequencies.

• Backtesting Built-In: Simulate signal-based trading strategies with historical_forecasts() to see how your model really sucked in the past.

Weaknesses:

• Heavy dependencies (PyTorch, etc.) bloat the library if you’re only using Linear Regression.

• Hierarchical forecasting (e.g., aggregating stock predictions across sectors) is clunky compared to MLForecast.

2. Sktime: the statistician’s safe haven

Best for: Pure statistical modeling, scikit-learn pipelines, and academic rigor.
Sktime is where ARIMA purists and PhDs hang out. It’s tightly integrated with statsmodels and pmdarima, making it ideal for replicating research papers or building interpretable models. Predicting oil prices with exogenous variables like geopolitical risk indices? Sktime’s AutoARIMA handles it with elegance.

Key advantages for finance:

• Best-in-Class Statistical Models: ETS, TBATS, SARIMAX—all with hyperparameter tuning and automatic seasonality detection.

• Scikit-Learn Compatibility: Slot ARIMA into a pipeline with PCA or clustering algorithms for portfolio optimization.

• Panel Data Mastery: Forecast 500 stocks simultaneously using hierarchical time series (though prep work is tedious).

Weaknesses:

• Covariate Chaos: Handling future-known covariates (e.g., earnings dates) requires manual hacks, unlike Darts’ built-in support.

• No Speed Demon: Training 1,000 ARIMA models on a universe of assets? Good luck—MLForecast would’ve finished yesterday.

3. MLForecast: the quant’s workhorse

Best for: High-frequency trading, massive asset universes, and tree-based models.
MLForecast is built by Nixtla, the same team behind StatsForecast, and it shows. This library is optimized for speed, leveraging numba and LightGBM to train on 10,000 crypto pairs in minutes. Predicting intraday BTC volatility with lagged features? MLForecast laughs at your GPU bill.

Key advantages for finance:

• Speed Kills: Built for low-latency systems—feature engineering (lags, rolling averages) happens at C++ speed.

• Tree-Based Dominance: Native integration with XGBoost/LightGBM/CatBoost for capturing non-linear patterns (e.g., market regime shifts).

• Conformal Prediction: Calibrate uncertainty intervals for black-box models—essential for algo trading risk limits. I think this is the major advantage.

Weaknesses:

• No Deep Learning: If you suddenly need an LSTM for overnight Fed speech analysis, you’re out of luck, unless you use sklearn wrapper (that’s terrible).

• Documentation Gaps: Prepare to dig through GitHub issues for advanced use cases.

---

Example: Predicting EUR/USD exchange rates

1. Darts (LinearRegression + exogenous variables)

from darts.models import LinearRegression  
from darts import TimeSeries  

forex_data = TimeSeries.from_csv("eurusd.csv", time_col="date", value_cols=["close"])  
fx_vol = TimeSeries.from_csv("fx_vol.csv", time_col="date")
fx_vol_estimates = TimeSeries.from_csv("fx_vol_estimates.csv", time_col="date")

model = LinearRegression()  
model.fit(forex_data, past_covariates=fx_vol)  
forecast = model.predict(30, future_covariates=fx_vol_estimates)  
# FX vol forecasts as known covariates ahead of time.
  
forecast.plot()

Straightforward example but the point is you don’t really bother about anything else than data preparation.

2. Sktime (AutoETS for volatility clustering)

from sktime.forecasting.ets import AutoETS  
from sktime.forecasting.base import ForecastingHorizon  

# Fit ETS on Bitcoin volatility (GARCH-like behavior)  
model = AutoETS(error="add", trend="add", seasonal="add")  
model.fit(y_train)  
fh = ForecastingHorizon(y_test.index, is_relative=False)  
predicted_vol = model.predict(fh)  

Sktime’s ETS implementation is robust, but adding external data (e.g., mining difficulty) requires manual DataFrame wrangling.

3. MLForecast (LightGBM + lagged features)

from mlforecast import MLForecast  
from lightgbm import LGBMRegressor  

models = MLForecast(  
    models=[LGBMRegressor()],  
    lags=[1, 5, 20],  # Daily, weekly, monthly lags  
    lag_transforms={  
        'rolling_mean_7': lambda x: x.rolling(7).mean(),  
        'volatility_30': lambda x: x.rolling(30).std()  
    }  
)  

# Train on 1,000 stocks in parallel  
models.fit(df, id_col='ticker', time_col='date', target_col='price')  
predictions = models.predict(horizon=5)  

Again, simple as that but setting up predictions are actually not that simple, since it “think” you’re going to roll the model. If you don’t, some additional tweaks must be implemented.

---

The final tally: what actually matters in finance

• Statistical models

  • Darts: Excellent ([Auto]ARIMA, Exponential Smoothing, Theta)

  • Sktime: Best-in-Class (SARIMAX, TBATS, AutoETS)

  • MLForecast: Limited (relies on StatsForecast under the hood for stats).

• ML integration

  • Darts: Seamless (LightGBM + PyTorch in one workflow).

  • Sktime: Scikit-learn pipelines only (no deep learning).

  • MLForecast: Built for trees (LightGBM/XGBoost optimized).

• Speed

  • Darts: Moderate (good for single-series, slow for large panels).

  • Sktime: Slow with large datasets (not for HFT).

  • MLForecast: Blazing fast (handles 10k series in minutes).

• Covariate support

  • Darts: Best (past/future/static covariates, automated).

  • Sktime: Manual and clunky (prepare for DataFrame wrestling).

  • MLForecast: Basic (lagged features only, though can generate time-based features).

The verdict:

• Darts wins for flexibility—it’s the only library that lets you mix ARIMA with LightGBM and covariates without rage-quitting.

• MLForecast dominates speed—if you’re running a multi-asset momentum strategy, this is your engine.

• Sktime remains the academic gold standard—use it for research papers or when you need bulletproof statistical rigor.

---

AI Conclusion

Most quants don’t need transformers or LSTMs. They need LinReg that doesn’t crash, trees that train fast, and confidence intervals they can trust. Darts bridges the gap between stats and ML, MLForecast handles scale, and Sktime keeps your models interpretable.

So, which one do I use?

• Daily trading signals: MLForecast (speed kills).

• Risk modeling: Darts (probabilistic everything).

• Academic publishing: Sktime (statsmodels under the hood).

Pretty much, I like Darts the most, though when I want to play around with conformal prediction, I go for MLForecast.