support dynamic universe？

[quant2008]

Wonder if vbt support dynamic universe and rebalance? For example, rebalance every weekend, when rebalancing, only trade top 1000 most liquid stocks.

[bsjung]

1. https://www.marketcalls.in/python/mastering-vectorbt-portfolio-backtesting-and-rebalancing-part-2-python-tutorial.html

---> This is for vectorbt stock universes.

2. https://quantnomad.com/running-backtesting-for-universe-of-stocks-in-python-with-backtrader/

3. https://www.youtube.com/watch?v=OvVtdBPYufo

And it is for backtrader, but it helps for vectorbt also.

[bsjung]

def find_code () : code_df = vbt.AQuantData.get_codes( market='KOSDAQ' ) df = [] for index in range(0, len(code_df)) : row = code_df.iloc[index] if (float(config['min_cap']) < row['marcap'] < float(config['max_cap'])) and (row['amount'] > 0) : df.append(row)

codes = []
for i in range(0, len(df)) :
print('[', str(i), '/', str(len(df)), ']', df[i]['code'], df[i]['name'])
dept = df[i]['dept']
if 'SPAC' in dept :
pass
else :
codes.append(df[i]['code'])
print('codes length', len(codes))
return codes


1. Firt find stock codes.
   codes = find_code()

2. Get data with stock codes.

   period = int(config['period'])
   data = vbt.AQuantData.download(
   codes,
   start= str(period) + ' day ago UTC',
   end='now UTC',
   exchange='stock',
   )
   close = data.get('close')
   print(close)

3. Do your job with data for stock universes.

4. For example, you can get ATR values from stock universes.
   

[quantresearch1]

@bsjung I had a quick look at the links you shared, and they don't address the question of a dynamic universe. I am not sure if this is possible in vbt but a workaround would be to get the data for all symbols that are going to be needed.

Schematically, this is
universe_by_date = dict()
all_symbols = set()
for date in all_dates:
most_liquid = get_top_1000_liquid(date)
daily_universe[date] = most_liquid
all_symbols |= set(most_liquid)

universe_mask = pd.DataFrame(False, index=dates, columns=all_symbols)

for date in dates:
universe_mask.loc[date, daily_universe[date]] = True

You can then use the mask for your entries and exits
entries_long = entries_long & universe_mask

[algoqt]

any solution find yet？
my strategy want to screen entire market symbos with 100+ indcators base on top N % OR bottom Y%，or gt x_value or lt y_value，want to use vector way for fast backtesing , the indcator calculating with lots rolling windodws (some with dynamic windows size or params), it is possiable backtesting this kind of strategy using vectorbt?

[initial-d]

You can model this in vectorbt, but I would think of it as a point-in-time universe mask, not as instruments being dynamically loaded during the backtest.

For weekly top-N liquidity rebalancing, the usual shape is:

# close/volume/etc: DataFrames indexed by date, columns=symbols
liq = (close * volume).rolling(20).mean()

# Important: decide membership using data known before the rebalance bar
liq_rank = liq.shift(1).rank(axis=1, ascending=False, method="first")
universe = liq_rank <= 1000

# If membership changes only weekly, compute on rebalance dates and ffill
rebalance = close.index.to_series().dt.weekday == 0
weekly_universe = universe.where(rebalance).ffill().fillna(False)

entries = raw_entries & weekly_universe
exits = raw_exits | ~weekly_universe

For "top N% / bottom Y% / greater than threshold", the same idea works: build one boolean mask per condition from point-in-time ranks or thresholds, then combine it with entries/exits or with your target weight matrix.

The harder part is not whether vectorbt can consume the mask; it is memory and lookahead control when you have the whole market plus 100+ rolling indicators. A few practical rules:

• Do not compute 100 indicators for all symbols and keep them all in memory at once. Compute one signal family, write/cache the resulting boolean/score matrix, then release the intermediate arrays.
• Shift every ranking/selection input by one bar, or by one rebalance period if your data is only known after close.
• Use float32/bool arrays where possible; boolean universe masks are much cheaper than full indicator panels.
• If the universe is very large, chunk by symbols and aggregate signals/weights before calling the final portfolio simulation.
• For complex dynamic parameters/windows, it may be cleaner to write a custom NumPy/Numba indicator that outputs the final score matrix instead of materializing every intermediate indicator.

So yes, this type of strategy is possible in a vectorized style, but the clean design is: precompute point-in-time eligibility/score matrices -> combine into entries/weights -> run portfolio simulation. Avoid selecting today’s universe from future information, and avoid treating “currently top 1000” as the historical universe.