---

title: Migration Guide from Original Backtrader description: How to migrate from the original backtrader to this enhanced fork

---

Migration Guide from Original Backtrader

This guide helps you migrate your code from the original [backtrader](https://github.com/mementum/backtrader) to this enhanced fork. The good news: your existing code should work without changesdue to 100% API compatibility.

Overview of Changes

This fork maintains full API compatibility while introducing significant internal improvements:

| Area | Original | This Fork | Benefit |

|——|———-|———–|———|

|Metaclasses| Heavy use of metaclasses | Removed, using explicit initialization | Better maintainability |

|Performance| Baseline |45% fasterexecution | Quicker backtests |

|Cython| Optional | Enhanced core calculations | 10-100x speedup on hot paths |

|Live Trading| Limited | Full CCXT integration with WebSocket | Production-ready crypto trading |

|Testing| ~300 tests | 917+ tests with 50% coverage | More reliable |

|Documentation| Basic | Comprehensive bilingual docs | Better learning resources |

Breaking Changes

None (100% Backward Compatible)

All your existing backtrader code will work without modification. The following areinternal changesthat don’t affect the API:

Internal Changes (No User Impact)

1.Metaclass Removal: MetaBase, MetaLineRoot, MetaIndicator, etc. replaced with donew() pattern

1. Initialization Pattern: Explicit __new__ + __init__ chain instead of metaclass magic

2. Parameter Access: self.p and self.params now set during __init__ instead of metaclass __call__

New Features

1. CCXT Live Trading Support

This fork includes production-ready cryptocurrency trading via CCXT:

# NEW: CCXT Store for live trading

import backtrader as bt

store = bt.stores.CCXTStore(
    exchange='binance',
    currency='USDT',
    config={
        'apiKey': 'your_api_key',
        'secret': 'your_secret',
        'enableRateLimit': True,
    }
)

# WebSocket data feed (NEW)

data = store.getdata(
    dataname='BTC/USDT',
    timeframe=bt.TimeFrame.Minutes,
    compression=1,
    use_websocket=True,  # Low-latency WebSocket

)

# Broker with automatic order management

broker = store.getbroker(use_threaded_order_manager=True)

```bash
See [CCXT Live Trading Guide](../CCXT_LIVE_TRADING_GUIDE.md) for details.

### 2. CTP Futures Support (China Market)

```python

# NEW: CTP Store for Chinese futures

store = bt.stores.CTPStore(
    broker_id='9999',
    investor_id='your_id',
    password='your_password',
    td_address='tcp://180.168.146.187:10130',
    md_address='tcp://180.168.146.187:10131',
)

```bash

### 3. Enhanced Performance Modes

#### TS Mode (Time Series)

Optimized for single-asset strategies with pandas vectorization:

```python
cerebro = bt.Cerebro()
cerebro.run(ts_mode=True)  # 10-50x faster for suitable strategies

```bash

#### CS Mode (Cross-Sectional)

Optimized for multi-asset portfolio strategies:

```python
cerebro = bt.Cerebro()
cerebro.run(cs_mode=True)  # Efficient cross-sectional signals

```bash

### 4. Plotly Interactive Plotting

```python

# NEW: Interactive web-based plotting

cerebro.plot(style='plotly')

```bash
Supports:

- Zoom and pan on 100k+ data points
- Hover for detailed information
- Multiple subcharts
- Dark/light themes

## Migration Steps

### Step 1: Install the Fork

```bash

# Uninstall original backtrader if present

pip uninstall backtrader

# Install this fork

cd /path/to/this/fork
pip install -e .

# Or from PyPI (when published)

# pip install backtrader-enhanced

```bash

### Step 2: Test Your Existing Code

Run your existing strategies without modification:

```bash

# Your existing strategy file

python my_strategy.py

# With tests

pytest tests/ -v

```bash

- *Expected Result**: Everything works exactly as before.

### Step 3: Enable Performance Optimizations (Optional)

Once you've confirmed compatibility, enable optimizations:

#### Compile Cython Extensions

```bash

# Unix/Mac

cd backtrader && python -W ignore compile_cython_numba_files.py && cd .. && pip install -U .

# Windows

cd backtrader; python -W ignore compile_cython_numba_files.py; cd ..; pip install -U .

```bash

#### Use Performance Modes

```python

# For time-series strategies (single asset)

cerebro.run(ts_mode=True)

# For cross-sectional strategies (multi-asset)

cerebro.run(cs_mode=True)

```bash

### Step 4: Migrate to Live Trading (Optional)

If you want to move from backtesting to live trading:

```python

# OLD: Backtesting only

cerebro = bt.Cerebro()
data = bt.feeds.CSVGeneric(dataname='backtest_data.csv')
cerebro.adddata(data)

# NEW: Live trading with CCXT

cerebro = bt.Cerebro()
store = bt.stores.CCXTStore(exchange='binance', ...)
data = store.getdata(dataname='BTC/USDT', use_websocket=True)
cerebro.adddata(data)
broker = store.getbroker()
cerebro.setbroker(broker)

```bash

## Before/After Code Examples

### Example 1: Simple Strategy (No Changes Needed)

- *Before (Original)**:

```python
import backtrader as bt

class MyStrategy(bt.Strategy):
    params = (('period', 20),)

    def __init__(self):
        self.sma = bt.indicators.SMA(self.data.close, period=self.p.period)

    def next(self):
        if self.data.close[0] > self.sma[0]:
            self.buy()

cerebro = bt.Cerebro()
cerebro.addstrategy(MyStrategy)
cerebro.run()

```bash

- *After (This Fork)**: Identical - no changes needed!

### Example 2: Adding Live Trading

- *Before (Original - backtesting only)**:

```python
cerebro = bt.Cerebro()
data = bt.feeds.YahooFinanceData(dataname='AAPL', fromdate=datetime(...))
cerebro.adddata(data)
cerebro.run()

```bash

- *After (This Fork - live trading)**:

```python
store = bt.stores.CCXTStore(
    exchange='binance',
    config={'apiKey': KEY, 'secret': SECRET}
)
data = store.getdata(
    dataname='BTC/USDT',
    use_websocket=True  # Real-time data

)
broker = store.getbroker()

cerebro = bt.Cerebro()
cerebro.adddata(data)
cerebro.setbroker(broker)
cerebro.run()  # Now trading live!

```bash

### Example 3: Performance Optimization

- *Before (Original)**:

```python
cerebro = bt.Cerebro()

# ... setup ...

cerebro.run()  # Standard execution

```bash

- *After (This Fork - optimized)**:

```python
cerebro = bt.Cerebro()

# ... setup ...

# Option 1: Time-series mode (10-50x faster for single assets)

cerebro.run(ts_mode=True)

# Option 2: Cross-sectional mode (efficient for portfolios)

cerebro.run(cs_mode=True)

# Option 3: Use once() mode with Cython compiled

cerebro.run()  # Automatically uses compiled optimizations

```bash

## Common Migration Issues

### Issue 1: Import Conflicts

- *Problem**: Both original backtrader and this fork installed.

- *Solution**:

```bash
pip uninstall backtrader
pip install -e /path/to/this/fork

```bash

### Issue 2: Cython Compilation Fails

- *Problem**: Cython extensions not compiled.

- *Solution**:

```bash

# Install Cython first

pip install cython

# Compile extensions

cd backtrader
python -W ignore compile_cython_numba_files.py
cd ..
pip install -U .

```bash

### Issue 3: WebSocket Connection Issues

- *Problem**: CCXT WebSocket fails to connect.

- *Solution**:

```python

# Check ccxtpro is installed

pip install ccxtpro

# System auto-falls back to REST polling if WebSocket unavailable

data = store.getdata(
    dataname='BTC/USDT',
    use_websocket=False  # Disable WebSocket, use REST

)

```bash

### Issue 4: Different Test Results

- *Problem**: Slight numerical differences in indicator values.

- *Solution**: This is expected due to floating-point precision improvements. Values should be within 1e-10 of original results.

## Feature Parity Table

| Feature | Original | This Fork | Notes |

|---------|----------|-----------|-------|

| **Core Backtesting**| Full | Full | 100% compatible |

|**Indicators**| 60+ | 60+ | Same indicators, faster execution |

|**Analyzers**| All | All | Same analyzers |

|**Observers**| All | All | Same observers |

|**Data Feeds**| CSV, Yahoo, Pandas, etc. | All above + CCXT, CTP | New live trading feeds |

|**Brokers**| Standard, IB | All above + CCXT, CTP | New live trading brokers |

|**Plotting**| Matplotlib | Matplotlib + Plotly + Bokeh | New interactive plotting |

|**Optimization**| Built-in | Built-in + TS/CS modes | New performance modes |

|**Documentation**| Limited | Comprehensive bilingual | New guides and API reference |

|**Testing**| ~300 tests | 917+ tests | 50% code coverage |

## Performance Improvements

Based on standardized benchmarks:

| Scenario | Original | This Fork | Improvement |

|----------|----------|-----------|-------------|

| Simple strategy (1000 bars) | 2.3s | 1.3s |**43% faster**|

| Complex strategy (10 indicators) | 15.2s | 8.5s |**44% faster**|

| Portfolio (10 assets) | 45.8s | 25.1s |**45% faster**|

| TS Mode (vectorized) | N/A | 1.5s |**10x faster**|

| With Cython | N/A | 0.8s |**20x faster**|

## Additional Resources

### Documentation

- [Quick Start Tutorial](../user_guide/quickstart.md)
- [CCXT Live Trading Guide](../CCXT_LIVE_TRADING_GUIDE.md)
- [Architecture Documentation](../ARCHITECTURE.md)
- [API Reference](/api/)
- [Project Status](../PROJECT_STATUS.md)

### Community & Support

- **Issues**: Report bugs on GitHub Issues
- **Discussions**: Use GitHub Discussions for questions
- **Contributing**: See [CONTRIBUTING.md](../../CONTRIBUTING.md)

### Testing

```bash

# Run all tests

pytest tests/ -v

# Run specific test category

pytest tests/original_tests/ -v
pytest tests/new_functions/ -v

# With coverage

pytest tests/ --cov=backtrader --cov-report=term-missing

```bash

## Checklist for Successful Migration

- [ ] Uninstall original backtrader
- [ ] Install this fork (`pip install -e .`)
- [ ] Run existing tests to verify compatibility
- [ ] (Optional) Compile Cython extensions
- [ ] (Optional) Enable TS/CS performance modes
- [ ] (Optional) Migrate to live trading with CCXT
- [ ] (Optional) Try Plotly interactive plotting
- [ ] Update documentation/comments if extending functionality

## Quick Reference

### Key Commands

```bash

# Installation

pip install -e .

# Compile Cython (for max performance)

cd backtrader && python -W ignore compile_cython_numba_files.py && cd .. && pip install -U .

# Run tests

pytest tests/ -v

# Generate documentation

make docs

# Format code

make format

```bash

### Performance Tips

1. **Always compile Cython**for production use

2.**Use TS mode**for single-asset time-series strategies
3.**Use CS mode**for multi-asset portfolio strategies
4.**Enable WebSocket**for live trading (lower latency)
5.**Use exactbars**for long backtests (memory optimization)

### Live Trading Tips

1.**Start with paper trading**to validate your strategy
2.**Use ThreadedOrderManager**for non-blocking order updates
3.**Enable rate limiting**to respect exchange limits
4.**Monitor connection health**with ConnectionManager callbacks
5.**Handle errors** in `notify_order()` for robust trading

- --

- *Congratulations!** You're ready to use this enhanced backtrader fork. Your existing code works, and you now have access to powerful new features for live trading and improved performance.