ECMAScript

ECMAScript is the standardized language specification for JavaScript, intended to make implementations interoperable across web browsers and other execution environments. The specification is maintained by Ecma International through Technical Committee 39, commonly called TC39. Its principal language definition is published as ECMA-262, while related Ecma standards define internationalization APIs, JSON syntax, and source-map formats. The language originated at Netscape, where Brendan Eich developed a browser scripting language that passed through the names Mocha and LiveScript before being marketed as JavaScript. The name JavaScript reflected a commercial relationship between Netscape and Sun Microsystems, although the language was not the same as Java. Microsoft developed a compatible implementation known as JScript, and the need for cross-browser compatibility helped drive formal standardization. In 1996, Netscape announced work with Ecma International, and the first edition of ECMA-262 was approved in June 1997. ECMAScript became the compromise name used for the standardized language because JavaScript was associated with Netscape and Sun trademarks and with the competing interests of browser vendors. ECMAScript defines core language behavior rather than a complete application platform. It specifies syntax, values, objects, functions, control structures, modules, error handling, internationalization-related integration, and built-in facilities such as Array, Function, Promise, Map, Set, and globalThis. It does not itself define networking, persistent storage, graphics, or general input/output. Those capabilities are supplied by host environments, including browser APIs and server-side runtimes such as Node.js, Deno, and Bun. The language combines structured and imperative programming with dynamic and weak typing, first-class functions, closures, and prototype-based object behavior. Earlier versions relied heavily on function-scoped var declarations; ECMAScript 2015 introduced let and const for block scoping, together with classes, modules, promises, iterators, generators, and other major improvements. Since the 2015 edition, TC39 has generally finalized a new edition each June through a staged proposal process. Proposals advance from early investigation to implementation-ready Stage 4 status through committee review and consensus. ECMAScript is used principally through JavaScript implementations. It supports client-side web applications, browser tooling, desktop and mobile application frameworks, command-line programs, server applications, automation, and increasingly distributed and cloud services. Developers frequently use transpilers and polyfills to adapt newer language features to older environments. Conformance is assessed through Test262, a large open test suite developed by TC39 participants and member organizations. The specification remains an active foundation for the JavaScript ecosystem rather than a conventional commercial product, company, or separately operated software platform.

ECMAScript developed from the browser scripting language created by Brendan Eich at Netscape. The language was initially called Mocha and later LiveScript before Netscape and Sun Microsystems promoted it under the name JavaScript in December 1995. Although JavaScript shared some marketing association with Java, it was a distinct language designed for scripting within web browsers. The rapid growth of browser scripting produced compatibility problems. Netscape had its JavaScript implementation, while Microsoft developed JScript for Internet Explorer. Their similarities made cross-browser programming possible, but differences in behavior made portability difficult. Netscape therefore announced in 1996 that it would pursue standardization through Ecma International. The effort was conducted by Technical Committee 39, now known as TC39. The term ECMAScript was selected as a neutral standardized name amid commercial and trademark considerations involving Netscape, Sun, and Microsoft. The first edition of ECMA-262 was approved by the Ecma General Assembly in June 1997. Later editions refined the language and added features while preserving compatibility with existing JavaScript programs. The specification covers the language's syntax and semantics, built-in objects, functions, execution model, and other core behavior. It does not prescribe the host APIs needed for networking, files, graphics, browser documents, or persistent storage. Those facilities are defined by the environment in which an ECMAScript implementation runs. The sixth edition, published in 2015 and commonly called ECMAScript 2015 or ES6, was a major expansion. It added block-scoped declarations through let and const, classes, modules, promises, iterators, generators, symbols, template literals, destructuring, and many other capabilities. After this release, ECMAScript moved to a regular yearly publication cycle, with proposals developed through TC39's staged process. A proposal normally progresses from early-stage exploration toward Stage 4, where the specification text and implementation evidence are considered sufficient for inclusion in a standard edition. The ecosystem expanded beyond browsers as JavaScript runtimes became common on servers and in other computing contexts. Node.js, Deno, and Bun are examples of runtimes that implement ECMAScript while adding their own input/output and system APIs. Development workflows also adopted transpilation, allowing newer source syntax to be converted for older engines, and polyfills, which provide missing functionality at runtime. These tools helped maintain compatibility during the gradual adoption of new editions. Ecma International maintains several standards around the core language. ECMA-402 defines internationalization APIs, including the Intl facilities used for locale-sensitive formatting and related operations. ECMA-404 defines JSON syntax, a language-independent data interchange format derived from JavaScript notation. ECMA-426 defines the source-map format used to relate generated or transformed code to its original sources. TC39 also coordinates Test262, a conformance suite containing tests for the requirements of ECMAScript editions. Together, the specification, related standards, tests, browser engines, and non-browser runtimes form the technical foundation of the modern JavaScript ecosystem.

