Smoothed Moving Average (SMMA / RMA)

Wilder's slow, recursive moving average — the RMA that quietly powers RSI and ATR, and mathematically an EMA in disguise.

What it is

A smoothed moving average (SMMA) is a recursive moving average that blends each new price into the previous average with a weight of 1/n. It is the smoothing method J. Welles Wilder Jr. used inside RSI, ATR, and ADX in 1978, which is why TradingView exposes it as ta.rma — the 'running moving average' — while MetaTrader lists it as the SMMA method in its moving-average options. The identity almost nobody documents: an SMMA of length n applies exactly the same smoothing weight as an EMA of length 2n−1, so SMMA(n) and EMA(2n−1) are the same filter apart from how the first value is seeded. That single fact explains many of the cross-platform value mismatches traders report between MetaTrader and TradingView — the platforms are usually both correct, just seeded or labelled differently. Like every moving average, the SMMA is a summary of past prices, not a forecast. This material is educational only, not financial advice, and all trading carries risk of loss.

How it works

The recursion is SMMA(t) = (SMMA(t−1) × (n−1) + price(t)) / n, which rearranges to SMMA(t−1) + (price − SMMA(t−1)) / n. In filter terms, that is an exponential smoother with alpha = 1/n. A standard EMA of length L uses alpha = 2/(L+1). Setting 2/(L+1) = 1/n and solving gives L = 2n−1: an SMMA(14) applies the same per-bar weight as an EMA(27). The two lines are not bar-for-bar identical from the first candle, because implementations seed differently — RMA conventionally seeds with a simple average of the first n bars, while EMA implementations often seed with the first price — but after a warm-up period they converge and sit on top of each other. Because the calculation is recursive, every value depends on the entire prior history, so two platforms with different amounts of loaded history can show slightly different values early in the chart. Understanding this is also the key to RSI and ATR: when you change 'RSI length 14', you are changing the length of two internal RMAs, which is why RSI feels smoother and slower than its nominal length suggests.

How traders read it

• Direction and side: as with any moving average, price holding above a rising SMMA is read as a description of recent upward drift, and below a falling SMMA as downward drift — a summary of the past, not a prediction.
• Calibrate the length honestly: SMMA(14) behaves like EMA(27), so comparing an SMMA to an EMA of the same nominal length is comparing two different speeds. Convert with L = 2n−1 before judging responsiveness.
• Expect it to be slow: for a given length the SMMA lags a same-length EMA noticeably; it is often chosen precisely for that extra smoothness.
• Inside other indicators: RSI, ATR, and ADX readings are shaped by this smoother, so an SMMA that feels sluggish on price explains why those indicators also respond gradually.
• Cross-platform checks: if MetaTrader and TradingView disagree on an SMMA-based value, compare seeding and loaded history length before assuming either implementation is wrong.

Common settings

Common lengths are 7, 14, 21, and 50 on the closing price. The Williams Alligator uses SMMAs of 13, 8, and 5 on the median price (with forward offsets). Wilder's original indicators effectively use SMMA lengths of 14 (RSI, ATR, ADX). There is no universally correct length: remember that an SMMA of length n runs at the speed of an EMA of length 2n−1, so choose with that conversion in mind.

Strengths

• Very smooth output for a given nominal length, which cuts bar-to-bar noise more than an equal-length SMA or EMA.
• It is the smoothing engine behind RSI, ATR, and ADX, so understanding it explains the behaviour of several major indicators at once.
• Simple one-line recursion that is cheap to compute and easy to verify by hand.
• The exact EMA(2n−1) equivalence makes its lag and weighting fully analyzable rather than a black box.
• Consistently defined across platforms once seeding differences are accounted for.

Pitfalls to watch

• Heavy lag by design: with an effective EMA length of 2n−1, the SMMA turns well after price does, and part of any move is over before the line confirms it.
• Length labels mislead: an 'SMMA 14' is not comparable to an 'EMA 14', so cross-platform or cross-indicator comparisons at equal nominal length are apples to oranges.
• Seeding and history depth matter: because the recursion never forgets, charts with different amounts of loaded history can show different values, especially near the left edge — this is expected, not a bug.
• Whipsaw in ranges: extra smoothness reduces but does not remove false direction changes when price moves sideways.
• No predictive power: the SMMA summarizes past prices only; no smoothing method forecasts price or removes the risk of loss.

Pine v6 example

//@version=6
indicator("SMMA / RMA vs EMA Equivalence", overlay = true)

len = input.int(14, "SMMA Length", minval = 1)
src = input.source(close, "Source")

smma     = ta.rma(src, len)
emaEquiv = ta.ema(src, 2 * len - 1)

plot(smma,     "SMMA / RMA",          color = color.blue, linewidth = 2)
plot(emaEquiv, "EMA(2n-1) equivalent", color = color.orange)

Pro tip: Run the example above and watch the two lines: after the warm-up bars they overlay almost perfectly, which is the SMMA(n) = EMA(2n−1) identity made visible. When two platforms disagree on an SMMA, RSI, or ATR value, suspect seeding or loaded-history depth before suspecting the formula. This is educational context only, not financial advice — no moving average predicts price, and all trading carries risk of loss.

Educational only — not financial advice, not a recommendation to trade. No indicator is predictive; trading involves substantial risk of loss.