TypeScript 6.0 RC: Temporal API and Breaking Changes

TypeScript 6.0 RC, announced March 6, 2026, delivers built-in support for JavaScript’s Temporal API while forcing modernization through major breaking changes. Consequently, strict mode becomes default, ES5 targets are deprecated (ES2015 minimum required), and the --outFile option is removed entirely. Moreover, this is Microsoft’s final JavaScript-based TypeScript release before version 7.0’s native Go rewrite in Q2 2026, making it a deliberate transition release that clears legacy options the new compiler won’t support.

Temporal API Finally Gets First-Class TypeScript Support

TypeScript 6.0 includes built-in type definitions for JavaScript’s Stage 3 Temporal proposal, ending 25+ years of Date()’s inadequacy. Specifically, Temporal provides immutable date/time handling with proper timezone support, calendar systems, and nanosecond precision. Firefox shipped Temporal in May 2025, Chrome followed in January 2026, and Safari support is actively under development.

// Date() - mutable, timezone-naive, broken
const yesterday = new Date();
yesterday.setDate(yesterday.getDate() - 1); // Mutates original!

// Temporal - immutable, timezone-aware, correct
const yesterday = Temporal.Now.instant().subtract({ hours: 24 });

// Timezone handling made easy
const meeting = Temporal.ZonedDateTime.from({
  timeZone: "America/New_York",
  year: 2026, month: 3, day: 15,
  hour: 14, minute: 30
});

Date() is fundamentally broken. Mutable state causes bugs, timezone handling requires external libraries like Moment.js or date-fns, and ISO 8601 parsing is inconsistent. In contrast, Temporal fixes all of this natively. Furthermore, TypeScript 6.0’s built-in types mean developers get autocomplete and type safety immediately without installing @types packages. Therefore, this is the convergence moment: 9-year TC39 journey plus browser support plus TypeScript integration equals Date() is finally replaceable.

Breaking Changes Force Modernization (Whether You Like It or Not)

TypeScript 6.0 makes strict: true the default, deprecates ES5 targets entirely (ES2015 minimum), removes --outFile, and changes types: [] to default. However, these aren’t optional improvements. They’re forced migrations preparing for TypeScript 7.0’s Go rewrite, which won’t support deprecated options at all.

// TypeScript 5.x (strict: false) - This compiled
function greet(name) { // Implicit 'any'
  return "Hello " + name;
}

// TypeScript 6.0 (strict: true default) - Error!
function greet(name) { // Error: Parameter 'name' implicitly has an 'any' type
  return "Hello " + name;
}

// Fix: Add explicit types
function greet(name: string): string {
  return "Hello " + name;
}

Strict mode catches 15-20% more bugs at compile time, but existing codebases with implicit any suddenly fail type checking. Meanwhile, projects targeting ES5 must either upgrade to ES2015+ (modern browsers supported this since 2015), use external transpilers like Babel or esbuild for ES5 output, or stay on TypeScript 5.x indefinitely and accept legacy maintenance mode.

The ts5to6 migration tool automates baseUrl removal and rootDir inference (the two most disruptive changes). Additionally, community reports cite 95% compatibility with TypeScript 5.x, with most modern projects migrating in under 1 hour. However, “most projects” excludes legacy applications using ES5 targets, --outFile, or non-strict mode. These face manual migrations with real costs.

Why the Breaking Changes Now: TypeScript 7.0’s Go Rewrite

TypeScript 6.0 is explicitly labeled a “transition release” by the Microsoft TypeScript team. Specifically, it’s the final JavaScript-based version before TypeScript 7.0’s native Go port, expected in Q2 2026. Options deprecated in TS 6.0 (ES5, --outFile, --baseUrl) will be completely removed in TS 7.0. Consequently, the Go rewrite promises faster compilation and lower memory usage but can’t support legacy options. This forces the ecosystem to modernize now rather than face a harder migration later.

Microsoft’s official announcement explains: “TypeScript 6.0 is designed as a transition release… The majority of changes are about alignment and preparation for TypeScript 7.0: new defaults that reflect the modern ecosystem, deprecations of legacy options that the Go-based compiler will not support.”

The timeline is tight. TypeScript 6.0 RC released March 6, 2026. The stable release follows soon. Moreover, TypeScript 7.0 arrives in Q2 2026 — roughly 3-6 months away. Therefore, projects that don’t migrate to TS 6.0 face a harder jump to TS 7.0 or get stuck on TS 5.x, which becomes unmaintained legacy. The "ignoreDeprecations": "6.0" flag provides temporary relief for enterprises with slow upgrade cycles, suppressing warnings during gradual migration. However, it’s a band-aid, not a solution.

Browser Support: Types Are Ready, Browsers Aren’t (Yet)

Firefox shipped Temporal in May 2025 (v139), Chrome followed in January 2026 (v144), but Safari still has no confirmed release date as of March 2026. Specifically, it’s available in Safari Technology Preview with the --use-temporal flag, but production support remains TBD. Edge has experimental support in beta. Meanwhile, the @js-temporal/polyfill provides compatibility for browsers without native support, but at ~150KB minified, it’s large enough to impact bundle sizes meaningfully.

The TC39 plenary meeting scheduled for March 2026 in New York is expected to advance Temporal to Stage 4, formally adding it to the ECMAScript standard. Once that happens, Safari’s timeline should become clearer. For now, developers get TypeScript types immediately, but production deployments targeting broad browser support require polyfills and careful bundle size management.

Key Takeaways

• Date() is finally replaceable: Temporal API fixes 25 years of broken date/time handling with immutability, timezone support, and nanosecond precision. Therefore, TypeScript 6.0 provides built-in types without @types packages.
• Breaking changes are mandatory, not optional: Consequently, strict mode default, ES5 deprecation, and --outFile removal force modernization. Modern projects migrate in <1 hour; legacy projects face manual work.
• TypeScript 7.0 Go rewrite is the forcing function: TS 6.0 deprecated options disappear entirely in TS 7.0 (Q2 2026). Moreover, the 3-6 month migration window is tight.
• Browser support is good but incomplete: Firefox and Chrome cover ~75% of users, but Safari’s absence means polyfills are mandatory for production. Additionally, the 150KB polyfill size matters for performance-sensitive apps.
• Plan migration now: Use ts5to6 tool for automated changes, enable "ignoreDeprecations": "6.0" for gradual migration, and budget time for strict mode type fixes.