Skip to main content
STRATEGY ARENA LAB — WINDOWS RESEARCH COCKPIT

Strategy Arena Lab

The Windows research cockpit where Strategy Arena imports real OHLCV CSV datasets, generates and evolves ArenaScript strategies, runs Rust CPU/CUDA backtests, exports Lab Reports, then sends validated survivors to chart review.

World Arena observes. Strategy Arena Lab creates. Lab Reports diagnose. TradingView inspects.

Windows Research Cockpit beta

Download the unsigned 0.1.0-beta Windows installer for Strategy Arena Lab. It includes the Market Data Vault, chronological unseen holdout proof, real OHLCV CSV import, Pine import, ArenaScript CPU reference metrics and CUDA signal kernels.

CUDA-enabled build is the default beta path. NVIDIA CUDA is used when available; the CPU reference path remains available without a compatible GPU.

Download Strategy Arena Lab MSI package View beta demo Read Pine guide Benchmark my Pine strategy TradingView setup

Your one-time install link

Paste this code in Strategy Arena Lab under Account > Install attribution. It expires after 30 minutes and does not require an account.

Preparing code...
App 0.1.0-beta Windows package 0.1.0-20 Build 20260715-arena-evolution-campaign-v23 Signature unsigned Windows x64 setup SHA256 published below
2026-07-15 beta changes
  • Arena Evolution Campaign v23 runs the complete local research loop from one action: baseline, unique candidate exploration, multi-window finalist tournament, untouched chronological holdout proof and Lab Report.
  • Candidate selection never reads the holdout. Up to 12 finalists compete on the full training set plus three rolling training windows before the selected champion is opened once on unseen data.
  • Campaign Passport records the requested and measured budgets, theoretical search space, finalist count, backend, robustness score, holdout evidence and deterministic AEC campaign ID.
  • The 1M-space option is explicit: it samples 100,000 measured candidates and never presents that sample as one million executions.
  • Live World Arena contracts now preserve RSI threshold, previous-window Donchian and volume-over-SMA rules through native ArenaScript execution and Pine review export.
  • The guided World Arena proof uses a separate deterministic compatibility fixture that produces measurable trades; imported market histories are never replaced or altered.
  • Signed one-time install attribution links this browser download to one native saf-* profile without an account. The 30-minute code is claimed once inside the Lab, while any API failure still leaves the installer download working normally.
  • Guided Focus removes completed source controls after proof and keeps the bound dataset, Reactor evidence and one next action visible; Advanced mode still exposes every command.
  • The compact Windows layout now keeps market controls and chronological train/holdout evidence in useful grids instead of a long single-column stack.
  • CPU-only proof is displayed as a valid measured state with a CPU reference map and N/A CUDA values, not as a failed backtest.
  • Chronological Holdout Proof reserves the final 10%, 20% or 30% before parameter selection, then replays the exact training winner unchanged on unseen data with the Rust CPU reference engine.
  • Lab Reports and public proof pages now distinguish a valid holdout from a survived holdout, with separate train/unseen PnL, retention, drawdown, trade count and server-checked candidate/window binding.
  • Market Data Vault v1 imports TradingView, Binance and generic OHLCV CSV histories, normalizes timestamps and columns, removes duplicates, measures gaps and stores a deterministic Dataset ID plus SHA256 locally.
  • Every CPU/CUDA proof, sweep, batch, benchmark and Operator run now uses the selected real dataset and binds it to Survivor Delivery, Lab Report, Arena Passport and TradingView handoff.
  • Short-side native CUDA coverage verified: bearish ADX threshold, MFI upper-band, OBV breakdown and Donchian lower-channel Pine gates now keep named native CUDA sweep paths in the Lab instead of falling back to anonymous staged labels.
  • Native Triple Momentum Confirmation CUDA upgraded: Strategy Arena generated EMA + ADX + ROC strategies now compute bidirectional long/short native signal vectors on GPU through cuda_triple_momentum_confirmation_native_signal_sweep_v1, intersect them, then reuse shared metrics before TradingView review.
  • Triple Momentum Confirmation now exports EMA + ADX + ROC long/short rules to Pine: Lab Reports keep the full Strategy Arena signal fusion intact before TradingView review.
  • Generated EMA RSI Combo is now bidirectional: Strategy Arena creates long pullback and short extension rules, preserves both in ArenaScript, then exports both sides to Pine for TradingView review after the local report.
  • Generated MACD Trend Continuation now exports both sides to Pine: Strategy Arena keeps MACD + EMA regime long/short rules through the local Lab Report, then sends the survivor to TradingView for review only.
  • Generated MACD RSI Pullback now exports both sides to Pine: Strategy Arena keeps bullish MACD + RSI pullback and bearish MACD + RSI extension rules in the same Lab Report before TradingView review.
  • Native ADX Trend Strength signal CUDA added: Strategy Arena generated EMA regime plus ADX(length,smoothing) filters now compute long and short EMA/ADX signal vectors on GPU through cuda_adx_trend_strength_native_signal_sweep_v1 before shared metrics.
  • Native Volume Liquidity signal CUDA added: Strategy Arena generated EMA regime plus volume > SMA(volume,n) filters now compute EMA and volume-SMA signal vectors on GPU through cuda_volume_liquidity_native_signal_sweep_v1 before shared metrics.
  • Native ALMA Cross signal CUDA added: Strategy Arena generated ALMA fast/slow regimes and pure Pine ta.alma crossover/crossunder gates now compute Arnaud Legoux moving-average signals on GPU through cuda_alma_cross_native_signal_sweep_v1, while ALMA composites with extra filters stay staged until fused kernels land.
  • Native HMA Cross signal CUDA added: Strategy Arena generated HMA fast/slow regimes and pure Pine ta.hma crossover/crossunder gates now compute Hull moving-average signals on GPU through cuda_hma_cross_native_signal_sweep_v1, while HMA composites with extra filters stay staged until fused kernels land.
  • Native SMA/HMA/VWMA price-gate CUDA added: simple price > SMA/HMA/VWMA and price < SMA/HMA/VWMA Strategy Arena gates now expose named native signal paths through cuda_sma_price_native_signal_sweep_v1, cuda_hma_price_native_signal_sweep_v1 and cuda_vwma_price_native_signal_sweep_v1 before shared metrics.
  • Native Donchian signal CUDA added: pure previous-channel breakout/breakdown gates now compute range signals on GPU through cuda_donchian_native_signal_sweep_v1, while Donchian strategies with EMA/regime filters stay staged until fused kernels land.
  • Native ATR signal CUDA added: pure previous-close ATR breakout/breakdown gates now compute volatility signals on GPU through cuda_atr_native_signal_sweep_v1, while ATR strategies with EMA/regime filters stay staged until fused kernels land.
  • Native VWMA Cross signal CUDA added: pure ta.vwma(close, fast) / ta.vwma(close, slow) crossover and crossunder gates now route through cuda_vwma_cross_native_signal_sweep_v1, while composite VWMA/HMA/regime strategies stay staged until fused kernels land.
  • Operator composite benchmark added: Strategy Arena generates all 70 native ArenaScript families, including MACD Bearish Reversal, MACD Trend Continuation, Triple Momentum Confirmation, RSI Band Reversal, CHANGE Momentum, MOM Momentum, DMI Directional Trend, Volatility Regime Breakout, adaptive HMA/VWMA regime, Keltner breakout, SuperTrend regime, Parabolic SAR trend, Linear Regression trend, VWAP trend, RMA Trend, OBV Momentum, EMA/SMA/WMA/HMA/ALMA/VWMA price trends, WMA Cross, HMA Cross, ALMA Cross and VWMA Cross, sweeps each candidate through CPU/CUDA paths, ranks survivors by quality score and PnL, then keeps TradingView as the export/review bridge.
  • Operator reports now name staged CUDA family paths such as volume liquidity native signal, Bollinger, Keltner, SuperTrend, ATR, Donchian, ADX and MFI instead of hiding non-SMA research behind a generic fallback label.
  • Operator composite payloads now include a family backend summary, making each generated family auditable from CPU reference to named CUDA staged path or explicit CUDA-unattempted status.
  • Pine compatibility diagnostics now explicitly reject TradingView runtime and broker-state features such as request.financial, strategy.order/risk, barstate/timeframe helpers, tables, drawings and alerts, keeping Strategy Arena Lab positioned as its own ArenaScript generation and backtest engine.
  • Donchian channelLength now participates in local parameter sweeps, so Strategy Arena generated Donchian Breakout plans optimize the real range window instead of only backtesting the default.
  • Native Stochastic mean-reversion generation added: Strategy Arena now exports ta.stoch(close, high, low, length), re-imports it as STOCH(length) threshold rules, and backtests the oscillator strategy locally.
  • Native CCI mean-reversion generation added: Strategy Arena now exports ta.cci(close, length), re-imports it as CCI(length) threshold rules, and backtests the pullback strategy locally.
  • Native Parabolic SAR regime CUDA added: pure ta.sar(start, increment, max) close-vs-stop gates and price/EMA + PSAR trend strategies now route through native signal backends before shared metrics.
  • Native VWAP regime CUDA added: pure ta.vwap(close) close-vs-volume-weighted-price gates and price/EMA + VWAP trend strategies now route through native signal backends before shared metrics.
  • Native Linear Regression regime CUDA added: pure ta.linreg(close, length, offset) close-vs-line gates and price/EMA + LINREG trend strategies now route through native signal backends before shared metrics.
  • Native SuperTrend regime CUDA added: pure ta.supertrend(factor, atrPeriod) close-vs-envelope gates and price/EMA + SuperTrend strategies now route through native signal backends before shared metrics.
  • Native Keltner regime CUDA added: pure ta.kc(source, length, mult) close-vs-channel gates and price/EMA + Keltner channel strategies now route through native signal backends before shared metrics.
  • Native Bollinger regime CUDA added: pure ta.bb(source, length, mult) close-vs-band gates and price/EMA + Bollinger band strategies now route through native signal backends before shared metrics.
  • Native Williams %R/ROC/CCI/Stochastic/MFI regime CUDA added: Strategy Arena generated price/EMA plus Williams %R, ROC, CCI, Stochastic and MFI strategies now route through native composed signal backends, while pure oscillator gates keep their native signal paths.
  • MFI lower/upper band reversal export added: Strategy Arena Lab can now export dual long/short MFI money-flow strategies to Pine, re-import the bridge into ArenaScript, preserve TP/SL/timeout controls, then validate the report on the Rust CPU reference before CUDA review.
  • Native Williams %R signal CUDA added: pure ta.wpr(length) gates now route through cuda_williams_r_native_signal_sweep_v1, while Strategy Arena keeps EMA-filtered oscillator strategies on staged full-plan evaluation.
  • Native Williams %R mean-reversion generation added: Strategy Arena now exports ta.wpr(length), re-imports it as WPR(length) threshold rules, and backtests the pullback strategy locally.
  • Pine import now accepts oscillator ta.crossunder/ta.crossover/ta.cross gates for Stochastic, CCI, ROC, CMO, ta.change, ta.mom, Williams %R, MFI and OBV, then compiles them into deterministic ArenaScript threshold rules before CPU/CUDA backtests.
  • Pine import now preserves symmetric negative momentum thresholds such as ta.change(close, n) < -threshold and ta.mom(close, n) < -threshold, so short gates stay native CHANGE/MOM signals instead of disappearing during import.
  • Pine import now accepts inline Donchian breakout gates such as close > ta.highest(high, length)[1], close > ta.highest(length)[1], close < ta.lowest(low, length)[1] and close < ta.lowest(length)[1], including strategy.entry when= expressions, while still compiling into Strategy Arena ArenaScript.
  • Strategy Arena Lab now generates a native Donchian Breakout family, exports a long/short Pine bridge with ta.highest(high, length)[1] and ta.lowest(low, length)[1], re-imports it into ArenaScript, then backtests the range breakout locally.
  • Strategy Arena Lab now generates a native ATR Breakout family, exports it to Pine for chart review, re-imports it into ArenaScript, then backtests the ATR volatility gate locally.
  • Pine import now accepts ta.atr(length) volatility breakouts like close > close[1] + ATR * multiplier and close < close[1] - ATR * multiplier, so common breakout scripts can become ArenaScript CPU backtests and Lab Reports.
  • Pine import now accepts named arguments such as source=close, length=14 and mult=2 on supported indicators, ta.bb(close, length, mult) tuple bands, inline ta.sma(close, length) +/- ta.stdev(close, length) * mult Bollinger formulas, ta.kc(close, length, mult) tuple channels, inline ta.ema(close, length) +/- ta.atr(length) * mult Keltner formulas, ta.supertrend(factor, atrPeriod) line gates and direction < 0 / > 0 gates, ta.sar(start, increment, max) assigned or inline price gates, ta.linreg(close, length, offset) assigned or inline price gates, ta.vwap(close) assigned or inline price gates, close crossover/crossunder gates against Bollinger/Keltner/SuperTrend/PSAR/LINREG/VWAP signal lines, ta.obv(close, volume) assigned or inline threshold plus ta.crossunder/ta.crossover/ta.cross gates and WMA/HMA/ALMA fast-slow gates, so Bollinger mean-reversion, Keltner breakout, SuperTrend regime, Parabolic SAR trend, Linear Regression trend, VWAP trend, OBV momentum, WMA Cross, HMA Cross, ALMA Cross and VWMA Cross scripts can become ArenaScript CPU backtests and Lab Reports.
  • Pine import now accepts volume > SMA(volume, n) and volume < SMA(volume, n) liquidity gates, so volume-confirmed Pine strategies can become ArenaScript backtests, native EMA+volume CUDA signals and Lab Reports.
  • Low-liquidity short filters are now regression-tested: Pine volume < ta.sma(volume, n) guards on bearish EMA gates preserve and volume < SMA(volume,n) through ArenaScript import and CPU validation.
  • Pine import now accepts close > EMA/SMA and close < EMA/SMA price filters, compiling common price-vs-average scripts into ArenaScript CPU backtests.
  • Strategy Arena Lab now generates a native MACD + RSI Pullback family, preserves it through Pine export/import, then backtests and sweeps it locally.
  • Pine import now accepts inline ta.sma(close, fast), ta.ema(close, fast) and ta.rma(close, fast) operands, price-vs-SMA/EMA/WMA/HMA/ALMA/VWMA/RMA crossovers plus ta.change(close, n) and ta.mom(close, n) momentum gates inside strategy.entry when= calls, including optional RSI or volume filters.
  • Lab Report upgrade prompts now react to the current proof, showing Free proof ready, Builder history value and Operator scaling value.
  • Pine compatibility fallback now mirrors the Rust engine matrix: strategy.entry when=, crossunder, generic input(...), close-only source aliases and explicit rejected features.
  • Strategy Arena Lab now generates a native Dual EMA Regime family with both long and short entries, Pine export, and ArenaScript roundtrip.
  • Pine import now accepts direct strategy.entry(..., when=ta.crossover(...)) and strategy.entry(..., when=ta.crossunder(...)) calls while compiling into ArenaScript.
  • Parameter sweeps now compute a robust quality score per variant and keep best_by_score alongside best_by_pnl for Operator-grade selection.
  • Native ArenaScript generator now creates 45 backtestable Strategy Arena families, including MACD Bearish Reversal, MACD Trend Continuation, DMI Directional Trend, adaptive HMA/VWMA regime, Keltner breakout, SuperTrend regime, Parabolic SAR trend, Linear Regression trend, VWAP trend, WMA Cross, HMA Cross, ALMA Cross, VWMA Cross, volume liquidity breakout, Bollinger mean reversion, ATR breakout, Donchian breakout, MACD+RSI pullback and oscillator pullbacks.
  • Lab Reports now keep Strategy Arena generation provenance plus the desktop conversion trail from generation to CPU/CUDA, export, sync, pricing and TradingView clicks.
  • Native ArenaScript strategy generator added: create local SMA/EMA/RSI/MACD/Stochastic/CCI/ROC/WilliamsR/ADX/Bollinger/Keltner/SuperTrend/ParabolicSAR/LinearRegression/VWAP/WMACross/HMACross/ALMACross/VWMACross/ATR/Donchian research plans before CPU/CUDA and Lab Reports.
  • CUDA benchmark replay now expands small Pine grids into real 1k/10k+ desktop workloads.
  • Pine import now accepts parenthesized EMA/RSI conditions such as (fastEma > slowEma) and (rsiValue < rsiThreshold).
  • GPU Arena submissions include benchmark sizes, strategy name and replay provenance.
  • TradingView desktop funnel links added for Pine import, report export and CUDA benchmark actions.
  • Pine compatibility matrix added inside the Backtest Desk.
