Migrating from Classic Zipline

Ziplime keeps the event-driven strategy model of classic Zipline and zipline-reloaded, but it is not a drop-in replacement. The differences that matter: async strategy functions, Polars data frames, explicit execution styles, and next-bar fills by default.

What stays the same

Persistent strategy state lives on context.
initialize sets up; handle_data trades bar by bar.
schedule_function with date_rules and time_rules, record, order_target_percent, pipelines, trading controls.

Quick conversion table

Classic Zipline	Ziplime
`def initialize(context)`	`async def initialize(context)`
`def handle_data(context, data)`	`async def handle_data(context, data)`
`def before_trading_start(context, data)`	`async def before_trading_start(context, data)`
`asset = symbol("AAPL")`	`asset = await context.symbol("AAPL")`
`symbols("AAPL", "MSFT")`	`await context.symbols("AAPL", "MSFT")`
`data.current(asset, "close")`	`(await data.current(assets=[asset], fields=["close"]))["close"][0]`
`data.history(asset, "close", 20, "1d")`	`await data.history(assets=[asset], fields=["close"], bar_count=20)`
`data.can_trade(asset)`	`data.can_trade([asset])[asset]`
`order(asset, 100)`	`await context.order(asset, 100, style=MarketOrder())`
`order_target_percent(asset, 0.5)`	`await context.order_target_percent(asset, 0.5, style=MarketOrder())`
`context.portfolio.positions[asset].amount`	`await context.portfolio.get_asset_positions_amount(asset)`
pandas from `data.*`	Polars from `data.*`
`run_algorithm(...)`	`ziplime run ...` or `run_simulation(...)`

Imports

Import what you use — the algorithm file is a normal Python module. Prefer context methods over the zipline.api functions:

from ziplime.finance.execution import MarketOrder
from ziplime.utils.events import date_rules, time_rules

ziplime.api exists for compatibility, but context calls are clearer in async code.

Lifecycle functions

Classic Zipline:

def initialize(context):
    context.asset = symbol("AAPL")


def handle_data(context, data):
    price = data.current(context.asset, "close")
    if price > 100:
        order_target_percent(context.asset, 1.0)

Ziplime:

from ziplime.finance.execution import MarketOrder


async def initialize(context):
    context.asset = await context.symbol("AAPL")


async def handle_data(context, data):
    current = await data.current(assets=[context.asset], fields=["close"])
    price = current["close"][0]

    if price > 100:
        await context.order_target_percent(context.asset, 1.0, style=MarketOrder())

before_trading_start should be async def so it can await data reads. analyze(context, perf) stays plain def, and perf is still a pandas DataFrame.

A missing await does not raise. The call returns a coroutine that never runs, and the migrated strategy silently places no orders.

Market data

Ziplime expects lists and returns a Polars DataFrame with date, sid and the requested fields:

history = await data.history(assets=[asset], fields=["close"], bar_count=20)
mean_close = history["close"].mean()
last_close = history["close"][-1]

.iloc, .loc, .at and .iat don’t exist on a Polars frame. If old code depends on pandas, convert explicitly with history.to_pandas(); prefer Polars expressions for new code. data.history excludes the current bar. Read it with data.current when the signal needs it.

Orders

Order calls are async and take an execution style:

from ziplime.finance.execution import MarketOrder, LimitOrder

await context.order(asset, 100, style=MarketOrder())
await context.order(asset, 100, style=LimitOrder(limit_price=150.0))
await context.order_value(asset, 5_000, limit_price=150.0)

Many Zipline rebalancers loop over order_target_percent and then close what’s left. context.rebalance(weights) does both:

await context.rebalance({asset: 1.0 / len(winners) for asset in winners})

Fill timing changes results

The CLI and the MCP server fill on the next bar by default; Zipline’s typical setup filled on the same bar. Expect a migrated backtest to differ. That difference is the look-ahead the old setup had. run_simulation still defaults to same-bar — pass same_bar_execution=False to compare like for like.

Symbols

asset = await context.symbol("AAPL")
asset = await context.symbol("AAPL", mic="XNGS")
asset = await context.symbol("AAPL@XNGS")

