跪拜 Guibai
← Back to the summary

ES2026 Lands, Temporal Ships, and Decorators Get Demoted: The State of JavaScript Standards

The Most Comprehensive ECMAScript Guide on the Web (Updated to ES2026)

This article was written in 2021 and is updated annually with each new standard release. Thanks to Claude's assistance, this year's edition has undergone the largest update ever: a detailed breakdown of each new ES2026 feature, a complete reversal to descending chronological order, and deep dives into TC39 proposals and Ecma member dynamics.

First, take a minute to catch up on what happened in the JavaScript standards world over the past year:

As a front-end developer, the term ES6 is likely familiar, and you probably know the oddly pronounced name ECMAScript. But have you ever been curious about the mysterious numeric codes of the ECMA world? What is ECMA-262? What is ESxxx? What is TC39? What do Stage 3 and Stage 4 mean? Are you confused by the endless stream of new ES20XX features, wondering which year a feature was introduced, where to find these proposals, which ones are usable, and where to look up past ES standards? Today, I'll unveil the mystery of ECMAScript, helping you thoroughly understand these cryptic codes and all ECMAScript features up to 2026.

Also: Congratulations to China's first JS language proposal, which entered Stage 3 in April 2021, successfully reached Stage 4 in November 2021, and was officially released in ECMAScript 2022, becoming a de facto standard. See Error Cause.

On June 30, 2026, the 131st Ecma International General Assembly in Geneva approved ECMA-262 17th Edition — the ECMAScript® 2026 standard. The same meeting also approved ECMA-402 13th Edition (ECMAScript Internationalization API). The full specification can be read online at tc39.es/ecma262/2026.

ECMAScript History

Let's first look at what ECMA is. ECMA, pronounced like "Ek-ma," is the abbreviation for the European Computer Manufacturers Association, an international membership-based information and telecommunications standards organization. After 1994, as the organization's standards involved many other countries, to reflect its international nature, it was renamed Ecma International. Thus, Ecma is no longer an acronym.

img-01.png Understanding this history, for the professionalism of technical writing, if you mention Ecma in an article, the standard way to write it is Ecma (the official logo uses lowercase ecma), not all-caps ECMA, unless it's a proper noun and standard number like ECMAScript or ECMA-262.

In 1995, Brendan Eich of the famous Netscape company developed a scripting language, initially named Mocha, later renamed LiveScript, and finally renamed JavaScript to ride the popularity of the then-hot Java.

With an understanding of Ecma International and JavaScript, it's easier to understand ECMAScript. ECMAScript is a scripting language specification defined by Ecma International in the standard ECMA-262. This language is often referred to as JavaScript or JScript (Microsoft's dialect from the IE era, now history), but in reality, they are implementations and extensions of the ECMA-262 standard.

The Mysterious ECMA-262

The first mysterious code mentioned above is ECMA-262. What exactly is ECMA-262? It turns out that Ecma International's standards are all named with "ECMA-number" (the standard number retains the historical all-caps writing). ECMA-262 is the 262nd standard, specifically referring to the standard that ECMAScript complies with. In November 1996, Netscape submitted JavaScript to Ecma International for standardization. The first version of ECMA-262 was adopted by Ecma International in June 1997.

Although JavaScript and JScript are compatible with ECMAScript, they contain features beyond ECMAScript.

How can we view the latest and most complete Ecma standards? You can check the Standards page on the Ecma International website. As of July 2026, the latest Ecma standard has reached ECMA-434. Interestingly, ECMA-430 ~ 434 are a full suite of NLIP (Natural Language Interaction Protocol) standards and their security configurations and transport bindings, approved in December 2025. In the AI Agent era, even "natural language interaction" itself is beginning to be standardized. The same batch also includes ECMA-429 (Minimum common web API, defining a minimal common Web API set for various JS runtimes).

img-02.png Ecma standards cover a wide range of categories. The official website provides the ability to sort by category and latest modification. Let's see which category ECMA-262 belongs to:

img-03.png ECMA-262 belongs to the "Software Engineering and Interfaces" category, which has a total of 22 standards, as shown in the image above (ECMA-427, 428, and 429, added in December 2025, are the Package-URL specification, Common Lifecycle Enumeration CLE, and Minimum common web API, respectively; the NLIP series is not in this category). Note that the latest update date for ECMA-262 is June 2026, and the current latest standard is ES2026.

