The Turtle Trading Strategy: A Classic Trend-Following System

The Turtle Trading Strategy is a classic trend-following approach developed in the 1980s by Richard Dennis and William Eckhardt. This strategy identifies entry and exit points by tracking a market’s highest and lowest prices over a defined period. It is designed to capture long-term trends and profit from sustained price movements.

The Origin of the Turtle Trading Strategy

Richard Dennis was a legendary futures trader in the 1970s, reportedly turning a few thousand dollars into $350 million in just a few years. Dennis believed that trading was a skill that could be taught — not an innate talent. To prove his point, he made a bet with his friend William Eckhardt that ordinary people could be trained to become successful traders.

Dennis recruited 24 individuals — whom he called “Turtles” — from various backgrounds and gave them a two-week intensive training program. After completing the training and passing evaluations, each Turtle received capital to trade, ranging from $250,000 to $2 million. Over the next five years, their accounts collectively grew to $175 million.

After the experiment, Dennis publicly shared the training system he had used — which became known as the Turtle Trading Strategy. It was one of the earliest examples of quantitative trading and demonstrated the power of systematic approaches over emotional or subjective decision-making.

Trading Rules

The Turtle Trading Strategy places a strong emphasis on risk management, which has had a lasting impact on modern quantitative trading. Below are the key components of the strategy:

1. Market Selection

The strategy works best in markets with sufficient liquidity and volatility, such as stocks, futures, or forex. Traders should ensure that the chosen instruments are actively traded and easy to enter or exit.

2. Entry Rules

The Turtles used a breakout system to determine when to enter a trade:

• A buy signal is generated when the price breaks above the highest high of the past N days (commonly 20 days).
• A sell signal is generated when the price breaks below the lowest low of the past N days.

3. Position Sizing

Turtle Trading uses a fixed risk model to determine position size. Typically, the risk per trade is capped at a specific percentage of total capital (e.g., 2%). Position size is calculated based on current price and volatility to ensure risk is controlled within set limits.

4. Stop Loss Rules

Risk management is central to the strategy. A stop-loss is placed at the beginning of each trade, often at the low/high of the last N days (e.g., 10 or 20 days). As the trade moves in a favorable direction, stop-loss levels may be adjusted to lock in profits and limit downside.

5. Exit Rules

The strategy uses a predefined profit target to exit trades. Once the price hits the target, the position is closed. These targets can be customized based on market volatility or specific strategy goals.

6. Signal Filtering

To avoid false signals, additional technical indicators can be used for confirmation — such as moving averages or Relative Strength Index (RSI). This helps improve trade quality and reduce noise.

7. Backtesting and Optimization

Before deploying the strategy live, it’s recommended to backtest it on historical data. Backtesting helps evaluate the strategy’s performance and refine parameters to match current market conditions.

While the Turtle Trading Strategy is a proven and influential system, it’s not without flaws. It may underperform in choppy or range-bound markets, and significant drawdowns can occur. Therefore, strict risk management and disciplined execution are essential to its success.

Lastly, specific parameters and rules may vary depending on individual preferences, risk appetite, and market conditions. Customization and continuous optimization are key to adapting the strategy effectively.

Java Code Example

import java.util.List;

public class TurtleTradingStrategy {
    public static void main(String[] args) {
        List<Double> prices = 
        int breakoutPeriod = 20; 

        double highestHigh = Double.MIN_VALUE;
        double lowestLow = Double.MAX_VALUE;
        boolean inMarket = false; 
        double entryPrice = 0.0; 

        for (double price : prices) {

            if (price > highestHigh) {
                highestHigh = price;
            }
            if (price < lowestLow) {
                lowestLow = price;
            }

            if (!inMarket && price > highestHigh) {

                inMarket = true;
                entryPrice = price;

            } else if (inMarket && price < lowestLow) {

                inMarket = false;

            }


            if (prices.indexOf(price) >= breakoutPeriod) {
                double previousPrice = prices.get(prices.indexOf(price) - breakoutPeriod);
                if (previousPrice == highestHigh) {

                    highestHigh = calculateHighestHigh(prices, prices.indexOf(price) - breakoutPeriod + 1, prices.indexOf(price));
                }
                if (previousPrice == lowestLow) {

                    lowestLow = calculateLowestLow(prices, prices.indexOf(price) - breakoutPeriod + 1, prices.indexOf(price));
                }
            }
        }
    }

    private static double calculateHighestHigh(List<Double> prices, int startIndex, int endIndex) {
        double highestHigh = Double.MIN_VALUE;
        for (int i = startIndex; i <= endIndex; i++) {
            double price = prices.get(i);
            if (price > highestHigh) {
                highestHigh = price;
            }
        }
        return highestHigh;
    }

    private static double calculateLowestLow(List<Double> prices, int startIndex, int endIndex) {
        double lowestLow = Double.MAX_VALUE;
        for (int i = startIndex; i <= endIndex; i++) {
            double price = prices.get(i);
            if (price < lowestLow) {
                lowestLow = price;
            }
        }
        return lowestLow;
    }
}

Python Code Example

def turtle_trading_strategy(prices, breakout_period=20, risk_percentage=0.02):
    highest_high = float('-inf')
    lowest_low = float('inf')
    in_market = False
    entry_price = 0.0

    for price in prices:
        if price > highest_high:
            highest_high = price
        if price < lowest_low:
            lowest_low = price

        if not in_market and price > highest_high:
            in_market = True
            entry_price = price


        elif in_market and price < lowest_low:

            in_market = False



        if prices.index(price) >= breakout_period:
            previous_prices = prices[prices.index(price) - breakout_period:prices.index(price)]
            previous_highest_high = max(previous_prices)
            previous_lowest_low = min(previous_prices)
            if previous_highest_high == highest_high:

                highest_high = calculate_highest_high(prices, prices.index(price) - breakout_period + 1, prices.index(price))
            if previous_lowest_low == lowest_low:

                lowest_low = calculate_lowest_low(prices, prices.index(price) - breakout_period + 1, prices.index(price))

def calculate_highest_high(prices, start_index, end_index):
    highest_high = float('-inf')
    for i in range(start_index, end_index + 1):
        price = prices[i]
        if price > highest_high:
            highest_high = price
    return highest_high

def calculate_lowest_low(prices, start_index, end_index):
    lowest_low = float('inf')
    for i in range(start_index, end_index + 1):
        price = prices[i]
        if price < lowest_low:
            lowest_low = price
    return lowest_low