• 2024

  Source Map Format standardized as ECMA-426

  [1]ECMAScripten.wikipedia.org

  Ecma published the source-map format as a standard for mapping transformed code back to original source files.

• 2015

  ECMAScript 2015 introduced major language features

  [1]ECMAScripten.wikipedia.org

  The sixth edition added major capabilities including block scoping, classes, modules, promises, iterators, generators, symbols, and template literals.

• 2010

  Ecma began development of an ECMAScript conformance test

  [1]ECMAScripten.wikipedia.org

  Ecma International began developing a test standard and suite for evaluating how closely implementations follow ECMA-262.

• 1997

  ECMA-262 first edition adopted

  [1]ECMAScripten.wikipedia.org

  The first edition of the ECMAScript language specification was approved by the Ecma General Assembly.

• 1996

  Standardization effort initiated through Ecma International

  [1]ECMAScripten.wikipedia.org

  Netscape announced cooperation with Ecma International to advance a common standard for JavaScript.

• 1995

  JavaScript announced

  [1]ECMAScripten.wikipedia.org

  Netscape and Sun Microsystems publicly announced JavaScript after its development under earlier names including Mocha and LiveScript.

An open, implementation-neutral language standard that provides the common behavioral foundation for JavaScript across browsers, servers, and other runtimes.

• Programming-language standard · 1997

  ECMAScript Language Specification

  Published as ECMA-262, this is the core specification for ECMAScript. It defines the language's syntax, semantics, execution behavior, built-in objects, functions, operators, control structures, modules, and other fundamental facilities. It is implemented by JavaScript engines in browsers and by standalone runtimes. The standard deliberately leaves many system capabilities, including networking, storage, graphics, and file access, to the host environment.

• Internationalization standard

  ECMAScript Internationalization API

  ECMA-402 complements ECMA-262 with APIs for internationalized applications. Its facilities support locale-sensitive operations such as formatting numbers, dates, lists, and text, enabling JavaScript programs to adapt output to different languages and regional conventions.

• Data format standard

  JSON Data Interchange Syntax

  ECMA-404 specifies JSON, a human-readable data interchange syntax derived from JavaScript notation. JSON is designed to be independent of any one programming language and is widely used for exchanging structured data between applications and services.

• Developer-tooling standard · 2024

  Source Map Format

  ECMA-426 defines a source-map format that connects generated or transformed code with its original source files. This allows debugging tools to show original source locations even when programs have been transpiled, bundled, or minified.

• Conformance test suite · 2010

  Test262

  Test262 is a conformance suite used to evaluate ECMAScript implementations against requirements in the language specification. It is developed through the TC39 community, with tests contributed by Ecma member organizations and other participants.

• 2015

  Adopt ECMAScript 2015 as a major language-generation updateGeneration change

  Background

  The language required substantial modernization while retaining compatibility with the large installed base of JavaScript programs and engines.

  Action taken

  The sixth edition introduced block scoping, classes, modules, promises, iterators, generators, symbols, template literals, destructuring, and other language features.

  Aftermath

  ECMAScript entered a regular annual release cycle, and transpilers and polyfills became widely used to support the gradual adoption of new features.

  Source

• 1996

  Move JavaScript toward neutral international standardizationStrategy

  Background

  Browser vendors were producing related but not always identical scripting implementations, creating interoperability problems and commercial tensions.

  Action taken

  Netscape announced work with Ecma International and its technical committee to define a standardized language specification.

  Aftermath

  The process produced ECMA-262 and established ECMAScript as the neutral name for the standardized language, while JavaScript remained the dominant implementation and ecosystem name.

  • Microsoft — Microsoft participated in the broader browser-standardization context and had its own compatible JScript implementation.

  Source

1. 1ECMAScripten.wikipedia.org
2. 2Ecma Internationalecma-international.org