PineSMA, EMA, WMA, HMA, ALMA, VWMA, Linear Regression, VWAP, WMA Cross, HMA Cross, ALMA Cross, VWMA Cross, RSI, Stochastic, CCI, ROC, CMO, ta.change, ta.mom, Williams %R, ADX, MFI, OBV, MACD long/short, Bollinger, Keltner, SuperTrend, Parabolic SAR, ATR, Donchian, EMA + RSI EngineRust CPU reference CUDALocal GPU kernels UICPU vs CUDA comparison
SMA crossover CUDA EMA trend CUDA RSI filter CUDA MACD long/short CPU/CUDA EMA + RSI CUDA

Pine compatibility matrix

Supported / Partial / Rejected beta scope. Strategy Arena generates native ArenaScript first; Pine is an import bridge. CPU reference is the truth source and CUDA is enabled only when the script maps to current Strategy Arena kernels.

Contract v1 Classify before benchmark Supported runs CPU/CUDA now; Partial preserves CPU truth with staged CUDA; Rejected shows a repair message before any TradingView review.
Best path Generate ArenaScript Strategy Arena creates native candidates, sweeps CPU/CUDA, ranks survivors, then exports only validated ideas.
Fast import Native CUDA gates MA crosses, pure indicators and supported price/EMA + oscillator/regime filters can use native signal lanes.
Accepted beta Staged full-plan Complex deterministic composites keep CPU truth and staged CUDA reports instead of being simplified.
Repair first No TradingView runtime Flatten MTF/data requests and rewrite broker state, alerts, drawings, arrays or loops into ArenaScript rules.
SupportedNative + CPU/CUDA PartialCPU truth + staged CUDA RejectedRepair before import
Supported
Native ArenaScript generation, Operator composite, strategy.entry, SMA/EMA/WMA/HMA/ALMA/VWMA/RMA crossover/crossunder/cross and price-vs-MA crosses, WMA, HMA, ALMA, VWMA, Linear Regression, VWAP, WMA Cross, HMA Cross, ALMA Cross, VWMA Cross, Stochastic, CCI, ROC, CMO, ta.change, ta.mom, Williams %R, ADX, MFI, OBV, Bollinger, Keltner, SuperTrend, Parabolic SAR, ATR, Donchian, direct if signals, numeric inputs Strategy Arena can generate its own ArenaScript candidates and run Operator composite across all 70 native families, including MACD Bearish Reversal, MACD Trend Continuation, Triple Momentum Confirmation, RSI Band Reversal, CHANGE Momentum, MOM Momentum, DMI Directional Trend, Volatility Regime Breakout, adaptive HMA/VWMA regime, Keltner breakout, SuperTrend regime, Parabolic SAR trend, Linear Regression trend, VWAP trend, RMA Trend, OBV Momentum, WMA Cross, HMA Cross, ALMA Cross and VWMA Cross candidates, or map assigned Pine signals, direct if ta.crossover(...) / ta.crossunder(...) / ta.cross(...), inline ta.sma(close, fast), ta.ema(close, fast), ta.wma(close, fast), ta.hma(close, fast), ta.alma(close, fast, 0.85, 6), ta.vwma(close, fast) and ta.rma(close, fast) operands, close crossing above/below SMA/EMA/WMA/HMA/ALMA/VWMA/RMA, ta.wma(close, length), ta.hma(close, length), ta.alma(close, length, 0.85, 6), ta.vwma(close, length) and ta.rma(close, length) price gates, ta.sar(start, increment, max) assigned or inline price gates, ta.linreg(close, length, offset) assigned or inline price gates, ta.vwap(close) assigned or inline price gates, close crossover/crossunder gates against Bollinger/Keltner/SuperTrend/PSAR/LINREG/VWAP signal lines, ta.stoch(close, high, low, length) threshold and ta.crossunder/ta.crossover/ta.cross gates, ta.cci(close, length) threshold and ta.crossunder/ta.crossover/ta.cross gates and ta.cci(close or hlc3, length) assigned or inline threshold gates, ta.roc(close, length), ta.cmo(close, length), ta.change(close, n) and ta.mom(close, n) momentum threshold plus ta.crossunder/ta.crossover/ta.cross gates, RSI lower/upper band reversal gates, ta.wpr(length) Williams %R threshold plus ta.crossunder/ta.crossover/ta.cross gates, ta.dmi(length, smoothing) ADX trend-strength threshold plus ta.crossunder/ta.crossover/ta.cross gates, plusDI > minusDI / minusDI > plusDI DMI directional gates, ta.mfi(close or hlc3, length) money-flow threshold plus ta.crossunder/ta.crossover/ta.cross gates including input.source(hlc3), ta.obv(close, volume) assigned or inline threshold plus ta.crossunder/ta.crossover/ta.cross gates, ta.bb(close, length, mult) tuple bands plus inline ta.sma(close, length) +/- ta.stdev(close, length) * mult formulas, ta.kc(close, length, mult) tuple channels plus inline ta.ema(close, length) +/- ta.atr(length) * mult formulas, ta.supertrend(factor, atrPeriod) line gates and direction < 0 / > 0 gates, ta.atr(length) volatility breakouts, ta.highest(high, n)[1] / ta.lowest(low, n)[1] and short-form ta.highest(n)[1] / ta.lowest(n)[1] Donchian gates and volume SMA gates into deterministic ArenaScript params, including legacy numeric input(...), CPU reference and the native CUDA SMA batch, WMA signal, HMA signal, ALMA signal, VWMA signal, RMA Trend signal, OBV Momentum signal, RMA price-gate signal, RMA price-cross signal, RMA+OBV regime signal, RMA+MFI regime signal, RMA+ADX regime signal, RMA+ATR regime signal, RMA+Donchian regime signal, RMA+Bollinger regime signal, RMA+Keltner regime signal, RMA+SuperTrend regime signal, RMA+PSAR regime signal, RMA+LINREG regime signal, RMA+VWAP regime signal, RMA+Stochastic regime signal, RMA+CCI regime signal, RMA+ROC regime signal, RMA+CHANGE regime signal, RMA+MOM regime signal, RMA+Williams %R regime signal, OBV threshold/cross signal, EMA+RSI signal, MACD+RSI signal, ADX threshold/cross signal, MACD bearish signal, MACD Trend Continuation signal, CHANGE signal, MOM signal, DMI Directional Trend signal, RSI Band Reversal signal, Triple Momentum Confirmation signal fusion, Parabolic SAR signal, Linear Regression signal and VWAP signal paths. Broader RMA composites and OBV composites beyond native RMA signal regimes run as CPU reference plus staged CUDA full-plan reporting until fused native signal paths land.
Native CUDA
Native lanes: SMA batch, EMA trend/cross, EMA+RSI, MACD+RSI, SMA/WMA/HMA/ALMA/VWMA cross and price gates, EMA + volume liquidity, EMA + ADX trend strength, price/EMA + ATR, price/EMA + Donchian, price/EMA + Bollinger, price/EMA + Keltner, price/EMA + SuperTrend, price/EMA + Parabolic SAR, price/EMA + Linear Regression, price/EMA + VWAP, price/EMA + Williams %R, price/EMA + ROC, price/EMA + CCI, price/EMA + Stochastic, price/EMA + MFI money-flow, Parabolic SAR, Linear Regression, VWAP, RSI, MACD, ADX, ATR, Donchian, Bollinger, Keltner, SuperTrend, Stochastic, CCI, ROC, Williams %R, MFI and OBV threshold gates. RSI Band Reversal adds a native lower/upper long/short signal lane. Pure ta.ema trend/cross, ta.rsi, RSI lower/upper band reversal, ta.macd, ta.linreg, ta.vwap, ta.bb, ta.kc, ta.supertrend, ta.stoch, close-based ta.cci, ta.roc, ta.change, ta.mom, ta.wpr, close-based ta.mfi and ta.obv threshold rules compute their signal vector in native CUDA before shared metrics. EMA regime plus volume > SMA(volume,n), bidirectional EMA regime plus ADX(length,smoothing), plusDI/minusDI DMI direction plus ADX, price/EMA plus ATR, price/EMA plus Donchian, price/EMA plus LINREG and price/EMA plus VWAP now combine native signal vectors before shared metrics. HLC3 CCI/MFI and broader composites stay partial/staged so the real strategy is preserved instead of simplified.
Partial
RMA composite, OBV composite, HLC3 sources, oscillator + EMA/regime composites, short entries, named exits, input.source(close), legacy input(close), volume SMA gates, staged broad CUDA families Accepted for Lab Reports with CPU reference, pure native signal paths when the script is deterministic, and staged CUDA full-plan paths for mixed strategies. Partial covers inline ta.ema/ta.wma/ta.hma/ta.alma/ta.vwma/ta.rma operands, MA cross + RSI filters, oscillator + EMA/regime composites, HLC3 CCI/MFI sources, parenthesized conditions, input.source(defval=close), legacy input(close), strategy.position_avg_price, entryPrice or close multiplier exits, entryPrice +/- entryPrice * pct / 100 formulas, named tpPrice/slPrice variables, input.int timeout bars, strategy.close(..., when=bar_index - entryBar >= timeout) and ta.barssince(signal) >= timeout close gates. Native regime gates such as EMA + volume, EMA + ADX, DMI plusDI/minusDI + ADX, EMA+RSI, MACD+RSI, price/RMA cross, RMA+OBV regime, RMA+MFI regime, RMA+ADX regime, RMA+ATR regime, RMA+Donchian regime, RMA+Bollinger regime, RMA+Keltner regime, RMA+SuperTrend regime, price/EMA + ATR/Donchian/Bollinger/Keltner/SuperTrend/PSAR/LINREG/VWAP/Williams %R/ROC/CHANGE/MOM/CCI/Stochastic/MFI stay available and SMA/WMA/HMA/ALMA/VWMA price gates and deterministic price/MA crosses stay native, while broader RMA-composite/OBV-composite/MA-cross composites with extra filters remain staged until fused kernels expand.
Rejected
request.security/request.financial, non-close sources, strategy.order/risk, broker state, barstate/timeframe, arrays/maps/matrices, loops, alerts, drawings Outside the beta runtime. Repair path: flatten to one local bar stream, replace broker/runtime state with explicit ArenaScript entry, exit, stop, take-profit or timeout rules, then rerun CPU/CUDA. TradingView remains chart review/export for survivors, not the engine.

