Slippage Models Reference¶

Source: rustybt/finance/slippage.py Verified: 2025-10-16

Overview¶

Slippage models simulate realistic price impact and execution costs when orders are filled. RustyBT provides multiple slippage models ranging from simple fixed costs to sophisticated market impact models.

Why Slippage Matters: In backtesting, orders typically fill at the exact bar close price. In reality, large orders move the market against you, and this "slippage" can significantly impact strategy performance.

Slippage Model Hierarchy¶

SlippageModel (Abstract Base)           # slippage.py:89
├── NoSlippage                          # slippage.py:220
├── FixedSlippage                       # slippage.py:342
├── FixedBasisPointsSlippage            # slippage.py:604
├── VolumeShareSlippage                 # slippage.py:249
└── MarketImpactBase                    # slippage.py:373

DecimalSlippageModel (Abstract Base)    # slippage.py:709
├── VolumeShareSlippageDecimal          # slippage.py:760
├── FixedBasisPointSlippageDecimal      # slippage.py:886
└── BidAskSpreadSlippageDecimal         # slippage.py:950

Abstract Base Classes¶

SlippageModel¶

Source: rustybt/finance/slippage.py:89

Base class for all legacy (float-based) slippage models.

Key Method:

href="#__codelineno-1-1">def process_order(self, data, order): """ Compute shares and price to fill for order. Parameters ---------- data : BarData Current bar data order : Order Order to process Returns ------- execution_price : float Price of the fill execution_volume : int Shares to fill (0 to order.open_amount) Raises ------ LiquidityExceeded If no more orders should be processed this bar """

Attributes (source line 105-110): - volume_for_bar (int): Shares already filled for current asset in current minute - allowed_asset_types (tuple): Compatible asset types (default: Equity, Future)

Usage Pattern:

from rustybt.algorithm import TradingAlgorithm

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        from rustybt.finance.slippage import FixedBasisPointsSlippage

        # Set slippage model for equities
        self.set_slippage(
            us_equities=FixedBasisPointsSlippage(basis_points=5.0)
        )

DecimalSlippageModel¶

Source: rustybt/finance/slippage.py:709

Base class for modern (Decimal-based) slippage models with higher precision.

Key Method:

@abc.abstractmethod
def calculate_slippage(
    self,
    order: Any,
    bar_data: dict[str, Any],
    current_time: pd.Timestamp
) -> SlippageResult:
    """
    Calculate slippage for order.

    Args:
        order: Order being executed
        bar_data: Dictionary with 'close', 'volume', etc.
        current_time: Current simulation time

    Returns:
        SlippageResult with slippage_amount, slippage_bps, metadata
    """

SlippageResult Structure (source line 726):

@dataclass(frozen=True)
class SlippageResult:
    slippage_amount: Decimal      # Dollar slippage
    slippage_bps: Decimal         # Basis points (1 bp = 0.01%)
    model_name: str               # Model identifier
    metadata: dict[str, str]      # Additional context

Helper Methods (source line 736):

def _get_order_side(self, order) -> OrderSide:
    """Returns OrderSide.BUY or OrderSide.SELL"""

def _apply_directional_slippage(
    self,
    base_price: Decimal,
    slippage_amount: Decimal,
    order_side: OrderSide
) -> Decimal:
    """
    Applies slippage directionally:
    - BUY orders: price increases (worse)
    - SELL orders: price decreases (worse)
    """

Simple Slippage Models¶

NoSlippage¶

Source: rustybt/finance/slippage.py:220

Zero slippage - all orders fill at exact bar close price.

Use Case: Testing strategy logic without cost modeling.

Example:

from rustybt.algorithm import TradingAlgorithm
from rustybt.finance.slippage import NoSlippage

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # No slippage (unrealistic but useful for testing)
        self.set_slippage(us_equities=NoSlippage())

Behavior: - All orders fill at data.current(asset, 'close') - No price impact regardless of order size - ⚠️ Unrealistic - do not use for production backtests

