JavaScript History

Why should you care about JavaScript History?

JavaScript's history explains its name, its relationship to ECMAScript, and why browser compatibility matters.

JavaScript began as a browser scripting language and later became a standardized language used in many environments.

This page traces the language's origins, its standard, and the reasons browser compatibility still matters.

The language changed names while it was being created. It was first called Mocha, then LiveScript, and finally JavaScript.

The name was partly a marketing decision because Java was popular at the time. JavaScript and Java are separate languages.

Remember: JavaScript is not a version of Java. The similar names do not mean that the languages are the same.

As JavaScript became popular, Netscape was not the only browser company using it. Microsoft added its own implementation to Internet Explorer. Different browsers sometimes interpreted the same code differently.

This period is often called the browser wars. For developers, it could mean writing one version of a page for one browser and another version for a different browser.

The web needed a shared set of rules so browser teams could build compatible implementations. Netscape submitted JavaScript to the standards organization ECMA, which led to the ECMAScript standard.

Why this matters: Standardization did not make every browser identical, but it gave them a common language foundation.

Picture this: it's 1995, and websites are mostly static documents. Netscape, the popular browser company at the time, wanted to change that and make web pages interactive. They hired a programmer named Brendan Eich to create a scripting language. In an impressive 10 days, he built the first version of JavaScript.

The first version was a small browser scripting language. JavaScript later grew as standards and new uses emerged.

As other browsers adopted JavaScript, developers needed shared rules for compatible implementations.

In short: Netscape developed JavaScript in 1995 to make web pages interactive.

  1. JavaScript debuts

    Netscape introduces the language in Navigator.

  2. First standard

    Ecma publishes the first edition of ECMA-262.

  3. Chrome and V8

    Google launches Chrome with the V8 JavaScript engine.

  4. ES5 and Node.js

    ES5 is published. Node.js brings V8 to a server-side runtime.

  5. ES2015

    Also called ES6, it adds modules, classes, and promises.

  6. Annual editions

    ECMAScript editions take the year as their name.

JavaScript is the programming language developers write and use in browsers, servers, and other environments.

ECMAScript is the specification, or rulebook, that describes how the core language should work. It defines things such as syntax, values, functions, and language features.

TC39 is the committee that develops and maintains the ECMAScript standard. Ecma International is the standards organization that publishes it.

A simple way to remember the relationship is:

  • TC39 develops the ECMAScript standard.
  • Ecma International publishes the specification.
  • JavaScript engines implement the standard.
  • Browsers provide the environment where your JavaScript runs.

Why this matters: A shared rulebook helps different JavaScript implementations agree on the core language, even though browser support for newer features can still vary.

What Is ECMAScript?

ECMAScript defines the core language. JavaScript engines implement that specification, while browsers and other hosts provide additional APIs and a runtime environment.

ECMAScript is maintained through two main official documents:

  • ECMA-262 - The main ECMAScript language specification defines syntax, types, and built-in behavior. JavaScript engine implementers use it as a common reference.
  • ISO/IEC 22275:2018 defines the ECMAScript Specification Suite as an ISO/IEC International Standard. It is not a yearly edition of ECMA-262.

JavaScript Versions: The Big Picture

The key milestones are ES3, the abandoned ES4, ES5, and the major ES2015 update. Since then, new editions have generally been published annually.

VersionYearWhy it matters
ES31999Established important early language features.
ES52009Added strict mode, JSON, and useful array methods.
ES6 / ES20152015Major modernization with features developers still use today.
ES2016 onwardGenerally annualIncremental updates; ES2026 is the latest edition.

Published ECMAScript editions

YearEdition
1997ES1
1998ES2
1999ES3
2009ES5
2011ES5.1
2015ES2015 (ES6)
2016ES2016
2017ES2017
2018ES2018
YearEdition
2019ES2019
2020ES2020
2021ES2021
2022ES2022
2023ES2023
2024ES2024
2025ES2025
2026ES2026

The proposed fourth edition was never published.

