Piercing Veil · Submit

Registration

Submit your algorithm

Upload one Python file. It runs one trading day at a time on market data since 2016 and never sees tomorrow. Its trades then go through the eight Trials. Any algorithm works: rules, statistics or machine learning.

Your strategy

Choose a .py file or paste it below. Download the starter file

# Piercing Veil strategy file. Upload this as-is to try it, then make it yours.
#
# UNIVERSE: up to 20 US-listed stocks or ETFs. Daily bars, split/dividend adjusted, from 2016
# (or from listing). decide() is called once per trading day, after the close.

import numpy as np

UNIVERSE = ["SPY", "TLT"]

def decide(history, state):
    """history: {symbol: DataFrame[open, high, low, close, volume]}, every day up to and including
                today. Never tomorrow.
       state:   a dict that persists between days (cache a trained model, counters, anything).
       return:  {symbol: position for tomorrow's open} between -1 (fully short) and 1 (fully long).
                Leave a symbol out, or return 0, to be flat."""
    positions = {}
    for symbol, bars in history.items():
        close = bars["close"]
        if len(close) < 200:                      # not enough history yet
            continue
        trend = close.iloc[-1] > close.tail(200).mean()
        vol = np.log(close).diff().tail(20).std() * np.sqrt(252)
        positions[symbol] = 1.0 if trend and vol < 0.25 else 0.0
    return positions

Name Ideas tried

Ideas tried means every version you tested before this one: each different rule, setting, model or symbol list. Give an honest number. The bar for beating luck rises with it, because testing many ideas and keeping the best is exactly how luck passes for skill.

Show the name and symbols on the Wall

Your code is never published. It is stored with your attempt so Trial 8 can re-run it on new data. The Wall shows the verdict, and the name and symbols only if you tick the box above. Your full report is at a private link only you get. No account, no email.

How to write it

Your file needs two things:

UNIVERSE = ["SPY", "AAPL", "TLT"]     # 1–20 US stocks or ETFs

def decide(history, state):
    ...
    return {"SPY": 1, "AAPL": -0.5}     # tomorrow's position per symbol

history: A dict of pandas DataFrames, one per symbol, with columns open high low close volume and a date index. Each holds every trading day up to and including today, never tomorrow, split- and dividend-adjusted. A symbol listed after 2016 starts on its first trading day.
state: A dict that stays alive across days. Use it to keep a trained model, refit it every month, count trades, or anything else. Starts empty.
return: Your target position for each symbol from the next day's open, between -1 (fully short) and 1 (fully long). Fractions size the position. Leave a symbol out, or return 0, to be flat. Out-of-range values are clipped.
how it trades: Positions change at the next open, after a 20 bp round-trip cost (0.20%) on every change. Trial 3 checks the result also survives double that.
libraries: numpy, pandas, scipy, scikit-learn, statsmodels, xgboost, lightgbm, PyTorch (CPU), plus Python's standard maths, statistics, collections, datetime, json and re modules. Nothing else can be imported.
limits: About 2 minutes of total CPU for the whole history, 4 GB of memory, and a 200 KB file. Randomness is seeded, so the same file gives the same result.
not allowed: No internet, no reading or writing files, and no other programs. Your code runs in an isolated sandbox. All data it can use arrives through history.
speed tip: decide runs about 2,700 times. Compute rolling features on tail(n), not the whole history, and cache anything expensive in state.

What happens next

HashYour file is fingerprinted before it runs. Change one character and it is a new attempt.

RunOne trading day at a time in the sandbox. Each day's prices arrive only after it has decided the day before.

TrialsIts trades are tested against random timing and time-shifted copies of themselves, after costs, deflated by ideas tried.

VerdictUsually a few minutes. Pass or fail, it goes on the Wall. If your code crashes, you get the exact line, and nothing counts against you. A pass still faces 90 days of new data.