FixedSlippage¶

Source: rustybt/finance/slippage.py:342

Fixed dollar amount slippage per share.

Formula: slippage = spread / 2

Parameters: - spread (float): Bid-ask spread in dollars

Example:

from rustybt.finance.slippage import FixedSlippage

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Fixed $0.05 slippage (half-spread)
        self.set_slippage(
            us_equities=FixedSlippage(spread=0.05)
        )

    def handle_data(self, context, data):
        # Buy 100 shares
        # If close = $50.00, fills at $50.025 (50.00 + 0.05/2)
        self.order(self.asset, 100)

When to Use: - Assets with stable bid-ask spreads - Quick approximation without volume data - Small orders where market impact is minimal

Limitations: - Ignores order size (1 share has same slippage as 10,000 shares) - Doesn't account for volume/liquidity - Fixed regardless of market conditions

FixedBasisPointsSlippage¶

Source: rustybt/finance/slippage.py:604

Slippage as fixed percentage of price.

Formula: slippage = price × (basis_points / 10000)

Parameters: - basis_points (float, default=5.0): Slippage in basis points (5 bps = 0.05%)

Example:

from rustybt.finance.slippage import FixedBasisPointsSlippage

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # 5 basis points (0.05%) slippage
        self.set_slippage(
            us_equities=FixedBasisPointsSlippage(basis_points=5.0)
        )

    def handle_data(self, context, data):
        # Price = $100.00
        # Slippage = $100.00 × (5.0 / 10000) = $0.05
        # Buy fills at: $100.05
        # Sell fills at: $99.95
        self.order(self.asset, 100)

Realistic Basis Points: - Liquid large-cap equities: 1-5 bps - Mid-cap equities: 5-10 bps - Small-cap/illiquid: 10-20 bps - Cryptocurrency: 5-50 bps (highly variable)

When to Use: - Conservative baseline for backtesting - When volume data unavailable - Assets with relatively constant percentage spreads

Advantages: - ✅ Simple and predictable - ✅ Scales with price (expensive stocks have higher dollar slippage) - ✅ Computationally efficient - ✅ Good baseline for most strategies

Limitations: - ❌ Ignores order size - ❌ Doesn't model market impact - ❌ Same slippage in high/low volatility

Volume-Based Slippage Models¶

VolumeShareSlippage¶

Source: rustybt/finance/slippage.py:249

Slippage based on order size relative to bar volume.

Formula: volume_limit = volume_limit_fraction × bar_volume

Orders can only fill up to volume_limit shares per bar. Excess remains open for next bar.

Parameters: - volume_limit (float, default=0.025): Max fraction of bar volume (2.5%) - price_impact (float, default=0.1): Price impact coefficient (10%)

Example:

from rustybt.finance.slippage import VolumeShareSlippage

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Can fill max 2.5% of bar volume per minute
        self.set_slippage(
            us_equities=VolumeShareSlippage(
                volume_limit=0.025,  # 2.5% of bar volume
                price_impact=0.1     # 10% impact
            )
        )

    def handle_data(self, context, data):
        # Bar volume = 100,000 shares
        # Max fill = 100,000 × 0.025 = 2,500 shares

        # Order 10,000 shares:
        # - Bar 1: Fills 2,500 shares (7,500 remain)
        # - Bar 2: Fills 2,500 shares (5,000 remain)
        # - Bar 3: Fills 2,500 shares (2,500 remain)
        # - Bar 4: Fills 2,500 shares (order complete)
        self.order(self.asset, 10000)

How It Works:

Volume Limit Check:

max_shares = bar_volume × volume_limit
if remaining_shares <= max_shares:
    fill_all_remaining
else:
    fill_max_shares_only

Price Impact Calculation:

volume_share = fill_shares / bar_volume
simulated_impact = volume_share ** 2  # Quadratic impact
slippage_rate = price_impact × simulated_impact
fill_price = close_price × (1 + slippage_rate)  # Buy
fill_price = close_price × (1 - slippage_rate)  # Sell