Early editions were released at irregular intervals. Since ES2016, editions have generally been published each year.

  • ES1 (1997), ES2 (1998), ES3 (1999) - These early versions established the basics. ES3 added regular expressions and error handling, which were huge at the time.
  • ES4 - Abandoned. The community couldn't agree on the direction, so this version never happened.
  • ES5 (2009) - After a long gap, ES5 brought strict mode (which catches common mistakes), JSON support, and useful array methods. This version gave JavaScript a stability boost.
  • ES6 / ECMAScript 2015 - ES6 introduced features such as arrow functions, template literals, block-scoped let and const declarations, and class syntax built on JavaScript's prototype system. It is often treated as the start of modern JavaScript, though the language continues to evolve. Important naming note: ES6 is also called ES2015. Later editions use year-based names, such as ES2016, ES2017, and ES2018. Both naming styles remain common online.
  • ECMAScript 2016 onwards - Yearly updates - New editions have generally been published annually since 2016. Examples of features follow:
    • 2016: Array.includes() for checking if an element exists in an array
    • 2017: async/await syntax, plus Object.values() and Object.entries()
    • 2018: Object rest and spread syntax; array rest and spread were standardized earlier.
    • 2020: Optional chaining (?.) and nullish coalescing (??) for safer property access
    • 2021: Promise.any() and String replaceAll() method
    • 2022: Class fields and private methods
    • 2023: Array methods like findLast() and toSorted() for convenient data manipulation
    • 2024-2026: Object.groupBy() and Map.groupBy() (2024); iterator helpers and Set methods (2025); further additions (2026). See the current specification for details.

Why Do Developers Talk About ES5 and ES6?

ES5 and ES6 mark major stages in JavaScript's development. ES6 / ES2015 introduced features such as let and const, arrow functions, template literals, and class syntax. These features remain common in modern code.

The language continues to evolve, but you can learn its core features without memorizing edition numbers.

Node.js (2009) made server-side JavaScript practical and expanded where the language could run. It complements rather than replaces browser JavaScript.

Pro tip for beginners: Some older features, such as var remains relevant when reading older code. Modern code generally prefers let and const because they are block-scoped. You will learn the differences later.

Major browsers use JavaScript engines that parse and execute code according to ECMAScript. Browsers can share engines: Chrome and Edge use V8, Firefox uses SpiderMonkey, and Safari uses JavaScriptCore. Engines may add support for new language features at different times.

JavaScript engines aim to follow the same ECMAScript standard, but new language features may arrive at different times. Browser APIs can also vary, so check support for the browsers you target. Feature detection and polyfills can help when needed.

A Simple Compatibility Example

Suppose a new JavaScript feature is released. A newer browser may support it, while an older browser may not understand it. Developers can check whether a feature exists, transform newer code into an older form with a transpiler, or provide a polyfill that adds a missing behavior. These tools help support more browsers, but an older browser cannot automatically understand brand-new syntax by itself.

Two compatibility concepts you'll encounter:

  • Backward compatibility - Newer engines aim to preserve the behavior of older JavaScript code, though browser APIs and surrounding services can still change.
  • Forward compatibility - A system is designed to tolerate some future changes. Older browsers still need transformed code or a fallback to handle newer JavaScript syntax.

These examples show how compatibility depends on which system is older and whether new additions are optional:

future-backward-compatible
Topic Backward Compatible Forward Compatible
Browsers Newer engines aim to run code written for older ECMAScript editions. Older browsers cannot parse new syntax unless code is transformed or a fallback is used.
File Formats Newer software can read older file formats when the format remains supported. Older software can ignore unknown optional fields if the format allows it.
APIs Newer API versions may preserve older endpoints or behavior. A client can tolerate added response fields if it ignores unknown fields.
Hardware Newer hardware can support software designed for older hardware when compatible. Older hardware cannot use unsupported features; software needs fallbacks for those devices.
Software Newer software may preserve compatibility with older versions or data. Older software can tolerate additions only when designed to handle them.

Browser Support for JavaScript APIs - MDN

"Can I use"

You do not need to memorize every ECMAScript version or every yearly feature. For now, remember:

  1. JavaScript was created in 1995 at Netscape by Brendan Eich. It was originally called Mocha, then LiveScript.
  2. ECMAScript is the specification behind the core language. TC39 develops it, and Ecma International publishes it.
  3. ES6 / ECMAScript 2015 marked a major modernization. New editions have generally followed an annual schedule since 2016, through ES2026.
  4. Node.js (released in 2009) made server-side JavaScript practical.
  5. Browsers use engines that may support new language features at different times, so check compatibility for your target browsers.
  6. Backward compatibility means newer systems can continue to work with older code or data.
  7. Forward compatibility means a system is designed to handle certain future changes; old browsers still need transformed code or a fallback for new JavaScript features.
  8. What's next? You now know where JavaScript came from and how it evolved. Next, let's set up your coding environment so you can start writing JavaScript yourself in the next tutorial.

JavaScript History, Hindi video
SimplyJavaScript Logo
JavaScript Introduction & History
JavaScript History, English video
SimplyJavaScript Logo
JavaScript Introduction & History

Reviewed by

SimplyJavaScript Editorial Team

Technical editors and JavaScript educators with hands-on experience building frontend projects, writing learning material, and reviewing tutorials for clarity, accuracy, and beginner-friendly guidance.