Plots, Clouds & Painted Bars
Plots become NinjaTrader plots, clouds become regions between lines, and painted price bars become bar colours. Any visual differences are agreed in advance.
thinkorswim → NinjaTrader Conversion
Convert thinkorswim Studies & Strategies to NinjaTrader
We rewrite thinkScript studies and strategies in NinjaScript — so a strategy that only backtests in thinkorswim can trade your account in NinjaTrader. The result is checked against criteria agreed with you.
thinkorswim Study to NinjaTraderthinkScript Strategy to NinjaTraderthinkScript to NinjaScriptRewritten by Hand
3,000+ Projects Delivered
Fixed Scope & Price Before Work
Full NinjaScript Source Code
Checked Against Agreed Criteria
thinkScriptNinjaScript
def ema = ExpAverage(close, 21);EMA(Close, 21)[0]plot EMA = ema;AddPlot(Brushes.DodgerBlue, "EMA")AddCloud(fast, slow, Color.GREEN, Color.RED);Draw.Region(this, "Cloud", …)AddOrder(OrderType.BUY_AUTO, cond);EnterLong(…) or ExitShort(…), as in the originalSame logic, rebuilt for NinjaTrader 8 — where a strategy can trade your account
Overview
What thinkorswim to NinjaTrader Conversion Means
thinkorswim to NinjaTrader conversion means rewriting thinkScript code in NinjaScript, NinjaTrader’s C#-based language: a study becomes a NinjaScript indicator, and a strategy — which in thinkorswim places simulated orders for backtesting — becomes a NinjaTrader strategy that can trade your account. Custom watchlist columns and scan conditions can be rebuilt as well. The two languages handle bars, time and orders differently, so the logic is rebuilt, not translated line by line.
- From
- thinkScript on thinkorswim
- To
- NinjaScript (C#) on NinjaTrader 8
- Study
- NinjaScript indicator
- Strategy
- NinjaTrader strategy that can trade
- You receive
- NinjaScript source code and everything needed to run it
- Method
- Rewritten by hand, no automatic converters
Studies
Convert a thinkorswim Study to a NinjaTrader Indicator
Converting a thinkorswim study means rebuilding its calculations in NinjaScript and everything it shows on the chart. We convert standard and custom studies, multi-timeframe studies, and watchlist columns.
Secondary Aggregations
Data requested from other periods becomes extra data series, keeping the original’s behaviour — from the forming bar or from confirmed bars only.
Initialization & Recursive Calculations
Starting values, the history prefetched for averages such as ExpAverage and WildersAverage, and values built with CompoundValue or fold are rebuilt to start the same way as the original.
Labels & Chart Bubbles
Labels and chart bubbles become drawing objects or on-chart panels; the agreed information is kept and the look is agreed separately.
Alerts & Notifications
Alert conditions become NinjaTrader alerts with sound, and other notifications where needed.
Watchlist Columns & Scans
Custom watchlist columns can become Market Analyzer columns, and scan conditions can be rebuilt to watch a list of instruments.
Strategies
Convert a thinkScript Strategy to a NinjaTrader Strategy
In thinkorswim, a strategy places simulated orders on the chart for backtesting. In NinjaTrader, the same rules become a strategy that places real orders on your account. This is what changes.
| thinkorswim strategy | NinjaTrader strategy | |
|---|---|---|
| Trading rules — entries, exits, filters | Yes | YesRebuilt in NinjaScript |
| Backtesting | YesOn the chart, with the strategy report | YesStrategy Analyzer, with optimisation |
| Strategy trading on your account | NoStrategy orders are simulated; pre-set conditional orders can be triggered by study conditions separately | YesThe strategy places and manages orders |
| Stops, targets, trailing stop | PartlyExit orders in the strategy’s simulation | YesIn the strategy’s code — or an ATM strategy |
| Price recorded for a trade | The price passed to AddOrder — the next bar’s open by default — whether or not a real order could get it | The actual fill from the market, or the fill modelled by the backtest’s fill rules |
| Watchlist columns and scans | Yes | PartlyMarket Analyzer columns and conditions |
Entries & Exits
AddOrder entries and exits are rebuilt with NinjaScript order methods — including reversals, scaling in, partial exits and exits tied to specific entries.
Position Sizing
The trade size from the strategy settings or AddOrder becomes contracts or shares, checked against your risk rules.
Instruments & Sessions
/ES-style continuous symbols are matched to a contract month, and time-based logic is matched function by function to NinjaTrader’s trading hours.
Strategy Analyzer results won’t match the thinkorswim strategy report exactly: the platforms use different data and fill rules, and thinkorswim records whatever price a strategy passes to AddOrder. We check that entries and exits follow the agreed rules. ATM-based versions are checked on Simulation or Playback, as ATM strategies don’t run in backtests.
Platform differences
thinkScript to NinjaScript: What Changes and How We Handle It
thinkorswim and NinjaTrader run scripts 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
thinkorswim’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
Time functions use their own time zones — SecondsFromTime, for example, works in Eastern 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
Studies update as the current bar forms; strategy orders are generated on bar close
Calculation mode is set per script; on history, bars are processed on close unless intrabar data is added
We agree whether signals act inside the bar or on its close, and check historical and real-time behaviour separately.
Secondary aggregation
Data from another period requested in the expression, within thinkScript’s rules
Added as extra data series and processed bar by bar
We keep the original’s behaviour — forming or confirmed values. We also check the original for future-data leakage and agree any corrections before conversion.
Strategy orders
Simulated by AddOrder, at the next bar’s open by default or at a price you pass
Real orders through your NinjaTrader connection
We build real order handling and agree sizing, protective orders and how fills are expected to work.
Visual elements
Plots, clouds, labels, chart bubbles and painted bars
Plots, regions, drawing objects and bar colours
We keep the agreed information and functions; the look can differ and is agreed with you.
What may not carry over one to one
Some things depend on the platform itself: data available only in thinkorswim, such as some fundamental or options data; built-in studies and functions that NinjaTrader calculates differently or doesn’t have; and the settings of thinkorswim’s strategy report. 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 behave differently, because thinkScript and NinjaScript handle bars, time and orders differently. We start from how the thinkorswim version behaves and rebuild it in NinjaScript.
| Automatic conversion | Manual conversion at Nordman Algorithms | |
|---|---|---|
| Starting point | Often the thinkScript syntax, statement by statement | How the thinkorswim version behaves |
| Platform differences | Often found later, if at all | Identified before work starts and agreed with you |
| Strategies | Simulated AddOrder logic carried over as it is | Real order handling built for NinjaTrader |
Where unchecked conversions usually go wrong
- Backtest prices that can’t be tradedthinkorswim records whatever price a strategy passes to AddOrder; carried over unchecked, the NinjaTrader version is judged against fills a real order couldn’t get.
- Trades a bar early or lateAddOrder fills at the next bar’s open by default; mapped wrongly to NinjaTrader orders, every trade shifts by a bar.
- Recursive values that driftValues built with CompoundValue, and averages that use prefetched history, depend on how the first bars are seeded; seeded differently, they drift away from the original.
- Time rules transferred wronglythinkScript time functions don’t all use the same time zone, so each one in the original is checked; transferred wrongly, session filters, trading dates and session boundaries shift.
- A continuous symbol compared with a contract month/ES and a NinjaTrader contract month have different history, so comparing them hides real differences or invents false ones.
- Signals on the wrong data seriesWith extra data series, NinjaScript runs the code for each series in turn; code that doesn’t check which series is updating acts on the wrong one.
Have a thinkorswim study 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 thinkorswim 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 thinkorswim to NinjaTrader Conversion Works
Send the thinkScript code
Share the study or strategy code and any other studies it references, the strategy’s global settings — trade size and how repeated entries in one direction are handled — and the symbol, aggregation and session settings of your chart, plus screenshots of how it should look and behave.
You sendScript + settingsReview and fixed quote
We analyse the script — including when each signal is actually known — logic whose conditions look at future bars can’t trade as drawn, while the standard open[-1] price in AddOrder is simply the simulated next-bar fill — and agree the instrument, sessions, settings, acceptance criteria, price and timeline.
You getFixed price + criteriaRewrite in NinjaScript
The study or strategy is rebuilt as a NinjaScript indicator or strategy, 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 study and strategy is reviewed before we quote. These are the main factors.
Size of the Script
How much logic the script contains, including recursive values and referenced studies.
Strategy Logic
For strategies: entries, exits, sizing and the order handling that live trading needs.
Secondary Aggregations
Data the script requests from other periods or symbols.
Visual Elements
Clouds, labels, chart bubbles and painted bars.
Watchlist Columns & Scans
Columns and scan conditions to rebuild for NinjaTrader’s Market Analyzer.
Extra Features
Settings, filters or functions you want beyond the original script.
★★★★★
"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."
★★★★★
"I had the pleasure of working with Nordman Algorithms on a custom indicator for NinjaTrader 8, and I couldn't be happier with the results. The customer support was exceptional; responses were prompt, and communication was smooth and consistent throughout the entire process. …"
★★★★★
"Alexei has completed three incremental projects for me. Any clarifications we have required have been well documented and in the debugging process, clear and methodical."
FAQ
thinkorswim to NinjaTrader Conversion — Common Questions
No. NinjaTrader runs NinjaScript, written in C#; thinkScript studies and strategies have to be rewritten.
Yes. A study becomes a NinjaScript indicator with its plots, clouds, labels and alerts; anything that works differently in NinjaTrader is agreed before work starts.
Yes. In thinkorswim a strategy places simulated orders for backtesting; in NinjaTrader it becomes a strategy that places real orders on your account, with sizing, protective orders and trade management agreed with you.
Custom watchlist columns can become NinjaTrader Market Analyzer columns, and scan conditions can be rebuilt to watch a list of instruments. What carries over is agreed before work starts.
Not always exactly. thinkorswim and your NinjaTrader connection provide different data, a continuous futures symbol differs from a contract month, and time-based logic has to be matched. How closely values must match is agreed before work starts, and any difference is traced to its cause.
Yes, when trade management is written in the strategy’s own code: it then runs in NinjaTrader’s Strategy Analyzer for backtesting and optimisation. ATM strategies don’t run in backtests, so an ATM version is checked on a simulation account or in Playback.
No. Our developers write the NinjaScript version themselves, based on how the thinkorswim version behaves.
No — we don’t currently offer conversion into thinkorswim. thinkorswim works as a source platform: studies and strategies can be converted from thinkorswim to NinjaTrader, as on this page, or to MT5.
It depends on the size of the script, secondary aggregations, visual elements and, for strategies, the order logic. After reviewing your thinkScript code we give you a fixed price and an estimated timeline before work starts.
Send Your thinkScript Code for a Quote
Share the study or strategy code 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