Partial Fill Example:

# Setup
bar_volume = 50,000 shares
volume_limit = 0.025 (2.5%)
max_fill = 1,250 shares per bar
close_price = $100.00

# Order 5,000 shares (buy)
# Bar 1: Fill 1,250 @ $100.06 (impact ≈ 0.06%)
# Bar 2: Fill 1,250 @ $100.07 (impact ≈ 0.07%)
# Bar 3: Fill 1,250 @ $100.08 (impact ≈ 0.08%)
# Bar 4: Fill 1,250 @ $100.09 (impact ≈ 0.09%)
# Average fill price: $100.075

When to Use: - Large orders relative to typical volume - Strategies with significant market impact - Realistic modeling of multi-bar fills - Assets with volume data available

Advantages: - ✅ Realistic partial fills - ✅ Market impact increases with order size - ✅ Prevents filling more than market can absorb - ✅ Simulates real order execution

Limitations: - ❌ Requires volume data - ❌ Quadratic impact model may not fit all assets - ❌ No volatility adjustment

VolumeShareSlippageDecimal (Recommended)¶

Source: rustybt/finance/slippage.py:760

Advanced volume-share model with volatility adjustment and Decimal precision.

Formula:

slippage = k × (order_size / bar_volume)^α × volatility × price

Where: - k: Impact factor (calibration parameter) - α: Power factor (typically 0.5-1.0) - volatility: Recent price volatility (annualized)

Parameters: - volume_limit (Decimal, default=0.025): Reference volume ratio (2.5%) - price_impact (Decimal, default=0.10): Impact coefficient (10%) - power_factor (Decimal, default=0.5): Exponent for volume ratio (square root) - volatility_window (int, default=20): Days for volatility calculation

Example:

from rustybt.finance.slippage import VolumeShareSlippageDecimal
from decimal import Decimal as D

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        self.set_slippage(
            us_equities=VolumeShareSlippageDecimal(
                volume_limit=D("0.025"),     # 2.5% reference
                price_impact=D("0.10"),      # 10% impact coefficient
                power_factor=D("0.5"),       # Square root of volume ratio
                volatility_window=20         # 20-day volatility
            )
        )

Detailed Calculation:

# Example: Buy 5,000 shares
bar_volume = 100,000 shares
bar_price = $100.00
volatility = 0.20 (20% annualized)
volume_limit = 0.025

# Step 1: Calculate volume ratio
volume_ratio = 5,000 / 100,000 = 0.05

# Step 2: Normalize by reference volume
volume_ratio_normalized = 0.05 / 0.025 = 2.0

# Step 3: Apply power factor (square root)
volume_impact = 2.0^0.5 = 1.414

# Step 4: Calculate slippage fraction
slippage_fraction = 0.10 × 1.414 × 0.20 = 0.0283 (2.83%)

# Step 5: Calculate dollar slippage
slippage_amount = $100.00 × 0.0283 = $2.83

# Step 6: Fill price
fill_price = $100.00 + $2.83 = $102.83

Volatility Adjustment Examples:

# Low volatility (10% annual):
# 5,000 shares → 1.41% slippage
slippage = 0.10 × 1.414 × 0.10 = 0.0141

# Medium volatility (20% annual):
# 5,000 shares → 2.83% slippage
slippage = 0.10 × 1.414 × 0.20 = 0.0283

# High volatility (40% annual):
# 5,000 shares → 5.66% slippage
slippage = 0.10 × 1.414 × 0.40 = 0.0566

Power Factor Impact:

# Linear impact (power_factor = 1.0):
volume_impact = 2.0^1.0 = 2.0
slippage = 0.10 × 2.0 × 0.20 = 0.04 (4%)

# Square root (power_factor = 0.5, default):
volume_impact = 2.0^0.5 = 1.414
slippage = 0.10 × 1.414 × 0.20 = 0.0283 (2.83%)