Exploring the Mysterious Organization: Ecma TC39

After unveiling the mystery of Ecma-262, let's explore a mysterious organization codenamed TC39.

img-04.png Actually, the official website explains it quite clearly. I'll briefly summarize in Chinese:

TC39 is the abbreviation for Technical Committee 39, the committee responsible for developing the ECMAScript standard. It is composed of representatives sent by Ecma member organizations: browser vendors are the core, but representatives from financial companies, open-source consulting firms, and universities are also among them (the extended reading below will elaborate). The chair group of three comes from IBM, Bloomberg, and Igalia (current in 2026), and there are 5 Task Groups:

We often see news like: XX company becomes a member of Ecma TC39. To participate in TC39 meetings as a member, you must first join Ecma (after the Ecma website revamp, this participation guide was moved to the TC39 website homepage, which also conveniently places the six-stage process and meeting minutes entry points together):

img-05.png So, who exactly are the members of Ecma? The Ecma official website provides the answer:

img-06.png Several giants are prominently listed! The 6 Ordinary members in 2026: Apple, Bloomberg, Google, Huawei, IBM, Meta. Here's a key point to clarify a common misunderstanding (which even earlier versions of this article didn't state precisely): There is only one type of membership, which is Ecma membership. There is no separate "TC39 membership." Ecma membership has 5 categories: Ordinary members, Associate members, SME members, SPC members, and NFP members. After paying dues to Ecma, participating in any technical committee like TC39 or TC54 incurs no extra charge, although joining TC39 requires signing an additional patent royalty-free agreement (RFTC registry, no cost). Let's look at the comparison between Ordinary and Associate members:

img-07.png Associate members do not have voting rights at the Ecma General Assembly! Among Associate members, China has 2 more: Alibaba and 360 (compared to 2021, Tencent is missing; ByteDance was listed between 2021-2025 but has exited the membership list in 2026).

Wait, CHF 70,000, is that 70,000 Swiss Francs? Ecma is indeed a European heavyweight. The annual fee for an Ordinary member is about 590,000 RMB (based on the July 2026 exchange rate of 1 CHF ≈ 8.4 CNY). A quick calculation shows Ecma International's annual membership fee income is 1,260,000 Francs, breaking the ten-million RMB mark.

img-08.png To learn more about TC39, you can explore its official website TC39 – Specifying JavaScript. and its GitHub repository Ecma TC39 · GitHub. Note that this repository is very important. Checking the members, you can find three domestic experts: Yue Ying, Li Songfeng, and Yuan Yan.

Latest Ecma Membership Updates (2026)

As of July 2026 (Ecma Members Page), the membership landscape has several noteworthy changes:

The total number of members has grown from about 70 in 2021 and 86 in 2025 to 92. Wait, what are graphics card makers NVIDIA and AMD doing in a JavaScript standards organization? And why did ByteDance quietly leave? Read the extended reading below.

Extended Reading: What Are the Giants Really Here For?

To answer the two questions above, I had Claude's research Agent comb through Ecma's yearbook (Memento, published annually, listing registered representatives by committee) and TC39's public meeting minutes—over 90 searches, each demanding a primary source. This kind of grunt work is exactly what an Agent excels at. The answers are more interesting than expected.

First, correct an intuition: Ecma ≠ TC39. In recent years, Ecma has quietly opened several new tables, and new members have different seats:

So the answer to the first question is revealed: The graphics card makers did indeed take a seat in Ecma's meeting room, but probably not in TC39's. Two fun facts uncovered while flipping through the yearbook: Dell joined as early as 2019, with its registered representative serving as Vice Chair of the TC26 Acoustics Committee, specializing in small fan noise—nothing to do with JS. F5's membership was inherited from its 2020 acquisition of Shape Security. Kevin Gibbons, who contributed two features to ES2026, wears an F5 badge.

Now, look at the departures:

When ByteDance joined in June 2021, the TC39 secretary left a remarkably blunt record in the meeting minutes: "Honestly speaking I have not heard about them." Over the next four years, ByteDance registered 8 representatives in the yearbook, but the Agent performed a full-text search of all public TC39 minutes from 2021-2026: zero speeches, zero proposals, zero sign-in records. The membership expired at the end of 2025 and was not renewed (website member page snapshots show it present in November 2025, gone by January 2026), a silent exit. Its real standards circle intersection was actually WinterCG (the community precursor to TC55, whose participant list still lists ByteDance). Its JS engine PrimJS (the runtime for the Lynx framework) only needs to implement ECMAScript, not hold membership.

This isn't an isolated case: Tencent joined in 2020, exited in 2023, also with zero hits in public minutes. In a word: An annual fee of less than 300,000 RMB buys a seat at the table easily; the hard part is actually sending someone to the meetings. In contrast: Alibaba's Error Cause proposal made it into ES2022, and Huawei holds Ordinary member voting rights at the General Assembly—the presence of Chinese companies at this table has never been determined by membership fees.

To answer a practical question: Can you directly check the "TC39 member list" on the official website? The closest page is the TC39 Royalty-Free Technical Committee Members list, but note that it's a historical cumulative list: once signed, you're on it, about 80 companies. Those who leave aren't removed, just marked with an asterisk as "Former Ecma member"—ByteDance and Tencent are still listed there. To see which companies currently have representatives registered for TC39, you have to dig through the annual Memento yearbook. This list also provides a small piece of evidence: Neither NVIDIA nor AMD has signed this TC39 agreement, indirectly confirming their entry wasn't for JavaScript.

Conversely, who is actually doing the work in TC39? A sketch based on the 2026 yearbook and proposal records:

The Familiar ES6

After exploring the mysterious ECMA-262 and TC39, let's take a breather and look at the ESX family we're most familiar with.

As mentioned above, ECMAScript is a scripting language specification defined by Ecma International in the standard ECMA-262. By 2015, a total of 6 versions had been officially released: 1, 2, 3, 5, 5.1, and 6 (the 4th edition died in the womb and was never released, leaving the version number vacant; see the ES6 inaugural year special below for this story).

We often collectively refer to the 5th edition and the 5.1 revision as ES5, and the 6th edition and subsequent versions as ES6 (because starting from 2015, ECMAScript finally got on track, releasing a version every year. To cope with the annual incrementing versions, ES6, which revolutionized the JavaScript era, is used as a proxy name for subsequent versions).

Key point: In web front-end job descriptions, the frequently seen ES6 does not just refer to the ES2015 version, but to ES2015 and the ECMAScript versions released annually thereafter.

Starting from ECMAScript 6th Edition, one ECMAScript version is released each year. Therefore, ECMAScript versions have many names, including the full name ECMAScript 6, the shorthand ES6, the year-based name ECMAScript 2015, and the year shorthand ES2015. The most common name is still ES6, and the same logic applies to subsequently launched ES7, ES8, etc. Note that versions after ES6 are basically referred to by their year shorthand; ES7, ES8, and similar shorthands are not commonly used.

img-09.png It's important to note that since the establishment of the TC39 process, the importance of ECMAScript versions has greatly diminished. You don't need to remember which year a particular ES feature was introduced. What truly matters now is which stage a proposal is in: Once a proposal reaches Stage 4, it is ready to be used. However, even so, you still need to check if your engine supports that feature.

This brings up the concepts of the TC39 process and Stages. Let's look at what these two concepts mean next.

TC39 Process and Stage X

The TC39 process, as the name suggests, is a process published by the TC39 organization. With the release of ECMAScript 6, the release process at the time had two obvious problems:

To solve these problems, TC39 established a new TC39 process:

Evolution of the TC39 Process

The New 6-Stage Process After November 2023

img-10.png

The Classic 5-Stage Process from 2015-2023

img-11.png

Why Add Stage 2.7?

On November 30, 2023, the TC39 committee decided to add Stage 2.7 to the process, primarily based on the following considerations:

  1. Separation of Concerns: Separating "specification completion" (Stage 2) from "test writing" (Stage 2.7) makes the goals of each stage clearer.
  2. Increased Certainty: When a proposal reaches Stage 2.7, the specification is frozen, allowing developers to start trying it out with more confidence.
  3. Optimized Review Process: Reviewers need to complete their sign-off before Stage 2.7, avoiding repeated changes later.

