Last updated: July 5, 2026

Image: Microsoft DevBlogs / TypeScript Team

Imagine checking out a colleague’s pull request on a two-million-line TypeScript codebase. You run tsc --noEmit to verify there are no type errors. Then you wait. Thirty seconds. Forty. A minute. By the time the result arrives, you’re in your email. That is not a hypothetical – it is the daily reality for engineering teams at companies like Slack, Notion, and Figma. The TypeScript 7.0 release is built to end that wait entirely.

Microsoft announced the Release Candidate on 18 June 2026, with Principal Product Manager Daniel Rosenwasser presenting the headline: the compiler has been ported from JavaScript to Go, and the result is roughly 10 times faster than TypeScript 6.0 on representative large codebases. That number has production validation behind it. This is not a benchmark run on a toy project.

TypeScript 6.x: Why the JavaScript Compiler Did Everything Right, Then Hit a Wall

Image: Microsoft DevBlogs / TypeScript Team

TypeScript 6.x represents the ceiling of what a bootstrapped JavaScript compiler can achieve. The original compiler was written in TypeScript, compiled to JavaScript, and run on Node.js – a self-hosting design that made development and community contribution straightforward. For projects under a few hundred thousand lines, it remains genuinely quick.

The problem was never the code quality. It was the runtime. JavaScript is single-threaded. Node.js’s event loop is optimised for I/O-bound work – network requests, database calls – not for CPU-heavy tasks like traversing a million-line type graph. There was no architectural path to shared-memory parallelism within that design. Teams were hitting 45-second cold builds not because the TypeScript team wrote slow code, but because they had reached the physical ceiling of their platform.

The JavaScript-era compiler also accumulated real ecosystem gravity. Tools like TypeDoc, ts-morph (a library that provides a high-level API for reading and manipulating TypeScript source files), and custom bundler transformers often import typescript as a Node module and call its compiler APIs directly. That programmatic surface is mature and well-documented – and it is the one thing TypeScript 7.0 does not yet fully replace.

TypeScript 7.0: What the Go Port Actually Changes

TypeScript 7.0 is not a rewrite. The Go codebase was ported methodically from the TypeScript 6.0 source, with the type-checking logic preserved structurally intact. Same rules, same error messages, same behaviour on every edge case. Microsoft ran the new compiler against its accumulated test suite and against production codebases at several large engineering organisations over a year of pre-release collaboration before publishing a single public build.

What Go provides is two things JavaScript cannot: native machine code execution and genuine shared-memory parallelism. Where the old compiler processed files sequentially on a single thread, the Go compiler checks independent modules simultaneously across real OS threads sharing the same type graph. The 10x figure is an average – your mileage will vary with codebase shape, but the direction is not in doubt.

Three Migration Scenarios, Honestly Assessed

Scenario 1 – Plain tsc --noEmit application. You run type-checking via tsc in CI and locally, no custom transformers, no programmatic API consumers. This is the easiest path. Run npm install -D typescript@rc, update your tsconfig.json if needed, and you are done. A 200,000-line project that currently takes 12 seconds will take roughly 1.2 seconds. Across a developer’s day – multiple saves, several CI runs, a handful of branch checkouts – that recovers twenty or thirty minutes of uninterrupted focus. On CI, if your type-check step was previously the longest job in your pipeline, it may no longer be the bottleneck at all, which can shorten your total pipeline duration even if parallelism was already in play.

Scenario 2 – Vite application with custom transformers. Vite uses esbuild for transpilation at development time, so the compiler is not in your hot path during vite dev. But if you have custom Vite plugins that invoke the TypeScript compiler API directly – using ts.createProgram() or calling transform hooks that reach into typescript’s Node module – those will break on 7.0. The stable programmatic API is not available until TypeScript 7.1. The practical answer here is to install both: keep typescript pinned to 6.x for your plugin consumers, add @typescript/typescript6 if you need the tsc6 executable for tooling disambiguation, and use typescript@rc only for the standalone type-check step in CI. It is not elegant, but it is stable. Start auditing your plugin dependencies now so you know exactly what needs 7.1 before you fully commit.

Scenario 3 – Monorepo with ts-morph. ts-morph is a wrapper around the TypeScript compiler API used for code generation, codemods, and documentation pipelines. It imports typescript as a peer dependency and calls internal compiler methods extensively. Running ts-morph against TypeScript 7.0 will fail – not because of type system changes, but because the programmatic API it depends on does not exist yet in the Go port. If your monorepo uses ts-morph for any automated code generation or documentation step, you are effectively blocked on 7.1 for that toolchain. The workaround is the same: lock ts-morph’s peer to typescript6 via @typescript/typescript6, run your generation scripts against that, and let the main tsc binary come from 7.0. Test this carefully – dependency resolution in monorepos can quietly pull in conflicting versions.

CI Cost and the Review Flow

Faster local checks change something less obvious than just your personal workflow: they change review dynamics. When a type-check takes 45 seconds, developers batch their checks, run them between tasks, and inevitably push commits without verifying. When it takes four seconds, you check constantly – the feedback loop tightens into the edit-save-verify cycle that strongly-typed languages are supposed to enable. The web development community has long recognised that reducing small frictions in the development loop compounds into meaningful productivity gains.

On CI, the impact depends on your pipeline architecture. If type-checking already ran in parallel with other checks, the wall-clock saving may be modest. If it was the gating step everything else waited on, shaving it from 50 seconds to 5 can meaningfully shorten the pull request review cycle – fewer context switches while waiting for green, less time between push and merge. It also reduces cost if you are paying per-minute on a cloud CI provider.

Recommendation Matrix

No hedging. Here is what to actually do:

Upgrade to 7.0 RC now if your type-checking is standard tsc CLI usage in CI and locally, with no tooling that imports typescript as a Node module. The validation is extensive, the semantics are identical, and you will feel the difference immediately.

Run 7.0 alongside 6.x if you have Vite plugins or other build tooling that calls the compiler API. Use @typescript/typescript6 for those consumers, typescript@rc for type-checking, and set a calendar reminder for the 7.1 release.

Stay on 6.x for now if ts-morph, TypeDoc, or custom transformer pipelines are deeply integrated into your build. Audit which tools depend on the programmatic API, document what needs to change, and you will be ready to migrate cleanly when 7.1 ships.

Do not wait if you are starting a new project. TypeScript 7.0 is where the toolchain is heading. The compatibility story is solid. Build against it from day one.

For teams evaluating TypeScript against other typed options for a new project – or comparing the frontend TypeScript ecosystem against a typed backend choice like Django with its own type annotation support – the 7.0 improvements strengthen TypeScript’s case considerably. Faster feedback loops change how a language feels to work in day to day.

The Go port removes the single largest scalability constraint TypeScript has faced. A decade of correctness. Now on hardware that can finally keep up.

Frequently Asked Questions

Q: Is TypeScript 7.0’s type-checking behaviour identical to TypeScript 6.0?
A: Yes. The compiler was ported methodically from the TypeScript 6.0 source rather than rewritten, preserving the type-checking logic structurally intact. Microsoft validated the new compiler against its full decade of accumulated test cases before releasing the RC.

Q: How do I install the TypeScript 7.0 Release Candidate?
A: Run npm install -D typescript@rc to install version 7.0.1-rc. The CLI interface is unchanged – use tsc as normal. For editor diagnostics, install the TypeScript Native Preview extension for VS Code, which uses the Language Server Protocol (LSP) to deliver the same speed improvements as you type.

Q: What happens to build tools and libraries that import typescript as a Node module?
A: The stable programmatic API is not available until TypeScript 7.1, expected several months after the stable 7.0 release. Microsoft’s @typescript/typescript6 compatibility package provides a tsc6 executable, allowing teams to run both TypeScript 6.x and 7.x side by side without naming conflicts while they wait for 7.1. Tools like ts-morph and TypeDoc fall into this category.

Q: Why is TypeScript 7.0 so much faster than 6.0?
A: The compiler was ported from JavaScript to Go, which provides native machine code execution and genuine shared-memory parallelism. The Go compiler can type-check independent modules simultaneously across multiple OS threads sharing the same type graph, whereas the JavaScript compiler was constrained to a single thread by Node.js’s event loop.

Q: Does the speed improvement affect CI pipelines as well as local development?
A: Yes, though the impact depends on your pipeline shape. If type-checking was your longest or gating CI step, reducing it from tens of seconds to a few seconds can shorten overall pipeline duration and, on per-minute cloud CI providers, reduce cost. The most immediate gains are in local development, where the tighter feedback loop changes how you write and review code.

Source: https://devblogs.microsoft.com/typescript/announcing-typescript-7-0-rc/