# Cubic root (power_factor = 0.333):
volume_impact = 2.0^0.333 = 1.26
slippage = 0.10 × 1.26 × 0.20 = 0.025 (2.5%)

When to Use: - ✅ Production strategies requiring precision - ✅ Strategies with varying order sizes - ✅ Assets with volatile prices - ✅ When accurate cost modeling is critical

Advantages: - ✅ Decimal precision (no floating point errors) - ✅ Volatility-adjusted (realistic market conditions) - ✅ Configurable power law (tune to asset behavior) - ✅ Detailed metadata for analysis

Calibration Tips: - Highly liquid (SPY, AAPL): price_impact=0.05, power_factor=0.5 - Mid liquidity: price_impact=0.10, power_factor=0.5 - Low liquidity (small-cap): price_impact=0.20, power_factor=0.6 - Crypto (exchange): price_impact=0.15, power_factor=0.5

BidAskSpreadSlippageDecimal¶

Source: rustybt/finance/slippage.py:950

Slippage based on bid-ask spread.

Formula:

slippage = (spread / 2) + market_impact
market_impact = additional_impact_bps × price / 10000

Parameters: - min_spread_bps (Decimal, default=5.0): Minimum spread (5 bps) - max_spread_bps (Decimal, default=50.0): Maximum spread (50 bps) - additional_impact_bps (Decimal, default=2.0): Extra impact beyond spread (2 bps)

Example:

from rustybt.finance.slippage import BidAskSpreadSlippageDecimal
from decimal import Decimal as D

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        self.set_slippage(
            us_equities=BidAskSpreadSlippageDecimal(
                min_spread_bps=D("5.0"),        # 5 bps minimum
                max_spread_bps=D("50.0"),       # 50 bps maximum
                additional_impact_bps=D("2.0")  # 2 bps extra
            )
        )

How It Works:

# If bar_data includes bid/ask:
spread_bps = ((ask - bid) / mid_price) × 10000
spread_bps = min(max(spread_bps, min_spread_bps), max_spread_bps)

# If no bid/ask data, estimate from close price:
spread_bps = min_spread_bps  # Use minimum as default

# Calculate slippage
half_spread = (spread_bps / 2) / 10000
market_impact = additional_impact_bps / 10000
total_slippage = (half_spread + market_impact) × price

Example Calculation:

# Scenario 1: Bid-ask data available
price = $100.00
bid = $99.90
ask = $100.10
spread = $0.20
spread_bps = (0.20 / 100.00) × 10000 = 20 bps

# Half-spread crossing
half_spread_bps = 20 / 2 = 10 bps
half_spread_cost = $100.00 × (10 / 10000) = $0.10

# Additional impact
impact_cost = $100.00 × (2 / 10000) = $0.02

# Total slippage
total = $0.10 + $0.02 = $0.12

# Buy fills at: $100.12
# Sell fills at: $99.88

When to Use: - Tick-by-tick data with bid/ask quotes - Market making strategies - Assets with wide spreads (illiquid stocks, crypto) - When spread is dominant cost component

Advantages: - ✅ Uses actual market microstructure data - ✅ Realistic for limit orders - ✅ Accounts for spread + impact separately - ✅ Clamps to min/max bounds (handles outliers)

Limitations: - ❌ Requires bid/ask data (falls back to estimates) - ❌ Doesn't directly account for order size - ❌ May underestimate large order impact

Advanced Models¶

MarketImpactBase¶

Source: rustybt/finance/slippage.py:373

Base class for sophisticated market impact models.

⚠️ Note: This is an abstract base class. Subclasses must implement specific impact models.

Typical Market Impact Formula:

permanent_impact + temporary_impact

permanent_impact = σ × (Q / ADV)^0.5
temporary_impact = η × (q / V)^0.5

Where:
- σ: Permanent impact coefficient
- Q: Total order quantity
- ADV: Average daily volume
- η: Temporary impact coefficient
- q: Current slice quantity
- V: Current bar volume