Regarding why the number 2.7 was chosen, TC39 gave an interesting explanation:

A Milestone for a Chinese Proposal

Understanding the meaning of each Stage helps understand the significance of the news that China's first JS language proposal entered Stage 3 at ECMA. In April 2021, the Error Cause proposal, put forward by Alibaba's Frontend Standardization Group and Taobao Technology, entered Stage 3. This meant:

How to Track Proposal Progress?

To understand the latest status of various proposals, you can visit the following resources:

  1. TC39 Proposals - View the current stage of all proposals.
  2. TC39 ECMA262 - The official repository for the ECMAScript specification.
  3. TC39 Meeting Notes - TC39 meeting records to understand the details of proposal discussions.

💡 Developer Advice: Starting from ES2016, stop thinking in terms of "Does this browser support ES20XX?" Instead, focus on specific features: "Has this feature reached Stage 4? Does the target environment support it?" This way of thinking is more aligned with the modern JavaScript development model.

Complete Collection of ES Features Through the Years (ES2026 → ES2015)

There are too many scattered ES feature summaries online. Many students wonder, is there an official list of ECMAScript features?

Of course, there is. The TC39 repository lists finished proposals and their versions. In the 11 years since the release of ES6 in 2015, as of July 2026, this list contains a total of 78 entries (where the Class Fields entry merges 3 proposals), with another 4 proposals having reached Stage 4 and set to be released with ES2027 (see the next chapter).

This chapter is arranged in descending chronological order: the latest ES2026 is placed first, tracing all the way back to the inaugural year of ES6 in 2015. Want to check a specific year? Just scroll to it. Before diving year by year, let's look at the big picture.

A Table Summarizing 12 Versions:

Version Released ECMA-262 Features Representative Features One-Liner Theme
ES2026 2026-06 17th Ed. 7 getOrInsert, Iterator.concat, Native Base64 Standard Library Gap Fill
ES2025 2025-06 16th Ed. 10 Iterator Helpers, Set Methods, RegExp.escape The Year of Iterators & Regex
ES2024 2024-06 15th Ed. 7 Object.groupBy, Promise.withResolvers, RegExp v Grouping & Concurrency Tools
ES2023 2023-06 14th Ed. 4 findLast, toSorted and other immutable methods Immutable Arrays
ES2022 2022-06 13th Ed. 8 Class Fields, Top-level await, .at(), Error Cause Class Maturity + China's First Proposal
ES2021 2021-06 12th Ed. 5 replaceAll, Promise.any, Logical Assignment Small but Beautiful
ES2020 2020-06 11th Ed. 9 Optional Chaining ?., Nullish Coalescing ??, BigInt, import() Syntax Highlight Year
ES2019 2019-06 10th Ed. 8 flat / flatMap, Object.fromEntries Array & Object Completion
ES2018 2018-06 9th Ed. 8 Async Iteration, Object rest/spread, Regex Quartet Async Iteration + Regex Year
ES2017 2017-06 8th Ed. 6 async/await, Object.entries, Shared Memory The Year of async/await
ES2016 2016-06 7th Ed. 2 includes, ** operator Minimum Viable Release
ES2015 2015-06 6th Ed. 20+ Class, Modules, Arrow Functions, Promise, let / const The Syntax Big Bang

Feature Count Trend:

img-21.png Spreading out these 78 entries over 11 years reveals three clear threads:

  1. Syntax is receding, the standard library is advancing. The last major syntax change that altered how we write code was Class Fields in ES2022 (the next one, using, will have to wait for ES2027). ES2026's 7 features are all APIs. The language's skeleton is largely set; now it's about adding flesh and blood.
  2. "Specification release" increasingly looks like "retroactive recognition of a fait accompli". Stage 4 requires two engine implementations and passing test262 tests, so features are generally usable first and enter the standard later: Array.fromAsync was usable in the three major browsers in 2023 but only written into the spec in 2026; Temporal waited 9 years. So don't ask "Does the browser support ES2026?" Ask "Has this feature reached Stage 4?"
  3. Iterators are becoming first-class citizens. Iterator Helpers in ES2025, concat in ES2026, zip in ES2027, plus chunking/includes/join in the pipeline—TC39 is cashing in the iterator protocol planted by ES6 a decade ago, all at once, into a full suite.

