TypeScript 7 After the Move to Go: What the New Compiler Really Delivers and How to Migrate Large Projects
TypeScript 7 is one of the most substantial engineering changes in the language’s history, even though most application developers will continue writing TypeScript much as they did before. Released in July 2026, the new generation replaces the previous compiler implementation, which ran as JavaScript, with a native implementation written in Go. The aim was not to redesign TypeScript syntax or introduce a new programming model, but to remove performance limits that had become increasingly visible in large codebases. Microsoft reports major reductions in compilation time, faster editor feedback and lower memory use in many real projects. For teams responsible for monorepos, large front-end applications or services with thousands of TypeScript files, those improvements can be significant. Migration is not completely automatic, however. TypeScript 7 also formalises configuration changes introduced around TypeScript 6, removes several older options and temporarily changes the way some developer tools can interact with the compiler.
What TypeScript 7 Really Changes After the Move to Go
The most important point about TypeScript 7 is that the move to Go is primarily an implementation change rather than a change to the TypeScript language itself. Microsoft did not simply design a different compiler with similar behaviour. The team methodically ported the existing compiler structure and type-checking logic so that projects which behave correctly under TypeScript 6 should normally receive the same type-checking results under TypeScript 7. This matters for large organisations because a faster compiler has limited value if developers must rewrite application logic just to adopt it. In normal TypeScript source files, interfaces, generics, unions, decorators and everyday type checking continue to work in familiar ways.
The visible difference is speed. Microsoft’s release measurements show full-build improvements commonly falling between roughly eight and twelve times compared with TypeScript 6. On the VS Code codebase, one published test fell from 125.7 seconds to 10.6 seconds. Sentry dropped from 139.8 seconds to 15.7 seconds, while Playwright moved from 12.8 seconds to 1.47 seconds. These figures should not be treated as a guarantee that every company will see the same ratio. Build structure, hardware, project references, dependency size and available processor cores all matter. They do, however, show that the improvement is not limited to a synthetic benchmark or a small demonstration project.
Memory behaviour has improved as well. In Microsoft’s published tests, the measured reduction in aggregate memory ranged from around 6% for Sentry to 26% for Bluesky, with other projects falling between those figures. The practical benefit can be especially useful in continuous integration, where memory limits often determine the size and cost of build machines. Faster feedback also reaches beyond command-line compilation. Microsoft measured the time from opening a problematic file in the VS Code codebase to receiving the first error at about 17.5 seconds with the older compiler and under 1.3 seconds with TypeScript 7. For developers working in very large repositories, that changes compilation from a noticeable interruption into a much shorter part of the normal editing cycle.
Why Go Makes the Compiler Faster Without Changing TypeScript Development
Go gives the TypeScript team a native executable and more direct access to parallel processing across multiple CPU cores. The previous compiler had been written in TypeScript itself and then executed through JavaScript, an approach that worked extremely well for many years but made some forms of shared-memory parallel work difficult. TypeScript 7 can divide tasks such as parsing, checking and output generation across several workers. The default compiler configuration uses four type-checking workers, while teams with more capable build machines can experiment with additional workers. This is particularly relevant to large repositories because the compiler can make better use of hardware that was previously underused during parts of a TypeScript build.
Parallel work is only part of the change. TypeScript 7 also includes a rebuilt watch mode, which is important for teams that keep the compiler running while files change. The new implementation uses file-watching work derived from the technology used by Parcel and is intended to reduce unnecessary resource use across major operating systems. Editor integration has also moved towards the Language Server Protocol, commonly called LSP. That gives editors a more standard way to communicate with TypeScript services and allows several requests to be handled more efficiently. Features such as references, completion suggestions, diagnostics, imports and navigation can therefore benefit from the same native implementation rather than leaving the performance improvement confined to production builds.
None of this means that application teams need to learn Go or maintain Go code. Installing the current TypeScript package still provides the familiar tsc command, and developers continue to work with .ts, .tsx and configuration files. During the preview period the native compiler was commonly called tsgo, but that name is no longer the normal command for TypeScript 7. The separate development repository used during the port was archived in September 2026, and development returned to the main TypeScript repository. For most application developers, Go is therefore an implementation detail. Its importance lies in what it allows the compiler to do faster, rather than in introducing another language into the application itself.
Where Large Codebases Can Run Into Problems During Migration
The biggest migration risk is often not the Go rewrite itself. TypeScript 7 deliberately carries forward changes associated with TypeScript 6 and turns several previously deprecated behaviours into errors. Microsoft recommends treating TypeScript 6 as the preparation stage for TypeScript 7 because a project that compiles cleanly under the newer TypeScript 6 rules is much closer to a predictable migration. Teams moving directly from TypeScript 5.x or an older release are effectively combining two upgrades: first the configuration and compatibility changes introduced in TypeScript 6, and then the native compiler. Splitting those jobs makes failures easier to understand because developers can tell whether a problem comes from an outdated project setting or from the change of compiler generation.
Several default settings deserve attention before a large repository is switched. TypeScript 7 enables strict behaviour by default, uses esnext as the default module setting and enables noUncheckedSideEffectImports. The default rootDir is now the project directory itself, so repositories that relied on an automatically inferred source directory may need to set something such as ./src explicitly. The default types value also becomes an empty list. This means projects that previously received global declarations automatically from installed @types packages may need to name packages such as Node or a test framework explicitly. These are small configuration edits individually, but in a monorepo with dozens or hundreds of tsconfig.json files they need to be reviewed systematically.
Older compiler options can cause more obvious failures. TypeScript 7 no longer supports an ES5 compilation target, the old node or node10 module-resolution modes, classic module resolution or older module formats such as AMD, UMD and SystemJS. The long-standing baseUrl setting is also no longer supported in the old form, so path mappings may need to be made relative to the project directory. Projects cannot disable esModuleInterop, allowSyntheticDefaultImports or strict-mode behaviour in the ways older configurations allowed. A modern application may already avoid all of these settings, while a repository that has evolved for eight or ten years can still contain them in inherited configuration files that developers rarely inspect.
Tooling and Framework Compatibility Needs Its Own Migration Check
TypeScript 7.0 has an important limitation for tools that use TypeScript as a library rather than simply running tsc: the 7.0 release does not provide the traditional compiler API. That distinction is easy to miss because ordinary command-line compilation can work correctly while another part of the development process still expects to import internal TypeScript functionality from JavaScript. Linters, custom code-analysis tools, build integrations and company-specific scripts may rely on that API. A large migration therefore needs an inventory of tools around the compiler, not just confirmation that the main application compiles. Microsoft is working on a new API for the 7.1 generation, but teams should not assume that older API consumers automatically work with 7.0.
Microsoft provides a transition route for projects that need both generations at once. The @typescript/typescript6 compatibility package makes the TypeScript 6 compiler and API available alongside TypeScript 7. This allows a team to use the native TypeScript 7 tsc for normal project checking while a tool that still depends on the older programmatic API continues using TypeScript 6. npm aliases can also help where a dependency specifically expects a package named typescript. This mixed arrangement is not as tidy as using one version everywhere, but it is considerably safer than forcing every tool migration into the same release window. It also allows teams to collect TypeScript 7 performance benefits before every surrounding dependency has completed its own update.
Projects built around embedded languages require particular care. Microsoft states that workflows involving Vue, MDX, Astro and Svelte may still need TypeScript 6 where their tooling depends on direct compiler integration. Angular projects can face a similar split for specialised template checking. A team may therefore be able to run TypeScript 7 successfully from the command line while retaining TypeScript 6 for part of the editor or framework-specific workflow. This is a compatibility issue rather than evidence that the TypeScript source code itself is unsuitable for version 7. Before changing a large repository, teams should test the actual framework extension, editor integration, linting setup, test runner and build chain used by their developers instead of treating a successful tsc run as the only acceptance test.
How to Migrate a Large Project to TypeScript 7 Safely
A controlled migration should begin before TypeScript 7 is installed. First bring the project onto the latest suitable TypeScript 6 release and remove deprecated configuration where possible. Record the existing build time, peak memory use, number of diagnostics and continuous-integration duration. It is also worth recording how long developers wait for initial editor diagnostics in one or two representative large workspaces. These measurements create a useful baseline and prevent the migration from becoming a discussion based only on impressions. A successful upgrade should preserve expected compiler behaviour while showing a measurable improvement in the parts of the workflow that matter to the team.
Next, introduce TypeScript 7 on a dedicated branch or limited group of projects rather than changing an entire monorepo in one commit. Run the existing TypeScript 6 checks and the TypeScript 7 compiler against the same revision and compare errors. Review tsconfig.json files from the root down through inherited configurations, paying particular attention to rootDir, types, module resolution, targets and old path settings. If the repository produces JavaScript or declaration files that are published to other projects, compare those outputs as well. The objective is not to make TypeScript 7 produce text that is byte-for-byte identical in every case, but to make sure that consumers receive the same intended public types and runtime behaviour.
Continuous integration should then be adjusted according to the resources available on the build machines. TypeScript 7 uses four type-checking workers by default, which is sensible for many environments but not automatically ideal everywhere. Increasing the worker count can improve large builds on machines with spare CPU capacity, while reducing it may be better on smaller runners where additional workers compete for memory. TypeScript 7 also allows project-reference builds to run several builders in parallel. Those settings can multiply one another, so a monorepo should be measured rather than given the largest possible values. Consistency matters too: using a fixed, tested configuration in developer builds and CI reduces the chance of confusing differences between environments.
What a Successful TypeScript 7 Migration Should Look Like
The clearest sign of success is not simply that the project reports TypeScript 7 in its dependency file. Developers should notice shorter waits for type checks, quicker editor feedback and faster CI stages without receiving a new stream of unexplained diagnostics. Microsoft has published impressive examples, including Slack reducing a reported type-checking stage from roughly 7.5 minutes to about 1.25 minutes, but every repository has its own bottlenecks. If most of a build is spent bundling assets, running tests or generating code, making tsc ten times faster will not make the whole pipeline ten times faster. The useful measure is the time removed from the workflows developers actually repeat throughout the day.
Teams should also resist treating the migration as an opportunity to change every related tool at once. Large repositories are easier to stabilise when compiler changes, framework upgrades, linting changes and build-system refactoring are separated wherever practical. If an API-dependent tool still needs TypeScript 6, running it temporarily alongside TypeScript 7 is a reasonable migration state. Once the main compiler has been proven in CI and ordinary development, the remaining compatibility work can be handled independently. This staged approach also makes rollback straightforward: if one integration causes trouble, the team can change that component without discarding the performance improvement already gained elsewhere.
By October 2026, TypeScript 7.0.2 is the current stable npm release, the temporary repository used for the Go port has been archived, and active work has returned to the main TypeScript codebase. Work on TypeScript 7.1 is intended to address an important part of the remaining transition by introducing the new programmatic API. For large projects, there is little reason to think of TypeScript 7 as an experimental compiler, but there is also no benefit in migrating blindly. The strongest approach is to enter the upgrade with a clean TypeScript 6 baseline, test every important part of the development toolchain, move projects in controlled stages and measure the results. Done that way, the move to the Go-based compiler becomes primarily a performance upgrade rather than a disruptive rewrite of the application.