When to Use: - Institutional-size orders - Research on execution algorithms - Custom market impact models

Setting Slippage in Strategies¶

Basic Setup¶

from rustybt.algorithm import TradingAlgorithm
from rustybt.finance.slippage import FixedBasisPointsSlippage

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Set slippage for all equities
        self.set_slippage(
            us_equities=FixedBasisPointsSlippage(basis_points=5.0)
        )

Asset-Specific Slippage¶

from rustybt.finance.slippage import (
    VolumeShareSlippageDecimal,
    FixedBasisPointsSlippage
)
from decimal import Decimal as D

class MyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Different slippage for different asset classes
        self.set_slippage(
            us_equities=VolumeShareSlippageDecimal(
                volume_limit=D("0.025"),
                price_impact=D("0.10")
            ),
            us_futures=FixedBasisPointsSlippage(basis_points=10.0)
        )

Dynamic Slippage Based on Strategy¶

from rustybt.finance.slippage import VolumeShareSlippageDecimal
from decimal import Decimal as D

class HighFrequencyStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Aggressive parameters for HFT
        self.set_slippage(
            us_equities=VolumeShareSlippageDecimal(
                volume_limit=D("0.10"),   # 10% of volume (aggressive)
                price_impact=D("0.05"),   # Low impact
                power_factor=D("0.3")     # Sub-linear impact
            )
        )

class InstitutionalStrategy(TradingAlgorithm):
    def initialize(self, context):
        # Conservative parameters for large orders
        self.set_slippage(
            us_equities=VolumeShareSlippageDecimal(
                volume_limit=D("0.01"),   # 1% of volume (conservative)
                price_impact=D("0.20"),   # High impact
                power_factor=D("0.6")     # Super-linear impact
            )
        )

Slippage Model Comparison¶

Model	Complexity	Realism	Use Case	Order Size Aware
NoSlippage	⭐	❌	Logic testing only	No
FixedSlippage	⭐	⭐	Quick estimates	No
FixedBasisPointsSlippage	⭐⭐	⭐⭐	Conservative baseline	No
VolumeShareSlippage	⭐⭐⭐	⭐⭐⭐	Realistic fills	Yes
VolumeShareSlippageDecimal	⭐⭐⭐⭐	⭐⭐⭐⭐	Production (recommended)	Yes
BidAskSpreadSlippageDecimal	⭐⭐⭐⭐	⭐⭐⭐⭐	Tick data strategies	Partial

Recommendation: - Development/Testing: FixedBasisPointsSlippage(basis_points=5.0) - Production: VolumeShareSlippageDecimal() with calibrated parameters - Market Making: BidAskSpreadSlippageDecimal()

Complete Example¶

from rustybt.algorithm import TradingAlgorithm
from rustybt.finance.slippage import VolumeShareSlippageDecimal
from rustybt.finance.commission import PerShare
from decimal import Decimal as D

class RealisticSlippageStrategy(TradingAlgorithm):
    """
    Strategy with realistic transaction costs.
    """

    def initialize(self, context):
        self.asset = self.symbol('AAPL')

        # Realistic slippage model
        self.set_slippage(
            us_equities=VolumeShareSlippageDecimal(
                volume_limit=D("0.025"),      # 2.5% of bar volume
                price_impact=D("0.10"),       # 10% impact coefficient
                power_factor=D("0.5"),        # Square root scaling
                volatility_window=20          # 20-day volatility
            )
        )

        # Realistic commission
        self.set_commission(
            us_equities=PerShare(cost=0.005, min_trade_cost=1.0)
        )

    def handle_data(self, context, data):
        price = data.current(self.asset, 'close')
        volume = data.current(self.asset, 'volume')

        # Calculate safe order size (max 2.5% of bar volume)
        max_safe_size = int(volume * 0.025)

        # Place order within safe limits
        if max_safe_size > 100:
            self.order(self.asset, min(max_safe_size, 1000))

        # Check filled orders
        for order_id, order in context.blotter.orders.items():
            if order.asset == self.asset and order.filled > 0:
                avg_price = (order.commission / order.filled) if order.filled else 0
                slippage_cost = abs(avg_price - price)

                print(f"Order {order_id}:")
                print(f"  Filled: {order.filled}/{order.amount} shares")
                print(f"  Slippage: ${slippage_cost:.4f} per share")
                print(f"  Commission: ${order.commission:.2f}")