After download: turn the install into a report.

The next useful step is not another download. Pair the desktop app, create one Lab Report, then decide whether Builder history or Operator diagnostics are worth paying for.

Pair account Open My Lab Reports Builder history Pine/CUDA checklist
1. InstallWindows LabEXE/MSI beta with published SHA256 and release manifest.
2. PairAccount linkConnect the desktop run to a Strategy Arena account before syncing.
3. ReportLocal proofCPU/CUDA result, GPU identity, ArenaScript and supported Pine bridge.
4. UpgradeBuilder / OperatorPrivate history first, heavier diagnostics only for serious candidates.

Lab Reports: Verified locally, Ready for Arena

Every serious Pine benchmark should leave an artifact: CPU reference, CUDA timing, supported subset, GPU metadata, JSON export, and the next action.

Open Hall of Fame My Lab Reports Pine benchmark leaderboard
SMA 50/200 CPU8.2s
SMA 50/200 CUDA0.34s
StatusVerified locally
NextOpen in TradingView

One install should produce one report, not just one launch.

The beta download becomes valuable when the user creates a Lab Report. That report is the object that can be saved in Builder, expanded in Operator, published in the Hall, ranked by GPU and reviewed on TradingView.

FreeCreate local proofRun one supported Pine or ArenaScript candidate through CPU/CUDA and export JSON.
BuilderPreserve the reportSave private URLs, versions, Arena Passport and export history.
OperatorExpand the proofRun heavier sweeps, wrong-market diagnostics and mutation candidates.
PublicPublish selectivelyTurn strong reports into indexable Hall of Fame benchmark pages.
TradingViewReview survivorsOpen chart review after Strategy Arena has produced a candidate.
Open My Lab Reports Builder history Operator diagnostics TradingView Ready strategies TradingView review

