Calculations & Plots
Calculations are rebuilt on Quantower’s API; plots become line series, and regions between lines become clouds. Any visual differences are agreed in advance.
NinjaTrader → Quantower Conversion
Convert NinjaTrader Indicators & Strategies to Quantower
Both platforms use C#, but NinjaScript doesn’t run in Quantower as it is. We keep the platform-independent logic, rebuild the parts tied to NinjaTrader’s API for Quantower, and check the result against criteria agreed with you.
NinjaTrader Indicator to QuantowerNinjaScript Strategy to QuantowerNinjaScript to Quantower C#Rewritten by Hand
3,000+ Projects Delivered
Fixed Scope & Price Before Work
Full C# Source Code
Checked Against Agreed Criteria
NinjaScriptC# · Quantower
EMA(Close, 21)[0]Core.Indicators.BuiltIn.EMA(21, PriceType.Close)AddPlot(Brushes.DodgerBlue, "EMA")AddLineSeries("EMA", Color.DodgerBlue, 2)AddDataSeries(BarsPeriodType.Minute, 60)Symbol.GetHistory(Period.HOUR1, …)EnterLong(qty, "L")Core.Instance.PlaceOrder(… Side.Buy …)Same C#, a different API — platform code rebuilt for Quantower
Overview
What NinjaTrader to Quantower Conversion Means
NinjaTrader to Quantower conversion means rebuilding a NinjaScript indicator or strategy on Quantower’s C# API: an indicator becomes a Quantower indicator and a strategy becomes a Quantower strategy. Both platforms use C#, but their APIs differ — in events, data access, drawing and order handling — so the code can’t simply be run in Quantower. Platform-independent calculations and classes can often be kept; the parts tied to NinjaTrader’s API, events, data and trading are rebuilt for Quantower.
- From
- NinjaScript (C#) on NinjaTrader 8
- To
- C# on Quantower’s API
- Indicator
- Quantower indicator
- Strategy
- Quantower strategy
- You receive
- C# source code and everything needed to run it
- Method
- Independent logic kept, platform code rebuilt by hand
Indicators
Convert a NinjaTrader Indicator to Quantower
Converting a NinjaTrader indicator to Quantower means rebuilding its calculations, data series and drawing on Quantower’s API. We convert standard, custom, multi-series and order-flow indicators, as well as panels and dashboards.
Custom Rendering
Charts drawn in OnRender with SharpDX are redrawn with Quantower’s own chart painting; the agreed information is kept and the look is agreed separately.
Additional Data Series
Logic built on extra data series and BarsInProgress is rebuilt with history loaded separately for each period or symbol, aligned to the chart.
Order-Flow Data
Indicators built on NinjaTrader’s volumetric data are rebuilt on Quantower’s volume analysis data. We check what your connection provides — trade volumes, buy and sell classification, history, price-level aggregation and sessions — because tick data alone doesn’t make the values equivalent.
Built-In Indicators
Calls to NinjaTrader’s built-in indicators use Quantower’s own versions where their values match; where the platforms calculate differently, we write the calculation ourselves.
Alerts & Improvements
Alert conditions are built into the Quantower version, and new settings or functions can be added on request.
Strategies
Convert a NinjaScript Strategy to a Quantower Strategy
A NinjaScript strategy and a Quantower strategy both place real orders, but they receive data, send orders and track positions differently. Converting a strategy keeps its rules and rebuilds its trade handling for Quantower and your connection.
Entries & Exits
Managed or unmanaged NinjaScript order logic is rebuilt with Quantower’s trading methods — including named entries, scaling in, partial exits and exits tied to specific entries.
ATM Strategies
Trade management that relies on NinjaTrader ATM strategies — stops, targets, trailing and scaling out — is rebuilt as the strategy’s own protective orders and rules.
Positions & Connection
Position handling depends on your Quantower connection, so it is checked and agreed — together with how the strategy runs alongside other strategies and manual trades, and what it does if a position is already open at start.
Calculation Mode
Logic written for on-bar-close, on-each-tick or on-price-change is mapped to Quantower’s update events; on-price-change gets an explicit filter that skips updates at an unchanged price.
Sessions & Instruments
NinjaTrader trading hours templates and instrument settings are matched to your connection’s session settings and symbols, including futures contract months. A template decides which data the chart uses, so the RTH or ETH data set, bar and trading-day boundaries and session resets are checked.
Filters & Conditions
Trading sessions and days, time limits and other filters are kept, and new ones can be added.
A regular NinjaScript strategy is compared with the Quantower version on history and in real time. ATM-based logic doesn’t run on history in NinjaTrader, so its original behaviour is compared on Simulation or Playback, and whether the Quantower version can be tested on history is checked separately. Either way, results won’t match exactly: the platforms can use different data and model fills differently, so we check that entries and exits follow the agreed rules.
Platform differences
NinjaScript to Quantower C#: What Changes and How We Handle It
NinjaTrader and Quantower run C# 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.
Language and API
NinjaScript — C# on NinjaTrader’s API
C# on Quantower’s API
Platform-independent calculations and classes can often be kept; code tied to NinjaTrader’s API, events, data and trading is adapted for Quantower.
Calculation
OnBarUpdate with a calculation mode per script; history processed on bar close unless intrabar data is added
Updates on history, new bars and ticks, with the reason passed to the code
We map each calculation mode to Quantower’s update events and check historical and real-time behaviour separately.
Additional data series
Added as extra series and handled by BarsInProgress
History loaded separately for each period or symbol
Values from other series are aligned with the chart’s bars, as in the original.
Orders
Managed or unmanaged order methods; ATM strategies
Orders through your connection, with the order types it supports
We rebuild order handling — and any ATM-based management — as the strategy’s own rules.
Positions
The strategy’s position, tracked separately from the account’s
Position handling depends on your connection
We agree how the strategy works alongside other strategies, manual trades and positions already open at start.
Drawing and rendering
Plots, drawing methods and SharpDX rendering
Line series, clouds, markers and chart painting
We keep the agreed information and functions; complex custom rendering may be simplified, and the look is agreed with you.
Sessions and data
Trading hours templates and your NinjaTrader data connection
Session settings and data of your Quantower connection
We compare sessions and bar timestamps; small differences between data feeds are traced to their cause.
What may not carry over one to one
Some things depend on the platform itself: order-flow indicators depend on the data your Quantower connection provides and on how each platform classifies trades and aggregates price levels; NinjaTrader add-ons and third-party indicators the code relies on need their source or a replacement; and ATM templates have no direct Quantower equivalent. We point these out before work starts and agree the closest Quantower equivalent with you.
Same language, different platform
Why the Same Language Isn’t Enough
Because both platforms use C#, it is tempting to copy the code across and swap the calls. The risk is an unchecked result: the code can compile and still behave differently, because the two platforms call it at different moments and handle data and orders differently. We start from how the NinjaTrader version behaves, keep the platform-independent logic and rebuild what depends on NinjaTrader’s API.
| Automatic conversion | Manual conversion at Nordman Algorithms | |
|---|---|---|
| Starting point | Often the C# code copied across, with NinjaScript calls swapped | How the NinjaTrader version behaves |
| Platform differences | Often found later, if at all | Identified before work starts and agreed with you |
| Orders and ATM | NinjaScript order methods and ATM logic carried over as they are | Rebuilt as orders and rules for your Quantower connection |
Where unchecked conversions usually go wrong
- Same C#, different APICode that compiles after renaming calls can still run at different moments — Quantower calls an indicator for history, new bars and ticks, each with its own reason.
- Signals on the wrong data seriesNinjaScript logic that switches on BarsInProgress has to be rebuilt when other series are loaded separately; missed, values come from the wrong series.
- ATM management lostStops, targets and trailing left to an ATM strategy disappear unless they are rebuilt as the strategy’s own rules.
- Order-flow values that don’t matchDelta can be calculated in different ways, and volumes depend on how trades are classified and price levels aggregated; values differ unless the data and settings are matched.
- Signals that change after the factValues calculated on the forming bar look stable on history but repaint in real time.
- Trades at the wrong momentWhen a signal is calculated, when the order is sent and when it fills depend on the order type and settings on each platform; transferred wrongly, they shift entries and exits.
Have a NinjaTrader indicator or strategy you want in Quantower?
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 NinjaTrader original and the Quantower 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
- Volumes, delta and price-level values for order-flow indicators
- 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
- C# source code — the full code of the indicator or strategy
- Everything needed to run it in Quantower; 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 NinjaTrader to Quantower Conversion Works
Send the NinjaScript code
Share the .cs files, any custom indicators or add-ons the code uses, and your strategy settings or ATM templates — plus a short description.
You sendSource + dependenciesReview and fixed quote
We analyse the code, point out anything that works differently in Quantower, agree which connection a strategy will trade through, and agree settings, acceptance criteria, price and timeline.
You getFixed price + criteriaRebuild for Quantower
The indicator or strategy is rebuilt on Quantower’s C# API, including any extra features you asked for.
We buildThe Quantower versionCheck against the criteria
The Quantower 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 and how many parts depend on each other.
Trade Handling
For strategies: order methods, ATM-based management, positions, scaling and partial exits.
Data Series & Order Flow
Additional data series and volumetric or other order-flow data the code uses.
Custom Rendering
Plots, drawings and charts drawn with SharpDX that need Quantower’s chart painting.
Add-Ons & Third-Party Indicators
NinjaTrader add-ons or third-party indicators the code relies on — without their source they need a replacement.
Only a Compiled Assembly?
Conversion needs the .cs source. Without it, recreating the indicator or strategy from your description is assessed separately.
★★★★★
"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. …"
★★★★★
"I asked Nordman Algorithms to write a Ninja Trader add-on script for me to assist in my trading. Alexei was able to complete my project in less than two weeks and did a fantastic job. I had one issue with the script and Alexei immediately corrected the error without any additional charge. …"
★★★★★
"Alexei's knowledge of C# is excellent and he was able to code to my exact requirements. Once the strategy was delivered, he was happy to make any adjustments I needed. I've enjoyed working with Alexei and I am sure we will work again."
FAQ
NinjaTrader to Quantower Conversion — Common Questions
No. NinjaScript is C# written against NinjaTrader’s own API, and Quantower has a different API — different events, data access, drawing and order handling. Platform-independent calculations can often be kept, while the code tied to NinjaTrader’s API is rebuilt for Quantower.
Yes. The strategy’s rules are rebuilt as a Quantower strategy that places orders through your connection, with position sizing, protective orders and any extra trade management agreed with you.
Quantower doesn’t run NinjaTrader ATM strategies. Trade management that relies on them — stops, targets, trailing and scaling out — is rebuilt as the strategy’s own protective orders and rules. Because ATM strategies don’t run on history in NinjaTrader, the original behaviour is compared on Simulation or Playback.
They can be rebuilt on Quantower’s volume analysis data. Whether the values match depends on what your connection provides — trade volumes, buy and sell classification, history, price-level aggregation and sessions — and on how each platform calculates delta, so this is checked rather than assumed.
Not always exactly. Your NinjaTrader and Quantower connections can provide different data, sessions can be set up differently, and some built-in indicators are calculated slightly differently. How closely values must match is agreed before work starts, and any difference is traced to its cause.
Yes. For indicators, the connection decides which symbols, history and volume data are available. For strategies, it also decides the order types, execution and position handling. We agree the connection before work starts and build for it.
Conversion needs the .cs source 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 with the original can’t be promised in advance.
Yes. Quantower indicators and strategies can be rebuilt in NinjaScript; parts that rely on Quantower-only features are agreed before work starts.
It depends on the size of the code, the trade handling, custom rendering, the data series and order-flow data involved and any add-ons the code relies on. After reviewing your NinjaScript code we give you a fixed price and an estimated timeline before work starts.
Send Your NinjaScript Code for a Quote
Share the .cs files with any custom indicators or add-ons they use, and a short description of what the indicator or strategy does. 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