TypeScript 7.0 RC: Go Compiler Cuts Build Times by 90%

TypeScript 7.0 RC landed on June 18. The compiler is now a native Go binary. VS Code’s 1.5 million lines of TypeScript compile in 7.5 seconds instead of 78. The stable release is weeks away. But before you reach for npm install typescript@rc, there is a critical toolchain gap that most coverage is glossing over — and it will break your linting setup if you skip it.

The Performance Numbers Are Real

Microsoft did not fabricate these benchmarks. They pre-tested with Bloomberg, Figma, Google, Slack, and Vercel on production codebases before shipping the RC. Here is what actually happened:

• VS Code (~1.5M LOC): 77.8s to 7.5s (10.4x faster)
• TypeORM (~270K LOC): 17.5s to 1.3s (13.5x faster)
• Playwright (~356K LOC): 11.1s to 1.1s (10.1x faster)
• Sentry: 133s to 16s (8.2x faster)

The gains come from two sources that multiply: native binary execution eliminates Node.js JIT warmup (roughly 3–4x by itself), and Go goroutines enable shared-memory parallelism across CPU cores (another 2–3x). A new --checkers flag — default 4 — controls parallel type-checking threads. Tune it to your CI runner’s core count and gains compound further. Memory use drops by roughly half compared to the JavaScript compiler.

These are not micro-benchmark numbers. They are from real projects that ship to real users. If your TypeScript compile times are eating developer cycles, this release is legitimately interesting.

The API Gap Nobody Is Leading With

Here is what the “10x faster!” headlines are burying: TypeScript’s programmatic API — what tools import as import * as ts from 'typescript' — does not exist in TypeScript 7.0. It ships in TypeScript 7.1, which is several months away.

That means typescript-eslint breaks. So does ts-morph. So does any custom compiler plugin or transformer your build pipeline depends on. If you upgrade the typescript package to 7.0 and run your linter, it will fail. This is documented, expected, and not a bug — but it is also not a footnote most teams can afford to ignore.

Microsoft’s workaround is an npm alias. In your package.json:

{
  "devDependencies": {
    "typescript": "npm:@typescript/typescript6@^6.0.0"
  }
}

This keeps the typescript package locked to 6.0 (for typescript-eslint and friends) while you install the 7.0 binary separately for actual compilation. It works, but running two TypeScript versions in parallel is exactly as fiddly as it sounds. For most teams, the right call is to wait for 7.1 before making any of this the default.

What Breaks in Your tsconfig

TypeScript 6.0 added deprecation warnings for a range of legacy options. TypeScript 7.0 makes them hard errors. Some are expected; a few will blindside you.

Options that are flat-out gone:

• target: es5 — removed. Use es2015 as a minimum.
• moduleResolution: node / node10 — removed. Use bundler or node16.
• module: amd, umd, systemjs — removed. Time to migrate to ESM.
• baseUrl — gone. Use relative paths entries instead.

New defaults that silently break things:

The sneakier problem is changed defaults. If your tsconfig relies on implicit behavior, you will hit errors that look confusing until you know what shifted:

• types now defaults to []. Previously TypeScript auto-included all installed @types/* packages. Now it includes none. If you use @types/node, @types/jest, or any other ambient type package without listing it explicitly, those globals silently disappear.
• strict now defaults to true. New type errors in code that previously passed cleanly.
• rootDir now defaults to ./, which can trigger “rootDir must contain all source files” errors in monorepo setups.

The types: [] change will be the most common silent failure. Fix it explicitly:

{ "compilerOptions": { "types": ["node", "jest"] } }

The practical advice: run through your tsconfig on TypeScript 6.0 first. Address all deprecation warnings before upgrading. Do not try to debug a broken tsconfig and a new compiler simultaneously.

Why Go Won Over Rust

The Go choice was deliberate and the reasoning is technically interesting. TypeScript’s AST uses cyclic object references extensively — a natural consequence of modeling JavaScript’s object graph, where symbols reference types that reference declarations that reference symbols. Rust’s ownership model does not allow cyclic references without heavy workarounds (think Rc<RefCell<T>> everywhere), which would have required redesigning the type-checker’s core data structures from the ground up. That is a multi-year rewrite with real risk of subtle behavioral divergence.

Go’s garbage-collected model allowed a file-by-file port of the existing compiler — the same data structures, the same logic, just in Go. The team completed it in roughly one year. The type-checking behavior is structurally identical to 6.0. This is a performance upgrade, not a type-system change.

When to Actually Upgrade

Here is the straightforward breakdown:

• Try it on a branch today: Run npm install -D typescript@rc and see what breaks in your tsconfig. A useful pre-GA audit.
• Wait for GA for production builds: Expected within weeks. Watch the TypeScript blog for the announcement. Run your full test suite before deploying.
• Wait for TypeScript 7.1 if you use compiler plugins, typescript-eslint, or ts-morph: The programmatic API gap is real. Do not fight the ecosystem — wait for it to close.

The TypeScript team’s own guidance for the RC: install it, experiment with --checkers tuning on CI, clean your tsconfig warnings, and install the TypeScript Native Preview extension in VS Code to try the Go-powered language server without committing to a full migration. The microsoft/typescript-go repo has the RC source and issue tracker if you want to follow progress directly.

This is the biggest structural change to TypeScript since the language launched. The performance gains are real and the direction is correct. But “wait a few months” is not hedging — it is the right production guidance given where the ecosystem stands right now. Read the full RC announcement for the complete breaking changes list before your team makes any migration decisions.