TradeStrike is an extensible trading platform. Indicators, strategies, bar types, drawing tools, market-data connections, trading providers and more are all plugins: you compile a single .NET DLL against the public SDK, drop it in a folder, and the host discovers it on the next launch.

This documentation teaches you to build every plugin kind, from a short "hello world" to production-grade tooling. Each subject lives on its own page so you can read exactly the topic you need — use the menu on the left to jump straight to it. You never modify, or even see, the host's source code: you reference one NuGet package and implement small, well-documented contracts.

Start here

Two pages get you from zero to a plugin on a chart, and one page gives you the mental model that makes every later chapter click. Read them in order if you are new.

What can I build?

The SDK surfaces the whole platform as contracts. Each plugin kind has its own chapter, and each chapter is split into focused pages — an overview, a "your first one" walkthrough, then one page per feature. Start anywhere; the chapters are independent.

How the SDK is structured

One meta-package, TradeStrike.Sdk, brings in everything: the contract assemblies you compile against, plus an MSBuild target that can auto-deploy your built DLL. The contract assemblies hold only interfaces, abstract base classes, attributes, enums and data records — no engine code. The host supplies the engine at load time, which is exactly why your deployed plugin ships only its own DLL and never copies of these assemblies.

• TradeStrike.Pipeline.Contracts — indicators, plots, series, bars, market depth, drawing tools and data providers.
• TradeStrike.Pipeline.Trading.Contracts — orders, positions, accounts, risk and ATM bracket types.
• TradeStrike.Pipeline.Strategies.Contracts — the Strategy base class and its runtime context.
• TradeStrike.Pipeline.Brokerage.Contracts — brokerage gateway interfaces.
• TradeStrike.Pipeline.TradeHistory.Contracts — the trade-history store and backfill contracts.

Core concepts walks through how these fit together: the plugin model, the "base class plus optional capability interfaces" pattern, series and bars-ago indexing, ambient providers, and the shared lifecycle every plugin kind follows.

How a plugin works

The mechanism is the same for every plugin kind, and it is deliberately simple. There is no plugin manifest, no registration call, and no host configuration to edit. You implement a contract, build a DLL, and the host finds it by inspecting the types inside. The four steps below are the whole story; the Building & deploying chapter explains each in depth.

1. Reference the SDK. One NuGet package, TradeStrike.Sdk, brings in every contract assembly you need. You compile against pure contracts — interfaces, base classes and data records — never the engine itself.
2. Implement a contract. Subclass IndicatorBase, Strategy, DrawingToolBase, or implement a factory interface such as IDataProviderFactory or ITradingProvider. The host constructs your type with a public constructor before applying any settings.
3. Build & deploy. Output a net10.0 DLL and copy it — just the DLL — into the host's Plugins folder. An MSBuild target shipped in the SDK can do this for you on every build.
4. Restart TradeStrike. The plugin loader scans the folder, discovers your types by the interfaces they implement, and registers them into the relevant catalog. Your tool now appears in the UI alongside the built-ins.

The pipeline at a glance

Everything is built on a small, allocation-conscious core. Two value types underpin the whole platform — a bar and a tick — and every plugin kind is a contract that produces or consumes them.

C#// One OHLCV bar — passed by value through the whole pipeline.
public readonly record struct Bar(
    DateTime StartUtc, DateTime EndUtc,
    double Open, double High, double Low, double Close,
    long Volume, long TickCount);

The flow reads left to right: connections produce ticks; bar builders aggregate ticks into bars; indicators and strategies read the bar series and emit plots, signals and orders; the chart renders plots and drawing tools. Each layer is a contract you can plug into, and the SDK reference maps the full surface.

Conventions used in this guide