gsTradingEngine v2.0

The gsTradingEngine is the C# backtesting engine built into gStockly. Write algorithmic trading strategies directly in the browser — they are compiled at runtime via Roslyn and executed against real historical OHLCV data.

How It Works

Every strategy inherits from TradingSystemBase and implements exactly two methods:

• ConfigureSystem() — called once at startup to set tickers, dates, capital and parameters.
• ExecuteStrategy() — called for every trading day × every ticker. This is where your buy/sell logic lives.

public override void ConfigureSystem()
{
    Config.Tickers  = new[] { "AAPL", "MSFT" };
    Config.FromDate = new DateTime(2020, 1, 1);
    Config.ToDate   = DateTime.Today;
    Config.StartEquity        = 10_000;
    Config.InvestmentPerTrade = 10_000;
}

public override void ExecuteStrategy(string ticker = null)
{
    // CurrentTicker and CurrentDate are set automatically by the engine
    double sma20 = GetSMA(20);
    double sma50 = GetSMA(50);
    bool inPos = OpenPositions.ContainsKey(CurrentTicker);

    if (sma20 > sma50 && !inPos) Buy("SMA20 crossed above SMA50");
    if (sma20 < sma50 &&  inPos) Sell("SMA20 crossed below SMA50");
    SetStopLoss(5.0);
}

ConfigureSystem()

Called once before the backtest begins. Set your tickers, date range, capital, commissions and execution parameters here. In v2 you can also define a dynamic universe and ranked portfolio rules. Parameters set via the UI always override values set in code.

TradingSystemConfig Properties

Selective realtime quote refresh

Paper and Live deployments have two initial-snapshot modes. The default, Config.UpdateQuotes = true, polls the realtime endpoint once for every ticker in the deployment and preloads the configured historical range. Set Config.UpdateQuotes = false for a broad universe: the runtime reads only the latest persisted candle for all tickers with a batched database query. A prior-bar helper such as GetClose(-1) reads just the needed persisted bar; EMA, RSI and other indicators lazily load the historical series only after the strategy has retained that ticker as a candidate. During ExecuteStrategy(), call RequestRealtimeQuotes(ticker, ...) only after the inexpensive cached screening has retained a candidate. The call waits for the selected quote, replaces that ticker's current candle, invalidates/recalculates its indicators and then continues in the same strategy call. Scanner signals are also fetched in batches for the current snapshot. Use IsRealtimeQuote(ticker) to verify the refresh. Backtests never access realtime data.

public override void ConfigureSystem()
{
    Config.UpdateQuotes = false;
}

public override void ExecuteStrategy(string ticker = null)
{
    if (!CachedCandidateCondition()) return;
    RequestRealtimeQuotes(CurrentTicker);
    if (!IsRealtimeQuote(CurrentTicker)) return;
    if (RealtimeConditionIsValid()) Buy("Realtime confirmation");
}

ExecutionType

Controls which price is used when an order is executed on a given day.

BacktestMode

Ranked Universe v2

v2 adds a new cross-sectional workflow. Instead of relying only on a manually typed ticker list, you can resolve a dynamic universe from metadata and assign a score to each ticker inside ExecuteStrategy(). On rebalance bars the engine automatically buys the top-ranked names.

UniverseFilter

RankedUniverseOptions

Operational observability

The Trading Console exposes more than the deployment status. Select a deployment and use the dedicated tabs to inspect the strategy’s actual runtime behavior:

• Decisions: one record per ticker evaluation, including no-action decisions, reference price, side, quantity and strategy reason.
• Trades: Paper fills with ticker, side, quantity, fill price and realized P&L. Selecting a trade loads the OHLC chart and overlays entry/exit markers.
• Performance: current equity, realized and unrealized P&L, return, win rate, profit factor, maximum drawdown and the Paper equity curve.

The corresponding endpoints are /api/ts/deployments/{id}/decisions, /trades and /performance. Decision rows are stored in ts_deployment_decision; Paper equity snapshots are stored in ts_paper_equity and survive service restarts.

Health & Versioning v2

The v2 backend exposes explicit deployment metadata from /health so you can verify which engine is active on the server.

{
  "status": "ok",
  "engine": "gsTradingSystemEngine_v2",
  "version": "2.0.0",
  "built": "2026-06-27",
  "ts": "2026-06-27T10:00:00Z"
}