Alright, let's dive year by year, starting with the latest ES2026.

ES2026 New Features

Officially released with ECMA-262 17th Edition on June 30, 2026 (TC39 approved the candidate specification at the March 2026 meeting; the Ecma General Assembly was just the final procedural step), it includes a total of 7 new features. If ES2025's theme was "iterators and regex," ES2026's theme is filling high-frequency gaps in the standard library: no major syntax-level moves, but each one eliminates a piece of boilerplate code you've written countless times.

First, a family portrait:

# Feature One-Liner Summary Stage 4 Date
1 Upsert (getOrInsert) Get a value from a Map, insert a default if missing, in one step. 2026-01
2 JSON.parse source text access The reviver can access the raw source text, eliminating large integer precision loss. 2025-11
3 Iterator Sequencing Iterator.concat lazily concatenates multiple iterators. 2025-11
4 Uint8Array to/from Base64 Native binary ↔ Base64/Hex conversion, goodbye atob. 2025-07
5 Math.sumPrecise Floating-point summation without cumulative error. 2025-07
6 Error.isError Reliably identify a genuine Error across realms. 2025-05
7 Array.fromAsync The async version of Array.from. 2025-05

Compatibility data in this section is as of July 2026, sourced from MDN BCD with some manual verification; Bun data is from hands-on testing with Bun 1.3.14.

Let's break them down one by one.

  1. Upsert (Map/WeakMap.prototype.getOrInsert / getOrInsertComputed)
// ❌ Before: Three lines of boilerplate, anyone who's grouped with Map knows this
if (!groups.has(user.dept)) {
  groups.set(user.dept, []);
}
groups.get(user.dept).push(user);

// ✅ ES2026: One step
groups.getOrInsertComputed(user.dept, () => []).push(user);

// For counter scenarios, use getOrInsert to provide a default value
counts.set(word, counts.getOrInsert(word, 0) + 1);
Chrome Firefox Safari Node.js Deno Bun
145 144 26.2 26+ 2.6.7 ✅
  1. JSON.parse source text access
// ❌ Before: Large integer ID is corrupted upon parsing
const txt = '{"id": 9007199254740993}';
JSON.parse(txt).id;      // 9007199254740992 —— silently lost 1

// ✅ ES2026: The reviver gets the original text, converts to BigInt without going through Number
const obj = JSON.parse(txt, (key, val, { source }) =>
  key === 'id' ? BigInt(source) : val
);
obj.id;                  // 9007199254740993n ✓

// Serialization side: rawJSON allows large integers to be output as-is
JSON.stringify({ id: JSON.rawJSON('9007199254740993') });
// '{"id":9007199254740993}'
Chrome Firefox Safari Node.js Deno Bun
114 135 18.4 21 1.33 ✅
  1. Iterator Sequencing (Iterator.concat)
// ❌ Before: Either materialize an array or hand-write a generator
const merged = [...map.keys(), ...someSet, 'tail']; // Fully expanded, memory waste
function* concat(...its) {                          // Or eight lines of boilerplate
  for (const it of its) yield* it;
}

// ✅ ES2026: Lazy concatenation, and you can continue chaining
const merged = Iterator.concat(map.keys(), someSet, ['tail']);
for (const x of merged.filter(v => v !== null).take(10)) {
  // Lazy evaluation: won't pre-expand any data source
}
Chrome Firefox Safari Node.js Deno Bun
146 147 26.4 26+ 2.7.2 ✅
  1. Uint8Array to/from Base64 (including Hex)
// ❌ Before: atob requires a three-step workaround
const binStr = atob('SGVsbG8gV29ybGQ=');
const bytes = Uint8Array.from(binStr, (c) => c.charCodeAt(0));

// ✅ ES2026: Direct
const bytes = Uint8Array.fromBase64('SGVsbG8gV29ybGQ=');
new TextDecoder().decode(bytes);  // 'Hello World'

// url-safe, no padding, Hex are all natively supported
bytes.toBase64({ alphabet: 'base64url', omitPadding: true });
Uint8Array.fromHex('deadbeef');   // Uint8Array [222, 173, 190, 239]