Strategy Arena Lab is the downloadable product layer

The web watches the Arena. The Windows Lab experiments locally. Lab Reports turn results into public proof pages. GPU Arena turns hardware runs into rankings. TradingView remains the chart review layer after the local survivor exists.

SEO entry Pine/CUDA pages Pages such as Pine Script CUDA Backtester and GPU Accelerated Backtesting send qualified users to this download page.
Proof artifact Public Lab Reports Every published report can become a shareable benchmark URL with CPU, CUDA, GPU and strategy context.
Viral loop GPU Arena ranking Desktop CUDA workloads can feed public GPU rankings once the user opts in from the app.
Directory prep PAD XML ready Software directory metadata is prepared, but broad submission waits for Windows signing.
Pine CUDA SEO page Public Lab Reports GPU Arena PAD XML

See the Pine to CUDA beta flow

The public demo shows the current app screen, the Pine import path, CPU/CUDA comparison, 100 / 1,000 / 10,000 variant benchmarks and the TradingView vs local GPU positioning.

Open desktop demo Pine backtester TradingView to CUDA Pine CUDA backtester GPU backtesting
Pine import CPU reference CUDA compare JSON export
Strategy Arena Lab Backtest beta screen

Windows signing gate before broad distribution

The beta is published unsigned from the official Strategy Arena page with SHA256 hashes, release JSON, build id and SmartScreen warning. The public manifest keeps signature_required_for_broad_distribution false for this accepted unsigned beta policy; Authenticode is deferred until a larger public launch.

