Chartsy|One Benchmark

How Chartsy|One speed compares to competition? You'll find out from this article.


We have compared Chartsy|One technical analysis software performance against five most popular competition programs: AmiBroker, Mathematica, MultiCharts, NinjaTrader and Sierra Chart. The performance of each program was determined by measuring the time needed to complete the following challenges:

To learn more about the benchmark details refer to a methodology description section.

Results in numbers

The table shows time to finish each test case in our performance benchmark between finance desktop programs (the smaller the better).


v6.00.2 64-bit

Sierra Chart

v8.0.9.0 64-bit

v11.0.14943 64-bit

Technology Java C/C++ C++ C# .NET C
Importing CSV file
1 million bars
3 s1) 6 s1) 21 s 54 s 35 s
Opening Chart
1 million bars
<2 s <2 s 4 s 159 s 15 s
Calculating H/L
1 million bars
10 ms 11 ms 15 ms 386 ms 31 ms
Calculating SMA(C, 45)
1 million bars
11 ms 17 ms 162 ms 309 ms 1 265 ms 2 474 ms2)
Calculating EMA(C, 45)
1 million bars
8 ms 8 ms 36 ms 291 ms 1 072 ms 2 550 ms
Calculating StdDev(C, 45)
1 million bars
13 ms 39 ms 381 ms 3 932 ms 2 020 ms 6 834 ms
Calculating MEDIAN(C, 45)
1 million bars
114 ms 527 ms 1 425 ms 46 220 ms 3 316 ms
Calculating LLV(L, 255)
1 million bars
26 ms 34 ms 1 317 ms 742 ms 3 546 ms 6 239 ms
Calculating ATR(45)
1 million bars
33 ms 25 ms 152 ms 586 ms 2 817 ms
Backtesting EMA system
1 million bars, 27 350 trades
1 s 6 s 489 s 15 s 51 s
Optimizing above system
100 steps
25 s 144 s 201 s 1 037 s

ms - milliseconds.
s - seconds.
- Not implemented.
1) - Only time to import data into memory measured due to AmiBroker trial version limitations.
2) - The timing obtained using formula FinancialIndicator["SimpleMovingAverage", 45]. Trying alternative formula with MovingAverage function the time was 72 ms.

What's the fastest financial software?

Out of the benchmarked software, Chartsy|One is the leader achieving the best results in almost all categories. The Java technology the program is based on did a pretty good job in speeding up repeatable computations that are common in a finance software like for example indicator calculations and trading system backtests. The benchmark of the trivial moving average crossover trading system reveals that Chartsy|One is able to process more than 1 million bars per second on a single core.

The second in our benchmark is AmiBroker, which has achieved slightly worse but very similar results in our performance tests. Major disadvantage of AmiBroker, however, is that it performs all calculations using 32-bit floating point arithmetic, whereas Chartsy|One and most other programs use 64-bit arithmetic. Using 32-bits for computations is not enough in financial areas, since some assets require more than 7 digits of precision, the maximum achievable using single precision floating-point arithmetic. For instance, a Bitcoin value is measurable to 8 digits after a decimal point and therefore requires double precision arithmetic for proper representation.

The third place was surprisingly hard to pick and it seems that the right answer depends on what features you need most from your trading tool. For example, although Sierra Chart was reasonably fast in indicator speed tests, its backtesting speed was the slowest and it lacks optimization features, what makes it probably not the good choice for all algorithmic oriented traders and investors. On the other hand NinjaTrader performed well in backtesting and optimizing but indicator calculations were a bit slower than in Sierra Chart and more importantly chart opening in NinjaTrader was insanely slow. The platform needed 159 seconds to open 1-million-bar chart and was the slowest one in our benchmark. For investors who for example need to browse a large number of charts daily, working with that platform can become a bit annoying sooner or later. MultiCharts platform has better chart opening times than NinjaTrader but the overall speed was not satisfactory enough to assign it the third place in our horse racing. For example, a simple moving average calculation time was one hundred times (yes, 100×) larger than in Chartsy|One or AmiBroker. It could be a Power Language specifics or a problem with poor design but whatever the reason is, it's just not right. The MultiCharts team certainly can do better.

The biggest surprise in this small speed benchmark in our opinion is Mathematica which performed very poorly across all categories. We deliberately used FinancialIndicator function for all indicator calculations to leverage Mathematica financial Toolkit capabilities and to stay consistent between tests. It's worth to point out however that whenever an alternative function existed for the same calculation it performed much better than FinancialIndicator function. The FinancialIndicator function was always the slowest method to calculate a financial indicator over the data series out of all possible alternatives. It looks like the Mathematica Financial Toolkit was very poorly written, without performance in mind, without speed benchmarks, just to place a checkmark on a features list, which is unfortunate because Mathematica is a really great piece of software after all.


All tests were performed on a computer with Core 2 Duo processor and SSD disk drive, using Windows 10 operating system. The dataset containing 1 044 800 bars of 5-min EUR/USD quotes was used. All indicator timing tests used high resolution timers whenever possible. For each test case 3 rounds with 10 tests were executed, then the longest and the shortest rounds were discarded and the average of timings from the remaining round was taken as a final time measure. The backtester challenge used a simple double exponential moving average crossover system, allowed to taking both long and short positions, with 15-period fast moving average and 45-period slow moving average. The optimizer challenge was setup to execute 100 steps of parameterized crossover system backtest, with slow moving average ranging from 16 to 115, allowing multi-threading if only a software supported it.

Mathematica tests used packed arrays for all indicator tests and tested command set based on FinancialIndicator function.

Sierra Chart tests used manual loops for all indicator tests and the fastest available, bar based backtesting, method for backtests.

Multi Charts tests used fast-execution compilation method for all indicator tests.

The reason to use a fairly old hardware in our performance tests was to cover a wider share of potential end users and to not give too much advantage to a Java technology software. In real scenarios with the newest hardware Java-based software will probably be much faster because of a so-called Just-In-Time compilation, which when running a Java application produces a machine code specific to your processor version. By choosing the older hardware for our benchmark we have put that technology-specific advantage aside and instead focus on other aspects of the software.