TypeScript 6.0 Beta: The Last JavaScript Version Before Go Rewrite

Microsoft dropped TypeScript 6.0 beta two days ago. The announcement got 66.5K views on Twitter in under 24 hours. Developers on Reddit are calling it "a significant version upgrade" that lets the team make changes they couldn't do in minor releases.

But here's what matters. This is the last TypeScript version written in JavaScript. Version 7.0 is being rewritten in Go with native code and multi-threading. That's wild. The team is basically saying "we need to go faster, and JavaScript can't get us there."

You're probably wondering what breaks. A lot, actually. The strict flag is now true by default. ES5 is gone, deprecated, not supported. If you were targeting old browsers, you'll need a different tool.

And the types field in your tsconfig? It now defaults to an empty array instead of loading every package in node_modules/@types. Microsoft says some projects saw 20-50% faster builds just from this change.

What Actually Changed

i spent an hour reading the announcement. Most of it is about cleaning up legacy stuff.

The team deprecated AMD, UMD, and SystemJS module formats. Makes sense. Nobody ships code that way anymore. ESM won, bundlers are everywhere, and those old formats are just technical debt.

But the baseUrl deprecation surprised me. Turns out it was doing two things at once, and most people only wanted one of them. It acted as both a prefix for path mappings and a module resolution root. That second part caused imports to resolve to weird places that would never work at runtime.

You can't use module: "commonjs" with most resolution strategies anymore either.

Or wait, you can. But only with --moduleResolution bundler now. The old node resolution (really node10) is deprecated because Node.js has changed a lot since version 10.

The Go Rewrite

This is the big story. TypeScript 7.0 won't be JavaScript.

The compiler will be written in Go. Native code. Shared-memory multi-threading. The team says this enables parallel type-checking, which should be way faster.

But parallelism creates a problem. When different threads visit types in different orders, the internal IDs become non-deterministic. That means your declaration files might look different between builds even though nothing changed.

They added a --stableTypeOrdering flag in 6.0 to match 7.0's behavior. It sorts things deterministically but can slow down type-checking by up to 25%. You're not supposed to use it long-term, just for comparing outputs between versions.

New APIs That Matter

The Temporal API finally has types. It's the new way to handle dates in JavaScript, replacing the awful Date object. It hit stage 3 and works in Firefox and Chromium already.

Maps got getOrInsert and getOrInsertComputed methods. The pattern of checking if a key exists, then setting a default if it doesn't, now takes one line instead of five.

And RegExp.escape is here. You can finally build regex patterns from user input without manually escaping every special character.

Inference Improvements

Functions without this are now treated differently during type inference. Before, method syntax and arrow functions behaved inconsistently even when they didn't use this.

The order of properties in an object literal used to affect whether TypeScript could infer types correctly. Now it doesn't. Small fix, but it removes a footgun that confused people for years.

Why Rewrite in Go

i keep thinking about this decision. Rewriting a compiler is brutal.

The TypeScript codebase is huge. It's been worked on for over a decade. Throwing that away for Go means months or years of work, compatibility issues, and weird bugs.

But JavaScript is single-threaded. You can use worker threads, but it's clunky. For a type-checker that needs to analyze massive codebases with thousands of files, parallelism matters.

Go gives you goroutines and channels. Real concurrency. Native performance. And the TypeScript team clearly hit a wall with JavaScript's performance.

My coworker builds in Next.js. His type-checking takes three minutes on a monorepo. Three minutes where he's just waiting. Every time he wants to see if his code works. That's the problem they're solving.

The Naming Thing

Can we talk about version numbers for a second?

TypeScript went from 5.9 to 6.0. Not because there's six major features. Because they needed to break stuff. Version numbers used to mean something technical. Now they're just marketing.

Python did this. Went from 2.7 to 3.0 and broke everything. It took the ecosystem a decade to fully migrate. Some people still run Python 2 in production.

TypeScript 6.0 to 7.0 feels similar. Except Microsoft is being smart about it. They're making 6.0 a bridge release that warns you about everything that will break in 7.0. You can set "ignoreDeprecations": "6.0" in your tsconfig and keep going.

But 7.0 won't honor that flag. Everything deprecated in 6.0 just won't work.

Who This Hurts

Small projects won't notice. If you've got five TypeScript files and you're already using strict mode, this is free.

But legacy enterprise codebases? They're in trouble. The ones targeting ES5 for old browsers. The ones using AMD modules because they started in 2012. The ones with a giant node_modules/@types folder and no types field set.

Those projects will hit hundreds of errors upgrading to 6.0. And they can't just stay on 5.9 forever because security updates will stop.

The Reddit thread had a comment about this. Someone said the module keyword deprecation shows that "evolution is possible" even for projects with legacy constraints. That's optimistic. What it really shows is that Microsoft is willing to break backwards compatibility when they need to move forward.

Try It

If you want to test 6.0 beta, run this:

npm install -D typescript@beta

Most projects will need to add a types field to their tsconfig. Start with "types": ["node"] if you're on Node.js. Add "jest" or "mocha" if you're using those test runners.

If you were using baseUrl, remove it and add the prefix to your paths entries instead. If your output files suddenly appear in the wrong directory, set "rootDir": "./src" explicitly.

And if you see errors about ES5 being deprecated, you need to either bump your target to ES2015 or switch to an external compiler like Babel.

The team says they'll ship 7.0 soon after 6.0 goes stable. That's fast. Unusually fast for a rewrite this big.

i still think about projects that can't upgrade easily. The ones locked into ES5 because they support ancient devices. They'll fork TypeScript 5.9 or pay someone to maintain it. That's what always happens when you break backwards compatibility this hard.