// Streaming decode: only consumes complete 4-character blocks, leaving the rest for the next round
const buf = new Uint8Array(1024);
const { read, written } = buf.setFromBase64(chunk, {
  lastChunkHandling: 'stop-before-partial',
});
Chrome Firefox Safari Node.js Deno Bun
140 133 18.2 25 2.5.0 ✅
  1. Math.sumPrecise
const xs = [1e20, 0.1, -1e20];

// ❌ Before: 0.1 is swallowed by 1e20
xs.reduce((a, b) => a + b, 0);  // 0

// ✅ ES2026: The mathematically correct answer
Math.sumPrecise(xs);            // 0.1

// Two details easy to stumble on
Math.sumPrecise([]);            // -0 (not 0)
Math.sumPrecise([1, '2']);      // TypeError! Rejects implicit conversion
Chrome Firefox Safari Node.js Deno Bun
147 137 26.2 ❌ Not yet supported 2.7.8 ✅
  1. Error.isError
// ❌ Before: Can't recognize an Error from another realm
const vm = require('node:vm');
const err = vm.runInNewContext('new Error("boom")');
err instanceof Error;   // false —— prototype chain comes from another realm

// ✅ ES2026: Brand check, doesn't look at the prototype chain
Error.isError(err);     // true

Error.isError({ name: 'Error', message: '', stack: '' }); // false, forgery-proof
Error.isError(new DOMException('x'));                     // true, DOMException also counts
Chrome Firefox Safari Node.js Deno Bun
134 138 18.4 24.3 2.2 ✅
  1. Array.fromAsync
// ❌ Before: Four lines of boilerplate
const chunks = [];
for await (const chunk of stream) {
  chunks.push(chunk);
}

// ✅ ES2026: One line
const chunks = await Array.fromAsync(stream);

// Collect paginated data with an async generator
async function* paginate(url) {
  while (url) {
    const r = await (await fetch(url)).json();
    yield* r.items;
    url = r.next;
  }
}
const ids = await Array.fromAsync(paginate('/api/list'), (item) => item.id);
Chrome Firefox Safari Node.js Deno Bun
121 115 16.4 22 1.38 ✅

ES2025

Officially released on June 25, 2025, including the following new features:

  1. RegExp.escape
// ❌ Before: Manual escaping was error-prone
const userInput = "price: $9.99";
const pattern = new RegExp(userInput); // 💥 $ and . will be treated as special characters
// ✅ ES2025: Standardized safe escaping
const escaped = RegExp.escape("price: $9.99");
// Returns: "price:\\x20\\$9\\.99"
const safePattern = new RegExp(escaped); // Correctly matches the literal string

img-12.png

  1. Float16 on TypedArrays, DataView, Math.f16round

img-13.png

  1. Promise.try

img-14.png

  1. Sync Iterator Helpers

img-15.png

  1. JSON Modules

img-16.png

  1. Import Attributes

img-17.png

  1. RegExp Modifiers

img-18.png

  1. New Set Methods

img-19.png

  1. Duplicate Named Capture Groups

img-20.png

  1. Redeclarable global eval-introduced vars

ES2024

ES2023

ES2022

ES2021

ES2020

ES2019

ES2018

ES2017

ES2016

ES2015 (ES6 Inaugural Year Special)

Tracing all the way back here, we finally arrive at the starting point of the legend. ES2015 is unlike all subsequent versions: it was the last "bundled" major release, predating TC39's staged process. The finished-proposals list only started recording from ES2016 onwards, and its twenty-plus features have no corresponding proposal entries to trace. Most "features through the years" recaps on the market therefore start from 2016. This article fills in that missing piece.

A one-sentence background: The overly ambitious ES4 was declared dead in 2008. The committee pivoted to a pragmatic route codenamed Harmony, accumulated work for six or seven years, and released the 6th Edition in one go on June 17, 2015. The "one version per year" rhythm started right here: holding back for six years produced a behemoth, stretching the release process to its limit. TC39 learned its lesson and switched to small, fast steps, which is why we have the 11 bars in the chart above.

