This is the OneEurFilter function in C, converted straight from Ehlers’ EasyLanguage code, the comments left in place:

var OneEurFilter(vars Data, int PeriodMin, var Factor)
{
  vars SmoothedDX = series(Data[0],2), 
    Smoothed = series(Data[0],2);
  var Alpha = 2*PI/(4*PI + 10);
//EMA the Delta Price
  SmoothedDX[0] = Alpha*(Data[0]-Data[1]) + (1.-Alpha)*SmoothedDX[1];
//Adjust cutoff period based on a fraction of the rate of change
  var Cutoff = PeriodMin + Factor*abs(SmoothedDX[0]);
//Compute adaptive alpha
  Alpha = 2*PI/(4*PI + Cutoff);
//Adaptive smoothing
  return Smoothed[0] = Alpha*Data[0] + (1.-Alpha)*Smoothed[1];
}

This is how the OneEurFilter (blue line) looks when applied on a ES chart:

The price curve is well reproduced with almost no lag. Cheap, efficient, low-latency — 1 Euro well spent. The code can be downloaded from the 2026 script repository.

A robust trading strategy has to meet several criteria:

• It must exploit a real and significant market inefficiency. Random-walk markets cannot be algo traded.
• It must work in all market situations. A trend follower must survive a mean reverting regime.
• It must work under many different optimization settings and parameter ranges.
• It must be unaffected by random events and price fluctuations.

There are metrics and algorithms to test all this. The robustness under different market situations can be determined through the R2 coefficient or the deviations between the walk forward cycles. The parameter range robustness can be tested with a WFO profile (aka cluster analysis), the price fluctuation robustness with oversampling. A Montecarlo analysis finds out whether the strategy is based on a real market inefficiency.

Some platforms, such as Zorro, have functions for all this. But they require dedicated code in the strategy, often more than for the algorithm itself. In this article I’m going to describe an evaluation framework – a ‘shell’ – that skips the coding part. The evaluation shell is included in the latest Zorro version. It can be simply attached to any strategy script. It makes all strategy variables accessible in a panel and adds stuff that’s common to all strategies – optimization, money management, support for multiple assets and algos, cluster and montecarlo analysis. It evaluates all strategy variants in an automated process and builds the optimal portfolio of combinations from different algorithms, assets, and timeframes. 

The process involves these steps: 

The first step of strategy evaluation is generating sets of parameter settings, named jobs. Any job is a variant of the strategy that you want to test and possibly include in the final portfolio. Parameters can be switches that select between different indicators, or variables (such as timeframes) with optimization ranges. All parameters can be edited in the user interface of the shell, then saved with a mouse click as a job. 

The next step is an automated process that runs through all previously stored jobs, trains and tests any of them with different asset, algo, and time frame combinations, and stores their results in a summary. The summary is a CSV list with the performance metrics of all jobs. It is automatically sorted – the best performing job variants are at the top – and looks like this:

So you can see at a glance which parameter combinations work with which assets and time frames, and which are not worth to examine further. You can repeat this step with different global settings, such as bar period or optimization method, and generate multiple summaries in this way. 

The next step in the process is cluster analysis. Every job in a selected summary is optimized multiple times with different walk-forward settings. The result with any job variant is stored in WFO profiles or heatmaps:

After this process, you likely ended up with a couple survivors in the top of the summary. The surviving jobs have all a positive return, a steady rising equity curve, shallow drawdowns, and robust parameter ranges since they passed the cluster analysis. But any selection process generates selection bias. Your perfect portfolio will likely produce a great backtest, but will it perform equally well in live trading? To find out, you run a Montecarlo analysis, aka ‘Reality Check’.

This is the most important test of all, since it can determine whether your strategy exploits a real market inefficiency. If the Montecarlo analysis fails with the final portfolio, it will likely also fail with any other parameter combination, so you need to run it only close to the end. If your system passes Montecarlo with a p-value below 5%, you can be relatively confident that the system will return good and steady profit in live trading. Otherwise, back to the drawing board.

The use case

For a real life use case,  we generated algorithms for the Z12 system that comes with Zorro. Z12 is a portfolio from several trend and counter trend algorithms that all trade simultaneously. The trading signals are generated with spectral analysis filters. The system trades a subset of Forex pairs and index CFDs on a 4-hour timeframe. The timeframe was choosen for best performance, as were the traded Forex pairs and CFDs. 

We used the evaluation shell to create new algos, not from a selected subset, but from all major Forex pairs and major index CFDs, with 3 different time frames from 60, 120, and 240 minutes. 29 algorithms passed the cluster and montecarlo analysis, of which the least correlated were put into the final portfolio. This is the equity curve of the new Z12 system:

Other performance parameters, such as Profit Factor, Sharpe ratio, Calmar Ratio, and R2 also improved by more than 30%. The annual return almost doubled, compared with the average of the previous years. Nothing in the basic Z12 algorithms has changed. Only new combinations of algos, assets, and timeframes are now traded.

The evaluation shell is included in Zorro version 3.01 or above. Usage and details are described under https://zorro-project.com/manual/en/shell.htm.  Attaching the shell to a strategy is described under https://zorro-project.com/manual/en/shell2.htm.

We already know Ehlers’ highpass filter from previous articles. It’s in the Zorro indicator library under the name HighPass3. The lowpass filter, Ehlers’ ‘SuperSmoother’, is also in the library, as well as the Sum of Sqares function for normalizing. This makes the Cybernetic Oscillator easy to code in C:

var CyberOsc(vars Data,int HPLength,int LPLength)
{
  vars HP = series(HighPass3(Data,HPLength));
  vars LP = series(Smooth(HP,LPLength));
  var RMS = sqrt(SumSq(LP,100)/100);
  return LP[0]/fix0(RMS);
}

We apply two Cybernetic Oscillators, one with a short and one with a long highpass cutoff, to an S&P500 chart from 2024:

void run()
{
  BarPeriod = 1440;
  LookBack = 250;
  StartDate = 20240301;
  EndDate = 20250407;
  asset("SPX500");
  plot("CyberOsc1",CyberOsc(seriesC(),30,20),NEW|LINE,RED);
  plot("CyberOsc2",CyberOsc(seriesC(),250,20),NEW|LINE,BLUE);
}

The resulting chart replicates Ehler’s chart in the article. The red line reproduces the swings of the price curve, the blue line the long-term trend:

Now we test the Cybernetic Oscillator by using it for a swing trading system. We open positions in the direction of the trend. The code, replicated from Ehlers’ EasyLanguage script:

void run()
{
  BarPeriod = 1440;
  LookBack = 250;
  StartDate = 2009;
  EndDate = 2025;
  Fill = 2; // enter at next open
  assetList("AssetsIB"); // simulate IBKR
  asset("SPY");
  vars LP = series(Smooth(seriesC(),20));
  vars BP1 = series(HighPass3(LP,55));
  var ROC1 = BP1[0] - BP1[2];
  vars BP2 = series(HighPass3(LP,156));
  var ROC2 = BP2[0] - BP2[2];

  if(!NumOpenLong && ROC1 > 0 && ROC2 > 0)
    enterLong();
  if(NumOpenLong && (ROC1 < 0 || ROC2 < 0))
    exitLong();
}

The system is opening a 1-share SPY position without reinvestment. We’re using commission, leverage and other trading parameters from a popular US broker for the simulation. Ehlers had produced his filter parameters with in-sample optimization, so take the result with a grain of salt. This is the equity curve:

Backtesting the same system with walk-forward optimization, for getting a more accurate result, is left as an exercise to the reader. Hint: you need to enter 4 extra lines. Ehlers’ system generates about 180 trades with 60% win rate and profit factor 2. The code can be downloaded from the 2025 script repository on https://financial-hacker.com.

The Ultimate Oscillator is built from the difference of two highpass filters. The highpass function below is a straightforward conversion of Ehlers’ EasyLanguage code to C:

var HighPass3(vars Data,int Period)
{
  var a1 = exp(-1.414*PI / Period);
  var c2 = 2*a1*cos(1.414*PI / Period);
  var c3 = -a1*a1;
  var c1 = (1.+c2-c3) / 4;
  vars HP = series(0,3);
  return HP[0] = c1*(Data[0]-2*Data[1]+Data[2])+c2*HP[1]+c3*HP[2];
}

The function is named HighPass3 because we have already 3 other highpass filters in the Zorro indicator library, all with different code. The Ultimate Oscillator is the difference of two highpass filters with different periods, and scaled by its root mean square for converting the output to standard deviations. Fortunately Zorro has already a sum of squares function, which makes the code shorter and simpler than Ehlers’ original:

var UltimateOsc(vars Data,int Edge,int Width)
{
  vars Signals = series(HighPass3(Data,Width*Edge)-HighPass3(Data,Edge));
  var RMS = sqrt(SumSq(Signals,100)/100);
  return Signals[0]/fix0(RMS);
}

For checking its lag and smoothing power, we apply the Ultimate Oscillator to an S&P500 chart from 2024:

void run()
{
  BarPeriod = 1440;
  StartDate = 20240101;
  EndDate = 20241231;
  asset("SPX500");
  plot("UltOsc", UltimateOsc(seriesC(),20,2),LINE,RED);
}

The resulting chart replicates Ehler’s chart in the article. The Oscillator output is the red line:

We can see that the ultimate oscillator reproduces the market trend remarkably well and with no visible lag. The code can be downloaded from the 2025 script repository.

The LR_EMA indicator can be directly converted from Apirine’s MetaStock to C:

var LREMA(int Periods,int Pds,var Mltp)
{
  var Mltp1 = 2./(Periods+1);
  var LR = LinearReg(seriesC(),Pds);
  vars Dists = series(abs(LR-priceC()));
  var ST = (Dists[0]-MinVal(Dists,Pds))/
     max(MaxVal(Dists,Pds)-MinVal(Dists,Pds),0.01);
  var Rate = min(1.,Mltp1*(1+ST*Mltp));
  return EMA(priceC(),Rate);
}

 The max and min functions prevent divisions by zero and EMA alpha parameters (Rate) above 1. This can otherwise happen at the begin of the backtest when price series are still flat.

The LREMA(20,20,5) and EMA(20) applied on SPY replicates the chart in Apirine’s article:

 We can see that the LREMA (blue line) follows the price more closely than the EMA (red line). Which is not really surprising, because LREMA period is smaller at most places. But how good can the LREMA identify trend changes in a real trading system?

For testing this, we write a simple SPY system that concurrently trades with EMA, and with LREMA. A single position is entered when the faster EMA crosses over a slower EMA, and closed when it crosses back. The LREMA is used likewise. For not comparing apples with oranges, we optimize all time periods and test with walk-forward analysis. The code of this trading system in C:

void run()
{
 BarPeriod = 1440;
 LookBack = 200;
 StartDate = 2005;
 EndDate = 2022;
 assetList("AssetsIB");
 asset("SPY");
// walk-forward optimization setup
 set(PARAMETERS,TESTNOW,PLOTNOW);
 NumWFOCycles = 8;
// run a loop over the two algos
 while(algo(loop("LR_EMA","EMA")))
 {
  vars Signals1, Signals2;
  int Color;
// optimize time periods
  int Period1 = optimize(20,10,50,10);
  int Period2 = Period1*optimize(2.5,1.5,3,0.5);
  if(Algo == "LR_EMA") {
   Signals1 = series(LREMA(Period1,Period1,5));
   Signals2 = series(LREMA(Period2,Period2,5));
   Color = BLUE;
  } else if(Algo == "EMA") {
   Signals1 = series(EMA(seriesC(),Period1));
   Signals2 = series(EMA(seriesC(),Period2));
   Color = GREY;
  }
// trade on fast/slow crossovers
  if(crossOver(Signals1,Signals2)) enterLong();
  if(crossUnder(Signals1,Signals2)) exitLong();
// plot equity curve
  plot(Algo,ProfitOpen+ProfitClosed,LINE+AXIS2,Color);
 }
}

This script trades two different algos and compares the resulting equity curves.  The fast and slow periods are optimized separately for both algorithms. The slow period is the fast period multiplied with a factor. This guarantees that the slow period is always bigger than the fast period during the optimization. The system must be first trained by clicking the [Train] button on the Zorro panel. After training, it automatically starts a backtest with walk-forward analysis.

Training and analysis take about 2 seconds. The resulting equity curve is plotted in a blue line for the LR_EMA algo, and in a grey line for the standard EMA algo:

 We can see that both algorithms yield a positive result, but the standard EMA a bit more so than the LR_EMA. Not only the profit is smaller, the drawdowns are also worse with the new invented indicator – which is probably the reason why the article, like almost any article about a new indicator, did not contain an example system or a backtest. But maybe the walk-forward period optimization was simply more effective on the fixed-period EMA, than on the variable-period LR_EMA. If so, then the LR_EMA would fare better with unoptimized systems.

The LREMA indicator and the EMA/LREMA trading system can be downloaded from the 2022 script repository.

Kaufman’s 6 patterns were named Key Reversal, Island Reversal, Outside Days, Wide Ranging days, 3-Day Compression, and Gap opening. All are calculated from the previous 3 or 4 candles or price ranges. All but one are symmetric, meaning they deliver bullish and bearish signals. And because I’m a bit on the evil side, I added a 7th pattern that I just invented: TotalRandom.

Here’s how the patterns look as indicators in C:

// a higher high followed by a lower close. 
var cdlKeyReversal()
{
  if(priceHigh(0) > priceHigh(1) && priceLow(0) < priceLow(1)) {
    if(priceClose(0) < priceLow(1)) return -100; // sell
    if(priceClose(0) > priceHigh(1)) return 100; // buy
  } 
  return 0;
}


// recent 3 days each have a true range smaller than the 4th previous day.
var cdl3DayCompression()
{
  vars TRs = series(TrueRange(),4);
  if(TRs[0] < TRs[3] && TRs[1] < TRs[3] && TRs[2] < TRs[3])
    return 100;
  else
    return 0;
}

// a gap higher followed by a lower close, but not filling the gap. 
var cdlIslandReversal()
{
  if(priceLow(0) > priceHigh(1) && priceClose(0) < priceOpen(0)) 
    return -100; // sell
  if(priceLow(1) > priceHigh(0) && priceClose(0) > priceOpen(0)) 
    return 100; // buy
  else return 0;
}

// a higher high and a lower low, close in upper or lower 25% of the range.
var cdlOutsideDay()
{
  if(priceHigh(0) > priceHigh(1) && priceLow(0) < priceLow(1)) {
    if(priceClose(0) < 0.75*priceLow(0) + 0.25*priceHigh(0)) 
      return -100; // sell
    if(priceClose(0) > 0.25*priceLow(0) + 0.75*priceHigh(0)) 
      return 100; // buy
  } 
  return 0; 
}

// same as outside days, but true range must exceed 1.5 × 20-day ATR
var cdlWideRangeDays()
{
  if(TrueRange() > 1.5*ATR(20))
    return cdlOutsideDay();
  else
    return 0;
}

// gap must be larger than 0.5 × 20-day ATR.
var cdlGapOpening()
{
  var Ratio = (priceOpen(0) - priceClose(1))/ATR(20);
  if(Ratio >= 0.5) return 100;
  if(Ratio <= -0.5) return -100;
  return 0; 
}

// just enter a trade when you feel lucky
var cdlTotalRandom()
{
  int Pattern = random(100);
  if(Pattern > 90) return 100;
  if(Pattern < 10) return -100;
  return 0;
}

Following the convention of the classic candle pattern indicators from the TA library, the pattern functions return +100 for a bullish pattern, -100 for a bearish pattern, and 0 for no pattern.

We’re now putting them to the  test. We want to trade the patterns with IWM, AAPL, AMZN, GE, WMT, and TSLA stocks, with SPY and QQQ index ETFs, and with and without an additional trend filter. For any detected pattern, we’re entering a long or short position depending on if it’s bullish or bearish. We always invest the same amount, regardless of the price of the stock. The position is closed after 1, 2, 3, 4, or 5 days. For any asset and any exit type we’ll export the number of trades and the total win and loss to a table in HTML format. That is convenient for me because I can paste it directly in this blog article.

The test script:

var pattern();

function run()
{
  pattern = cdlKeyReversal;
  bool WithTrend = 0;
  string Name = "KeyRev";

  BarPeriod = 1440;
  StartDate = 20100101; // TSLA went public in 2010
  EndDate = 2020; // test until 2020
  var Investment = 10000;
  TradesPerBar = 40; // 8 assets * 5 algos

  char File[100];
  if(is(EXITRUN)) {
    sprintf(File,"Log\\%s.htm",strf("%s%s",
      Name,ifelse(WithTrend,"WithTrend","NoTrend")));
    printf("\nStoring results in %s",File);
    file_write(File,strf("<p>%s:</p>\n<table><tr>",File),0);
// write the table header
    file_append(File,"<td>Asset</td>",0);
    file_append(File,"<td>Long/Short</td>",0);
    file_append(File,"<td>Day 1</td>",0);
    file_append(File,"<td>Day 2</td>",0);
    file_append(File,"<td>Day 3</td>",0);
    file_append(File,"<td>Day 4</td>",0);
    file_append(File,"<td>Day 5</td></tr>",0);
  }

  assetAdd("SPY","STOOQ:*.US"); // load price history from Stooq
  assetAdd("QQQ","STOOQ:*.US");
  assetAdd("IWM","STOOQ:*.US");
  assetAdd("AAPL","STOOQ:*.US");
  assetAdd("AMZN","STOOQ:*.US");
  assetAdd("GE","STOOQ:*.US");
  assetAdd("WMT","STOOQ:*.US");
  assetAdd("TSLA","STOOQ:*.US");

  while(asset(loop("SPY","QQQ","IWM","AAPL","AMZN","GE","WMT","TSLA"))) {
  vars Trend = series(SMA(seriesC(),80));
  while(algo(loop("Day1","Day2","Day3","Day4","Day5"))) {

  Lots = Investment/priceClose();
  LifeTime = Itor2+1; // life time in days
  int Signal = pattern();
  if(Signal > 0 && (!WithTrend || rising(Trend)))
    enterLong();
  else if(Signal < 0 && (!WithTrend || falling(Trend)))
    enterShort();
  if(is(EXITRUN)) {
    if(Algo == "Day1") // first loop run
      file_append(File,strf("\n<tr><td>%s</td><td>%i/%i</td>",
        Asset,NumWinLong+NumLossLong,NumWinShort+NumLossShort),0);
    string Color = ifelse(WinLong-LossLong+WinShort-LossShort > 0,
      "bgcolor=\"lime\"","bgcolor=\"red\"");
    file_append(File,strf("<td %s>%.0f/%.0f</td>",
      Color,WinLong-LossLong,WinShort-LossShort),0);
    if(Algo == "Day5")
      file_append(File,"</tr>",0);
  }

  }} // loops
  if(is(EXITRUN)) {
    file_append(File,"</table>",0);
    file_append(File,strf("<p>Total Profit: %.0f (%.0f%%)</p>",
      WinTotal-LossTotal,100*(WinTotal-LossTotal)/Investment),0);
  }
}

Some explanations about the code. At the begin of the run() function the pattern and the trend mode are set up. For convenience we’re using a function pointer that is set to the pattern function to be tested. Afterwards, when it’s the last run, the table header is written into the HTM file. A char array (File) and the sprintf() function is used for the file name instead of the more convenient strf(), because we need to keep the file name for later writing into the table.

The test uses two nested loops, first for selecting the stocks, second for selecting the trade life time to get the results from a 1-day trade up to a 5-days trade. The predefined Itor2 variable is the iterator of the second loop and runs from 0 to 4, so we just use it to set the LifeTime variable for the subsequent trade. The results are printed in the EXITRUN at the last day of the simulation.

The numbers in the tables are the results from long/short trades. A winning pattern is displayed in green, a losing pattern in red. Transaction costs are considered.

The original OBV indicator was invented by Joseph Granville in 1963. It differs from other indicators insofar as it takes trade volume into account. The purpose was to measure the volume ‘flowing into and out’ (whatever that means) of an asset. Volume supposedly flows out when the price goes down, and flows in when it goes up. The net sum of all the flowing is the OBV. This is its algorithm in C for the Zorro platform:

var OBV(vars Data,var Volume)
{
  vars OBVData = series(Volume,2);
  if(Data[0] > Data[1])
    return OBVData[0] = OBVData[1]+Volume;
  else if(Data[0] < Data[1])
    return OBVData[0] = OBVData[1]-Volume;
  else
    return OBVData[0] = OBVData[1];
}

Since it follows the sign of price changes, the OBV is correlated to the price curve. By the way, before you read further on, here’s a trick that can save  money when you’re using the free Zorro version. Normally, volume and market depth are only available in Zorro S. But even the free version reads volume from online sources and stores it in historical data. So you only need to read it out of the history file and store it in a dataset, and can then access it in the script for any given bar with the dataFind function. 4 lines of code save EUR 35 per month. 

For using OBV crossovers or price divergences for trade signals, the article author smoothed the OBV with an EMA and named it “OBVM”. The algorithm:

var OBVM(vars Prices, int Period)
{
   vars OBVData = series(OBV(Prices,marketVol()));
   return EMA(OBVData,Period);
}

For a crossover, naturally a second curve will be needed. Apirine invented the “OBVM Signal” by applying another EMA to the OBVM: 

var OBVMSignal(vars OBVMData, int Period)
{
   return EMA(OBVMData, Period);
}

The resulting OBVM (blue) and OBVM Signal (red) curves with the S&P 500:

We’re now going to test the OBVM usefulness for trade signals. Following the author’s suggestions, we’ll use a crossover of the OBVM and the OBVM signal for entering a short or long SPY position. Of course it’s no problem to manually tweak the indicator and signal periods (7 and 10 in the chart above) until they produce great results. But that would not work in live trading, so we’re optimizing them with walk forward analysis. This is the C script for Zorro that trades SPY on SPX OBVM crossovers:

function run() 
{
	set(PARAMETERS,LOGFILE,TESTNOW,PLOTNOW);
	BarPeriod = 1440;
	EndDate = 20200215;

	assetAdd("SPX","STOOQ:^SPX"); // load price history from Stooq
	assetAdd("SPY","STOOQ:SPY.US");
	asset("SPY");

	NumWFOCycles = 5; // activate walk forward analysis
	int ShortPeriod = optimize(7,3,20);
	int LongPeriod = ShortPeriod*optimize(1.3,1.1,2.0);
	
	asset("SPX");
	vars Prices = series(priceClose());
	vars OBVMData = series(OBVM(Prices,ShortPeriod));
	vars OBVMSignals = series(OBVMSignal(OBVMData,LongPeriod));

	asset("SPY");
	if(crossOver(OBVMData,OBVMSignals))
		enterLong();
	else if(crossUnder(OBVMData,OBVMSignals))
		enterShort();
}

For ensuring that the long period is always longer than the short one, not the period itself, but a multiplication factor is optimized. After training, the system produces indeed a positive result. But the equity curve (blue bars) does not look very convincing:

We can see that the smoothed OBV crossover system is not really superior to a buy-and-hold strategy. But the author also recommended trading on divergence between the OBVM and the price curve. Maybe this produces a better result? The divergence trading system:

function run() 
{
	set(PARAMETERS,LOGFILE,TESTNOW,PLOTNOW);
	BarPeriod = 1440;
	EndDate = 20200215;

	assetAdd("SPX","STOOQ:^SPX"); // load price history from Stooq
	assetAdd("SPY","STOOQ:SPY.US");
	asset("SPY");

	NumWFOCycles = 5; // activate walk forward analysis
	int ShortPeriod = optimize(7,3,20);
	int LongPeriod = ShortPeriod*optimize(1.3,1.1,2.0);
	
	asset("SPX");
	vars Prices = series(priceClose());
	vars OBVMData = series(OBVM(Prices,ShortPeriod));
	vars Highs = series(priceHigh()), Lows = series(priceLow());
	int Div = Divergence(Highs,Lows,OBVMData,LongPeriod);

	asset("SPY");
	MaxLong = MaxShort = 1;	// don't open several trades
	if(Div&1) // bullish divergence
		enterLong();
	else if(Div&2) // bearish divergence
		enterShort();	
}

This system uses the Divergence indicator. The indicator draws lines between the most prominent recent peaks and valleys of the data series, and returns a result with several flags depending on  which of the lines go in which different directions. The details of the Divergence function can be found in the Zorro manual under “Indicators”. After training again, we get this result:

Not much better than the crossover. But at least in the first part of the price curve, both tests produced a positive result. Maybe the indicator can be improved with a different signal generation method, a better smoothing function than EMA, and/or adding an anti-whipsaw or trend detection filter.

So when not directly for a trade system, how can you otherwise use the OBVM? The author knows the answer: “It is not a standalone indicator. As with all indicators, it is important to use OBVM in conjunction with other aspects of technical analysis”. Those other aspects are, of course, other indicators. Thats the beauty of technical analysis: Combine any two indicators and get a new one. And if in doubt, use it only in conjunction with other indicators. So just have many, many indicators. If possible in many, many different colors.

Reference

Vitali Apirine, On-Balance Volume Modified, Stocks&Commodities 4/2020

The indicator and test script is available in the Scripts 2020 repository.