ECMAScript - Introducing All Stages of the TC39 Process

November 30, 2020 4 min read ECMAScript

Explaining the process that's responsible for evolving the ECMAScript specification - from an idea to a fully specified feature, which is eventually delivered with the next edition.

Every year, an edition of the ECMAScript specification is released - containing all recent features and changes which were approved since the previous edition.

In this article, we’re not going to explain the new changes themselves - but rather the authority approving them and the entire way until the approval.

The content is available as a video as well:

If you like this kind of work, you can save the full playlist and subscribe to my YouTube channel today to not miss new content.

Let’s begin.


TC39 or the 39nth Technical Committee by its full name, is a group under ECMA International containing ECMA members - which are JavaScript developers, implementers, academics and more; from various companies and institutions. The committee collaborates with the community to maintain and evolve the definition of the ECMAScript specification.

The committee meets regularly with a neat agenda, in order to plan and make decisions regarding the specification. It’s worth mentioning that the decisions are made by consensus, meaning most of the members should agree when nobody extremely disagrees or veto.

TC39's Logo

TC39's Logo

The TC39 Process

The process of making changes in the ECMAScript specification is done by the TC39, and naturally called the TC39 process. This process is built from five stages, starting with stage zero. Any proposal for a change in the specification goes through these stages without exception, when the committee must approve the progress from one stage to the next one.

The process was born due to the conduct of ECMAScript 2015 edition, also known as ES6, which was a pretty huge release lasting very long without delivery (actually almost 6 years). Therefore, as of ECMAScript 2017, the editions have become smaller and are delivered every year, containing all proposals which are accepted at all stages of the process, since the previous edition.


Now, let’s elaborate on the stages of the process.

🀷🏻 Stage 0: Strawperson

This is the first stage, called “Strawperson”, representing an initial idea for addition or change to the specification that isn’t considered as a formal proposal. Suggestions for this stage must come from a TC39 member or registered contributor.

πŸ’‘ Stage 1: Proposal

This stage is a formal proposal that describes a discrete problem or general need, suggests a shape of the solution and points out potential challenges - such as β€œcross-cutting” concerns with other features or complex implementation. The solution’s description should contain a high-level API with concrete examples; and also discuss algorithms, abstractions and semantics.

On top of that, one of the TC39 members is defined as the owner that is responsible to advance the proposal, and practically named champion. Typically the champion is the original author of the proposal, but not always. If the proposal meets the criteria of stage 1, and hereby representing the committee’s will of going forward with the proposal, then it moves to the draft stage.

✍🏻 Stage 2: Draft

This stage is the initial draft of the proposal in the specification, phrased by the ECMAScript language.

The draft should describe the syntax, semantics and APIs precisely as much as possible, although it can have “TODO” comments or placeholders. An experimental implementation is also needed, runnable by a browser or a build-time transpiler like Babel.

Moving forward from this stage means that the committee expects that the proposal would be developed and included eventually in the official specification - when only incremental changes (and mostly fixes) are expected.

πŸ“ Stage 3: Candidate

This stage is a candidate proposal that’s almost final - but ready for feedback and refinements from implementations and users. The proposal defined as completely final when there is neither further work with the specification nor external feedback.

All ECMAScript editors and designated reviewers should sign off on this specification. In addition, it should include two independent spec-compatible implementations passing the acceptance tests.

After this stage, changes would be made only for critical issues.

βœ… Stage 4: Finished

This is the last stage, called “finished” obviously, indicating that the proposal is ready to be included in the latest draft of the specification - and be delivered with its next edition.


The ECMAScript specification evolves every year through the TC39 process.

Key points to remember:

  • TC39 is a diverse group of members working with JavaScript under ECMA International
  • TC39 collaborates with the community to maintain and evolve the ECMAScript specification
  • The TC39 process allows making changes in the ECMAScript specification using five regulated stages
  • TC39 must approve each stage of the TC39 process for any change in the specification
  • New editions of the specification are delivered every year
  • Stage 0 represents an initial idea for addition or change to the specification
  • Stage 1 is a formal proposal describing a problem and suggesting a proper solution
  • Stage 2 is an initial draft of the proposal specification
  • Stage 3 represents the draft when it’s almost final but ready for last feedback
  • Stage 4 is when the proposal specification completely ready and included within the next edition
βœ‰οΈ Subscription
Only new content, no spam.
Aspire. Accomplish. Online courses from $9.99