ExecuteStrategy()

Called for every active trading day for every ticker. The engine sets the following properties automatically before your code runs:

Score Helpers v2

double score = 0;
if (Close() > GetSMA(200)) score += 10;
score += GetChangePercent(60);

if (score >= 20)
    SetScore(score, $"score={score:F1}");
else
    ClearScore();

Execution Runtimes: Backtest, Paper and Live

The engine separates strategy logic from the runtime that applies it. The same strategy concepts can therefore be reused across historical testing, simulated execution and — once a broker adapter is configured — real-time trading.

Runtime pipeline

Market-data snapshot
        ↓
ILiveStrategyEvaluator
        ↓
TradingOrderIntent
        ↓
LiveTradingCoordinator
        ↓
Safety checks + idempotency
        ↓
Paper simulator or broker gateway

The live cycle is implemented by LiveTradingSession. Each cycle is serial and follows the same order:

1. Read a coherent market and portfolio snapshot.
2. Evaluate the strategy through ILiveStrategyEvaluator.
3. Produce one or more TradingOrderIntent objects.
4. Validate each intent through the safety guard.
5. Submit it to the configured paper simulator or broker gateway.
6. Persist the result so the same intent cannot be submitted twice.

Live contracts

Current broker and feed status

Recommended rollout

Live Trading

Live Trading applies the strategy to current market data and can submit orders to a configured broker. It is a separate operational runtime from historical backtesting and paper trading.

Live Trading cycle

1. Poll current quotes and candles
2. Read broker positions and available cash
3. Evaluate the strategy on the current snapshot
4. Create a Buy / Sell / Short / Cover intent
5. Check broker capabilities and safety limits
6. Submit the order only in Live mode
7. Persist the intent and broker result
8. Reconcile the next snapshot

Mode selection rules

Trading Console: multiple deployments

The Trading Console is the operational surface for running more than one configured instance of a Trading System. A deployment pins a saved strategy version to its execution mode, ticker universe, account, capital, schedule and refresh interval.

Deployment definitions are persisted in the master database. After an engine restart or VPS reboot, the Trading Console loads the saved deployments again; deployments whose Enabled flag is active are restored and started automatically. Recent cycle, signal and order events are persisted as well.

Paper accounts are isolated per deployment and persisted in the master database. The Portfolio tab reads the virtual cash balance, open positions, market values, unrealized P&L and recent Paper fills from /api/ts/deployments/{id}/portfolio. A restart therefore restores the Paper portfolio instead of starting with an empty account.

The polling feed is tolerant of partial failures: if one ticker returns an HTTP or payload error, that ticker is skipped and the valid tickers continue through the cycle. The problem is recorded as a warning event. The deployment enters Error only when no valid ticker remains.

Refresh interval

The console offers controlled values from 15 seconds to 60 minutes: 15 seconds, 30 seconds, 1 minute, 5 minutes, 15 minutes, 30 minutes and 60 minutes. The interval is configured independently for each deployment and can be changed directly from the deployment grid.

Deployment lifecycle

1. Select a saved Trading System and version
2. Choose Paper or Live mode
3. Keep the ticker override empty to use Config.Tickers, or provide an override
4. Configure account, capital, schedule and refresh interval
5. Create the deployment
6. Start or stop it from the grid
7. Inspect cycles, signals and order results in Recent events

Stopping a deployment stops new evaluation cycles and disables automatic restart. It does not close existing positions. Closing positions is a separate operational action.

Deployment API

Orders

// Exit if price drops 5% below entry (long position)
SetStopLoss(5.0);

// Stop with early return — skip remaining logic if stopped out
if (SetStopLoss(7.0)) return;

// Exit at +15% profit
if (SetTakeProfit(15.0)) return;

// Combine with stop loss: take profit at 15%, stop at 5%
if (SetTakeProfit(15.0)) return;
SetStopLoss(5.0);

// Trail 8% from peak (long)
if (SetTrailingStop(8.0)) return;

// Combine: tight initial stop, then trail once in profit
if (currentGainPercent() > 5.0)
    SetTrailingStop(6.0); // switch to trailing once +5%
