March 2026, Revisited: TypeScript 6.0 Closes the JavaScript Era, and Temporal Finally Lands

This post is part of our Three-Year Retrospective series: thirty-six posts, one per month, looking back at what actually mattered in software engineering. This one covers March 2026.

March 2026 gave the JavaScript ecosystem two endings that were really beginnings. On March 23, Microsoft shipped TypeScript 6.0 — the final major release built on the original JavaScript compiler codebase, and the deliberate staging ground for the Go-native TypeScript 7. And at the TC39 meeting earlier that month, the Temporal proposal reached Stage 4 after nearly a decade in flight, finally giving JavaScript a real date-and-time API and consigning the Date object to legacy status. Neither was a surprise; both had been telegraphed for a year. That's what made the month satisfying — the plans actually landed.

Strict by default, at last

TypeScript 6.0's defining change fit in one line: strict is now true by default. After a decade of every tutorial, linter preset, and senior engineer telling you to turn strictness on, the compiler finally agreed. And 6.0 didn't stop there — it changed nine compiler defaults in one release: module now defaults to esnext, target to the latest supported ECMAScript spec, and a series of legacy options were deprecated or removed outright. New projects now start where best practice had long since arrived.

For existing codebases, the upgrade was as disruptive as your config was honest. Projects that had explicit settings — which is to say, most mature ones — were barely touched, since explicit values override the new defaults. Projects that had been silently coasting on lax defaults got an overdue accounting. Our advice in trainings that month was simple: before upgrading, write your current effective settings into tsconfig.json explicitly, upgrade with zero behavior change, and then walk toward the new defaults deliberately. Boring, mechanical, effective.

A 6.0 designed to be a bridge

The deeper purpose of 6.0 was alignment. Microsoft had announced the native-compiler effort — a Go rewrite, with reported 10x compile speedups and roughly half the memory use — back in March 2025, and the project's promise was that 6.0 and 7.0 would behave as identically as possible. So 6.0's deprecations and default flips weren't housekeeping; they were the migration path. Everything 6.0 removed was something the Go compiler would never implement. Teams that got clean on 6.0 were, by design, already 7.0-ready, with the tsgo preview available for the adventurous to verify it. We'd spent a year telling teams the rewrite was the most important thing happening in front-end tooling; 6.0 was the first time the migration became something you could do rather than read about.

Temporal reaches Stage 4

The month's other milestone was older than TypeScript itself in spirit: Temporal, the replacement for JavaScript's famously broken Date, reached Stage 4 at TC39's March 2026 meeting, locking it into ECMAScript 2026. Nine years from first proposal to standard — immutable types, first-class time zones, calendar support, sane arithmetic. Implementations had led the way: Firefox shipped it in 2025, Chrome and Edge in January 2026, with Safari in preview. Our take for working teams: start using Temporal for new date logic now (with a polyfill where support lags), and treat Date-heavy modules the way you treat any legacy API — wrap, isolate, migrate opportunistically. Nobody who has handled a daylight-saving bug needs the sales pitch.

const today = Temporal.Now.plainDateISO();   // e.g. 2026-06-11
const due = today.add({ days: 30 });         // immutable; returns a new PlainDate

const meeting = Temporal.ZonedDateTime.from(
  "2026-06-15T09:00[America/New_York]",
);
console.log(meeting.withTimeZone("Europe/Berlin").toString());
// 2026-06-15T15:00:00+02:00[Europe/Berlin]

Looking back from June 2026

Three months on, the 6.0 transition has gone about as smoothly as a nine-defaults release can — the explicit-config-first playbook worked, and ecosystem tooling caught up quickly. The tsgo/TypeScript 7 preview keeps maturing on its public timeline, and teams that did their 6.0 homework report the native preview running their codebases largely unchanged, with the promised speedups very real on large projects. Temporal adoption is following the polyfill-then-native curve we expected. March 2026 will likely be remembered as the month the JavaScript platform cleared its two oldest debts: lax-by-default typing and the Date object.

If your team is planning its own 6.0-to-7 path, TypeScript Essentials now teaches the strict-by-default world from day one, and Advanced TypeScript covers the migration mechanics, compiler configuration, and the type-system depth that makes large codebases ready for the native era.