ES2026 is the 17th edition of the ECMAScript standard, published by Ecma International in June 2026. Its associated additions include APIs for working with maps, JSON, iterators, byte arrays, errors, and numeric sums. The list below distinguishes proposals the TC39 tracker associates with 2026 from features associated with a later edition—and explains why standardization is not the same as support in your target browser or runtime.
What is ES2026?
ECMAScript is the standardized programming language commonly called JavaScript. The official ECMA-262 standard defines the language for browser, server, and embedded environments. Ecma International identifies ECMAScript 2026 as its 17th edition, published in June 2026; the HTML version is the normative copy. The standard itself states, “This Ecma Standard defines the ECMAScript 2026 Language.”
TC39’s finished-proposals tracker associates the proposals below with an expected publication year of 2026. “Expected” matters: the tracker’s year is not a promise that every engine implements a feature, nor does it replace the published specification as the authority for exact semantics.
What are the ES2026 features?
The tracker associates these seven finished proposals with 2026. Their names indicate the tasks they address; consult the specification or proposal text for the precise API and behavior before relying on details in production.
#1 Best Overall
| Feature | What it addresses |
|---|---|
| Upsert | An update-or-insert operation. Check the normative API and semantics before assuming how it applies to a particular collection or key. |
| JSON.parse source text access | Access to source text during JSON parsing. The exact reviver/API behavior should be taken from the specification, not inferred from the proposal name. |
| Iterator Sequencing | Composing iterators. Verify method names, ordering, and edge cases in the normative text before writing code against it. |
| Uint8Array to/from Base64 | Converting byte arrays to and from Base64. Encoding options and conversion behavior are defined by the specification. |
| Math.sumPrecise | A Math API for summing values. Its name signals a numerical-summation use case; consult the normative definition for its accuracy and behavior rather than assuming a guarantee from the name. |
| Error.isError | An Error-related API. Use the specified detection semantics rather than assuming it is interchangeable with instanceof. |
| Array.fromAsync | An Array construction API involving asynchronous input. Check which inputs it accepts and how it processes them before choosing it for a specific task. |
This is a map of the features associated with the 2026 edition, not a substitute for their API documentation. The tracker confirms names and expected year; the applicable specification or proposal text is where exact signatures, algorithms, options, and caveats belong.
How to distinguish ES2026 features from proposals still in progress
TC39 describes finished proposals as those that have reached Stage 4 and are or soon will be included in the latest specification draft. Its active proposal tracker covers proposals at Stage 2 and above that have not been withdrawn, rejected, or finished. Stage 2 means the committee expects a proposal to be developed and eventually included; it is not evidence that the feature is part of a published edition.
Rank #2
- Finished proposal: Has reached Stage 4. Check the tracker’s expected publication year to see which edition it is associated with.
- Active proposal: Has not finished. A proposal at Stage 2 or Stage 3 should not be described as part of the published ES2026 edition.
- Published standard: The normative ECMA-262 text determines the language definition. Use it to confirm exact behavior.
Finished proposals associated with 2027
A proposal can be finished without belonging to ES2026. The tracker associates these finished proposals with an expected publication year of 2027, so they are separate from the 2026 feature list:
- Iterator Includes
- Iterator Join
- Explicit Resource Management
- Temporal
The expected year describes the tracker’s publication association; it does not establish implementation availability in a particular engine.
How to decide whether to use an ES2026 feature
Use the standard to understand what a feature means, then check the actual environments your application targets. Browser support, Node.js or other server-runtime support, and support in embedded JavaScript engines are separate questions. The publication of ECMA-262 alone does not tell you which runtime version implements a feature, and compatibility can change as engines ship updates.
- Confirm the exact API. Read the relevant normative specification or proposal text, including its accepted inputs, return values, and edge cases.
- List your target environments. Include the browsers, server runtimes, and embedded engines your project must support.
- Check compatibility for each target. Consult current engine documentation or compatibility data; do not infer support from the ES2026 label.
- Choose a fallback if needed. Determine whether your build target can transpile the syntax or whether a polyfill or alternative implementation is appropriate. Transpilers and polyfills do not automatically cover every runtime API or semantic detail.
- Test the production path. Run tests in the actual supported runtimes, especially for behavior where ordering, asynchronous inputs, encoding options, or numeric results matter.
No engine-version compatibility matrix is established here, so check current sources for the versions you intend to support before deployment.
Quick Recap
Rank #4
Product prices and availability are accurate as of the date/time indicated and are subject to change. Any price and availability information displayed on Amazon at the time of purchase will apply.