else
    SetStopLoss(3.0);   // tight fixed stop while not yet in profit

// Standard: 2× ATR(14) stop
SetATRStop();

// Wide stop for swing trading: 3× ATR(14)
SetATRStop(3.0);

// Tight stop for mean reversion: 1.5× ATR(10)
SetATRStop(1.5, 10);

OpenPositions

OpenPositions is a Dictionary<string, TradePosition> where the key is the ticker symbol. It always reflects the currently open trades.

// Check if a position is open for the current ticker
bool inPos = OpenPositions.ContainsKey(CurrentTicker);

// Filter by side using PositionSide
bool hasLong  = OpenPositions.Any(p => p.Value.PositionSide == 1);
bool hasShort = OpenPositions.Any(p => p.Value.PositionSide == -1);

// How many positions are open?
int count = OpenPositions.Count;

TradePosition Properties

Equity & Gain Helpers

// Take profit at +15%
if (currentGainPercent() > 15.0)
    Sell("Take profit +15%");

// Invest 10% of current equity per trade (compounds over time)
Config.InvestmentPerTradePercTotalEquity = 10;

Log()

Log($"RSI={rsi:F1} SMA20={sma20:F2} — entering long");
// → [AAPL 2023-06-15] RSI=28.4 SMA20=182.34 — entering long

Log($"Stop hit at {Close():F2}, entry was {pos.OpenPrice:F2}");

Candle Access

All candle functions default to CurrentTicker and DefaultTimeframe. Offset 0 = current day, -1 = one period back, -2 = two periods back, etc.

// Compare yesterday's close to today's
double today     = GetClose(0);
double yesterday = GetClose(-1);
bool   upDay     = today > yesterday;

// Access another ticker (e.g. S&P 500 as filter)
double spxClose = GetClose(0, "d", "^GSPC");
if (spxClose < GetClose(-1, "d", "^GSPC")) return; // skip if market is down

Date Helpers

Trading Signals

The engine can read the existing trading_signals table while evaluating the current ticker and date. The signal model exposes the table metadata, including StrategyName, StrategyCode, Timeframe, ClosePrice and the raw ExtraData JSON payload.

public override void ConfigureSystem()
{
    // Restrict the live universe to the setup this system trades
    Config.Tickers = GetTradingSignalTickers(
        "Near EMA 50 daily",
        "Near EMA 50 weekly");
}

public override void ExecuteStrategy(string ticker = null)
{
    var signals = GetTradingSignals(
        "Pre-Breakout Bollinger Squeeze - Balanced",
        "pre_breakout_squeeze_balanced");

    var signal = signals.FirstOrDefault();
    if (signal is null) return;

    var rsi = GetTradingSignalExtraValue<double>(signal, "RSI");
    var bollWidth = GetTradingSignalExtraValue<double>(signal, "BollWidth");

    if (rsi is double rsiValue && bollWidth is double width && rsiValue < 55 && width < 5)
        Buy("Signal confirmed from trading_signals");
}

GetChangePercent()

// 20-day momentum
double mom20 = GetChangePercent(20);

// Weekly performance over last 4 weeks
double w4 = GetChangePercent(4, "w");

// Only buy if 3-month momentum is positive
if (GetChangePercent(63) > 0 && !inPos) Buy("Positive 3-month momentum");

GetSlopePercent()

// Confirm uptrend: slope > 0.05% per day
if (GetSlopePercent(30) > 0.05) Buy("Rising slope");

// Weekly slope > 0 = structural uptrend
bool weeklyUp = GetSlopePercent(26, "w") > 0;

GetDaysInPosition()

// Exit if held more than 20 days without reaching target
if (GetDaysInPosition() > 20)
    Sell("Time exit: 20 days elapsed");

// Tighten stop after 10 days in position
double stopPct = GetDaysInPosition() > 10 ? 3.0 : 6.0;
SetStopLoss(stopPct);

IsFirstBarOfWeek() / IsFirstBarOfMonth()

// Only enter positions at start of week
if (!IsFirstBarOfWeek()) return;

// Monthly rebalancing
if (IsFirstBarOfMonth())
{
    CloseAllPositions();
    Log("Monthly rebalance triggered");
}

Moving Averages

