HyperionX Course

A learning path for platform operation, Code Lab, research, AI, and market data, with version-specific guidance.

15course modules

Versionedrelease guidance

Sim firstexecution rule

Use this course to learn a workflow. Use the linked knowledge-base and reference pages for the maintained product contract. Every exercise identifies when a surface is Current, Preview, Beta, Internal, Unavailable, or blocked in the reviewed public package.

Public-release scope

Check the documentation version map before starting a lesson. Signed release notes now include changes through 1.1.25, while the public update feed and newer reviewed source are tracked separately. Lessons identify newer features and historical limitations where they affect an exercise. Verify the installed version, first-launch module discovery, and a small known workflow before relying on research results.

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

Learn Validator and Optimizer assumptions, exact-installer verification, fill models, commissions, and version-gated slippage behavior.

07AI

Rion AI Automation

Separate Current chat/context from Preview tools, simulation actions, Agent Builder, and Internal transport.

08Market Data

Market Data And Order Flow

Prove provider, instrument, clock, depth, tape, fallback, and active-chart provenance before acting.

09Research

Performance Database

Save, inspect, compare, and export results while keeping the missing reproducibility record separately.

10Operations

Simulation And Risk

Test Hyperion Sim and OCO behavior, respect Trade Copier Beta, and rehearse recovery without implying public server control.

11Code Lab

Production Code Lab

Build the atomic custom project, create fresh instances, test generated helpers, and package supportable source.

12Charting

Chart Tools And Bar Types

Use Current inspection/export tools and learn the Preview custom bar-builder boundary.

13Context

News And AI Context

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

14Automation

Platform Extensions

Build Current add-ons and evaluate the token-provisioned Preview loopback API without treating it as a public network API.

15AI

Agent Builder

Test a non-baseline Preview profile and distinguish enforced filters from advisory risk fields and placeholder telemetry.

Course Rule

A visible name, source-tree class, placeholder, or roadmap item is not proof of public availability. The linked canonical status and reference pages override a lesson summary when the product changes.

Status Labels

Label	How this course uses it
Current	Implemented in the reviewed build, subject to documented provider/package limits.
Preview	Implemented for evaluation; compatibility or packaging can change.
Beta	Functional but not approved as an unattended live-trading dependency.
Internal	HyperionX implementation surface; not a public integration contract.
Unavailable	Placeholder or code may exist, but no supported public workflow is usable.
Roadmap	Direction only; never a current exercise prerequisite.

Start each session with Feature And Provider Status, Platform APIs, and API Status And Compatibility.

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 by separating Current read context, Preview actions, and Internal transport.
• Teach provider/instrument metadata before leverage, market depth, and order-flow tools.
• Teach saved results, exports, and logs as part of a research record, while documenting what the database does not preserve.
• 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 the Local Desktop API as a token-provisioned Preview interface whose generated token has no public reveal/bootstrap UI.
• Teach Agent Builder as a Preview profile layer with enforced and advisory fields, not a hard trading-risk engine.

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 assumption that an entitlement name enables live automation. Hyperliquid or KuCoin routing must be exposed by the installed release and pass the provider-specific capability, setting, active-context, connection, and exchange-permission checks.
• 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 Builder risk field described as enforced unless the current execution policy enforces it for a non-baseline profile.

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.
• Its required platform surface is available in the installed public package and has the stated release status.