Current statusSignature unsigned Future broad launchAuthenticode signature valid on EXE Future broad launchAuthenticode signature valid on MSI Future broad launchSHA256 hashes recalculated after signing Current betaSHA256 hashes verified before running
npm run signature:preflight npm run signature:ready npm run signature:plan npm run directory:verify powershell.exe -NoProfile -ExecutionPolicy Bypass -File scripts/verify-windows-signature.ps1 -RequireSigned

Release manifest JSON Signature report JSON

Requirements

Windows 10/11 x64

Native Tauri desktop build for modern Windows machines.

WebView2

Usually already installed on Windows 11; install Microsoft WebView2 Runtime if missing.

NVIDIA CUDA optional

CUDA accelerates supported Strategy Arena workloads including SMA, EMA, WMA/HMA/ALMA/VWMA, adaptive HMA/VWMA native signal regimes, Linear Regression, VWAP, WMA Cross, HMA Cross, ALMA Cross, VWMA Cross, RSI, MACD long/short, Bollinger, Keltner, SuperTrend, Parabolic SAR, ATR, Donchian and volume paths. CPU reference remains available without GPU.

Build
20260715-arena-evolution-campaign-v23

SHA256
strategy-arena-desktop-0.1.0-beta-x64-setup.exe
628b8637e46e002310404e9415a0ac2f55437ed440b80e1370e831a4d48e1d6a
strategy-arena-desktop-0.1.0-beta-x64.msi
a79984b186d7f970404616219b84ce5ae111b489ae3f54f706c4aafe2f2c3a65
Verify the installer before running it Get-FileHash "$env:USERPROFILE\Downloads\strategy-arena-desktop-0.1.0-beta-x64-setup.exe" -Algorithm SHA256

