The History of ECMAScript and JavaScript Guide

ECMAScript history is the story of the official standard behind JavaScript. Think of ECMAScript as the rulebook. JavaScript engines like V8 (Chrome), SpiderMonkey (Firefox), and JavaScriptCore (Safari) implement those rules. When people say "JavaScript," they almost always mean "ECMAScript as implemented by browser engines."

What ECMAScript Standardizes

The ECMAScript specification defines the core language -- the parts of JavaScript that work the same way in every environment. This includes:

• Syntax rules (how you write valid code)
• Data types (Number, String, Boolean, Object, etc.)
• Control flow (if/else, loops, switch)
• Functions and scope
• Error handling (try/catch)
• Built-in objects (Array, Object, Math, JSON, Promise, etc.)
• The module system (import/export)

What ECMAScript does not define:

• DOM APIs like element selection methods (standardized by WHATWG)
• Web APIs like fetch and timers (standardized by WHATWG)
• Node.js APIs like file system access (defined by the Node.js project)

This separation is why DOM methods work in browsers but not in Node.js. They are Web APIs, not part of ECMAScript.

ECMAScript and JavaScript: The Relationship

In everyday conversation, "ECMAScript" and "JavaScript" mean the same thing. The distinction only matters when discussing the standardization process or edge cases where different engines implement the spec differently.

How TC39 Works

TC39 (Technical Committee 39) is the group that decides what goes into ECMAScript. It includes representatives from Google, Apple, Mozilla, Microsoft, and other companies with a stake in the web platform. Meetings happen every two months.

New features go through a four-stage process:

Each stage raises the bar for how settled a proposal is before it reaches the standard:

This process is public. Anyone can read proposals, follow discussions, and even contribute on the TC39 GitHub organization.

The ECMAScript Version History

ES1 (1997): The First Standard

Published in June 1997, ES1 was essentially JavaScript 1.1 with the rough edges smoothed. It defined the basic syntax, data types, and built-in objects that are still the foundation of the language.

ES2 (1998): Minor Cleanup

A small update to align the specification with an ISO standard. No new language features.

ES3 (1999): The Long Baseline

ES3 was the version of JavaScript that most developers learned for over a decade. It added regular expressions, try/catch error handling, the switch statement, and do-while loops. ES3 was the stable foundation during the long period when browser development stalled.

ES4 (Abandoned): The Revolution That Failed

ES4 was supposed to be a massive update with classes, static typing, packages, and generics. Work stalled by 2003, and after years of disagreement between browser vendors, TC39 formally abandoned the effort in 2008. JavaScript stayed largely frozen for most of that decade.

ES5 (2009): The Quiet Modernization

ES5 was the first meaningful update in a decade. It added:

• Strict mode, a stricter parsing and error-checking variant of JavaScript
• Native JSON parsing and stringifying
• Functional array methods for mapping, filtering, reducing, and iterating
• Object creation and property definition helpers
• An array type check and function binding

ES5 is the baseline for virtually all JavaScript written today. If you see a feature that works in Internet Explorer 9 and above, it is probably from ES5.

ES6 / ES2015: The Transformation

ES6 was the largest update in JavaScript's history. Released in June 2015, it was the culmination of years of work after the failed ES4 effort. It added the features that make modern JavaScript feel modern:

ES6 also marked the start of the yearly release cycle, renamed ES2015.

ES2016 to Present: Yearly Evolution

After ES6, TC39 committed to yearly releases. Each version is smaller than ES6 was, but the steady cadence means features reach developers faster:

• ES2017: async/await made asynchronous code read like synchronous code
• ES2018: object rest/spread and a way to run cleanup code after a promise settles
• ES2020: optional chaining, nullish coalescing, and arbitrary-precision integers
• ES2022: top-level await and private class fields
• ES2024: built-in promise helpers and object grouping utilities

The yearly cycle means JavaScript now improves continuously rather than in disruptive, once-a-decade leaps.

Why the ECMAScript Name Exists

The name "JavaScript" is a trademark owned by Oracle (which acquired Sun Microsystems). To avoid trademark issues, the standards body cannot call the specification "JavaScript." "ECMAScript" is the trademark-neutral name used for the standard document.

In practice, nobody says "I write ECMAScript." Everyone says "JavaScript." The name distinction is a legal artifact, not a technical one.

For a broader view of how JavaScript as a whole evolved alongside ECMAScript, see the complete history of JavaScript explained. To see exactly what features were added in each version from ES1 through ES6, read about how JavaScript evolved from ES1 to modern ES6.