All MA functions now support the tf parameter for multi-timeframe indicators. If tf differs from DefaultTimeframe, the engine automatically preloads that timeframe's data on first use. Powered by Skender.Stock.Indicators.

Oscillators

double rsi = GetRSI(14);
var (macd, signal, hist) = GetMACD();
var (upper, mid, lower)  = GetBollingerBands(20, 2.0);
var (k, d) = GetStochastic();

if (rsi < 40 && hist > 0 && !OpenPositions.ContainsKey(CurrentTicker))
    Buy("RSI oversold + MACD positive histogram");

Trend & Channels

Volume

Other Indicators

Example: SMA Crossover

The classic golden/death cross — long when SMA20 > SMA50, exit when it crosses back. Uses NextOpen execution for realism.

public override void ConfigureSystem()
{
    Config.Tickers            = new[] { "AAPL" };
    Config.FromDate           = new DateTime(2018, 1, 1);
    Config.ToDate             = DateTime.Today;
    Config.StartEquity        = 10_000;
    Config.InvestmentPerTrade = 10_000;
    Config.SpreadPricePerc    = 0.01;
    Config.PercTax            = 26;
    Config.DefaultExecutionType = ExecutionType.NextOpen;
}

public override void ExecuteStrategy(string ticker = null)
{
    double sma20 = GetSMA(20);
    double sma50 = GetSMA(50);
    bool   inPos = OpenPositions.ContainsKey(CurrentTicker);

    if (sma20 > sma50 && !inPos) Buy("SMA20 > SMA50");
    if (sma20 < sma50 &&  inPos) Sell("SMA20 < SMA50");
    SetStopLoss(5.0);
}

Example: Trend Following Long/Short

Long when all three SMAs are aligned up, short when aligned down. Uses PositionSide to distinguish position direction.

public override void ExecuteStrategy(string ticker = null)
{
    double sma20  = GetSMA(20);
    double sma50  = GetSMA(50);
    double sma200 = GetSMA(200);

    bool longEntry  = sma20 > sma50 && sma50 > sma200;
    bool shortEntry = sma20 < sma50 && sma50 < sma200;
    bool hasLong  = OpenPositions.Any(p => p.Value.PositionSide == 1);
    bool hasShort = OpenPositions.Any(p => p.Value.PositionSide == -1);

    // Exits first
    if (!longEntry  && hasLong)  Sell("Trend reversal exit");
    if (!shortEntry && hasShort) Cover("Trend reversal cover");

    // Entries
    if (longEntry  && !hasLong  && !hasShort) Buy("Bullish alignment");
    if (shortEntry && !hasShort && !hasLong)  Short("Bearish alignment");

    SetStopLoss(5.0);
}

Example: RSI Mean Reversion + Bollinger Bands

public override void ExecuteStrategy(string ticker = null)
{
    double rsi = GetRSI(14);
    var (upper, mid, lower) = GetBollingerBands(20, 2.0);
    double close = Close();
    bool   inPos = OpenPositions.ContainsKey(CurrentTicker);

    // Entry: RSI oversold AND price near lower Bollinger band
    if (rsi < 30 && close < lower * 1.01 && !inPos)
        Buy("RSI oversold + BB lower");

    // Exit: RSI overbought OR price touches upper band
    if (inPos && (rsi > 70 || close > upper * 0.99))
        Sell("RSI overbought or BB upper");

    SetStopLoss(8.0);
}

Example: Multi-Ticker Portfolio

Use DateFirst mode to process all tickers on the same date. Invest a fixed % of equity per trade so positions scale with portfolio growth.

public override void ConfigureSystem()
{
    Config.Tickers = new[] { "AAPL", "MSFT", "GOOGL", "AMZN", "NVDA" };
    Config.FromDate           = new DateTime(2020, 1, 1);
    Config.ToDate             = DateTime.Today;
    Config.StartEquity        = 50_000;
    Config.InvestmentPerTradePercTotalEquity = 20; // 20% of equity per position
    Config.Mode               = BacktestMode.DateFirst;
}

