Microsoft officially released TypeScript 7.0 on July 8, 2026. The port to Go, one of the biggest transformations in its 12-year history, has increased build speed by about tenfold and fundamentally changed the nature of large-scale development.

A historic renewal through a full port to Go

On July 8, 2026, Microsoft officially released TypeScript 7.0, the next major version of its programming language. This release is not just a feature addition; it brings a refreshing redesign of the most ambitious architecture in TypeScript’s 12-year history. The biggest feature is that the compiler and language services, which TypeScript had previously written to run on JavaScript (Node.js), have been fully ported to Go.

This porting project was codenamed Project Corsa, and after more than a year of development, it was completed. This removes performance constraints in traditional JavaScript execution environments, enabling fast execution as native code. According to official measurements, the time required for a full build is approximately 8 to 12 times faster than the previous major version, TypeScript 6.0, which is about 8 to 12 times faster. This overhaul is positioned as a decisive step to eliminate the biggest bottleneck: build wait times, which is the biggest bottleneck in today’s increasingly large-scale web application development.

Please refer to the diagram below.

A revolution in build speed in large-scale codebases

The benefits of TypeScript 7.0 go beyond just improved build speed. Measured data from large-scale open source projects demonstrates its power. For example, the build time for Visual Studio Code, which contains about 1.5 million lines of code, was reduced from the previous 125.7 seconds to about 10.6 seconds, marking an 11.9-fold speed. Similarly, well-known projects like Sentry and Playwright have confirmed speeds of about 8 to 10 times.

The most beneficial aspect of developers’ daily work is improved responsiveness in the editor. The time from opening a file in Visual Studio Code’s codebase to the first error was dramatically reduced from about 17.5 seconds to less than 1.3 seconds. This means about 13 times faster than the game, indicating that the delay from writing code to receiving feedback has virtually disappeared. Furthermore, runtime memory consumption was reduced by approximately 6 to 26 percent across the entire build. With optimized memory management, even for massive monorepo projects containing hundreds of packages, development can proceed without worrying about depleting computing resources.

Technical Background and the Logic of Go Language Adoption

Structural Limitations of Node.js and the Need for Localization

For many years, tsc, the TypeScript compiler, has been self-hosted—that is, TypeScript itself and running Node.js as JavaScript. However, as the codebase grew to millions of lines, three structural limitations due to the characteristics of the Node.js (V8 engine) surfaced.

• Difficulties in parallel processing with single-thread V8 engine models

• Impact of frequent execution stoppages (GC pauses) caused by JavaScript garbage collection

• Node.js process startup costs and time to warm up JIT compilation

Anders Hejlsberg pointed out that the current cost of loading and type checking in large projects that can only take tens of seconds to minutes is unacceptable, and concluded that a fundamental solution through native coding is necessary. The migration to Go was an inevitable choice to overcome these Node.js-inherent bottlenecks and fully utilize the computational power of multi-core CPUs for type checking.

Technical Rationale for Choosing Go Over Rust

When renewing the architecture, the choice of Go over the high-performance Rust was based on highly practical technical decisions. The main reason is that the internal data structure of the TypeScript compiler is full of circular references. Nodes in the Abstract Syntax Tree (AST) have pointers to both parent and child, and the type system is a complex graph structure that references each other.

Such a structure fundamentally conflicted with Rust’s strict ownership model and borrowing checkers, and implementing it in Rust required a complete redesign of the data structure itself. On the other hand, Go included garbage collection, allowing for faithful porting of the design philosophy and code structure of existing TypeScript implementations at the file level. To avoid years of delays from rewriting from scratch and unintended behavioral differences, Microsoft adopted a port strategy that accurately copies existing logic into Go. Go could generate native code optimized for all platforms and had the optimal level of abstraction to complete the porting work within a realistic timeframe of about a year.

Enhanced development experience brought by shared memory parallel processing

With its port to Go, TypeScript finally achieved true multithreaded parallel processing with shared memory. Traditional TSC had to process files one by one in order, but the new compiler utilizes Goroutine, a lightweight thread from Go, to parse multiple files and perform type checks in parallel. TypeScript 7.0 introduces experimental flags like –checkers and –builders, allowing you to adjust the number of workers according to the available CPU cores.

