Mungomash LLC
JavaScript Versions

1997 – 2026

JavaScript Versions

Every public release of ECMAScript — from ES1 in June 1997 through ES2026 (finalized December 2025) — with ship year and the headline language features per edition. Plus a feature-to-year lookup, an engine-support matrix, and the surrounding history: Brendan Eich's ten-day prototype, the JavaScript / Java naming dispute, the original engine wars, the ES4 collapse, the December 2009 ES5 detente, the June 2015 ES6 watershed, the TC39 stage process, and the Node.js fork-of-V8 lineage.

Era

Pre-Annual — ES1 – ES5.1, 1997–2011, irregular cadence with the seven-year ES4 deadlock at the middle
Annual — ES2015 (ES6) onward, year-pinned each June by the Ecma General Assembly

ECMAScript editions are spec versions, not implementations. For per-feature engine support see MDN and caniuse.com — both update on a sub-week cadence. The engine-support matrix below is the high-level "what edition does each major engine fully support" view.

ECMAScript edition table

Edition
ES2026 (17th Ed.)
Annual
Dec 2025 (finalized)
Finalized at the Dec 2025 TC39 plenary; Ecma General Assembly ratification expected June 2026. Iterator Sequencing, JSON.parse source-text, Math.sumPrecise.
  • Iterator Sequencing — Iterator.concat(...iterables) chains multiple iterables into one. Reached Stage 4 at the November 2025 TC39 plenary.
  • JSON.parse source-text access — the optional reviver argument now receives access to the source text of the value being parsed, enabling lossless round-trips for numeric precision. Reached Stage 4 at November 2025.
  • Math.sumPrecise(values) — correctly-rounded summation of an iterable of numbers, avoiding the floating-point accumulation error of a naive .reduce((a, b) => a + b) over a Number array.
  • Various smaller items per the TC39 finished-proposals list — check the “ES2026” section for the authoritative cutoff list.
  • Status: technically finalized at the December 2025 TC39 plenary (Stage 4 cutoff) and published as the 17th Edition draft. Formal Ecma General Assembly ratification expected June 2026, on the standard annual cadence.
Edition
ES2025 (16th Ed.)
Annual
Jun 25, 2025
Iterator helpers; Set methods (union, intersection, difference, …); JSON modules & import attributes; RegExp.escape; Promise.try; Float16Array.
  • Iterator helpers — Iterator.prototype.{map, filter, take, drop, flatMap, reduce, toArray, forEach, some, every, find} plus the Iterator global. Lazy, composable iterator pipelines without converting to arrays.
  • Set methods — Set.prototype.{union, intersection, difference, symmetricDifference, isSubsetOf, isSupersetOf, isDisjointFrom}. The convenience methods Set has long been missing.
  • JSON modules & import attributes — import data from "./data.json" with { type: "json" }. The standardized form of the older "import assertions" syntax.
  • RegExp.escape(s) — safely escape a string for use in a regex; the missing primitive that has shipped as third-party utility code for two decades.
  • Inline regex modifier flags — (?i:...), (?-i:...) for scoped flag changes inside a regex.
  • Promise.try(fn) — wrap a possibly-throwing, possibly-async callback in a single Promise without conditional handling.
  • Float16Array + Math.f16round + DataView.{get,set}Float16 — IEEE 754 half-precision floats; useful for ML inference and color pipelines.
  • Ratified by the Ecma General Assembly on June 25, 2025.
Edition
ES2024 (15th Ed.)
Annual
Jun 26, 2024
Object.groupBy / Map.groupBy; Promise.withResolvers; resizable ArrayBuffers; RegExp /v flag; well-formed Unicode strings.
  • Object.groupBy(items, fn) and Map.groupBy(items, fn) — the canonical group-by primitive that has shipped as a Lodash _.groupBy utility for a decade.
  • Promise.withResolvers() — returns { promise, resolve, reject }; eliminates the deferred-pattern boilerplate of capturing resolvers from inside the executor.
  • Resizable ArrayBuffers + transferable ArrayBuffers — new ArrayBuffer(n, { maxByteLength: m }), .resize(), .transfer().
  • RegExp /v flag — "Unicode sets" mode with set notation ([\p{L}--\p{ASCII}]) and properties of strings.
  • Well-formed Unicode strings — String.prototype.{isWellFormed, toWellFormed} for surrogate-pair sanity.
  • Atomics.waitAsync; ArrayBuffer.prototype.transferToFixedLength.
  • Ratified June 26, 2024.
