We rewrite cTrader cBots as TradeStation strategies and cTrader indicators as EasyLanguage indicators, ShowMe and PaintBar studies — moving the logic from C# to EasyLanguage, rebuilding orders, sizes and stops for your TradeStation account, and checking the result against criteria agreed with you.
Indicators.ExponentialMovingAverage(…, 21)Value1 = XAverage(Close, 21);[Output("EMA")] IndicatorDataSeries EmaPlot1(Value1, "EMA");ExecuteMarketOrder(TradeType.Sell, …, "SE")Sell Short ("SE") next bar at market;… stopLossPips: 20, takeProfitPips: 40Buy To Cover … StopPx stop; … TargetPx limit;Same short trade — SL and TP in pips become exit orders; the entry is rebuilt for the next bar
cTrader to TradeStation conversion means rewriting C# code written for cTrader in EasyLanguage: a cBot becomes a TradeStation strategy, and an indicator becomes a TradeStation indicator — or a ShowMe or PaintBar study, when it marks bars rather than plotting lines. The language changes along with the platform, so the logic is rebuilt rather than copied. cTrader brokers mostly offer forex and CFDs, while TradeStation is used mainly for US stocks, ETFs and futures, so a cBot usually moves to a different market; trade sizes, price distances and sessions are then adapted as well.
| In cTrader | In TradeStation | Carries over |
|---|---|---|
| Indicator outputs | Indicator with numbered plots | Yes |
| Icons and text drawn on bars | ShowMe study or drawing objects | Yes |
| Clouds between lines | Two plots | PartlyHow the area between them is shown is agreed |
| Classes and helper methods | EasyLanguage functions and methods | YesRestructured where EasyLanguage works differently |
| cBot | Strategy | YesOrders, sizes and positions are rebuilt |
| Running in cTrader Cloud | TradeStation Desktop, on your computer or a VPS | NoWhere the strategy runs is agreed |
A cBot and a TradeStation strategy both trade automatically, but they react to data, size trades and track positions differently. Converting a cBot keeps its trading rules and rebuilds its trade handling for TradeStation.
Market and pending orders, modifications and closes become Buy, Sell Short, Sell and Buy to Cover orders with entry names — including scaling in, partial closes, exits tied to an entry and reversals. cBots find their positions by label; a TradeStation strategy holds one position at a time — long, short or flat — so a cBot that keeps long and short positions open together on a hedging account has that logic redesigned and agreed with you.
cTrader pending orders stay until filled, cancelled or expired; EasyLanguage stop and limit orders last one bar and are sent again on every bar they should stay active. When each order becomes active and is cancelled is rebuilt and checked against the agreed criteria.
Stop-loss and take-profit set in pips become stop and limit exit orders or TradeStation’s built-in stops, which are set in dollars. cBot stops can trigger on the opposite side of the price or after two consecutive quotes; these rules are checked separately and, where needed, rebuilt in the code or agreed as a deviation, so stop behaviour is checked, not only the distance. Trailing stops and breakeven are rebuilt the same way.
Volume in units becomes shares or contracts for the TradeStation symbol — fixed, or calculated in the code from a dollar amount or your risk rules. If the market changes, say from a US500 CFD to ES futures, the size is recalculated for the new contract rather than copied.
In cBots, OnBar runs as a new bar opens and OnBarClosed reads the last closed bar — both wait for the next bar’s first tick — and OnTick runs on every tick. A strategy calculates on bar close unless intrabar order generation is on, so tick logic is rebuilt with intrabar order generation and variables kept with IntrabarPersist; on charts with more than one data stream intrabar order generation isn’t available, so the approach is agreed for each strategy.
Logic in position events — a position opening, or closing at a stop, at a target or by hand — is rebuilt with checks of the strategy’s position, or with order updates where the cBot needs fill details or the reason a position closed; the approach follows the original code. Timers become EasyLanguage timer objects, which run in real time.
TradeStation backtest results won’t match cTrader’s backtest exactly: the platforms use different data — usually for a different instrument — and model fills differently. We choose how intrabar history is calculated and filled for each strategy and check that entries and exits follow the agreed rules.
Converting a cTrader indicator means rebuilding its calculations in EasyLanguage and everything it shows on the chart. We convert standard, custom and multi-timeframe indicators, as well as panels and dashboards.
Outputs become numbered plots with their line, histogram or dot style, and colours that change from bar to bar are set plot by plot. Clouds between two lines become two plots; how the area between them is shown is agreed in advance.
Icons and text drawn on bars become a ShowMe study or drawing objects, and logic that colours bars becomes a PaintBar study.
Bars requested for other timeframes or symbols become additional data streams on the chart, such as Data2, or price series in the code — keeping the original’s behaviour, forming or confirmed values. We also check the original for future-data leakage and agree any corrections before conversion.
cTrader series count from the oldest bar, while EasyLanguage reads values back from the current bar — Close[1] is the previous bar — so every index is rewritten and checked. MaxBarsBack and warm-up history are set so values start the same way as in cTrader.
Tick, Renko and range charts are TradeStation chart types, and minute intervals of any length are supported; bars can form slightly differently, so values are checked. Where the logic depends on Heikin-Ashi candles, their values are calculated in the code.
Alerts, sounds and notifications become TradeStation alerts, and new settings or functions can be added on request.
cTrader and TradeStation usually trade different instruments, use different languages and run code in different ways. These are the differences that decide whether a converted script behaves like the original — and what we do about each of them.
C# on cTrader’s Automate API, with classes, collections and .NET libraries
EasyLanguage — a bar-by-bar language with its own functions and objects
We keep the logic and restructure the code for EasyLanguage; .NET libraries are rewritten or replaced one by one.
Forex, CFDs and other symbols from your cTrader broker
US stocks, ETFs and futures through TradeStation
If the instrument changes, we agree which one replaces each cTrader symbol and adapt sizes, price distances and sessions.
Volume in units, from the symbol’s lot size and volume step
Shares or contracts — fixed, or from a dollar amount per trade
Sizes are recalculated for the TradeStation symbol and checked against your risk rules.
Positions found by label, on a hedging or netting account
One strategy position — long, short or flat — built from named entries
Each entry and its exits are mapped to TradeStation’s strategy position, with account synchronisation agreed separately; hedged positions are redesigned, and we agree how the strategy works alongside manual trades and positions already open at start.
OnBar as a new bar opens and OnBarClosed for the last closed bar — both wait for the next bar’s first tick; OnTick for each tick
Strategies calculate on bar close unless intrabar order generation is on
We match which bar each piece of logic reads — forming or closed — and when orders are sent, and check intrabar behaviour.
The cBot’s time zone setting and the symbol’s sessions
Bar times follow the chart’s setting — local or exchange time
We compare sessions, bar timestamps and the time zone each version’s logic uses — matching chart clocks alone isn’t enough.
cTrader backtesting on tick data or bar data
Look-Inside-Bar Back-testing for intrabar fills
We choose how intrabar history is calculated and filled for each strategy, so both backtests are compared on similar assumptions.
Some things depend on the platform itself: forex and CFD symbols the cBot trades, which TradeStation may not offer; cTrader Cloud, which has no TradeStation counterpart; and .NET libraries, web requests and file access, which are checked one by one. A TradeStation strategy trades the symbol of its chart: a cBot that trades several symbols independently can run as separate strategies, but if a signal on one instrument drives orders on another, or a shared risk limit applies, how the parts work together and how they are tested is agreed separately. We point these out before work starts and agree the closest TradeStation equivalent with you.
A converter or an AI pass can turn C# into EasyLanguage quickly. The risk is not the tool but an unchecked result: code can compile and still trade differently, because the two languages work differently and cTrader and TradeStation place orders, size trades and hold positions differently. We start from how the cTrader version behaves and rebuild it in EasyLanguage.
| Automatic conversion | Manual conversion at Nordman Algorithms | |
|---|---|---|
| Starting point | Often the C# code, statement by statement | How the cTrader version behaves |
| Platform differences | Often found later, if at all | Identified before work starts and agreed with you |
| Orders and positions | Units, pips and labelled positions copied as they are | Rebuilt for TradeStation’s order statements, sizes and one strategy position |
Send it to us — we review it and give you a fixed price and timeline before work starts.
We run the cTrader original and the TradeStation version on the same timeframe, with matching trading sessions and bar timestamps, and compare them against acceptance criteria agreed with you:
If the instrument stays the same, we compare values and signal timing directly. If it changes — say, from a CFD to a futures contract — the data differ, so we check that the agreed rules are followed and the risk is recalculated correctly, rather than expecting identical values or trades. If something doesn’t match, we find the cause — price data, platform behaviour or the code.
Share the cBot or indicator source — the .cs files or an .algo file saved with source — any libraries it uses and your settings, plus a short description.
You sendSource + dependenciesWe analyse the code, check it for future-data leakage, agree the TradeStation symbols and sessions — the same market or a new one — and how hedged positions or multi-symbol logic will work, then agree settings, acceptance criteria, price and timeline.
You getFixed price + criteriaThe cBot or indicator is rebuilt as a TradeStation strategy, indicator or study, including any extra features you asked for.
We buildThe TradeStation versionThe TradeStation version is checked against the acceptance criteria agreed in step 2.
We checkValues, signals, tradesBugs and differences from the agreed specification are fixed after delivery.
You getSource in an .ELD fileEvery cBot and indicator is reviewed before we quote. These are the main factors.
How much logic the code contains, including its classes and helper methods.
For cBots: pending orders, labels, hedged positions, stops, scaling and partial closes.
Which TradeStation symbols the strategy will trade, and data from other timeframes or symbols.
Outputs, clouds, icons, text and panels drawn on the chart.
Each .NET library, web request and file the code uses is checked and rewritten or replaced.
Conversion needs the source. An .algo file saved without source can’t be read, so recreating the cBot from your description is assessed separately.
No. TradeStation runs EasyLanguage, not C#; cBots and cTrader indicators have to be rewritten.
Yes. The cBot’s trading rules are kept and its trade handling is rebuilt for TradeStation — orders, shares or contracts, stops and the strategy’s position — with sizing and risk agreed with you.
TradeStation is used mainly for US stocks, ETFs and futures, so a forex or CFD cBot usually moves to a related market — say, from a US500 CFD to ES futures. Sizes, price distances and sessions are adapted, and how the strategy behaves there is checked against the agreed rules; a different market can give different results.
Not as it is. A TradeStation strategy holds one position — long, short or flat — and an opposite order closes or reverses it, so logic that keeps long and short positions open together on a cTrader hedging account has to be redesigned. How is agreed before work starts.
Clouds between two lines become two plots, icons and text drawn on bars become a ShowMe study or drawing objects, logic that colours bars becomes a PaintBar study, and panels are rebuilt with drawing objects and text. The agreed information is kept, and the look is agreed separately.
A TradeStation strategy runs in TradeStation Desktop — on your computer or a VPS — so where it will run is agreed before work starts.
On the same market, values can come close but not always match exactly: your cTrader broker and TradeStation provide different data, and starting values depend on the history each platform loads. If the instrument changes, identical values aren’t the goal — we check that the agreed rules are followed and the risk is recalculated correctly.
Yes. EasyLanguage indicators and strategies can be rewritten in C# as cTrader indicators and cBots; parts that rely on TradeStation-only features are agreed before work starts.
It depends on the size of the code, the trade handling, data from other timeframes or symbols, visual elements and any libraries or web requests. After reviewing your cTrader code we give you a fixed price and an estimated timeline before work starts.
Share the cBot or indicator source with the libraries it uses, and a short description of what it should do in TradeStation and which symbols it should trade. We will review it and give you a fixed price and timeline before work starts.