I Know You Miss This: Tail Call Optimization in Modern JavaScript

Once promised as a game-changer for recursion, Tail Call Optimization (TCO) faded away. Here’s what happened and what to use instead today.

Introduction

Remember when ES6 promised us Tail Call Optimization (TCO) back in 2015?

The idea was thrilling:

No more stack overflows with deep recursion.
Cleaner functional programming in JavaScript.
Performance boosts without changing code.

For a moment, it felt like recursion was about to go mainstream in JS.

But here we are in 2025… and most devs don’t even talk about TCO anymore. Safari briefly implemented it, Chrome never really did, and it quietly vanished from most engines.

If you’ve ever thought, “Wait, wasn’t JavaScript supposed to support this?” you’re not alone.

Let’s dig into what TCO was, why it mattered, why it disappeared, and what you can do today.

What Was Tail Call Optimization?

A tail call is when a function ends by calling another function (or itself).

Example:

function factorial(n, acc = 1) {
  if (n === 0) return acc;
  return factorial(n - 1, n * acc); // tail call
}

Normally, recursion like this grows the call stack. With TCO, the engine could reuse the current stack frame, making recursion effectively infinite without stack overflow.

Languages like Scheme and Haskell have relied on TCO for decades.

Why Did Devs Get Excited?

Because recursion in JS has always been fragile:

factorial(10000) → 💥 Maximum call stack size exceeded
Tree traversals blow up easily.
Functional programming patterns feel unsafe.

TCO would have made recursion as safe and efficient as loops.

Why Did TCO Die in JavaScript?

Debugging got worse
With TCO, stack traces became shorter. Errors didn’t show the full call chain, confusing developers.
Inconsistent performance
In some cases, TCO made code slower instead of faster because of stack frame reuse overhead.
Lack of vendor agreement
Chrome (V8), Firefox, and Safari disagreed on implementation. Safari shipped it, then rolled it back.
Low real-world demand
Most developers were fine with writing loops. Few apps truly depended on recursion-heavy logic.

The result? By 2020, TCO was basically gone. In 2025, it’s a ghost feature.

Is Tail Call Optimization Really Dead?

Yes, in native JavaScript engines.

✅ Safari removed it.
✅ Chrome never enabled it.
✅ Node.js doesn’t support it.
✅ TC39 no longer prioritizes it.

For modern JavaScript devs, TCO is officially a missed opportunity.

So What Do We Use Instead?

1. Iterative Loops (The Practical Fix)

Most recursion-heavy problems can be rewritten as loops:

function factorialIterative(n) {
  let acc = 1;
  for (let i = n; i > 0; i--) {
    acc *= i;
  }
  return acc;
}

2. Trampolines (Simulated TCO in JS)

A trampoline turns recursive calls into looped function calls, preventing stack growth.

function trampoline(fn) {
  return function (...args) {
    let result = fn(...args);
    while (typeof result === "function") {
      result = result();
    }
    return result;
  };
}

function factorial(n, acc = 1) {
  if (n === 0) return acc;
  return () => factorial(n - 1, n * acc);
}

const trampolinedFactorial = trampoline(factorial);
console.log(trampolinedFactorial(100000)); // ✅ Works

3. Use Languages That Compile to JS

Languages like Elm, ReasonML, or Scala.js implement their own optimizations and compile down to efficient JS.

Why This Still Matters in 2025

The TCO story is a reminder:

Specs don’t guarantee reality; engines and vendors decide what sticks.
Sometimes “perfect” functional patterns don’t fit the messy realities of debugging and performance.
Developers need practical tools, not just theoretical elegance.

Conclusion

Tail Call Optimization in JavaScript is dead in 2025.

It promised safer recursion and functional programming elegance, but debugging issues, performance quirks, and vendor politics killed it.

✅ Key takeaway: Write recursion when it makes sense, but don’t rely on the engine to optimize it. Use iteration, trampolines, or helper libraries when stack safety matters.

Call to Action

Were you one of the devs who got hyped about TCO back in ES6 days?
Or do you still hit stack overflow errors and wish it had survived?

Share your story in the comments 👇

And if you know a teammate who still thinks TCO is coming someday, send them this post better to move forward with tools that actually work in 2025.

Skill Stuff