Pass a MIC only when a ticker exists on several venues. For named universes, await context.universe_symbols("Q500US") returns tradeable listings and follows membership over time.

Scheduling

from ziplime.finance.execution import MarketOrder
from ziplime.utils.events import date_rules, time_rules


async def initialize(context):
    context.schedule_function(
        rebalance,
        date_rule=date_rules.month_end(),
        time_rule=time_rules.market_close(minutes=30),
    )


async def rebalance(context, data):
    await context.order_target_percent(context.asset, 1.0, style=MarketOrder())

Time rules work at any intraday emission rate; on a daily run the time rule is ignored. For a simple weekly or monthly rebalance, if not context.is_month_start(): return at the top of handle_data is often enough.

Portfolio

Positions are keyed by exchange, account and listing, so use helpers:

cash = context.portfolio.cash
amount = await context.portfolio.get_asset_positions_amount(asset)
value = await context.portfolio.get_asset_positions_value(asset)

Pipelines

The Pipeline API is Zipline-like — Pipeline, EquityPricing, CustomFactor, screens, attach_pipeline, pipeline_output. Pricing via EquityPricing is the standard path; custom datasets need custom loaders. For alternative data, point-in-time datasets are usually the simpler route.

Running migrated algorithms

ziplime ingest-assets
ziplime ingest -b mybundle -s AAPL,MSFT --start-date 2015-01-01 --end-date 2025-12-31
ziplime run -f my_migrated_algo.py -b mybundle -s AAPL,MSFT \
  --start-date 2016-01-01 --end-date 2025-12-31 --commission-per-share 0.005

Or from Python with run_simulation(...) — see Install & Run.

Full before and after

Classic Zipline:

from zipline.api import order_target_percent, record, symbol


def initialize(context):
    context.asset = symbol("AAPL")
    context.window = 20


def handle_data(context, data):
    history = data.history(context.asset, "close", context.window, "1d")
    price = data.current(context.asset, "close")
    mean_price = history.mean()

    if price > mean_price:
        order_target_percent(context.asset, 1.0)
    else:
        order_target_percent(context.asset, 0.0)

    record(price=price, mean_price=mean_price)

Ziplime:

from ziplime.finance.execution import MarketOrder


async def initialize(context):
    context.asset = await context.symbol("AAPL")
    context.window = 20


async def handle_data(context, data):
    history = await data.history(
        assets=[context.asset], fields=["close"], bar_count=context.window,
    )
    if len(history) < context.window:
        return
    current = await data.current(assets=[context.asset], fields=["close"])

    price = current["close"][0]
    mean_price = history["close"].mean()
    target = 1.0 if price > mean_price else 0.0

    if not context.get_open_orders(context.asset):
        await context.order_target_percent(context.asset, target, style=MarketOrder())

    context.record(price=price, mean_price=mean_price, target=target)

Migration checklist

Make initialize, handle_data, before_trading_start and scheduled callbacks async def; keep analyze plain def.
Add await to asset lookups, data reads, orders and cancellations.
Pass lists to data.current and data.history; replace pandas indexing with Polars.
Add an execution style such as MarketOrder() to order calls.
Replace portfolio.positions[asset] with portfolio helper methods.
Pass MIC codes only for ambiguous tickers.
Rebuild data: ziplime ingest-assets, then ziplime ingest.
Expect different numbers from next-bar fills and enforced controls, and set a real commission.

Introduction

Writing Strategies

Strategy Language

Migrating to Ziplime

Limitations

Migrating from Classic Zipline

What stays the same

Quick conversion table

Imports

Lifecycle functions

Market data

Orders

Fill timing changes results

Symbols

Scheduling

Portfolio

Pipelines

Running migrated algorithms

Full before and after

Migration checklist

​What stays the same

​Quick conversion table

​Imports

​Lifecycle functions

​Market data

​Orders

​Fill timing changes results

​Symbols

​Scheduling

​Portfolio

​Pipelines

​Running migrated algorithms

​Full before and after

​Migration checklist

What stays the same

Quick conversion table

Imports

Lifecycle functions

Market data

Orders

Fill timing changes results

Symbols

Scheduling

Portfolio

Pipelines

Running migrated algorithms

Full before and after

Migration checklist