TypeScript 6.0 RC: The Last JS-Era Release Before the Go Compiler

Microsoft released the TypeScript 6.0 Release Candidate today — and it carries more weight than most version bumps. This is the last TypeScript release built on JavaScript. Starting with 7.0, the compiler will be rewritten in Go.

If you've been following TypeScript's trajectory, you'll know this was coming. But the RC landing this morning makes it official: we're at the end of an era.

Why This Version Matters

TypeScript 6.0 is explicitly described by the team as a bridge between TypeScript 5.9 and 7.0. Most of its changes are about alignment — preparing codebases to smoothly migrate when the Go-based compiler drops.

Announced last year, the Go rewrite (internally called tsgo) is designed to take advantage of native code speed and shared-memory multi-threading. Early benchmarks have shown compile times up to 10× faster. TypeScript 7.0 will be the foundation of that new era.

So what does 6.0 actually ship?

What's New in TypeScript 6.0 RC

Better Type Inference for Method Syntax

One of the most developer-facing improvements fixes a subtle but maddening inconsistency with generic type inference. Previously, TypeScript treated arrow functions and method syntax differently when inferring types — even when they behaved identically at runtime.

callIt({
  consume: y => y.toFixed(), // ✅ no error
  produce: (x: number) => x * 2,
});

callIt({
  consume(y) { return y.toFixed(); }, // ❌ used to fail: 'y' is unknown
  produce(x: number) { return x * 2; },
});

The reason was subtle: method syntax implies a possible this reference, which affected how TypeScript prioritized inference. TypeScript 6.0 now checks whether this is actually used — if not, the function is treated the same as an arrow function for inference purposes. Both examples above now work correctly.

This improvement was contributed by community member Mateusz Burzyński.

Subpath Imports: `#/` Now Supported

Node.js's subpath imports let you define internal package aliases in package.json. You might have something like:

{
  "imports": {
    "#utils": "./dist/utils.js"
  }
}

Previously, all subpath import specifiers had to start with exactly #, but not #/. TypeScript 6.0 now supports #/ prefixes — aligning with how many real-world projects have been structuring internal paths.

`--outFile` Removed

The long-deprecated --outFile compiler option has been removed in TypeScript 6.0. This option concatenated input files into a single output file — a job that Webpack, Rollup, esbuild, Vite, and Parcel now do far better. If you still have --outFile in a tsconfig.json somewhere, now's the time to clean it up.

Import Assertions Deprecated Further

TypeScript continues phasing out the old import assertion syntax (import ... assert { type: 'json' }), which was not adopted by TC39. This deprecation now extends to dynamic import() calls as well. The replacement is the with keyword: import data from './data.json' with { type: 'json' }.

Updated DOM Types + Temporal API

The bundled DOM types have been updated to reflect current web standards. Notably, the Temporal API types have been adjusted — keeping TypeScript's type definitions in sync as this long-awaited date/time standard moves closer to full browser support.

What This Means for Your Nuxt/Vue Projects

If you're running a Nuxt 4 or Vue project, TypeScript 6.0 is worth testing now via the RC:

npm install -D typescript@rc
# or
bun add -D typescript@rc

The main things to watch for:

Generic JSX expressions may catch more bugs (some calls may need explicit type arguments)
Method-syntax functions in generics will now infer correctly — existing workarounds with arrow functions can be cleaned up
Any lingering --outFile configs or import ... assert {} syntax will need updating

The Bigger Picture

TypeScript 6.0 is a cleanup release disguised as a milestone. The real story is what comes next: a compiler written in Go, built for parallelism, targeting the performance demands of today's massive TypeScript codebases.

The JavaScript ecosystem has relied on TypeScript as its de facto type layer for years. Moving the compiler itself to Go — while keeping the language and developer-facing APIs intact — is a bet that the current JS-based approach has hit its limits.

When TypeScript 7.0 lands, it should feel like the same TypeScript you know, but dramatically faster. Version 6.0 RC makes sure the codebase is ready for that jump.

Try the RC now, update your configs, and file any regressions on the TypeScript GitHub.

Sources: