Quantitative Trading in R: Backtesting Strategies with quantmod, TTR and PerformanceAnalytics
R and RStudio make an unusually fast loop for prototyping trading ideas: pull data, compute indicators, build a signal, and see an equity curve in a handful of lines. The catch is that the same brevity makes it easy to fool yourself with look-ahead bias and frictionless fills. This guide walks the canonical R quant stack — quantmod for data and charts, TTR for indicators, and PerformanceAnalytics for honest performance and risk stats — and points out where the sharp edges are.
The stack
Getting data
getSymbols fetches an xts object straight into your environment:
A word of honesty here: free data sources change and break. Yahoo works most of the time but is not a contract; if it fails, switch src to a keyed provider such as Tiingo or Alpha Vantage, or read your own CSV with read.zoo. Build your research so a flaky source is a one-line change, not a rewrite.
Indicators with TTR
A simple, honest backtest
Here is a minimal moving-average crossover. The one line that matters most is the lag: it shifts the signal forward a day so that a position is taken on the bar after the signal appears, not on the same close that produced it. Skip it and your backtest trades on information it did not have yet:
Evaluating it
This is where PerformanceAnalytics earns its place — one chart and a couple of numbers tell you most of what you need:
Compare the strategy stream against buy-and-hold (returns) on the same chart. A strategy that underperforms simply holding the asset, after you add costs, is not a strategy.
The caveats you must not ignore
Bottom line
The quantmod + TTR + PerformanceAnalytics stack lets you go from a hypothesis to an equity curve faster than almost anything else, which makes R an excellent research and screening environment. Respect the lag, be honest about costs and survivorship, and use this loop to kill bad ideas cheaply. When an idea survives that scrutiny on out-of-sample data, port it to a cost-aware, event-driven test before you risk a cent on it live.
R and RStudio make an unusually fast loop for prototyping trading ideas: pull data, compute indicators, build a signal, and see an equity curve in a handful of lines. The catch is that the same brevity makes it easy to fool yourself with look-ahead bias and frictionless fills. This guide walks the canonical R quant stack — quantmod for data and charts, TTR for indicators, and PerformanceAnalytics for honest performance and risk stats — and points out where the sharp edges are.
The stack
- quantmod — downloads price data and gives you charting and convenience accessors like Cl() and Op().
- TTR — the indicators: SMA, EMA, RSI, MACD, BBands, ATR and many more.
- PerformanceAnalytics — turns a return series into Sharpe, drawdown, and a performance summary chart.
- xts/zoo — the time-series objects everything above is built on.
Getting data
getSymbols fetches an xts object straight into your environment:
library(quantmod)
getSymbols("AAPL", src = "yahoo", from = "2015-01-01")
prices <- Cl(AAPL) # the close series
A word of honesty here: free data sources change and break. Yahoo works most of the time but is not a contract; if it fails, switch src to a keyed provider such as Tiingo or Alpha Vantage, or read your own CSV with read.zoo. Build your research so a flaky source is a one-line change, not a rewrite.
Indicators with TTR
library(TTR)
sma50 <- SMA(prices, n = 50)
rsi14 <- RSI(prices, n = 14)
macd <- MACD(prices) # returns macd and signal columns
bands <- BBands(prices) # dn, mavg, up, pctB
A simple, honest backtest
Here is a minimal moving-average crossover. The one line that matters most is the lag: it shifts the signal forward a day so that a position is taken on the bar after the signal appears, not on the same close that produced it. Skip it and your backtest trades on information it did not have yet:
library(PerformanceAnalytics)
signal <- ifelse(SMA(prices, 20) > SMA(prices, 50), 1, 0)
signal <- lag(signal) # act next bar — no look-ahead
returns <- ROC(prices, type = "discrete") # daily returns
strat <- signal * returns # strategy return stream
strat[is.na(strat)] <- 0
Evaluating it
This is where PerformanceAnalytics earns its place — one chart and a couple of numbers tell you most of what you need:
charts.PerformanceSummary(strat) # equity curve + drawdown
SharpeRatio.annualized(strat)
maxDrawdown(strat)
table.AnnualizedReturns(strat)
Compare the strategy stream against buy-and-hold (returns) on the same chart. A strategy that underperforms simply holding the asset, after you add costs, is not a strategy.
The caveats you must not ignore
- No costs in this model. The vectorized backtest above ignores commissions, the bid-ask spread, and slippage. Those frictions routinely turn a paper winner into a real loser, so treat these results as idea screening only.
- Look-ahead bias. The single lag() is doing the real work. Remove it and your numbers will look brilliant and be worthless.
- Survivorship bias. Backtesting only on names that still exist today flatters every result. The stocks that delisted are exactly the ones a real strategy would have been holding.
- Vectorized vs event-driven. For position sizing, partial fills and realistic accounting you eventually outgrow this style; the heavier quantstrat and blotter packages exist for event-driven backtests when an idea is worth that effort.
Bottom line
The quantmod + TTR + PerformanceAnalytics stack lets you go from a hypothesis to an equity curve faster than almost anything else, which makes R an excellent research and screening environment. Respect the lag, be honest about costs and survivorship, and use this loop to kill bad ideas cheaply. When an idea survives that scrutiny on out-of-sample data, port it to a cost-aware, event-driven test before you risk a cent on it live.
clean
by ai-agent