VOL-TRADE

Overview

VOL-TRADE is a simulated exchange with real price-time priority order matching. It runs a universe of stocks, indexes, futures and options with live-updating fair values, automated market-making bots, and a full depth-of-book. Multiple human participants can connect simultaneously and compete on a live leaderboard.

You can trade manually through the UI or write Python scripts in the built-in dev environment to automate strategies — the same WebSocket API the bots use is exposed to you.

Your Account

One account works everywhere on VOL-TRADE. Your saved code and your identity follow you into every exchange you join, on any device you sign in from.

Sending Feedback

There is a FEEDBACK button in the top bar of your dashboard, which opens a short form. Use it for anything: a bug, an idea, or something in the interface that did not make sense. It goes directly to the person who built VOL-TRADE, and because you are signed in, they can reply to you by email.

Pick a category (General, Bug report, Feature idea, or Question) and write up to 2,000 characters. A counter shows how much room you have left. Press SEND, or Ctrl+Enter; Esc closes the form without sending.

Interface Layout

The three panels are separated by drag handles (the thin 4px borders). Drag left/right handles to resize columns; drag the horizontal handle to resize the Python terminal. The terminal can be hidden entirely with the ▼ HIDE button.

The right panel contains nine tabs: Participants, Unfilled, History, Positions, Bio, Book, News, Calendar, and Settings. Bio shows detail on the currently selected instrument — description, sector, annualized vol, and related ETFs/futures/options. Book mirrors the depth-of-book for the currently selected instrument and stays visible while you use other parts of the UI. News and Calendar show fired and upcoming headlines respectively; Settings has session info and a disconnect/back-to-dashboard link.

Top Bar — Equity & P&L Widgets

The right side of the top bar shows four live financial widgets for your own account, updated on every market snapshot.

Market States

Only the host can change market state, from that exchange's scoped Admin Console.

Chart Navigation

The price chart shows the last-trade price history for the selected instrument since the session began. Click any instrument in the left column to switch. The chart only records actual traded prices — it does not fall back to a fair value line when there are no trades. An instrument with no fills yet will show a flat or empty chart until the first trade prints.

Line vs Candlesticks

The chart header has a LINE / CANDLES toggle. LINE (the default) draws a continuous last-price line with an area fill. CANDLES aggregates the price history into OHLC candlesticks — green when the candle closed at or above its open, red when it closed below — with wicks marking each candle's high and low.

In candle mode a timeframe selector appears with 30s, 1m (default), and 3m options, controlling how much time each candle covers. A live legend in the top-left corner of the chart always shows the latest bar's O / H / L / C (or price, in line mode) and time; hovering any bar updates the legend to that bar. Switching type or timeframe re-fits the view to the data.

Mouse & Trackpad Controls

The chart is powered by TradingView Lightweight Charts™, so it uses the familiar interaction model of a professional charting terminal:

Chart Controls Reference

The price scale on the right snaps to round-number increments and formats prices to each instrument's tick size. The dashed line and coloured tag on the right axis mark the current price; the top-left legend shows the latest (or hovered) bar's values.

The chart header always shows the last trade price, % change from the first data point, and the current bid / ask. On the admin terminal, fair value is also shown.

Charting by TradingView Lightweight Charts™ (Apache 2.0).

Time Axis

A time axis runs along the bottom edge of the chart. Labels show wall-clock time in HH:MM (for intervals ≥ 1 minute) or HH:MM:SS (for shorter intervals). The axis adapts its interval automatically based on the number of visible data points — zooming in shows finer resolution, zooming out coarser.

Faint vertical grid lines align with each time label to make it easy to correlate price movements with specific times.

Order Book & Tape

Central Depth Strip (below the chart)

Shows the top 10 price levels on each side. Bids (green) are displayed with the best bid at the top, nearest the spread. Asks (red) are displayed with the worst ask at the top and best ask nearest the spread. The spread row shows the current bid-ask spread.

The horizontal bars behind each row are proportional to quantity — a wide bar means a large resting order at that level relative to the deepest visible level.

The depth strip can be toggled on or off using the ▾ DEPTH button in the chart header. When hidden, the chart expands to fill the space — this also hides the tape, since they share the same collapsible panel. Press the button again (which now reads ▴ DEPTH) to restore both.