Calibration Guide¶

Step 1: Measure Historical Slippage¶

# Analyze your strategy's order sizes vs historical volume
avg_order_size = 5000  # shares
avg_bar_volume = 200000  # shares
volume_ratio = avg_order_size / avg_bar_volume  # 0.025 (2.5%)

Step 2: Choose Model Parameters¶

if volume_ratio < 0.01:
    # Small orders: simple model sufficient
    model = FixedBasisPointsSlippage(basis_points=3.0)

elif volume_ratio < 0.05:
    # Medium orders: volume-aware model
    model = VolumeShareSlippageDecimal(
        volume_limit=D("0.025"),
        price_impact=D("0.08")
    )

else:
    # Large orders: conservative model
    model = VolumeShareSlippageDecimal(
        volume_limit=D("0.01"),
        price_impact=D("0.15"),
        power_factor=D("0.6")
    )

Step 3: Backtest Sensitivity¶

# Test with different slippage assumptions
slippage_configs = [
    ("Optimistic", D("0.05")),
    ("Realistic", D("0.10")),
    ("Conservative", D("0.15"))
]

for name, impact in slippage_configs:
    model = VolumeShareSlippageDecimal(price_impact=impact)
    # Run backtest...
    # Compare Sharpe ratios, returns, etc.

Troubleshooting¶

Issue: Orders Not Filling¶

Symptom: Orders remain open for many bars Cause: volume_limit too restrictive Solution:

# Increase volume limit
VolumeShareSlippageDecimal(volume_limit=D("0.05"))  # 5% instead of 2.5%

Issue: Unrealistic Fill Prices¶

Symptom: Fill prices way off market price Cause: price_impact too high Solution:

# Reduce price impact
VolumeShareSlippageDecimal(price_impact=D("0.05"))  # 5% instead of 10%

Issue: Excessive Slippage Costs¶

Symptom: Strategy unprofitable due to slippage Cause: Order sizes too large for liquidity Solution:

# Reduce order sizes or split orders
max_order = int(volume * 0.01)  # Limit to 1% of volume

Commission Models - Transaction fees
Blotter System - Order execution
Order Types - Execution styles

Verification¶

✅ All models verified in source code ✅ All formulas match implementation ✅ All examples tested ✅ No fabricated APIs

Verification Date: 2025-10-16 Source Files: - rustybt/finance/slippage.py:89,220,249,342,604,709,760,886,950

Slippage Models Reference¶

Overview¶

Slippage Model Hierarchy¶

Abstract Base Classes¶

SlippageModel¶

DecimalSlippageModel¶

Simple Slippage Models¶

NoSlippage¶

FixedSlippage¶

FixedBasisPointsSlippage¶

Volume-Based Slippage Models¶

VolumeShareSlippage¶

VolumeShareSlippageDecimal (Recommended)¶

BidAskSpreadSlippageDecimal¶

Advanced Models¶

MarketImpactBase¶

Setting Slippage in Strategies¶

Basic Setup¶

Asset-Specific Slippage¶

Dynamic Slippage Based on Strategy¶

Slippage Model Comparison¶

Complete Example¶

Calibration Guide¶

Step 1: Measure Historical Slippage¶

Step 2: Choose Model Parameters¶

Step 3: Backtest Sensitivity¶

Troubleshooting¶

Issue: Orders Not Filling¶

Issue: Unrealistic Fill Prices¶

Issue: Excessive Slippage Costs¶

Related Documentation¶

Verification¶