Skip to content

vix-index

Autonomous VIX infrastructure: modular computation and GitHub Pages.

View on GitHub

Information

Property Value
Language Python
Stars 0
Forks 0
Watchers 0
Open Issues 25
License No License
Created 2026-01-03
Last Updated 2026-02-19
Last Push 2026-01-04
Contributors 1
Default Branch main
Visibility private

Reproducibility

This repository includes reproducibility tools:

  • Python requirements.txt

  • Dockerfile for containerization

Status

  • Issues: Enabled
  • Wiki: Enabled
  • Pages: Enabled

README

VIX Index Replication

Production-grade implementation of the CBOE VIX Index calculation with millisecond precision.

Overview

This repository provides a complete, transparent implementation of the VIX methodology: - Exact CBOE formula implementation - Millisecond-level timestamp precision - Comprehensive visualization suite (12 charts) - Full test coverage - Docker support for reproducibility

Quick Start

# Clone and install
git clone https://github.com/Digital-AI-Finance/vix-index.git
cd vix-index
pip install -r requirements.txt

# Generate all charts
python scripts/generate_all_charts.py

# Run validation
python scripts/validate_against_cboe.py

# Run backtest
python scripts/run_backtest.py --start 2024-01-01 --end 2024-12-31

Project Structure

vix-index/
├── src/                    # Core calculation engine
│   ├── vix_calculator.py   # Main VIX calculator
│   ├── options_processor.py# Options chain handling
│   ├── forward_price.py    # Forward price calculation
│   ├── strike_selection.py # OTM strike selection
│   ├── variance_calc.py    # Variance computation
│   ├── interpolation.py    # 30-day interpolation
│   ├── data_ingestion.py   # Data pipeline
│   └── treasury_rates.py   # Risk-free rates
├── charts/                 # 12 visualization charts
├── scripts/                # Execution scripts
├── tests/                  # Test suite
├── config/                 # Configuration
└── docs/                   # Documentation

VIX Calculation Methodology

Formula

The VIX is calculated using:

VIX = 100 * sqrt(sigma^2)

sigma^2 = (2/T) * sum[(DeltaK/K^2) * e^(RT) * Q(K)] - (1/T) * [(F/K0) - 1]^2

Steps

  1. Forward Price: Calculate using put-call parity at ATM strike
  2. Strike Selection: Select OTM puts (below K0) and calls (above K0)
  3. Variance Calculation: Sum weighted option contributions
  4. Interpolation: Interpolate near/next term to 30-day maturity
  5. Final VIX: Convert variance to index (100 * sqrt)

Usage Examples

Basic Calculation

from src.vix_calculator import VIXCalculator
from src.data_ingestion import SimulatedDataGenerator
from datetime import datetime

# Generate sample data
generator = SimulatedDataGenerator()
snapshot = generator.generate_single_snapshot(datetime.now())

# Calculate VIX
calculator = VIXCalculator()
result = calculator.calculate_from_snapshot(snapshot)

print(f"VIX: {result.vix_value:.2f}")
print(f"Near-term variance: {result.near_term_variance:.6f}")
print(f"Calculation time: {result.calculation_time_ms:.3f} ms")

Backtesting

from src.vix_calculator import VIXCalculator
from src.data_ingestion import SimulatedDataGenerator

generator = SimulatedDataGenerator()
calculator = VIXCalculator()

# Generate timeseries
snapshots = list(generator.generate_timeseries(
    start_time=datetime(2024, 1, 2, 9, 30),
    end_time=datetime(2024, 1, 2, 16, 0),
    frequency_ms=1000
))

# Calculate VIX timeseries
df = calculator.calculate_timeseries(snapshots)
print(df[['timestamp', 'vix']].head())

Charts

Chart Description
01_vix_timeseries VIX over time with regime highlighting
02_options_chain_heatmap Strike x Expiry IV heatmap
03_iv_surface 3D implied volatility surface
04_term_structure VIX futures term structure
05_strike_contributions Per-strike variance contribution
06_near_vs_next_term Near vs next term comparison
07_forward_price_evolution Forward price over time
08_variance_decomposition Variance waterfall chart
09_spx_vs_vix SPX vs VIX inverse relationship
10_intraday_vix Millisecond intraday view
11_options_volume_oi Volume and open interest
12_calculation_waterfall Calculation pipeline visualization

Performance

  • Average calculation time: < 1 ms
  • Throughput: > 1000 calculations/second
  • Memory efficient for large datasets

Testing

# Run all tests
pytest tests/ -v

# With coverage
pytest tests/ --cov=src --cov-report=html

Docker

# Build
docker build -t vix-index .

# Run validation
docker run vix-index

# Run with docker-compose
docker-compose up vix-charts

License

MIT License

References

  • CBOE VIX White Paper
  • Options Pricing Theory (Black-Scholes)
  • Financial Engineering literature