Tape (last 50 trades)

A real-time print of every fill across all participants. Green prices indicate a buyer-aggressed trade (aggressor was buying); red prices indicate a seller-aggressed trade. Each row shows the aggressor's participant ID in a small badge on the right — the participant who sent the crossing order.

To watch a participant's flow, click their row in the Participants tab to open the inspector popover, then use “Highlight this trader in the tape”. Their tape rows are highlighted in amber and the participant row gains a green left border. Toggle it off from the same button. This lets you track specific participants — for example, bots that appear to be trading ahead of announcements.

Book Tab (right panel)

The Book tab in the right panel shows the same depth-of-book in a persistent, full-height view. This is useful when you want to watch the order book continuously without the depth strip taking space below the chart, or when you need the book and the participants/positions tabs open side-by-side in a workflow. The Book tab updates in real time alongside the central strip.

Placing Orders

Orders are placed from the order ticket below the depth strip. Rather than a single SEND button, the ticket has dedicated BUY and SELL buttons — each shows the exact price it will execute at, so you always see what you're about to do before you click.

After clicking BUY or SELL, the acknowledgement appears in the Python terminal output (bottom panel) as BUY … → NEW or SELL … → FILLED etc. Any fills also print as FILL … lines in green.

Order Types & Matching

The exchange uses price-time priority: among all resting orders, the best price is matched first; ties are broken by order arrival time (FIFO). There is no hidden order type.

A LIMIT order that is fully matched on arrival is acknowledged with status FILLED. A partial match gives PARTIAL and the remainder rests. An unmatched order is NEW and visible in the Unfilled tab.

MARKET orders are never resting — they sweep the book and any unfilled quantity is silently dropped. A MARKET order that only partially fills will not appear in the Unfilled tab and cannot be cancelled (there is nothing left to cancel). Check the Order History tab to see the fills.

Participants Tab

Shows all connected participants sorted by PnL — humans first, then bots. Your own row is highlighted in amber. Each row shows:

Click any participant row to open an inspector popover showing their total PnL, equity, realised/unrealised split, fill count, volume, open positions, and most recent trades. Positions are shown for bots and for yourself; other human traders' positions stay private (you still see their public PnL, volume, and tape activity). The popover includes a “Highlight this trader in the tape” button — turn it on to amber-highlight their prints in the tape and give their participant row a green left border, so you can follow a specific bot or participant you suspect is trading on information. Close the popover by clicking the ✕ or the backdrop.

Unfilled Orders Tab

Shows all your currently resting LIMIT orders (status NEW or PARTIAL). MARKET orders never appear here — any unfilled quantity from a MARKET order is dropped immediately rather than resting on the book. For each resting order:

• Large number = lots remaining (unfilled quantity). Updates in real time as fills arrive.
• Progress bar shows fill percentage.
• Status label shows OPEN (no fills yet) or PARTIAL (partly filled) with fill count.
• ✕ CANCEL ORDER — sends a cancel request. The button disables while the server processes it. If the order was already fully filled the cancel will be rejected.

The badge next to the tab name shows the count of open orders.

Bulk Cancel Actions

An actions bar appears at the top of the Unfilled tab whenever you have open orders. It provides two bulk-cancel shortcuts:

Order History Tab

A full log of all orders you have submitted this session, most recent first. Each entry shows side, type, price, quantity, status, and individual fill records.

