TC39 Proposals in 2026: Decorators, Temporal, and Signals Explained

JavaScript has been declared "finished" by skeptics roughly once a year since the late 1990s, and each time the language proves them wrong. TC39, the committee that steers ECMAScript's evolution, keeps quietly pushing proposals through its stages that reshape how you write everyday code.

If you build with full-stack JavaScript, React, or Next.js, a handful of proposals currently moving through the pipeline deserve a spot on your radar. None of them are flashy headline features — they're the kind of change that just quietly removes boilerplate you've been writing without questioning it for years.

Here are the three worth following.

1. Native Decorators Are Almost Here

TypeScript developers have spent years relying on decorators through the experimentalDecorators compiler flag. That workaround is on its way out. The standardized Decorators proposal has reached Stage 3, meaning browsers and JavaScript runtimes are already building real implementations of it.

// before: relying on experimentalDecorators + reflect-metadata
class UserService {
  @logCall
  fetchUser(id: string) {
    return api.get(`/users/${id}`);
  }
}

The updated specification abandons the old reflect-metadata-based design in favor of something more predictable: a decorator function now receives the value it decorates along with a context object describing it, and it can return a replacement for that value. If you've ever dealt with mismatched versions between Babel's decorator implementation and TypeScript's own, this convergence is genuinely good news.

Bottom line: if your framework of choice — Angular-style dependency injection, MobX, or NestJS-adjacent patterns — leans on decorators, expect fewer compiler-flag headaches in upcoming releases.

2. Temporal Is Nearly Ready to Ship

JavaScript's built-in Date object has been a source of frustration for close to three decades. It lacks immutability, handles time zones in confusing ways, and exposes mutating methods that trip up even experienced engineers. Temporal, a proposal that has had long-term backing from Mozilla contributors and other stakeholders, has now reached the finished stage and is expected to land in a future edition of ECMAScript.

const meeting = Temporal.ZonedDateTime.from(
  "2026-09-14T10:00:00[America/New_York]"
);
const inTokyo = meeting.withTimeZone("Asia/Tokyo");

With Temporal, you get proper time-zone-aware datetimes without reaching for a library like moment.js, and conversions such as shifting a meeting time into another zone become straightforward instead of an exercise in manual offset math. If you're building scheduling features inside a Next.js application, this is arguably the biggest quality-of-life upgrade coming to the language.

3. Signals: A Standard for Reactive State

React's useState, Vue's ref, and Solid's signals are all different answers to the same underlying problem: tracking values that change over time and reacting to those changes. TC39's Signals proposal aims to give JavaScript a native reactive primitive that frameworks can build on top of, rather than each ecosystem inventing its own flavor of the same mechanism.

This proposal is still early in the process, but the direction it signals — pun intended — is clear: less duplicated reactivity logic across Redux, React, and other state-management libraries, and more shared, reusable building blocks underneath them.

What This Means for Your Stack

• TypeScript benefits arrive first. Cleaner, standardized type definitions for both decorators and Temporal will flow upstream into the tools you already use.
• Your UI layer and styling setup, including something like Tailwind CSS, won't be directly affected, but faster and more reliable date/time handling means less custom utility code cluttering your components.
• Even before client-side libraries fully adopt Temporal, Next.js server components are a likely early home for it, particularly for server-side date formatting.

TC39 co-chair Rob Palmer has noted in committee updates that it's now common for several proposals to advance in the same meeting cycle. That pattern suggests the pace of language evolution has genuinely picked up over the past couple of years.

Final Thought

None of this rewrites the JavaScript you're shipping today. But the next time you instinctively reach for moment.js, or fight with a decorator polyfill, remember that a native solution is already working its way through the pipeline. Staying a proposal or two ahead of the curve is how experienced developers avoid painting themselves into a corner — and it's also why many of them push back on adopting patterns that would create technical debt before those proposals are even finalized.