The default number of workers is 4, but on machines with many cores—such as checkers 8—you can maximize performance even more. In actual experiments where the number of workers was increased in Visual Studio Code builds, an overwhelming speed of up to 16.7 times was reported. Additionally, a new –watch mode has been added, porting Parcel Bandler’s file watcher to Go. This enabled the entire process from file saving to type check results to be completed instantly, creating a seamless loop that did not interfere with developers’ thinking. The fast feedback loop proposed by Hejlsberg can be said to be the result of both nativeization and parallelization.

Please refer to the diagram below.

Migration Guide and Disruptive Changes from Existing Environments

Changing default settings and disabling deprecated features

When updating to TypeScript 7.0, you need to pay close attention to changing the default settings (tsconfig.json) in the configuration file. In this version, the long-recommended modern settings have been made by default, and many legacy settings have been removed.

• Changed the strict flag to Enabled (true) by default

• Module setting changed to esnext by default

• End of support for target ES5 (minimum ES2015 required)

• deleting moduleResolution node10 (formerly node) and classic

• Removal of the baseUrl option (migration to paths is required)

• Changed rootDir to default to directories with tsconfig.json

• Changed the default types setting to empty array ([])

The most significant impact is the default activation of the strict flag. This makes type inference more rigorous, allowing any types and null check defects—which were previously implicitly accepted—to be detected as hard errors. Also, with the abolition of baseUrl, path resolution needs to be rewritten from the project route to a relative path-based approach.

Safe migration steps using TypeScript 6.0 as a bridge

To ensure a safe transition to TypeScript 7.0 with disruptive changes, Microsoft strongly recommends using TypeScript 6.0, released in March 2026, as the bridge version. TypeScript 6.0 is the final version of the JavaScript implementation and serves to issue deprecated warnings in advance for older settings that cause hard errors in 7.0.

The specific migration steps are to first upgrade your current project to TypeScript 6.0 and remove all warnings displayed there. On top of that, the safest approach is to introduce TypeScript 7.0 RC (or the official version) and carefully observe whether there are any discrepancies in the type check results. If you want to temporarily ignore warnings, you can continue operation by setting the ignoreDeprecations flag to 6.0, but since these options are removed in 7.0, this is only a temporary measure. Also, some plugin-based transformers may not work on the new 7.0 architecture, so prior technical evaluations, such as considering migrating to plugins on the bandra side, are essential.

Future Ecosystem and Development Culture Transformation

Status of Support for Peripheral Tools and Future API Deployment

At the time of the official release of TypeScript 7.0, some public APIs for directly manipulating internal type information from programs were not included. Microsoft has announced plans to provide an API suite optimized for new native implementations in the upcoming minor update, TypeScript 7.1. Therefore, peripheral tools that heavily rely on compiler APIs, such as ESLint, Prettier, or ts-node, are expected to require additional time for a full transition to 7.0.

The development team recommends that these tool creators use compatible packages that can also use TypeScript 6.0 as an API server until they support the new API. Additionally, workflows with custom extensions like type checking within Vue templates and Svelte and Astro also need to wait for tools to catch up. However, for CI processes dedicated to type checking or for local build acceleration, operating existing tools and native compilers in a hybrid way can dramatically improve productivity even now.

Elimination of waiting times driving the evolution of software engineering

The tenfold acceleration achieved by TypeScript 7.0 has the potential to fundamentally change the definition of development workflows in software engineering. Until now, waiting to build has been accepted as an unavoidable break in large projects, but reducing this to just a few seconds allows developers to boldly take on more experimental refactoring.

Especially in development environments where automatic code generation by AI assistants and agents has become mainstream as of 2026, an environment where the validity of generated code can be instantly verified through type checking forms a foundation that dramatically increases development throughput. Microsoft has partnered with companies with large codebases like Bloomberg and Slack to see concrete results such as a 40 percent reduction in merge wait times and optimization of CI costs. Beyond mere tool updates, slow builds are treated as management challenges, focusing engineers’ resources on creative work. The release of TypeScript 7.0 will mark a historic turning point as the entire web ecosystem transitions to a more sophisticated, delay-free development experience.

[#TypeScript7 #プログラミング #Go言語 #ビルド高速化 #マイクロソフト #フロントエンド開発 #技術ニュース #ソフトウェア工学]