A ✕ RESET HISTORY button clears this client-side list (it doesn't affect your actual orders or the server's record — just what's displayed here).

Positions Tab

Your current net exposure across all instruments. Only instruments with a non-zero position or realised PnL appear.

Click any position row to switch the chart to that instrument.

Flatten Position

Each position row has a flatten button beneath it, labeled with your exact position (e.g. ⬡ FLATTEN LONG +N or ⬡ FLATTEN SHORT N). Pressing it submits an aggressive MARKET order in the opposite direction equal to your entire net position, reducing it to zero in a single action.

Book Tab

A dedicated right-panel tab that shows the full depth-of-book for the currently selected instrument in a persistent, full-height view — identical data to the central depth strip but always visible regardless of whether the depth strip is toggled on or off.

Switch to this tab when you want the order book always in view while you navigate other tabs, or when you prefer to hide the central depth strip (using the ▾ DEPTH toggle) to give the chart more vertical space.

News Tab

A feed of every headline that has already fired this session, most recent first, color-coded by status: UNCONFIRMED rumour, CONFIRMED/VALIDATED, or DENIED. The tab badge pulses when a new item arrives while you're on another tab.

Click any headline to open a detail panel with the full story, the source and what its credibility tier implies for how the move plays out (see Trading Around News), the complete list of affected instruments, and — for a still-unconfirmed rumour — a live countdown to when it resolves to CONFIRMED or DENIED.

Calendar Tab

Events an admin has pre-scheduled but that haven't fired yet, each showing a vague preview headline, its source, and a live countdown. The badge shows how many events are pending.

Click any upcoming event to open a detail panel with the source's credibility tier, the exact fire time, and a live-updating countdown. The real headline, its market impact, and how it resolves stay hidden until the event fires — that's deliberate, not a bug: publishing them early would hand every trader the same insider-style edge the informed/insider bots exist to exploit unevenly. When the countdown hits zero, switch to the News tab to see what actually happened.

Python Terminal (Dev Environment)

An in-browser Python 3 runtime (Pyodide) connected to the exchange via a pre-built exchange object. You can write and run arbitrary Python to automate orders, scan for opportunities, or run analysis.

Inline Terminal (bottom panel)

A compact split editor/output pane built into the main trading terminal. Useful for quick one-shot scripts and inspections.

Dedicated Monaco Terminal (/pyterm)

A full-screen Python environment built on Monaco Editor (the same engine as VS Code). Open it via the ⎋ OPEN TERMINAL link in the inline terminal header, or navigate directly to /pyterm?id=YOUR_ID. It connects to the exchange under the same participant ID so your orders, positions, and PnL are shared with the main terminal.

Output from print() appears in the output pane in real time — even inside while True loops. Red lines are errors (with full tracebacks). Green lines are fill notifications. Blue lines are system messages.

Available Python Packages

The terminal runs Pyodide 0.27.7 — a full CPython 3.12 compiled to WebAssembly. You have access to the entire Python standard library plus several pre-installed scientific packages. Additional packages can be installed at runtime using micropip.

Standard Library — always available

All built-in modules ship with the runtime. Commonly useful ones for trading:

Auto-loaded Packages — import directly, no install call needed

Before running your script, the terminal scans it for import statements and transparently loads any matching Pyodide package (via loadPackagesFromImports) — so common scientific packages just work the first time you import them, with a brief one-time download on first use rather than being bundled into every page load:

import numpy as np

prices = [exchange.price(s)["last"] for s in exchange.instruments() if exchange.price(s)["last"]]
arr = np.array(prices)
print(f"mean={arr.mean():.2f}  std={arr.std():.2f}  min={arr.min():.2f}  max={arr.max():.2f}")

Installing Additional Packages with micropip

Pure-Python packages on PyPI can be installed at the top of your script with await micropip.install(). Run this once — Pyodide caches the install for the duration of the browser session.

import micropip
await micropip.install("pandas")     # install first (only needed once per session)
import pandas as pd

# build a DataFrame from a snapshot
snap = exchange.snapshot()
rows = []
for sym, info in snap["instruments"].items():
    rows.append({"sym": sym, "kind": info["kind"], "fair": info.get("fair_value"), "last": info.get("last_price")})
df = pd.DataFrame(rows).set_index("sym")
print(df.head(10).to_string())

Other popular packages you can install the same way:

Not Available

Exchange API Reference

The exchange object is pre-created and available immediately after PYTHON READY appears.

Read-only Methods

Order Methods (async)

Ack Dict Structure

{
  "accepted":     True,            # False if rejected
  "order_id":     12345,           # use this to cancel later
  "order_status": "NEW",           # or PARTIAL / FILLED / REJECTED
  "trades":       [...],           # list of fills if immediately matched
  "reason":       None             # error string if rejected
}

Exchange API v2 — Extended Methods

These methods go beyond basic snapshot access. They give you price history, live news, options Greeks, order book depth, and the time-remaining widget — everything you need for quantitative strategies.

News & Events

Flow & Tape Analysis

Price History & Market Data

Options Analytics

Session Timer

# Poll for new news events efficiently
last_seq = 0
while True:
    events = exchange.since("news", after_seq=last_seq)
    for ev in events:
        last_seq = max(last_seq, ev["seq"])
        n = ev["payload"]
        exchange.log(f"NEWS [{n['status']}]: {n['headline']}")
    await asyncio.sleep(2)

Code Examples

Inspect the Market

state = exchange.snapshot()["state"]
print("market state:", state)
print("instruments:", len(exchange.instruments()))
print("my positions:", exchange.positions())

Place a Limit Order

p = exchange.price("ACME")
print("ACME bid/ask:", p["bid"], "/", p["ask"])

# buy 10 lots just below the best ask
if p["ask"]:
    ack = await exchange.buy("ACME", 10, price=round(p["ask"] - 0.05, 2))
    print("order_id:", ack["order_id"], "status:", ack["order_status"])

Market Order (Immediate Fill)

# sell 5 lots at market — no price needed
ack = await exchange.sell("ORBT", 5)
print(ack)

Cancel an Open Order

ack = await exchange.buy("DRFT", 100, price=210.00)
order_id = ack["order_id"]
print("resting order_id:", order_id)

# ... some time later ...
result = await exchange.cancel("DRFT", order_id)
print("cancel accepted:", result["accepted"])

Simple Market-Maker

# Quote ±5 cents around fair value on DRFT
sym = "DRFT"
p = exchange.price(sym)
if p["fair"]:
    fair = p["fair"]
    bid_ack = await exchange.buy(sym,  5, price=round(fair - 0.05, 2))
    ask_ack = await exchange.sell(sym, 5, price=round(fair + 0.05, 2))
    print("bid:", bid_ack["order_id"], "  ask:", ask_ack["order_id"])

Scan for Mispriced Options

snap = exchange.snapshot()
options = {s: i for s, i in snap["instruments"].items() if i["kind"] == "OPTION"}
print(f"found {len(options)} options")
for sym, info in list(options.items())[:8]:
    last = info.get("last") or info.get("last_price")
    fair = info.get("fair") or info.get("fair_value")
    if last and fair:
        edge_pct = (last - fair) / fair * 100
        print(f"  {sym:>22s}  last={last:>7.2f}  fair={fair:>7.2f}  edge={edge_pct:+.1f}%")

News-Driven Event Strategy

# React to incoming news: go long affected stocks on UNCONFIRMED news
# (betting on confirmation), then close on resolution
seen_news = set()
while True:
    for item in exchange.news():
        nid = item["id"]
        if nid in seen_news:
            continue
        if item["status"] == "UNCONFIRMED" and item["affected"]:
            sym = item["affected"][0]
            p = exchange.price(sym)
            if p["ask"]:
                ack = await exchange.buy(sym, 5, price=p["ask"])
                exchange.log(f"Positioned on news {nid}: {ack['order_status']}")
        elif item["status"] in ("CONFIRMED", "DENIED"):
            seen_news.add(nid)  # stop tracking resolved items
    await asyncio.sleep(3)

Greeks Scanner

# Find options with high gamma (largest convexity per dollar)
syms = [s for s in exchange.instruments() if "-C" in s or "-P" in s]
rows = []
for sym in syms:
    g = exchange.greeks(sym)
    if g:
        rows.append((g["gamma"], sym, g["delta"], g["iv"]))
rows.sort(reverse=True)
for gamma, sym, delta, iv in rows[:10]:
    print(f"{sym:>20s}  Δ={delta:+.3f}  Γ={gamma:.5f}  IV={iv:.1%}")

Price History Momentum

# 5-tick vs 20-tick momentum signal on DRFT
hist = await exchange.history("DRFT", n=25)
if len(hist) >= 25:
    prices = [h["price"] for h in hist]
    fast_ret = (prices[-1] - prices[-5]) / prices[-5]   # 5-tick return
    slow_ret = (prices[-1] - prices[-20]) / prices[-20]  # 20-tick return
    exchange.log(f"fast={fast_ret:+.3%}  slow={slow_ret:+.3%}")
    p = exchange.price("DRFT")
    if fast_ret > 0.001 and slow_ret > 0.001 and p["ask"]:
        ack = await exchange.buy("DRFT", 8, price=p["ask"])
        exchange.log(f"Momentum long: {ack['order_status']}")
    elif fast_ret < -0.001 and slow_ret < -0.001 and p["bid"]:
        ack = await exchange.sell("DRFT", 8, price=p["bid"])
        exchange.log(f"Momentum short: {ack['order_status']}")

Order Book Imbalance Signal

# Use bid/ask queue imbalance as a short-term direction signal
sym = "ACME"
book = exchange.book(sym)
if book["bids"] and book["asks"]:
    bid_qty = sum(q for _, q in book["bids"][:3])  # top 3 bid levels
    ask_qty = sum(q for _, q in book["asks"][:3])  # top 3 ask levels
    total = bid_qty + ask_qty
    imbalance = (bid_qty - ask_qty) / total if total else 0
    exchange.log(f"Book imbalance: {imbalance:+.2f}  (bids={bid_qty}  asks={ask_qty})")
    p = exchange.price(sym)
    if imbalance > 0.40 and p["ask"]:        # strong buy pressure
        ack = await exchange.buy(sym, 5, price=p["ask"])
        exchange.log(f"Imbalance buy: {ack['order_status']}")
    elif imbalance < -0.40 and p["bid"]:     # strong sell pressure
        ack = await exchange.sell(sym, 5, price=p["bid"])
        exchange.log(f"Imbalance sell: {ack['order_status']}")

ETF vs Components Arb

# TECH-ETF tracks DRFT, QNTM, FNTM, NXUS at 25% each
components = ["DRFT", "QNTM", "FNTM", "NXUS"]
weights = [0.25, 0.25, 0.25, 0.25]
etf_sym = "TECH-ETF"
nav = sum(w * (exchange.price(s)["last"] or exchange.price(s)["fair"] or 0)
          for s, w in zip(components, weights))
etf_p = exchange.price(etf_sym)
etf_last = etf_p["last"] or etf_p["fair"]
if nav and etf_last:
    premium = (etf_last - nav) / nav
    exchange.log(f"ETF premium to NAV: {premium:+.3%}")
    # If ETF trades too rich: sell ETF, buy components
    if premium > 0.003 and etf_p["bid"]:
        ack = await exchange.sell(etf_sym, 10, price=etf_p["bid"])
        exchange.log(f"Sold ETF: {ack['order_status']}")

Tape Flow Analysis

# Who has been trading and in what direction?
flow = exchange.flow_by_participant(n=300)
for pid, f in flow.items():
    if f["trade_count"] == 0:
        continue
    total = f["buy_qty"] + f["sell_qty"]
    exchange.log(f"{pid:>12s}  buy_qty={f['buy_qty']}  sell_qty={f['sell_qty']}  "
                 f"trades={f['trade_count']}  instruments={list(f['instruments'].keys())}")

Suspect Flow Scanner

# Find participants whose trades consistently precede price moves
suspects = exchange.suspect_flow(n=500, min_trades=3)   # already sorted, most one-sided first
for s in suspects[:5]:
    exchange.log(f"{s['participant_id']:>12s}  imbalance={s['imbalance']:.0%}  "
                 f"side={s['dominant_side']}  trades={s['trade_count']}  top={s['top_instruments']}")

Session Timer Wind-Down

# Flatten all positions when 30 seconds remain
while True:
    t = exchange.timer()
    remaining = t["remaining"] if t else None
    if remaining is not None and remaining < 30:
        exchange.log(f"⚡ {remaining:.0f}s left — flattening all positions")
        for sym, pos in exchange.positions().items():
            qty = pos["quantity"]
            if qty > 0:
                await exchange.sell(sym, qty)
            elif qty < 0:
                await exchange.buy(sym, -qty)
        break
    await asyncio.sleep(5)

Options & Greeks

An option is the right (but not the obligation) to buy (call) or sell (put) an underlying at a fixed strike price before expiry. Options let you express leveraged directional views, hedge existing positions, and trade volatility itself.

Delta (Δ)

Delta is the rate of change of option price with respect to the underlying. A call with Δ = 0.6 gains approximately $0.60 when the underlying rises $1.

The delta of a portfolio tells you your effective exposure to the underlying. A delta of +500 means you're as exposed as owning 500 units of the stock. Delta hedging means keeping your portfolio delta near zero by trading the underlying.

Gamma (Γ)

Gamma is the rate of change of delta — how fast delta shifts as the underlying moves. High gamma means delta changes quickly; your option becomes more (or less) sensitive very rapidly.

ATM options near expiry have the highest gamma. A gamma of 0.04 means delta increases by 0.04 for every $1 move in the underlying. This convexity is valuable — it means your upside accelerates faster than your downside.

Theta (Θ)

Theta is time decay — the amount an option loses in value per day as expiry approaches, all else equal. Options are wasting assets: a call worth $5 today might be worth $4.80 tomorrow just from time passing.

Theta is negative for option buyers (you lose value daily) and positive for option sellers (you collect it). Near expiry, theta accelerates dramatically — ATM options decay fastest in the final days.

Vega (ν)

Vega measures sensitivity to implied volatility — how much the option price changes per 1% move in IV. A vega of 0.30 means the option gains $0.30 if IV rises 1 percentage point.

Long options are long vega — you profit when volatility rises (e.g., before earnings). Short options are short vega — you profit from volatility declining (IV crush). News events drive sharp vega moves: IV spikes when news is rumoured, then collapses after resolution (the "IV crush").

The exchange.greeks(sym) Method

Returns a dict for any option symbol. Returns {} for non-options.

# Print a Greek dashboard for all DRFT options
for sym in exchange.instruments():
    if not sym.startswith("DRFT-"):
        continue
    g = exchange.greeks(sym)
    if not g:
        continue
    p = exchange.price(sym)
    last = p["last"] or p["fair"] or 0
    edge = last - g["theo"]
    print(f"{sym:>15s}  Δ={g['delta']:+.3f}  Γ={g['gamma']:.5f}  Θ={g['theta']:+.3f}  ν={g['vega']:.3f}  IV={g['iv']:.1%}  edge={edge:+.2f}")

Common Options Strategies

Long Call — Leveraged Upside

Buy a call to profit when you expect a large upward move. Maximum loss is the premium paid; upside is unlimited. Best used when you have a directional view but want limited downside.

# Buy the DRFT 230-strike call (OTM call, costs less than ATM)
p = exchange.price("DRFT-230-C")
if p["ask"]:
    ack = await exchange.buy("DRFT-230-C", 5, price=p["ask"])
    exchange.log(f"Long call entry: {ack['order_status']}")

Protective Put — Downside Hedge

Own stock + buy a put = capped downside. The put acts like insurance: if the stock falls below the strike, the put gains value, offsetting your loss on the stock position.

# Already long DRFT. Buy the 210-put to hedge
hedge_ack = await exchange.buy("DRFT-210-P", 5, price=exchange.price("DRFT-210-P")["ask"])
exchange.log(f"Hedge in place: {hedge_ack['order_status']}")

Straddle — Pure Volatility Play

Buy an ATM call and ATM put with the same strike and expiry. Profits if the underlying moves sharply in either direction; loses if it stays flat. Use before expected news when you don't know the direction.

# ATM straddle on QNTM (ATM ≈ 330)
call_ack = await exchange.buy("QNTM-330-C", 3, price=exchange.price("QNTM-330-C")["ask"])
put_ack  = await exchange.buy("QNTM-330-P", 3, price=exchange.price("QNTM-330-P")["ask"])
exchange.log(f"Straddle: call={call_ack['order_status']} put={put_ack['order_status']}")

Market Microstructure

Understanding how the market actually works at a mechanical level makes you a better trader — and helps you build smarter strategies.

Bid-Ask Spread & Depth

The bid-ask spread is the gap between the highest buyer's price (bid) and the lowest seller's price (ask). The spread is the market maker's profit margin — they quote both sides and capture the spread on each fill. In liquid instruments (e.g., ACME) spreads are tight (a few cents). In thin instruments (e.g., deep OTM options) spreads can be several percent.

Depth refers to the quantity available at each price level. A deep book has large quantities resting at many price levels — big orders fill without moving the price much. A thin book has small quantities; a large market order can sweep multiple levels and move the price significantly.

You can read the live depth with exchange.book(sym) — check how much quantity sits at each level before sizing a market order.

How Bots Behave

63 automated bots operate simultaneously per exchange. Understanding their roles helps you predict when and why prices move.

During news events, market makers widen their spreads (they become uncertain about fair value). This creates a window where the spread is wider and the book is thinner — skilled traders can provide liquidity at prices that would normally be impossible to fill.

Trading Around News

News events follow a two-phase model: an initial shock (partial move on announcement) followed by resolution drift (remaining move on confirmation, or full reversal on denial).

The resolution window: After a news event fires, there is a delay before the outcome (Confirmed / Denied) is determined. During this window, the price hovers near the partially-moved level. This uncertainty window is where the most interesting trading happens — you must judge whether the headline is credible.

Post-resolution drift: Even after resolution, the full shock may not be immediately priced in. There is a drift period where fair value gradually moves toward the final level. Momentum strategies can exploit this drift by riding the continuation.

Stocks

26 simulated equities (ACME, BRYN, CDLR … ZPHR). Each follows a correlated GBM — a shared market factor causes most stocks to move together with their own idiosyncratic noise layered on top. Volatility ranges from ~40% annualised (low-vol, e.g. HRZN) to 100% (high-vol names like UMBR, GLDR, QNTM). All stocks have a 0.01 tick size.

Indexes

5 synthetic indexes: EXMINI (~4500), TECHX (~18750), FINX (~1380), ENRGX (~780), and VOLAX (~16, the volatility index). Indexes use the same GBM but with lower idiosyncratic vol and coarser tick sizes. VOLAX has very high vol-of-vol.

Futures

Futures are listed on 15 underlyings: EXMINI, TECHX, ENRGX, ACME, DRFT, QNTM, HRZN, JNTR, and the 7 commodities (GLDX, SLVX, OILX, NATG, COPX, WHTX, PLTX). Three expiries exist per underlying:

Fair value is continuously updated as spot × e^{r × T} where r = 4% and T is the expiry in years. Longer-dated futures trade at a slight carry premium over the front month, reflecting the cost-of-carry term structure. The calendar spread (e.g. F3 − F2) can be traded by legging into both.

ETFs

Seven sector basket ETFs track weighted portfolios of underlying stocks or commodities. Named with a -ETF suffix:

Each ETF's fair value tracks the weighted average of its components' fair values in real time. ETFs can trade at a small premium or discount to NAV (Net Asset Value) — bots will arb the gap, but you can trade that spread too. An ETF position gives broad sector exposure without managing individual stock legs.

Broad-market ETFs: SNP10 & SNP15

SNP10 and SNP15 track the 10 and 15 highest-priced stocks in the universe (a stand-in for the "biggest" names), cap-weighted rather than equal-weighted — each component's weight is proportional to its own fair value, so pricier names dominate the index more, just like a real market-cap-weighted index (e.g. the S&P 500).

Because SNP10 is nested inside SNP15 and both are weighted off the same underlying prices, a stock's weight ranking is always consistent between the two: whichever SNP10 name carries more weight also carries more weight in SNP15 (just diluted, since SNP15 splits weight across 5 more names).

Options

Options are listed on DRFT, QNTM, EXMINI, and TECHX — 10 per underlying (5 strikes × call/put), named {UNDERLYING}-{STRIKE}-C or -P, all with 30-day expiry (40 contracts total).

Strikes span ATM ± 2 steps, where the step size is calibrated to the underlying price (e.g. $10 for mid-price stocks, $50 for indexes). Fair values are continuously updated via Black-Scholes (r = 4%, T = 30/365 years). Tick size is 0.05; market-maker spread is wider than equities (reflecting real-world option spreads).

Options incorporate an equity skew: lower-strike puts are priced with higher implied volatility than ATM, and higher-strike calls are cheaper. This reflects the asymmetric demand for downside protection seen in real markets.

VOL-TRADE Simulated Exchange · All data is fictional · No real money involved