HyperionX Course

A HyperionX-native learning path for platform use, Code Lab scripting, strategy research, AI agents, automation, market data, and production readiness.

16course modules

100%HyperionX APIs

0other-platform assumptions

Use this course when you want to move from platform basics into real Code Lab work: indicators, strategies, order management, advanced chart logic, and research workflows.

Course Map

01Foundation

Platform Orientation

Connect, chart, manage data, use Chart Trader, and save workspaces.

02Code Lab

C# For Trading Scripts

Read and write small script helpers without guessing at syntax.

03Code Lab

Indicators

Build plotted, colored, and rendered indicators safely.

04Code Lab

Strategies

Build market, limit, stop, filtered, and modular strategies.

05Code Lab

Advanced Scripts

Add tick logic, multiple data series, chart rendering, strategy plots, and scale logic.

06Research

Research Workflow

Test strategies with Validator, Optimizer, commissions, slippage, and realistic assumptions.

07Operations

Live Readiness

Verify licensing, data, strategy behavior, manual trading, workspace restore, and operational risk.

08AI

Rion AI Automation

Use chart-aware AI, tool actions, confirmations, agent settings, and audit-safe automation.

09Market Data

Market Data And Order Flow

Understand providers, instrument metadata, historical storage, Level 2, DOM, Time and Sales, and active-chart context.

10Research

Performance Database

Save, inspect, compare, export, and reproduce strategy and optimizer results.

11Operations

Simulation And Risk

Configure Hyperion Sim, OCO behavior, account safety, server strategy control, and recovery.

12Code Lab

Production Code Lab

Use script policy, runtime validation, generated helpers, hot reload, logs, and supportable builds.

13Charting

Chart Tools And Bar Types

Use Data Box, chart options, scale controls, dataset exports, logs, built-in bars, and custom bar-builder rules.

14Context

News And AI Context

Use the shared economic calendar, News window, NewsEcon indicator, alerts, and Rion news context.

15Automation

Platform Extensions

Understand add-ons, Rion's loopback API, permissions, confirmations, trading guardrails, and audit logs.

16AI

Agent Builder

Configure specialized Rion agents with profile, model, workspace, prompt files, skills, tools, routing, and risk limits.

Course Rule

Every lesson is written against HyperionX APIs and current platform behavior. If the platform does not implement a method or workflow, the course does not teach it as available.

Learning Approach

The course builds in order:

• Build from variables and methods into indicators.
• Teach plots and output series before strategies depend on them.
• Teach strategy structure before advanced order management.
• Teach market, limit, stop, and event-based entries separately.
• Teach exits as modules, not as random code inside OnBarUpdate().
• Teach tick updates, multi-series work, and rendering only after the basic lifecycle is understood.
• Teach AI and automation as permissioned platform workflows, not as unrestricted chat commands.
• Teach provider/instrument metadata before leverage, market depth, and order-flow tools.
• Teach saved results, exports, and logs as part of the research record.
• Teach simulation, risk, and operational recovery before live execution.
• Teach Code Lab scripts as production assets that need policy, validation, and repeatable builds.
• Teach chart utilities, exports, and bar-builder source requirements before debugging strategy output.
• Teach news as shared platform context so windows, indicators, and agents do not drift apart.
• Teach local API automation as authenticated, permissioned, audited platform control.
• Teach Agent Builder as the configuration layer for specialized Rion agents, not just another chat screen.

The course avoids patterns that confuse HyperionX users:

• No NinjaTrader assumptions.
• No unsupported fixed text or drawing calls.
• No direct WPF chart control manipulation as a beginner pattern.
• No copied strategy examples that bypass HyperionX's current order model.
• No live order automation without entitlements, explicit settings, confirmations, risk controls, and audit logs.
• No research result without enough metadata to reproduce it.
• No custom script treated as complete until it compiles through the same runtime path used by the app.
• No tick-built bar type tested from minute-only data.
• No AI or local API action treated as complete without checking the returned status and audit path.
• No agent allowed to move from read-only context into execution without explicit permissions, risk limits, and audit behavior.

Required Script Pattern

Every Code Lab lesson follows this shape:

using System.ComponentModel.DataAnnotations;
using System.Windows.Media;
using HyperionX.Core.Attributes;
using HyperionX.Core.DataCalc;
using HyperionX.Core.Enums;

public class MyScript : Indicator
{
    [HyperionXProperty]
    [Display(Name = "Period", GroupName = "Parameters", Order = 0)]
    public int Period { get; set; }

    public override void OnStateChanged()
    {
        if (State == State.SetDefaults)
        {
            Name = "MyScript";
            Version = "1.0";
            Period = 14;
        }
        else if (State == State.Configured)
        {
            // Create series, plots, and reusable state here.
        }
    }

    public override void OnBarUpdate()
    {
        if (CurrentBar < Period)
            return;
    }
}

Acceptance Rule

A lesson is not complete because the code was typed. It is complete when:

• The script compiles in Code Lab.
• It appears in the correct indicator or strategy list.
• It handles short histories without exceptions.
• It behaves correctly in dark and light themes if it renders UI.
• It can be explained from HyperionX APIs, not another platform documentation set.