public override void ExecuteStrategy(string ticker = null)
{
    double rsi    = GetRSI(14);
    double sma50  = GetSMA(50);
    double sma200 = GetSMA(200);
    bool   inPos  = OpenPositions.ContainsKey(CurrentTicker);

    if (Close() > sma50 && sma50 > sma200 && rsi > 50 && rsi < 75 && !inPos)
        Buy($"Momentum entry {CurrentTicker}");

    if (inPos && (Close() < sma50 || rsi < 40))
        Sell("Exit: below SMA50 or RSI weak");

    SetStopLoss(6.0);
}

Example: Ranked S&P 500 Universe v2

This is a simple v2 validation strategy. It resolves the S&P 500 dynamically, scores every ticker and on weekly rebalance bars buys the 5 highest scores using a unified portfolio.

public override void ConfigureSystem()
{
    Config.Universe = new UniverseFilter
    {
        PartOf = "S&P 500",
        Category = "Stock",
        EnabledOnly = true
    };

    Config.RankedUniverse = new RankedUniverseOptions
    {
        Enabled = true,
        MaxPositions = 5,
        RebalanceFrequency = "Weekly",
        MinScore = 20
    };

    Config.UnifiedPortfolio = true;
    Config.FromDate = new DateTime(2022, 1, 1);
    Config.ToDate = new DateTime(2024, 12, 31);
    Config.StartEquity = 100000;
    Config.InvestmentPerTradePercTotalEquity = 20;
    Config.DefaultExecutionType = ExecutionType.Close;
    Config.DefaultTimeframe = "d";
}

public override void ExecuteStrategy(string ticker = null)
{
    double sma50 = GetSMA(50);
    double sma200 = GetSMA(200);
    double rsi = GetRSI(14);
    double momentum60 = GetChangePercent(60);

    if (sma50 <= 0 || sma200 <= 0)
    {
        ClearScore();
        return;
    }

    double score = 0;
    if (Close() > sma200) score += 10;
    if (sma50 > sma200) score += 10;
    if (rsi >= 50 && rsi <= 70) score += 10;
    score += momentum60;

    if (score >= 20)
        SetScore(score, $"score={score:F1}");
    else
        ClearScore();
}

Example: Trailing Stop + Take Profit

Combines a fixed initial stop loss with a trailing stop that activates once the trade is profitable, plus a take profit target.

public override void ExecuteStrategy(string ticker = null)
{
    double rsi  = GetRSI(14);
    double sma50 = GetSMA(50);
    bool   inPos = OpenPositions.ContainsKey(CurrentTicker);

    // Entry: RSI recovering from oversold, above SMA50
    if (!inPos && rsi > 35 && rsi < 55 && Close() > sma50)
    {
        Buy("RSI recovery above SMA50");
        Log($"Entry RSI={rsi:F1} close={Close():F2}");
        return;
    }

    if (!inPos) return;

    // Take profit at +20%
    if (SetTakeProfit(20.0)) return;

    // Once +5% in profit: switch to 8% trailing stop
    if (currentGainPercent() > 5.0)
    {
        if (SetTrailingStop(8.0)) return;
    }
    else
    {
        // Fixed stop while not yet in profit
        SetStopLoss(4.0);
    }

    // Time exit: close after 30 days regardless
    if (GetDaysInPosition() > 30)
        Sell("Time exit: 30 days");
}

Example: Multi-Timeframe Strategy

Filter entries using weekly trend context, execute on daily signals. The engine loads the weekly data automatically on demand.

public override void ExecuteStrategy(string ticker = null)
{
    // Weekly context: only trade in the direction of the weekly trend
    double weeklySMA20 = GetSMA(20, "w");
    double weeklySMA50 = GetSMA(50, "w");
    double weeklySlope = GetSlopePercent(26, "w");
    bool   weeklyUp    = weeklySMA20 > weeklySMA50 && weeklySlope > 0;

    // Daily entry signal
    double dailyRSI  = GetRSI(14);
    double dailySMA20 = GetSMA(20);
    bool   inPos      = OpenPositions.ContainsKey(CurrentTicker);

    if (!inPos && weeklyUp && dailyRSI < 45 && Close() > dailySMA20)
    {
        Buy("Daily pullback in weekly uptrend");
        return;
    }

    if (inPos)
    {
        SetATRStop(2.0);       // volatility-adaptive stop
        SetTakeProfit(15.0);  // fixed target
        // Exit if weekly trend turns
        if (!weeklyUp) Sell("Weekly trend broken");
    }
}