Category Features
Syntax let / const, Arrow functions, Class, Template strings, Destructuring assignment, Default parameters, rest/spread, Enhanced object literals
Modules import / export (ES Modules)
Async Promise, Generator (function* / yield)
Collections & Iteration Map / Set / WeakMap / WeakSet, Iterator protocol, for...of
Metaprogramming Symbol, Proxy / Reflect
Standard Library Object.assign, Array.from / Array.of / find, String.prototype.includes, Binary/Octal literals, and a large batch of others
Other Tail call optimization (written into the spec, but to this day only Safari's JavaScriptCore has truly implemented it)

How heavy is this edition? The following 11 years totaled 78 entries, but ES2015 alone reshaped half the face of the language. So when a job description says "proficient in ES6," it never refers to just one year, but to the entire modern JavaScript era that started from here.

Expected New Features for ES2027 (Preview)

The ES2026 candidate specification was finalized at the March 2026 meeting, but TC39 was firing on all cylinders in the first half of 2026. 4 proposals reached Stage 4 after the cutoff line, and by convention, they will ship with ES2027. Moreover, this batch is heavier than the ES2026 main event itself:

  1. Temporal —— A nine-year marathon, finally crossing the finish line 🏁
const meeting = Temporal.ZonedDateTime.from(
  '2026-07-12T10:00[Asia/Shanghai]'
);
meeting.add({ hours: 3 }).toString(); // Immutable, timezone-safe
Temporal.Now.plainDateISO().toString(); // '2026-07-12'
  1. Explicit Resource Management (using declaration)
async function copy(src, dst) {
  await using input = await fs.open(src);
  await using output = await fs.open(dst, 'w');
  // Both automatically call [Symbol.asyncDispose]() when leaving scope, even on exceptions
}
  1. Joint Iteration (Iterator.zip / Iterator.zipKeyed)
  1. Atomics.pause

The four above, see you in 2027.

TC39 Proposal Dynamics Quick Look (H2 2025 → H1 2026)

Besides the finalized features, there was quite a bit of big TC39 news this year. Let's look at them one by one:

📉 Decorators Rarely Downgraded: On May 19, 2026, Decorators was demoted from Stage 3 back to Stage 2.7 (Decorator Metadata followed suit the same day). After reaching Stage 3 in March 2022 and waiting four years without any native browser implementation, engine vendors ultimately pushed for the downgrade citing "incomplete tests, specification issues, and implementation complexity." The meeting even discussed the possibility of a future demotion to Stage 2. The TS/Babel transpilation ecosystem works as usual, but "native decorators" are again nowhere in sight. This is also the most famous "reheat" since the establishment of Stage 2.7.

🪦 Records & Tuples Officially Withdrawn: The #{} / #[] immutable primitive value path was officially withdrawn in April 2025, officially marked as "succeeded by Composites" (Stage 1). The new path abandons new primitive types, instead using composite keys with regular object semantics to allow Map/Set to support value-based lookup.

🔥 The Iterator Full Suite Era: Following ES2025 Iterator Helpers, ES2026 Iterator.concat, and ES2027 Iterator.zip, Iterator Chunking (chunks(n) / windows(n), Stage 3), Iterator Includes (Stage 3, jumped from Stage 1 to 3 in about three months, the fastest-rising proposal of 2026), and Iterator Join (Stage 3) are queuing up. The May 2026 meeting also specifically discussed the iterator proposal roadmap.

📦 Module Harmony Family Advancing: import defer (Stage 3, TypeScript 5.9 already supports the syntax, V8 has implemented it behind a flag), Import Text / Import Bytes (importing text/binary resources, Stage 3 / 2.7 respectively), import.sync (Stage 2). ES modules are filling in the two puzzle pieces of "non-JS resource imports" and "fine-grained loading timing control."

Other Highlights: Immutable ArrayBuffer received "conditional Stage 3" (waiting for test262 to land); Error Stack Accessor was promoted to Stage 3 (error.stack is finally being standardized); RegExp Buffer Boundaries (\A \z), dormant for four and a half years, was revived and jumped two stages in one week to Stage 3; ShadowRealm is still stuck on host integration; AsyncContext remains at Stage 2, with browser vendors' concerns about performance overhead unresolved.

Conclusion

Give a man a fish, and you feed him for a day; teach a man to fish, and you feed him for a lifetime. I hope that by tracing things back to their roots, this article can lead you into the world of ECMAScript, making the mysterious ES codes no longer mysterious and new ES features no longer bewildering.

References