Edition
ES2023 (14th Ed.)
Annual
Jun 27, 2023
Array find-from-last; array by copy (toSorted, toReversed, toSpliced, with); hashbang grammar; Symbols as WeakMap keys.
  • Array find from last — Array.prototype.{findLast, findLastIndex}.
  • Array by copy — non-mutating versions of sort, reverse, splice and a new with method that returns a new array with one element replaced. Long-overdue React-friendly primitives.
  • Hashbang grammar — #!/usr/bin/env node as a valid first line of a script.
  • Symbols as WeakMap keys — previously WeakMap keys had to be Objects; now non-registered Symbols are valid too.
  • Ratified June 27, 2023.
Edition
ES2022 (13th Ed.)
Annual
Jun 22, 2022
Class fields (public, private, static); top-level await; Object.hasOwn; Error.cause; Array.prototype.at; class static blocks.
  • Class fields — public instance fields, private fields with # prefix, public and private static fields, public and private methods. The largest class-syntax expansion since ES6.
  • Top-level await — in module scope, no async wrapper required. Reshapes how module loading composes with async work.
  • Object.hasOwn(obj, prop) — the safe-on-null-proto replacement for Object.prototype.hasOwnProperty.call.
  • Error.cause — throw new Error("msg", { cause: original }) for chained errors.
  • Array.prototype.at(i) — supports negative indices (arr.at(-1)).
  • Class static initialization blocks (static { ... }); RegExp /d flag for match indices; private fields presence checks (#field in obj).
  • Ratified June 22, 2022.
Edition
ES2021 (12th Ed.)
Annual
Jun 22, 2021
Logical assignment (||=, &&=, ??=); String.prototype.replaceAll; Promise.any; numeric separators; WeakRefs.
  • Logical assignment operators — x ||= y, x &&= y, x ??= y — conditional-assignment shortcuts pairing ES2020's ?? with the standard logical operators.
  • String.prototype.replaceAll(pattern, replacement) — the long-missing form that doesn't require a global regex flag.
  • Promise.any(promises) — resolves on the first fulfilled, rejects with AggregateError if all reject.
  • Numeric separators — 1_000_000 for readability; works on integers, floats, and BigInts.
  • WeakRefs and FinalizationRegistry — weak references and finalizers, with the explicit caveat in the spec that they're rarely the right tool.
  • Ratified June 22, 2021.
Edition
ES2020 (11th Ed.)
Annual
Jun 16, 2020
Optional chaining (?.); nullish coalescing (??); BigInt; Promise.allSettled; dynamic import(); globalThis; String.prototype.matchAll.
  • Optional chaining (?.) — obj?.prop?.method?.(). Eliminated a generation of "cannot read property of undefined" boilerplate; landed in TypeScript and V8 around the same time.
  • Nullish coalescing (??) — x ?? "default" falls back only on null / undefined, unlike || which falls back on any falsy value.
  • BigInt — arbitrary-precision integers with the 123n literal syntax.
  • Promise.allSettled — like Promise.all but waits for every promise regardless of rejection.
  • Dynamic import() — runtime-resolved modules; the foundation of every modern code-splitting bundler.
  • globalThis — the universal global reference (replaces the window / self / global / this sniffing pattern).
  • String.prototype.matchAll; export * as ns from "..." namespace re-export; for-in mechanics standardized.
  • Ratified June 16, 2020. The single largest "modern dialect" release since ES6.
Edition
ES2019 (10th Ed.)
Annual
Jun 17, 2019
Array.prototype.flat / flatMap; Object.fromEntries; optional catch binding; String.prototype.trimStart / trimEnd; stable Array.sort.
  • Array.prototype.flat(depth) and Array.prototype.flatMap(fn).
  • Object.fromEntries(iter) — the inverse of Object.entries.
  • Optional catch binding — try {} catch {}.
  • String.prototype.{trimStart, trimEnd}; Symbol.prototype.description.
  • Array.prototype.sort required to be stable.
Edition
ES2018 (9th Ed.)
Annual
Jun 26, 2018
Async iteration / for-await-of; object spread / rest; Promise.prototype.finally; RegExp lookbehind, named captures, /s dotAll, Unicode property escapes.
  • Async iteration — for-await-of, async generators (async function*).
  • Object spread / rest properties — { ...obj }, const { a, ...rest } = obj.
  • Promise.prototype.finally(fn).
  • Major regex expansion: lookbehind (?<=...) / (?<!...), named captures (?<name>...), /s dotAll, Unicode property escapes \p{...}.
  • Template literal revision (drops the well-formedness restriction on cooked strings).
Edition
ES2017 (8th Ed.)
Annual
Jun 27, 2017
async / await; Object.values / Object.entries; Object.getOwnPropertyDescriptors; string padding; trailing commas in function params.
  • async / await — the syntactic-sugar layer over Promises that reshaped async JavaScript. The most-celebrated post-ES6 addition.
  • Object.values(obj) and Object.entries(obj) — the long-missing siblings to Object.keys.
  • Object.getOwnPropertyDescriptors.
  • String padding: String.prototype.padStart / padEnd.
  • Trailing commas in function parameter lists.
  • Shared memory / Atomics (SharedArrayBuffer, Atomics).
Edition
ES2016 (7th Ed.)
Annual
Jun 14, 2016
First annual edition. Tiny scope by design: Array.prototype.includes; exponentiation operator **.
  • First annual edition. Deliberately tiny scope to prove out the new "ship-when-ready" cadence after ES6's six-year gap.
  • Array.prototype.includes(value) — clearer than indexOf(x) !== -1; correctly handles NaN.
  • Exponentiation operator ** — 2 ** 10 === 1024; the explicit operator form of Math.pow.
  • Set the template for every annual edition since: small, focused on what reached Stage 4 by the March cutoff, no big-bang feature drops.
Edition
ES2015 / ES6 (6th Ed.)
Annual
Jun 17, 2015
The watershed. let / const, arrow functions, classes, modules, Promises, template literals, destructuring, default / rest / spread, Map / Set / WeakMap / WeakSet, Symbols, generators, iterators, Proxies.
  • The watershed release of JavaScript. Six years in development after ES5 (2009) and the abandoned ES4. The single largest expansion of the language in its history; the "modern JavaScript" era starts here.
  • Lexical scoping — let and const at block scope. Replaces the var-only function-scope model that had defined the language since 1995.
  • Arrow functions — x => x * 2; lexical this.
  • Classes — sugar over the prototype model with extends / super.
  • ES Modules — import / export as the standard module system, ending the CommonJS / AMD / UMD wars.
  • Promises as a built-in primitive (replacing the proliferation of third-party Promise libraries).
  • Template literals, destructuring, default / rest / spread, Map / Set / WeakMap / WeakSet, Symbols, generators (function*, yield), iterators (for-of), Proxies and Reflect.
  • Tail calls were specified but never widely implemented (Safari is the only engine that ever shipped them).
  • Officially renamed from "ES6" to "ES2015" mid-process, marking the move to year-pin naming. Both names are still in common use; "ES6" is the cultural reference, "ES2015" is the spec name.

The ES6 watershed and the move to annual releases — June 2015. Above this line: the Annual era — year-pinned editions ratified each June by the Ecma General Assembly, with the Stage 4 cutoff for inclusion at the March TC39 plenary. Below: the Pre-Annual era — ES1 through ES5.1, 1997 through 2011, irregular cadence with the seven-year ES4 deadlock at its middle. The shift to annual editions is the most consequential process change in the language's history; the underlying TC39 stage process and the "what's at Stage 4 in March goes in the June edition" cadence date from this transition.

Edition
ES5.1 (5.1 Ed.)
Pre-Annual
Jun 2011
Editorial alignment with ISO/IEC 16262:2011. No new language features.
  • Editorial revision aligning ECMA-262 with the ISO/IEC 16262:2011 reference; no normative language changes.
  • This is the edition that was current for nearly four years — from June 2011 through June 2015 — while the post-ES4 community worked through what would become ES6.
Edition
ES5 (5th Ed.)
Pre-Annual
Dec 3, 2009
Strict mode; native JSON; getter / setter syntax; Object.create, Object.defineProperty; Array iteration methods (forEach, map, filter, reduce).
  • The detente release. Ratified December 3, 2009, ten years after ES3 and four years after the ES4 split. The "what we can all agree on" subset that emerged when ES4 was abandoned in 2008 and the committee broke into the ES3.1-becomes-ES5 track and the Harmony-becomes-ES6 track.
  • Strict mode ("use strict") — the opt-in stricter parsing and runtime that has been the foundation of every modern JS toolchain since.
  • Native JSON — JSON.parse / JSON.stringify. Replaces the older Crockford json2.js shim that every site had been carrying around.
  • Array iteration methods — forEach, map, filter, reduce, reduceRight, every, some, indexOf, lastIndexOf. Reshaped how JavaScript collections are processed.
  • Property descriptors — Object.create, Object.defineProperty, Object.freeze, getter / setter syntax in object literals.
  • Reserved words allowed as property names; trailing commas in object / array literals.
  • The first ECMAScript edition that all major browsers fully implemented within ~18 months — the engine wars finally produced cross-browser stability around a single spec.
Edition
ES3 (3rd Ed.)
Pre-Annual
Dec 1999
Regular expressions; try / catch; do-while; better Unicode handling.
  • Regular expressions as a first-class language feature — literal syntax (/pattern/flags), RegExp object, String-method integration.
  • try / catch / finally — structured exception handling.
  • do-while loops; switch statement standardized; better Unicode handling.
  • The edition that was current for ten years (1999–2009) while ES4 was being debated and ultimately abandoned.
Edition
ES2 (2nd Ed.)
Pre-Annual
Jun 1998
Editorial alignment with ISO/IEC 16262. No new language features.
  • Editorial revision aligning ECMA-262 with the ISO/IEC 16262 standard. No normative language changes.
Edition
ES1 (1st Ed.)
Pre-Annual
Jun 1997
First standardized edition. The Netscape JavaScript / Microsoft JScript common subset, formalized at Ecma International.
  • The first standardized edition of the language. Ratified by Ecma International in June 1997 as ECMA-262, derived from Netscape JavaScript 1.1 and Microsoft JScript with the convergent subset both engines implemented.
  • Brendan Eich's original Mocha / LiveScript / JavaScript prototype dated to May 1995 at Netscape; Microsoft's reverse-engineered JScript shipped in Internet Explorer 3.0 in August 1996; Netscape submitted JavaScript to Ecma International in November 1996, producing the ES1 standard the following June.
  • The edition number is "ECMAScript Edition 1" — the prefix "ES" became conventional only later.
  • The "ECMAScript" name was a compromise — "JavaScript" was a Sun trademark licensed to Netscape; "JScript" was Microsoft's preferred name for its implementation. The standards body needed a vendor-neutral term, and "ECMAScript" was the result.

Each row anchors as #es-YYYY for annual editions (e.g. #es-2025) or #esN for pre-annual editions (#es5, #es3, #es1). The TC39 finished-proposals list at github.com/tc39/proposals/blob/main/finished-proposals.md is the authoritative source for what landed in which edition.

Feature → ES year

Inverse of the table above — people search both "what's in ES2024" and "when did optional chaining ship". This curated list answers the second question at a glance for the high-search-volume features.

let / const, arrow functions, classes, modules, Promises, template literals, destructuring, Map / Set, generators, Proxies
ES2015 (ES6)
Array.prototype.includes, exponentiation **
ES2016
async / await, Object.values / entries, string padding
ES2017
Async iteration / for-await-of, object spread / rest, regex lookbehind & named captures
ES2018
Array.flat / flatMap, Object.fromEntries, optional catch binding, stable sort
ES2019
Optional chaining ?., nullish coalescing ??, BigInt, dynamic import(), globalThis, Promise.allSettled
ES2020
Logical assignment (||= &&= ??=), String.replaceAll, Promise.any, numeric separators, WeakRefs
ES2021
Class fields (public / private / static), top-level await, Object.hasOwn, Array.at, Error.cause, class static blocks, RegExp /d
ES2022
Array find from last (findLast, findLastIndex), array by copy (toSorted, toReversed, toSpliced, with), hashbang grammar, Symbols as WeakMap keys
ES2023
Object.groupBy / Map.groupBy, Promise.withResolvers, resizable ArrayBuffers, RegExp /v flag, well-formed Unicode strings
ES2024
Iterator helpers, Set methods (union, intersection, difference, …), JSON modules & import attributes, RegExp.escape, inline regex flags, Promise.try, Float16Array
ES2025
Iterator Sequencing, JSON.parse source-text access, Math.sumPrecise
ES2026
Strict mode, native JSON, Array iteration methods (forEach, map, filter, reduce), Object.create, getter / setter syntax
ES5
Regular expressions, try / catch, do-while
ES3

Curated subset of the high-search-volume features. For the full per-edition feature list, click the corresponding row in the table above. For per-feature engine support, see MDN and caniuse.com.

Engine support matrix

High-level "what edition does each major engine fully support" view. Per-feature status is on MDN and caniuse.com — both update on a sub-week cadence and are the canonical sources.

Engine ES5 (2009) ES2015 (ES6) ES2020 ES2024 ES2025
V8 (Chrome / Node / Edge) Chrome 23 (Nov 2012) Chrome 51 (May 2016) Chrome 85 (Aug 2020) Chrome 124 (Apr 2024) Chrome 134 (Mar 2025)
SpiderMonkey (Firefox) Firefox 21 (Apr 2013) Firefox 53 (Apr 2017) Firefox 80 (Aug 2020) Firefox 125 (Apr 2024) Firefox 136 (Mar 2025)
JavaScriptCore (Safari / WebKit) Safari 6 (Jul 2012) Safari 10 (Sep 2016) Safari 14 (Sep 2020) Safari 17.4 (Mar 2024) Safari 18.4 (Mar 2025)
Chakra (legacy Edge / IE11) IE 10 (Sep 2012) Edge 14 (Aug 2016, partial) EOL EOL EOL

"Full support" cells are best-effort calls based on the engine's own release notes plus MDN's compat-data — the standard's idea of "complete" sometimes lags an engine's last shipped feature for that year by a few months. Chakra was discontinued when Microsoft adopted Chromium / V8 for Edge in January 2020; the row remains for historical context.

The 1995 origin and Brendan Eich's ten-day prototype

JavaScript was prototyped by Brendan Eich at Netscape over ten days in May 1995. Netscape needed a scripting language to embed in their browser; Marc Andreessen and the Netscape leadership wanted something that "looked like Java" because Java was the hot language at the time and Sun was a strategic partner. Eich was hired with the brief to build a Scheme-in-the-browser; once the strategic decision came down to ship a Java-syntax-flavored language instead, Eich did the design work in ten days against a hard ship deadline. The result was named Mocha, then LiveScript, then JavaScript — the last name was a marketing move to capitalize on Java's mindshare, not a technical lineage statement. The language shipped in Netscape Navigator 2.0 beta on September 18, 1995.

Eich's design under the ten-day deadline produced both the language's strengths (first-class functions, prototype-based objects, dynamic typing, garbage collection) and most of its long-running quirks (the == coercion rules, typeof null === "object", automatic semicolon insertion, the var function-scope model). Many of the language's modern revisions are about working around or around the original ten-day decisions. Eich has been candid about this in talks and interviews: the brief said "make it look like Java," the deadline was non-negotiable, and the design committee was him.

JScript and the original engine wars

Microsoft reverse-engineered JavaScript and shipped JScript in Internet Explorer 3.0 in August 1996. The two implementations diverged immediately on subtle semantic edges; web developers spent the next decade writing browser-specific code paths because the same JavaScript could behave differently between Netscape and IE. Netscape submitted the language to Ecma International in November 1996 to produce a vendor-neutral standard; the result was ECMAScript Edition 1 in June 1997. The "ECMAScript" name was the standards-body compromise — "JavaScript" was a Sun-trademarked name licensed to Netscape, "JScript" was Microsoft's preferred name, and Ecma needed something neither side could veto.

The ES4 collapse and the seven-year freeze (2003–2008)

After ES3 in December 1999, the TC39 committee began work on a much more ambitious ECMAScript 4 — classes, packages, namespaces, optional static typing, generators, an enhanced type system. Mozilla and Adobe (using their ActionScript 3.0 implementation, which was already a partial ES4) backed the design; Microsoft and Yahoo argued ES4 was too ambitious, would fragment the language, and risked breaking the web. The argument ran for years.

The committee deadlocked. In August 2008, after multiple failed attempts at consensus, TC39 split the work into two tracks: a small editorial-and-cleanup release that would become ES5 (December 2009), and an ambitious longer-horizon project codenamed Harmony that would eventually ship as ES6 / ES2015 in June 2015. ES4 itself was abandoned. Most of its design ideas survived into ES6 and beyond — classes, modules, destructuring, default parameters — but the seven-year-zero-edition gap is the largest in the language's history and shaped how every TC39 process decision since has been made (smaller scope, shorter cycles, Stage-gated proposals, no big-bang releases).

The TC39 stage process

The post-ES6 TC39 process is structured around five stages for every proposed language addition:

  • Stage 0 — Strawperson. Anyone can submit; the proposal is in the conversation.
  • Stage 1 — Proposal. A champion takes ownership; the committee accepts the problem is worth solving.
  • Stage 2 — Draft. Initial spec text and one experimental implementation; the design is "probably going to ship something like this."
  • Stage 3 — Candidate. Spec text is complete; engines are expected to implement and gather feedback. Most TC39 features that ship in any given year were at Stage 3 the year before. Most TypeScript compiler features at this level land in TS via the Stage-3 implementation pipeline.
  • Stage 4 — Finished. Implementations exist in two engines, the spec text has been approved, and the proposal is included in the next year's edition. The March TC39 plenary is the cutoff for the June ratification.

The cadence: Stage 4 by March → Ecma General Assembly ratifies in June → spec snapshot pinned at tc39.es/ecma262/<year>/. Most modern editions have 5–15 finished proposals.

The engine lineage

Four major JavaScript engines have shaped the modern landscape:

  • SpiderMonkey (Mozilla) — the original engine, descendant of Brendan Eich's 1995 prototype. Written in C++ with a JIT (IonMonkey, then WarpMonkey). Powers Firefox.
  • V8 (Google) — built by Lars Bak at Google's Aarhus office for Chrome's launch in September 2008. Open-source from day one (BSD), JIT-driven (TurboFan, Maglev, Sparkplug), the engine that turned JavaScript performance into a serious cross-vendor competition. Now powers Chrome, Node.js, Microsoft Edge (since January 2020), Opera, Brave, Cloudflare Workers, Deno, and most of the rest of the modern V8-derived ecosystem.
  • JavaScriptCore / Nitro (Apple) — powers Safari and the WebKit web view used in every iOS app. Less aggressively marketed than V8 but technically peer; the FTL JIT and B3 backend produce competitive numbers.
  • Chakra (Microsoft) — powered Internet Explorer 9 through 11 and the original (2015–2020) Edge. Discontinued when Microsoft adopted Chromium / V8 for Edge in January 2020. The engine wars effectively ended at that point: every major modern browser uses a V8 / SpiderMonkey / JavaScriptCore engine, and V8 has the largest share by a wide margin.

Smaller specialized engines exist alongside: Hermes (Meta, for React Native), QuickJS (Fabrice Bellard's tiny embeddable engine), Boa (Rust implementation), Engine262 (TC39's reference interpreter for spec testing).

Node.js — JavaScript on the server (2009–)

Ryan Dahl announced Node.js at JSConf EU on November 8, 2009 — V8 (Google's then-newish JavaScript engine) wrapped in an event-loop runtime designed for non-blocking I/O. The pitch: write the same language on both ends of a network connection, with concurrency handled by the event loop instead of by threads. The combination caught on faster than anyone expected. Within five years, Node.js had reshaped the back-end JavaScript ecosystem, the browser-tooling ecosystem (every modern frontend toolchain runs on Node), and effectively created the npm package-management universe that has now cleared more than two million packages. Dahl handed off Node.js to the community and OpenJS Foundation; he later founded Deno in 2018 as an attempt to retry the design with the lessons learned. Bun (Jarred Sumner, 2022) is a third attempt with a Zig-based runtime, JavaScriptCore instead of V8, and a much faster cold-start path.

People who actually shaped JavaScript / ECMAScript

Origin and language design: Brendan Eich (Netscape, 1995; the ten-day prototype; later co-founded Mozilla and Brave); Marc Andreessen (Netscape co-founder; the strategic decision to make the language Java-syntax-flavored).

TC39 chairs and editors: Allen Wirfs-Brock (long-serving editor through the ES5 / ES6 era), Brian Terlson (editor through the early-annual era), Bradley Farias and Daniel Ehrenberg (modern co-editors), Rob Palmer and Yulia Startsev (recent TC39 co-chairs). Champions of long-running modernizations include Mark Miller, Allen Wirfs-Brock, Waldemar Horwat, Daniel Ehrenberg, Jordan Harband, Mathias Bynens, and many others.

Engines: Lars Bak (V8 architect, ex-Sun HotSpot lineage), Andreas Rossberg and the Mozilla SpiderMonkey lineage, Filip Pizlo and the JavaScriptCore / FTL JIT team. Server-side / runtimes: Ryan Dahl (Node.js, Deno), Jarred Sumner (Bun). The community of proposal champions who actually drag features through the Stage process — the per-proposal author lists in the TC39 finished-proposals repository are the canonical credit list.

Sources: TC39 finished-proposals; ECMA-262 standards page; TC39 spec snapshots; MDN web docs (CC-BY-SA); caniuse.com (CC-BY); Brendan Eich's history posts and 2008 JSConf talk; TC39 meeting notes. Cross-references: TypeScript Versions. Last updated April 2026.

Mungomash LLC · More data pages