The SHA256 output must match the EXE hash above. This beta is intentionally unsigned for now, so Windows SmartScreen may show an extra confirmation screen.

Software directory metadata: PAD XML · release JSON · signature JSON

Strategy Arena Lab FAQ

Which Pine scripts work?

The beta supports native Strategy Arena generation first, plus Pine import for SMA/EMA/WMA/HMA/ALMA/VWMA/RMA crossover/crossunder, price crossing above/below SMA/EMA/WMA/HMA/ALMA/VWMA/RMA, EMA trend, WMA/HMA/ALMA/VWMA/RMA price gates, Linear Regression price gates and VWAP trend gates, RSI mean reversion, RSI lower/upper band reversal, Stochastic, CCI, ROC, CMO, ta.change, ta.mom, Williams %R, ADX, MFI, OBV, MACD, Bollinger, Keltner, SuperTrend and Parabolic SAR gates, ATR volatility breakouts, Donchian highest/lowest breakouts, volume SMA filters, MA + RSI, short EMA + RSI and direct if signal conditions.

Is a GPU required?

No. CPU reference mode runs everywhere; CUDA is used only when available.

Where does my data go?

Local backtests stay on the machine unless you explicitly connect the desktop app to your Strategy Arena account.

Free research datasets

🏆
Arena Live Snapshot
Top 20 AI trading strategies on BTC with full metrics: PnL, Sharpe, win rate, drawdown, trade count. Fresh snapshot generated on demand.
JSON~8 KB60 trackedlive
{ "schema": "strategy-arena-snapshot-v1", "asset": "BTC", "initial_capital_usd": 10000, "top_20": [{ "rank": 1, "id": "cuda_evolved", "capital_current": 11234, "pnl_percent": 12.34, ... }, ...] }
⬇ Download JSON or view raw API →
🐉
DLB Benchmark Summary
The Dragon Labyrinth Benchmark condensed: 14,580 measured trials, ablation study on 800 fixed-seed games, M1+M3 synergy ×2.5, 7.5× structure-over-compute ratio. Plus links to the 3 research articles.
JSON~5 KB14,580 trialsarXiv-grade
{ "name": "Dragon Labyrinth Benchmark", "results": { "total_trials": 14580, "approaches_measured": [ {"name": "Bare LLM", "win_rate_pct": 1}, {"name": "MCTS brute", "win_rate_pct": 2}, {"name": "Oracle-X1 M1+M3", "win_rate_pct": 15}, {"name": "TMS1100 (cheats)", "win_rate_pct": 85} ] } }
⬇ Download JSON or view raw API →
🧪
PromptForge Library
The 12 context sources injected before every AI trading decision on the arena. 217-token budget. Use it as a template for your own multi-source LLM reasoning pipeline.
JSON~3 KB12 sources217 tokens
{ "name": "PromptForge Context Library", "token_budget": 217, "sources": [ {"id": 1, "name": "OHLCV 20-tick window"}, {"id": 2, "name": "Regime classification"}, {"id": 3, "name": "Chimera patterns top 3"}, {"id": 5, "name": "Invictus death-context flags"}, ... ] }
⬇ Download JSON or view raw API →

Get the Pine/CUDA Lab checklist (optional)

A short beta checklist for the first useful run: supported Pine subset, CPU reference, CUDA status, Lab Report export and Builder next step. The download works without subscribing.

License & attribution
All three datasets are released under Creative Commons BY 4.0. You can use them commercially, cite them, remix them, integrate them into your products or papers. Just credit the source: "Data from Strategy Arena (strategyarena.io)" or "Data from Dragon Labyrinth Benchmark (outilsia.fr/dnd-challenge)". A link is preferred but not required.

Disclaimer — All trading data is simulated on paper capital. Strategy Arena is an educational platform, not investment advice.