ECMAScript-features is a cheatsheet organised by the year the feature shipped

The table of contents is a history of the language

The repository opens with a short definition, that ECMAScript is the scripting language which acts as the basis of JavaScript, and that it is standardized by ECMA International in the ECMA-262 and ECMA-402 specifications. Then comes the part that makes the project worth reading, a version history table with one row per edition, from ES2015, also called ES6, in June 2015 through ES2024 in June 2024 and ES2025 in June 2025, one edition a year. The feature tables follow the same shape, one table per edition, and the number of entries in each is a small history in itself. ES2015 has twenty-four listed features, from variable scoping and arrow functions through to proxies, symbols, promises, reflect, proper tail calls and the array find methods. ES2016 has two, the array includes method and the exponentiation operator. ES2017 has seven. The rest follow the same pattern, and the trend is unmistakable.

The proposal stages explain the gaps in your browser

One short section explains why a feature you have read about is not in the browser you use. Each proposal for an ECMAScript feature goes through five maturity stages, Stage 0 as a strawman, Stage 1 as a proposal, Stage 2 as a draft, Stage 3 as a candidate and Stage 4 as finished. That is the single most useful thing in the repository for a developer, because it tells you that a feature documented here might be a strawman, and it is the reason the same name can appear in two editions with different meanings, as the Temporal API does, listed under ES2024 and again under ES2025. The readme does not tag each feature with its stage, so the stage list is background rather than a lookup table, but it frames the whole collection correctly. The project also notes that pull requests are welcome and that the author posts technical updates, so the cheatsheet is a maintained document rather than a snapshot.

One directory per edition, and the examples are meant to run

The repository layout mirrors the table of contents, with a directory per edition from `es2015/` through `es2025/`, plus an `images/` directory and a Babel configuration at the root. The package manifest is named `ECMAScript-cheatsheet` and describes itself as ECMAScript features with a list of examples, and the only dependencies are the Babel pieces, the core, the node runner and the preset for the environment. There is a section at the top of the readme explaining how to run the examples, and it is two commands, an install and then a run of a single file through babel-node:

npm install
npx babel-node es2020\bigint.js  # Try other examples too

The path in that command uses a backslash separator, which is worth noticing if you are on Linux, since the same file lives in the `es2020/` directory. The point of the arrangement is that the examples are not illustrations in a document, they are files you can execute, and the BigInt example is the one the readme sends you to first, which is a reasonable place to start since BigInt is the one ES2020 feature with arithmetic behind it.

What the ES2015 section spends its space on

The first edition is where the bulk of the page is, and reading the list tells you what JavaScript looked like before it changed. Two entries are about variables, variable scoping and the difference between `let` and `const`, with the examples showing the block scope behaviour and the read-only reference of a constant. Arrow functions get their own entry with the function expression rewritten, and the note about when the parentheses can be dropped. Then there are classes, enhanced object literals, template literals, destructuring, default parameters, the rest parameter and the spread operator, the iterators and for-of, generators, and modules. The collection types follow, with Set, WeakSet, Map and WeakMap as separate entries, then Unicode, proxies, symbols, promises and reflect, and the language level features of binary and octal literals, proper tail calls and the array find methods. The proportions are the interesting part, because roughly half of the entries are about how data is declared and moved around, which is what a language does when it spends a decade absorbing the ideas of functional languages.

The later editions are thinner, and that is the point

After ES2015 the entries become short lists. ES2016 brings the array includes method and the exponentiation operator. ES2017 has async functions, object values, object entries, object property descriptors, string padding, shared memory and atomics, and trailing commas. ES2018 has async iterators, object rest and spread, and promise finally. ES2019 has array flat and flatMap, object fromEntries, string trimStart and trimEnd, symbol description, optional catch binding, JSON improvements, array stable sort, function toString and private class variables. ES2020 has BigInt, dynamic import, the nullish coalescing operator, optional chaining, promise allSettled, string matchAll, globalThis, import.meta and the for-in order fix. ES2021 has replaceAll, promise any, WeakRef, numeric separators and the logical assignment operators. ES2022 has top level await, class fields, array at, error cause, hasOwn and regex match indices. ES2023 has find last, hashbang syntax, symbols as WeakMap keys and change array by copy. ES2024 and ES2025 are the recent ones, with the Temporal API, groups, well formed unicode strings, the regex v flag, promise withResolvers, the pipeline operator, records and tuples, decorators, and then set methods, iterator helpers and decorator metadata.

What a cheatsheet can and cannot do for you

It is worth being clear about the limits, because a cheatsheet is a summary and a summary loses the things you most often need. The prose is uneven, since some entries have a couple of sentences of explanation and others are a heading with three lines of code, and there is no index of the proposals by stage, so you cannot tell from the document whether a feature is safe to use in production or is still a strawman. The bigger limit is the one the readme itself points at, that the real definition is in ECMA-262 and ECMA-402, and that a language standard and a particular engine are different things, so the presence of a feature in the cheatsheet says nothing about whether Node, a browser or a bundler supports it yet. What the repository is good for is orientation, seeing what changed in a given year, remembering what a feature is called, and finding a twenty line example before you go and read the specification.

Editorial conclusion

ECMAScript-features suits a developer who needs the shape of a language feature in one screen, with an example small enough to read in thirty seconds, and it suits a teacher assembling a syllabus from the editions. It is a poor fit if you want the normative text, because the reference is the ECMA specifications in ECMA-262 and ECMA-402, and it is a poor fit if you want to know what a runtime supports, since a language standard and a particular engine are different things. Before you rely on it, check three things: which edition you care about, since the file layout stops at ES2025 and the newest entries are the least revised, how you intend to read it, because the examples are in JavaScript with a few non-standard annotations and the prose is uneven in places, and the licence, since the package manifest says MIT while the repository itself records no licence, so the terms for reusing the text are worth confirming.

Frequently asked questions

Official sources

1. Issues
2. README
3. sudheerj/ECMAScript-features on GitHub