Calculations & Plots
Calculations are rebuilt in NinjaScript; numbered plots become NinjaTrader plots, including colours that change from bar to bar.
TradeStation → NinjaTrader Conversion
Convert TradeStation Indicators & Strategies to NinjaTrader
We rewrite EasyLanguage indicators, ShowMe and PaintBar studies and strategies in NinjaScript — matching orders, fills, data streams and sessions to NinjaTrader, and checking the result against criteria agreed with you.
TradeStation Indicator to NinjaTraderTradeStation Strategy to NinjaTraderEasyLanguage to NinjaScriptRewritten by Hand
3,000+ Projects Delivered
Fixed Scope & Price Before Work
Full NinjaScript Source Code
Checked Against Agreed Criteria
EasyLanguageNinjaScript
Value1 = XAverage(Close, 21);EMA(Close, 21)[0]Plot1(Value1, "EMA");AddPlot(Brushes.DodgerBlue, "EMA")Close of Data2Closes[1][0]Buy ("LE") next bar at market;EnterLong(qty, "LE")Same ShowMe and PaintBar logic, rebuilt for NinjaTrader 8
Overview
What TradeStation to NinjaTrader Conversion Means
TradeStation to NinjaTrader conversion means rewriting EasyLanguage code in NinjaScript, NinjaTrader’s C#-based language. Both platforms backtest strategies and trade them automatically, but they handle orders, intrabar fills, additional data streams and sessions differently — so the logic is rebuilt for NinjaTrader, not translated line by line.
- From
- EasyLanguage on TradeStation
- To
- NinjaScript (C#) on NinjaTrader 8
- Indicator or study
- NinjaScript indicator
- Strategy
- NinjaTrader strategy
- You receive
- NinjaScript source code and everything needed to run it
- Method
- Rewritten by hand, no automatic converters
What each part of your EasyLanguage code becomes
| In TradeStation | In NinjaTrader | Carries over |
|---|---|---|
| Indicator | NinjaScript indicator with plots | Yes |
| ShowMe study | Indicator that draws markers on bars | Yes |
| PaintBar study | Indicator that colours bars | Yes |
| Function | Shared method or NinjaScript indicator | Yes |
| Strategy | NinjaTrader strategy | YesOrders and fills are rebuilt |
| RadarScreen columns | Market Analyzer columns | PartlyAgreed column by column |
Indicators & studies
Convert a TradeStation Indicator to NinjaTrader
Converting a TradeStation indicator means rebuilding its calculations in NinjaScript and everything it shows on the chart. We convert indicators, ShowMe and PaintBar studies, functions and multi-data indicators.
ShowMe & PaintBar
ShowMe dots become markers drawn on bars, and PaintBar colouring becomes bar colours in NinjaTrader.
Additional Data Streams
Data2 and other streams become extra data series, keeping the original’s behaviour — from the forming bar or from confirmed bars only.
Functions & Initialization
Functions become shared methods or indicators; series functions, which update on every bar even inside a condition that didn’t run, keep that behaviour. Starting values, warm-up history and when each data series is ready are rebuilt so calculations line up.
Built-In Functions
Calls such as XAverage use NinjaTrader’s own indicators where their values match; where the platforms calculate differently, we write the calculation ourselves.
Alerts & RadarScreen
Alert conditions become NinjaTrader alerts, and RadarScreen columns can become Market Analyzer columns.
Strategies
Convert a TradeStation Strategy to a NinjaTrader Strategy
A TradeStation strategy and a NinjaTrader strategy both backtest and trade automatically, but they phrase orders, apply stops and model fills differently. Converting a strategy keeps its rules and maps its orders to NinjaTrader.
Entries & Exits
Buy, Sell, Sell Short and Buy to Cover orders with their entry names become NinjaScript entries and exits with signal names — including exits tied to a named entry and pyramiding settings.
Order Timing
“Next bar” market, stop and limit orders and “this bar on close” orders are mapped to NinjaTrader’s order methods — including when each order becomes active, how long it stays and when it is cancelled — and trade timing is checked against the agreed criteria.
Built-In Stops
Stop loss, profit target, breakeven and trailing stops are rebuilt with NinjaTrader’s stop methods, keeping whether each was set per contract or for the whole position.
Intrabar Order Generation
Real-time calculation frequency, intrabar conditions on history and the way fills are modelled are handled separately, and the method is chosen for each strategy — no single NinjaTrader setting reproduces them all. Variables kept with IntrabarPersist are rebuilt so their changes inside the bar behave the same way.
Position & Sizing
Trade size becomes contracts or shares, checked against your risk rules; how the strategy works alongside other strategies, manual trades and positions already open at start is agreed in advance.
Instruments & Sessions
Continuous symbols such as @ES are matched to a contract month, and session templates and time-based rules to NinjaTrader’s trading hours.
Strategy Analyzer results won’t match TradeStation’s backtest exactly: the platforms use different data and model intrabar fills differently. We choose how intrabar history is calculated and filled for each strategy and check that entries and exits follow the agreed rules. ATM-based versions are checked on simulation or in Playback, as ATM strategies don’t run in backtests.
Platform differences
EasyLanguage to NinjaScript: What Changes and How We Handle It
TradeStation and NinjaTrader 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.
Price data
TradeStation’s own data
Your NinjaTrader data connection
We take the data difference into account and agree with you how closely values must match.
Futures symbols
Continuous symbols such as @ES
A specific contract month; history depends on the merge setting
We compare on the same contract and agree how rollover and history are handled.
Time and sessions
Bar times follow the chart’s setting — local or exchange time
The trading hours template and the platform time zone
We compare sessions, bar timestamps and the time zone each version’s logic uses — matching chart clocks alone isn’t enough.
Calculation
Strategies calculate on bar close unless intrabar order generation is on
Calculation mode is set per script; on history, bars are processed on close unless intrabar data is added
We keep the original’s timing and check historical and real-time behaviour separately.
Historical fills
Look-Inside-Bar Back-testing for intrabar fills on history
Order fill resolution, or an extra tick series where a strategy uses several data series
We choose how intrabar history is calculated and filled for each strategy, so both backtests are compared on similar assumptions.
Additional data streams
Data2, Data3 and so on, on the same chart
Extra data series, processed bar by bar in turn
Values from other streams are aligned with the chart’s bars, as in the original.
Starting the calculation
MaxBarsBack sets the history needed before calculation starts
Calculation runs from the first bar; the bars required only delay plotting and trading
We rebuild starting values, warm-up history and readiness checks for each series, so calculations line up.
What may not carry over one to one
Some things depend on the platform itself: protected .ELD files can’t be opened without the original code; DLL calls and global variables used by EasyLanguage are checked one by one; and data available only in TradeStation, such as some fundamental fields, has no NinjaTrader equivalent. We point these out before work starts and agree the closest NinjaTrader equivalent with you.
Why manual
Manual vs. Automatic Conversion
A converter or an AI pass can produce NinjaScript quickly. The risk is not the tool but an unchecked result: code can compile and still trade differently, because TradeStation and NinjaTrader phrase orders, apply stops and model fills differently. We start from how the TradeStation version behaves and rebuild it in NinjaScript.
| Automatic conversion | Manual conversion at Nordman Algorithms | |
|---|---|---|
| Starting point | Often the EasyLanguage syntax, statement by statement | How the TradeStation version behaves |
| Platform differences | Often found later, if at all | Identified before work starts and agreed with you |
| Orders and fills | Order statements and stop settings carried over as they are | Rebuilt for NinjaTrader’s order methods and fill settings |
Where unchecked conversions usually go wrong
- Orders a bar early or late“Next bar” and “this bar on close” orders map to NinjaTrader differently; mapped wrongly, trades shift by a bar or orders stay active too long.
- Stops in the wrong modeTradeStation’s built-in stops can be set per contract or for the whole position; copied in the wrong mode, the stop distance changes with position size.
- Intrabar fills assumed differentlyLook-Inside-Bar Back-testing and NinjaTrader’s ways of filling inside the bar work differently; compared without matching them, results drift apart.
- Values that start differentlyMaxBarsBack, warm-up history and averages such as XAverage decide how values start; rebuilt differently, they drift away from the original.
- Signals on the wrong data seriesData2 logic needs the matching NinjaTrader series; NinjaScript runs the code for each series in turn, and logic that doesn’t check which one is updating acts on the wrong one.
- Time rules shiftedBar times in TradeStation follow the chart’s local or exchange time setting; carried over unchecked, session filters fire at the wrong time.
Have a TradeStation indicator or strategy you want in NinjaTrader?
Send it to us — we review it and give you a fixed price and timeline before work starts.
Checking the result
How We Check the Converted Script
We run the TradeStation original and the NinjaTrader version on the same instrument and timeframe, with matching trading sessions and bar timestamps, and compare them against acceptance criteria agreed with you:
- Calculated values on selected bars
- Signal timing — on which bar a signal appears, inside the bar or after it closes
- Entry and exit conditions for strategies
- Agreed deviations — differences accepted in advance, such as visual layout or broker-specific execution
If something doesn’t match, we find the cause — price data, platform behaviour or the code — and check the result against the agreed specification.
What you receive
- NinjaScript source code — the full code of the indicator or strategy
- Everything needed to run it in NinjaTrader 8; we help with installation if you need it
- Settings agreed with you before work starts
- Fixes for bugs and differences from the agreed specification after delivery
Process
How a TradeStation to NinjaTrader Conversion Works
Send the EasyLanguage code
Export the indicator or strategy as an unprotected .ELD file — or send the code as text — with the functions it calls and your strategy settings, plus a short description.
You sendSource + functionsReview and fixed quote
We analyse the code, point out anything that works differently in NinjaTrader, and agree the instrument, sessions, historical fill settings, acceptance criteria, price and timeline.
You getFixed price + criteriaRewrite in NinjaScript
The indicator or strategy is rebuilt in NinjaScript, including any extra features you asked for.
We buildThe NinjaTrader versionCheck against the criteria
The NinjaTrader version is checked against the acceptance criteria agreed in step 2.
We checkValues, signals, tradesDelivery and support
Bugs and differences from the agreed specification are fixed after delivery.
You getSource + files to run
Scope
What Affects the Price and Timeline
Every indicator and strategy is reviewed before we quote. These are the main factors.
Size of the Code
How much logic the code contains, including the functions it calls.
Strategy Logic
For strategies: order types, built-in stops, intrabar order generation and pyramiding.
Additional Data Streams
Data2 and other streams the code uses.
Visual Elements
ShowMe and PaintBar studies, drawings and text on the chart.
DLLs & Global Variables
External DLL calls and global variables — each is checked and replaced where needed.
Protected .ELD File?
Conversion needs unprotected code. Without it, recreating the indicator or strategy from your description is assessed separately.
★★★★★
"Alexei is the only one who got this project done, i have tried many before him but all of them failed. a professional programmer i can rely on very mature and excellent in communication. really patient and will revise and develop the coding to satisfaction level. …"
★★★★★
"I cannot recommend Nordman Algorithms/Alexei highly enough!!! I have had the pleasure of working with Alexei on a very, very complex program for Ninja Trader for a couple of months and he has made the whole experience extremely pleasurable and seamless. …"
★★★★★
"Did several jobs with Alexei. Absolute top quality. Excellent communication, always happy to explain things and make adjustments as required but above all knows his stuff inside out. Couldn't rate this guy highly enough. Will definitely be working with him again."
FAQ
TradeStation to NinjaTrader Conversion — Common Questions
No. NinjaTrader runs NinjaScript, written in C#; EasyLanguage indicators, studies, functions and strategies have to be rewritten.
Yes. The strategy’s rules are rebuilt as a NinjaTrader strategy, with its entries and exits, built-in stops, sizing and pyramiding settings mapped to NinjaScript and agreed with you.
ShowMe and PaintBar studies become NinjaScript indicators that draw markers or colour bars; functions become shared methods or indicators; RadarScreen columns can become Market Analyzer columns. What carries over is agreed before work starts.
A protected .ELD file doesn’t show its source code, and conversion needs the code. Without it, we can assess recreating the indicator or strategy from your description, settings and examples of how it behaves — but an exact match can’t be promised in advance.
Not always exactly. TradeStation and your NinjaTrader connection provide different data, a continuous symbol such as @ES differs from a contract month, and starting values depend on the bars each platform loads first. How closely values must match is agreed before work starts, and any difference is traced to its cause.
Not exactly. The platforms use different data and model intrabar fills differently, so we choose how intrabar history is calculated and filled for each strategy and check that entries and exits follow the agreed rules. ATM strategies don’t run in backtests, so an ATM version is checked on simulation or in Playback.
No. Our developers write the NinjaScript version themselves, based on how the TradeStation version behaves.
Yes. NinjaScript indicators and strategies can be rewritten in EasyLanguage; parts that rely on NinjaTrader-only features, such as ATM strategies, are agreed before work starts.
It depends on the size of the code, the functions it calls, additional data streams, visual elements and, for strategies, the order logic. After reviewing your EasyLanguage code we give you a fixed price and an estimated timeline before work starts.
Send Your EasyLanguage Code for a Quote
Share an unprotected .ELD file or the code as text, with the functions it uses, and a short description of what it should do in NinjaTrader 8. We will review it and give you a fixed price and timeline before work starts.
Free Technical Assessment
Fixed Price Before Work
Source Code Ownership